adding noise simulator

examples/Stochastic_noise_usage.ipynb

@@ -0,0 +1,307 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create noise channel(s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qtensor.noise_simulator.NoiseChannels import DepolarizingChannel\n",
+    "from qtensor.noise_simulator.NoiseModel import NoiseModel\n",
+    "\n",
+    "# Depolarizing channel for a single qubit. The probability of the error occuring is related to 0.003\n",
+    "depol_chan_1Q = DepolarizingChannel(param = 0.003, num_qubits = 1)\n",
+    "# Depolarizing channel for two qubits. The probability of the error occuring is related to 0.03\n",
+    "depol_chan_2Q = DepolarizingChannel(param = 0.03, num_qubits = 2)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create noise model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "noise_model = NoiseModel()\n",
+    "# If a circuit uses this noise model, all H, XPhase, and ZPhase gates will experience depolarizing noise \n",
+    "# based on the single qubit depolarizing channel created above\n",
+    "noise_model.add_channel_to_all_qubits(channel = depol_chan_1Q, gates = ['H', 'XPhase', 'ZPhase'])\n",
+    "# If a circuit uses this noise model, all cX gates will experience depolarizing noise \n",
+    "# based on the two-qubit depolarizing channel created above\n",
+    "noise_model.add_channel_to_all_qubits(channel = depol_chan_2Q, gates = ['cX'])"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create a circuit. Here we create a QAOA circuit. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qtree.operators import from_qiskit_circuit\n",
+    "from qtensor import QiskitQAOAComposer, QtreeSimulator\n",
+    "import qtensor\n",
+    "import numpy as np\n",
+    "import networkx as nx\n",
+    "\n",
+    "# degree of graph\n",
+    "d = 3\n",
+    "num_qubits = 4\n",
+    "G = nx.random_regular_graph(d, num_qubits)\n",
+    "\n",
+    "# optimal gamma and beta parameters previously found for these values of d and n\n",
+    "gammabeta = np.array(qtensor.tools.BETHE_QAOA_VALUES[str(d)]['angles'])\n",
+    "gamma = -gammabeta[:d]\n",
+    "beta = gammabeta[d:]\n",
+    "\n",
+    "# composes a qaoa circuit of type qiskit\n",
+    "qiskit_comp = QiskitQAOAComposer(G, gamma=gamma, beta=beta)\n",
+    "qiskit_comp.ansatz_state()\n",
+    "\n",
+    "# converts the circuit to qtensor type, which is just a list \n",
+    "n, circ = from_qiskit_circuit(qiskit_comp.circuit)\n",
+    "# from_qiskiit_circuit returns each gate as a list so we remove the lists from the gates. Might want to fix that.\n",
+    "circ = sum(circ, [])"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Instatiate simulator with noise model and then simulate the circuit with noise. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.14060763, 0.0349968 , 0.04040751, 0.06550023, 0.05163103,\n",
+       "       0.06425988, 0.03407733, 0.06851953, 0.06851953, 0.03407733,\n",
+       "       0.06425988, 0.05163103, 0.06550023, 0.04040751, 0.0349968 ,\n",
+       "       0.14060763])"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from qtensor.noise_simulator.NoiseSimulator import NoiseSimulator\n",
+    "\n",
+    "noise_sim = NoiseSimulator(noise_model)\n",
+    "\n",
+    "num_circs = 10\n",
+    "# simulate an ensemble of 10 circuits with stochastic noise\n",
+    "noise_sim.simulate_batch_ensemble(circ, num_circs, num_qubits)\n",
+    "# get the approximate noisy probabilities \n",
+    "qtensor_probs = noise_sim.normalized_ensemble_probs\n",
+    "qtensor_probs"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This same circuit can also be simulated without noise."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.26962495, 0.03924902, 0.03924902, 0.02445963, 0.03924902,\n",
+       "       0.02445963, 0.02445963, 0.03924902, 0.03924902, 0.02445963,\n",
+       "       0.02445963, 0.03924902, 0.02445963, 0.03924902, 0.03924902,\n",
+       "       0.26962495])"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ideal_sim = QtreeSimulator()\n",
+    "amplitudes = ideal_sim.simulate_batch(circ, num_qubits)\n",
+    "ideal_probs = np.abs(amplitudes)**2\n",
+    "ideal_probs"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can check how well our simulation approximated the exact noisy state by running the same circuit with a density matrix simulator and then calculating the fidelity between the exact and approximate noisy states."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.13403107, 0.05506911, 0.05646327, 0.0514643 , 0.05139734,\n",
+       "       0.0499991 , 0.04779918, 0.05377664, 0.05377664, 0.04779918,\n",
+       "       0.0499991 , 0.05139734, 0.0514643 , 0.05646327, 0.05506911,\n",
+       "       0.13403107])"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import qiskit.providers.aer.noise as noise\n",
+    "from qiskit.providers.aer import AerSimulator\n",
+    "\n",
+    "# Create the same noise model with the same channels and noisy gates in Qiskits framework\n",
+    "depol_chan_qiskit_1Q = noise.depolarizing_error(param = 0.003, num_qubits = 1)\n",
+    "depol_chan_qiskit_2Q = noise.depolarizing_error(param = 0.03, num_qubits = 2)\n",
+    "\n",
+    "noise_model_qiskit = noise.NoiseModel()\n",
+    "noise_model_qiskit.add_all_qubit_quantum_error(depol_chan_qiskit_1Q, ['rz', 'rx', 'h'])\n",
+    "noise_model_qiskit.add_all_qubit_quantum_error(depol_chan_qiskit_2Q, ['cx'])\n",
+    "\n",
+    "# Take the Qiskit circuit we created before, and add some final touches to it. These do not effect any measurement outcomes \n",
+    "qiskit_circ = qiskit_comp.circuit\n",
+    "\n",
+    "# Qiskit uses little endian notation by default, and Qtensor uses big endian, so we change the Qiskit circuit to match qtensor\n",
+    "qiskit_circ = qiskit_circ.reverse_bits()\n",
+    "qiskit_circ.save_density_matrix()\n",
+    "qiskit_circ.measure_all(add_bits = False)\n",
+    "\n",
+    "# Simulate the circuit\n",
+    "backend = AerSimulator(method='density_matrix', noise_model=noise_model_qiskit, fusion_enable=False, fusion_verbose=True)\n",
+    "result = backend.run(qiskit_circ).result()\n",
+    "\n",
+    "# The stochastic noisy simulation gives us a probability density vector, so we need to save the diagonal elements of the density matrix for our comparison\n",
+    "qiskit_probs = np.diagonal(np.asarray(result.results[0].data.density_matrix).real)\n",
+    "qiskit_probs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9851105052526412"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# The fidelity is defined for probability amplitudes, so we need to take the square root of our probability density vectors\n",
+    "A = np.sqrt(qtensor_probs)\n",
+    "B = np.sqrt(qiskit_probs)\n",
+    "fidelity = np.dot(A, B)**2\n",
+    "fidelity"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can increase our fidelity by increasing the number of circuits in the ensemble."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9954629065353349"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "num_circs = 100\n",
+    "noise_sim.simulate_batch_ensemble(circ, num_circs, num_qubits)\n",
+    "qtensor_probs = noise_sim.normalized_ensemble_probs\n",
+    "A = np.sqrt(qtensor_probs)\n",
+    "B = np.sqrt(qiskit_probs)\n",
+    "fidelity = np.dot(A, B)**2\n",
+    "fidelity"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.2"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

qtensor/OpFactory.py

@@ -181,6 +181,14 @@ def cX(cls):
     def cZ(cls):
         return qiskit_lib.CZGate
 
+    @property
+    def X(cls):
+        return qiskit_lib.XGate
+
+    @property
+    def Y(cls):
+        return qiskit_lib.YGate
+
     @property
     def Z(cls):
         return qiskit_lib.ZGate