Evolution_in_Closed_and_Open_System.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Evolution of a state $\\psi$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Quantum states evolve and their evolution can be described by Unitary Matries. \n",
    "\n",
    "A unitary matrix has the property that its conjugate transpose is its inverse. Formally, it means that a matrix $U$ is unitary if \n",
    "\n",
    "$UU^\\dagger=U^\\dagger U=\\mathbb{1}$\n",
    "\n",
    "Pauli Spin Matrices are Unitary matrices. \n",
    "\n",
    "$X = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix} = |0\\rangle\\langle1| + |1\\rangle\\langle0|$\n",
    "\n",
    "$Y = \\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix} \\quad\\quad\\quad\\quad Z = \\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}$\n",
    "\n",
    "$Y = -i|0\\rangle\\langle1| + i|1\\rangle\\langle0| \\quad\\quad Z = |0\\rangle\\langle0| - |1\\rangle\\langle1|$\n",
    "\n",
    "We will now call them as X, Y and Z gates. \n",
    "\n",
    "Let's check if they are indeed Unitary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#!pip install git+https://github.com/qiskit-community/qiskit-textbook.git#subdirectory=qiskit-textbook-src"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \n",
       "\\text{Y = } \\begin{bmatrix}\n",
       "0 & -i  \\\\\n",
       "i & 0  \\\\\n",
       "\\end{bmatrix}\n",
       "$$\n",
       "$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \n",
       "\\text{Y_dag = } \\begin{bmatrix}\n",
       "0 & -i  \\\\\n",
       "i & 0  \\\\\n",
       "\\end{bmatrix}\n",
       "$$\n",
       "$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \n",
       "\\text{A = } \\begin{bmatrix}\n",
       "1 & 0  \\\\\n",
       "0 & 1  \\\\\n",
       "\\end{bmatrix}\n",
       "$$\n",
       "$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from qiskit_textbook.tools import array_to_latex\n",
    "Y=np.array([[0,complex(0,-1)],[complex(0,1),0]])\n",
    "#print ('Y:',Y)\n",
    "print (array_to_latex(Y,pretext=\"\\\\text{Y = } \"))\n",
    "Y_dag= Y.conj().transpose()\n",
    "print (array_to_latex(Y_dag, pretext=\"\\\\text{Y_dag = } \"))\n",
    "A=np.dot(Y,Y_dag)\n",
    "#print ('A:',A)\n",
    "print (array_to_latex(A,pretext=\"\\\\text{A = } \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Similary, you can show X and Z are unitary matrices too. \n",
    "The beauty of Unitary matrix is that the norm is reserved. That is a quantum state is mapped to another quantum state. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The main beauty of unitary matrices or operation is reversibility. Quantum computing libraries often proved a function to reverse entire circuit. Reversing a gate is very simple: we just apply it again!\n",
    "\n",
    "Let's check if this is true!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister\n",
    "from qiskit import execute\n",
    "from qiskit import Aer\n",
    "from qiskit.tools.visualization import circuit_drawer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \n",
       "\\text{Psi after X-gate is applied = } \\begin{bmatrix}\n",
       "0 \\\\\n",
       "1\n",
       "\\end{bmatrix}\n",
       "$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "      ┌───┐┌───┐\n",
      "q0_0: ┤ X ├┤ X ├\n",
      "      └───┘└───┘\n",
      "c0_0: ══════════\n",
      "                \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \n",
       "\\text{Psi after X-gate is applied again = } \\begin{bmatrix}\n",
       "1 \\\\\n",
       "0\n",
       "\\end{bmatrix}\n",
       "$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "# Calling a simulator to see what happened after applying the gate\n",
    "backend_statevector = Aer.get_backend('statevector_simulator')\n",
    "# create a quantum register and a classical register\n",
    "q = QuantumRegister(1)\n",
    "c = ClassicalRegister(1) #used to measure the result\n",
    "circuit = QuantumCircuit(q, c) # Now we created a circuit\n",
    "circuit.x(q[0]) # Applied a Pauli X-gate to q0\n",
    "job = execute(circuit, backend_statevector)\n",
    "print(array_to_latex(job.result().get_statevector(circuit),pretext=\"\\\\text{Psi after X-gate is applied = } \"))\n",
    "circuit.x(q[0]) # Apllied another Pauli X-gate to q\n",
    "print(circuit.draw(style='mpl'))\n",
    "job1 = execute(circuit, backend_statevector) # ran the job\n",
    "#print(\"Psi after X-gate applied again:\",job1.result().get_statevector(circuit))\n",
    "print(array_to_latex(job1.result().get_statevector(circuit),pretext=\"\\\\text{Psi after X-gate is applied again = } \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Let's see this mathematically:\n",
    "\n",
    "$X|0\\rangle = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} = |1\\rangle$\n",
    "\n",
    "$X|1\\rangle = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} = |0\\rangle$"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "This Unitary evolution is true for Closed system, that is, a quantum system perfectly isolated from the environment.\n",
    "This is not the case in the quantum computers we have today: these are open quantum systems that evolve differently due to uncontrolled interactions with the environments.\n",
    "    Now let us look as Open systems in Quantum Computing."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "This also means that the actual time evolution of Psi is not described by a unitary matrix as we would want it, but some other operator (the technical name for it is a completely positive trace-preserving map)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Quantum computing libraries often offer a variety of noise models that mimic different types of interaction, and increasing the strength of the interaction with the environment leads to faster decoherence. The timescale for decoherence is often called $T_2$ time. Among a couple of other parameters, $T_2$ time is critically important for the number of gates or the duration of the quantum computation we can perform.\n",
    "\n",
    "A very cheap way of studying the effects of decoherence is mixing a pure state with the maximally mixed state $\\mathbb{1}/2^d$, where $d$ is the number of qubits, with some visibility parameter in $[0,1]$. This way we do not have to specify noise models or any other map modelling decoherence. For instance, we can mix the $|\\phi^+\\rangle$ state with the maximally mixed state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0.],\n",
       "       [0., 1., 0., 0.],\n",
       "       [0., 0., 1., 0.],\n",
       "       [0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(4) # Creates an identity matrix of 4 X 4 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \n",
       "\\text{ϕ = } \\begin{bmatrix}\n",
       "\\tfrac{1}{\\sqrt{2}}  \\\\\n",
       "0  \\\\\n",
       "0  \\\\\n",
       "\\tfrac{1}{\\sqrt{2}}  \\\\\n",
       "\\end{bmatrix}\n",
       "$$\n",
       "$"
      ],
      "text/plain": [
       "<IPython.core.display.Math object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "Density_matrix\n",
      "[[0.5 0.  0.  0.5]\n",
      " [0.  0.  0.  0. ]\n",
      " [0.  0.  0.  0. ]\n",
      " [0.5 0.  0.  0.5]]\n",
      "Maximum visibility is a pure state:\n",
      "[[0.5 0.  0.  0.5]\n",
      " [0.  0.  0.  0. ]\n",
      " [0.  0.  0.  0. ]\n",
      " [0.5 0.  0.  0.5]]\n",
      "The state is still entangled with visibility 0.8:\n",
      "[[0.45 0.   0.   0.4 ]\n",
      " [0.   0.05 0.   0.  ]\n",
      " [0.   0.   0.05 0.  ]\n",
      " [0.4  0.   0.   0.45]]\n",
      "Entanglement is lost by 0.6:\n",
      "[[0.4 0.  0.  0.3]\n",
      " [0.  0.1 0.  0. ]\n",
      " [0.  0.  0.1 0. ]\n",
      " [0.3 0.  0.  0.4]]\n",
      "Barely any coherence remains by 0.2:\n",
      "[[0.3 0.  0.  0.1]\n",
      " [0.  0.2 0.  0. ]\n",
      " [0.  0.  0.2 0. ]\n",
      " [0.1 0.  0.  0.3]]\n"
     ]
    }
   ],
   "source": [
    "def mixed_state(pure_state, visibility):\n",
    "    density_matrix = pure_state @ pure_state.T.conj()\n",
    "    maximally_mixed_state = np.eye(4)/2**2\n",
    "    return visibility*density_matrix + (1-visibility)*maximally_mixed_state\n",
    "\n",
    "ϕ = np.array([[1],[0],[0],[1]])/np.sqrt(2)\n",
    "#####################\n",
    "print(array_to_latex(ϕ,pretext=\"\\\\text{ϕ = } \"))\n",
    "d_m= ϕ @ ϕ.T.conj()\n",
    "print ('Density_matrix')\n",
    "print (d_m)\n",
    "###############################\n",
    "print(\"Maximum visibility is a pure state:\")\n",
    "print(mixed_state(ϕ, 1.0))\n",
    "#############################\n",
    "print(\"The state is still entangled with visibility 0.8:\")\n",
    "print(mixed_state(ϕ, 0.8))\n",
    "################################\n",
    "print(\"Entanglement is lost by 0.6:\")\n",
    "print(mixed_state(ϕ, 0.6))\n",
    "############################\n",
    "print(\"Barely any coherence remains by 0.2:\")\n",
    "print(mixed_state(ϕ, 0.2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Another way to look at what happens to a quantum state in an open system is through equilibrium processes. Think of a cup of coffee: left alone, it will equilibrate with the environment, eventually reaching the temperature of the environment. This includes energy exchange. A quantum state does the same thing and the environment has a defined temperature, just like the environment of a cup of coffee.\n",
    "\n",
    "The equilibrium state is called the thermal state. The samples pulled out of a thermal state follows a Boltzmann distribution. The Boltzmann -- also called Gibbs -- distribution is described as \n",
    "\n",
    "$P(E_i) =  \\frac {e^{-E_{i}/T}}{\\sum _{j=1}^{M}{e^{-E_{j}/T}}}$,\n",
    "\n",
    "where $E_i$ is an energy, and $M$ is the total number of possible energy levels. Temperature enters the definition: the higher the temperature, the closer we are to the uniform distribution. In the infinite temperature limit, it recovers the uniform distribution. At high temperatures, all energy levels have an equal probability. In contrast, at zero temperature, the entire probability mass is concentrated on the lowest energy level, the ground state energy. To get a sense of this, let's plot the Boltzmann distribution with vastly different temperatures:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x212205c56c8>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "temperatures = [.5, 5, 200]\n",
    "energies = np.linspace(0, 20, 100) # Creating uniform energy levels\n",
    "fig, ax = plt.subplots()\n",
    "for i, T in enumerate(temperatures):\n",
    "    probabilities = np.exp(-energies/T)\n",
    "    Z = probabilities.sum()\n",
    "    probabilities /= Z\n",
    "    ax.plot(energies, probabilities, linewidth=3, label = \"$T_\" + str(i+1)+\"$=\"+str(T))\n",
    "ax.set_xlim(0, 20)\n",
    "ax.set_ylim(0, 1.2*probabilities.max())\n",
    "#ax.set_xticks([])\n",
    "#ax.set_yticks([])\n",
    "ax.set_xlabel('Energy')\n",
    "ax.set_ylabel('Probability')\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here $T_1 < T_2 < T_3$. Notice that $T_1$ is a low temperature, and therefore it is highly peaked at low energy levels. In contrast, $T_3$ is a very high temperature and the probability distribution is almost completely flat."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is why Quantum Qubits needs to be cooled at extremely low temperatures. \n",
    "https://www.newscientist.com/article/2240539-quantum-computer-chips-demonstrated-at-the-highest-temperatures-ever/#:~:text=For%20the%20first%20time%2C%20quantum,made%20in%20several%20different%20ways."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum Error Correction using Repetition Codes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical Qubit: No errors\n",
    "\n",
    "Physical Qubits: Will always have errors\n",
    "\n",
    "In the current era of quantum computing, we seek to use physical qubits despite their imperfections, by designing custom algorithms and using error mitigation effects. For the future era of fault-tolerance, however, we must find ways to build logical qubits from physical qubits. This will be done through the process of quantum error correction, in which logical qubits are encoded in a large number of physical qubits. The encoding is maintained by constantly putting the physical qubits through a highly entangling circuit.\n",
    "\n",
    "we will look at a particular example of error correction: the repetition code. Though not a true example of quantum error correction - it uses physical qubits to encode a logical bit, rather than a qubit - it serves as a simple guide to all the basic concepts in any quantum error correcting code.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic ideas behind error correction are the same for quantum information as for classical information. This allows us to begin by considering a very straightforward example: speaking on the phone. If someone asks you a question to which the answer is 'yes' or 'no', the way you give your response will depend on two factors:\n",
    "\n",
    "How important is it that you are understood correctly?\n",
    "How good is your connection?\n",
    "\n",
    "Both of these can be paramaterized with probabilities. For the first, we can use  Pa , the maximum acceptable probability of being misunderstood. If you are being asked to confirm a preference for ice cream flavours, and don't mind too much if you get vanilla rather than chocolate,  Pa  might be quite high.\n",
    "\n",
    "For the second we can use  p , the probability that your answer is garbled by a bad connection. For simplicity, let's imagine a case where a garbled 'yes' doesn't simply sound like nonsense, but sounds like a 'no'. And similarly a 'no' is transformed into 'yes'. Then  p  is the probability that you are completely misunderstood.\n",
    "\n",
    "A good connection or a relatively unimportant question will result in  p<Pa . In this case it is fine to simply answer in the most direct way possible: you just say 'yes' or 'no'.\n",
    "\n",
    "f, however, your connection is poor and your answer is important, we will have  p>Pa . A single 'yes' or 'no' is not enough in this case.The probability of being misunderstood would be too high. Instead we must encode our answer in a more complex structure, allowing the receiver to decode our meaning despite the possibility of the message being disrupted. The simplest method is the one that many would do without thinking: simply repeat the answer many times. For example say 'yes, yes, yes' instead of 'yes' or 'no, no no' instead of 'no'.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Summary:\n",
    "\n",
    "There is some information to be sent or stored: In this case, a 'yes' or 'no.\n",
    "The information is encoded in a larger system to protect it against noise: In this case, by repeating the message.\n",
    "The information is finally decoded, mitigating for the effects of noise: In this case, by trusting the majority of the transmitted messages."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implementing in Qiskit:\n",
    "\n",
    "We consider two forms of error that can occur. One is a gate error: an imperfection in any operation we perform. We model this here in a simple way, using so-called depolarizing noise. The effect of this will be, with probability  p_gate  ,to replace the state of any qubit with a completely random state. For two qubit gates, it is applied independently to each qubit. The other form of noise is that for measurement. This simply flips between a 0 to a 1 and vice-versa immediately before measurement with probability  p_meas .\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.providers.aer.noise import NoiseModel\n",
    "from qiskit.providers.aer.noise.errors import pauli_error, depolarizing_error\n",
    "\n",
    "def get_noise(p_meas,p_gate):\n",
    "\n",
    "    error_meas = pauli_error([('X',p_meas), ('I', 1 - p_meas)])\n",
    "    error_gate1 = depolarizing_error(p_gate, 1)\n",
    "    error_gate2 = error_gate1.tensor(error_gate1)\n",
    "\n",
    "    noise_model = NoiseModel()\n",
    "    # measurement error is applied to measurements\n",
    "    noise_model.add_all_qubit_quantum_error(error_meas, \"measure\") \n",
    "    # single qubit gate error is applied to x gates\n",
    "    noise_model.add_all_qubit_quantum_error(error_gate1, [\"x\"]) \n",
    "     # two qubit gate error is applied to cx gates\n",
    "    noise_model.add_all_qubit_quantum_error(error_gate2, [\"cx\"])\n",
    "        \n",
    "    return noise_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create noise_model with a probability of 1% for each type of error\n",
    "noise_model=get_noise(0.01,0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     ┌─┐      \n",
      "q_0: ┤M├──────\n",
      "     └╥┘┌─┐   \n",
      "q_1: ─╫─┤M├───\n",
      "      ║ └╥┘┌─┐\n",
      "q_2: ─╫──╫─┤M├\n",
      "      ║  ║ └╥┘\n",
      "c_0: ═╩══╬══╬═\n",
      "         ║  ║ \n",
      "c_1: ════╩══╬═\n",
      "            ║ \n",
      "c_2: ═══════╩═\n",
      "              \n",
      " No noise: {'000': 1024} \n",
      " Noise: {'100': 11, '000': 993, '001': 12, '010': 8}\n"
     ]
    }
   ],
   "source": [
    "# initialize circuit with three qubits in the 0 state\n",
    "qc0 = QuantumCircuit(3,3,name='0') \n",
    " # measure the qubits\n",
    "qc0.measure(qc0.qregs[0],qc0.cregs[0])\n",
    "print(qc0.draw(style='mpl'))\n",
    "# run the circuit with th noise model and extract the counts\n",
    "counts_noise = execute( qc0, Aer.get_backend('qasm_simulator'),noise_model=noise_model).result().get_counts()\n",
    "counts = execute( qc0, Aer.get_backend('qasm_simulator')).result().get_counts()\n",
    "\n",
    "print(' No noise:',counts,'\\n','Noise:',counts_noise)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     ┌───┐┌─┐      \n",
      "q_0: ┤ X ├┤M├──────\n",
      "     ├───┤└╥┘┌─┐   \n",
      "q_1: ┤ X ├─╫─┤M├───\n",
      "     ├───┤ ║ └╥┘┌─┐\n",
      "q_2: ┤ X ├─╫──╫─┤M├\n",
      "     └───┘ ║  ║ └╥┘\n",
      "c_0: ══════╩══╬══╬═\n",
      "              ║  ║ \n",
      "c_1: ═════════╩══╬═\n",
      "                 ║ \n",
      "c_2: ════════════╩═\n",
      "                   \n",
      " No noise: {'111': 1024} \n",
      " Noise: {'100': 1, '101': 9, '110': 18, '011': 13, '111': 983}\n"
     ]
    }
   ],
   "source": [
    "n =1024 # number of shots\n",
    "#Running same with '111' this time!\n",
    "qc1 = QuantumCircuit(3, 3, name='0') \n",
    "qc1.x(qc1.qregs[0]) # flip each 0 to 1\n",
    "\n",
    "qc1.measure(qc1.qregs[0],qc1.cregs[0]) # measure the qubits\n",
    "print(qc1.draw(style='mpl'))\n",
    "# run the circuit with th noise model and extract the counts\n",
    "counts_noise = execute( qc1, Aer.get_backend('qasm_simulator'),noise_model=noise_model,shots=n).result().get_counts()\n",
    "counts = execute( qc1, Aer.get_backend('qasm_simulator'),shots=n).result().get_counts()\n",
    "\n",
    "print(' No noise:',counts,'\\n','Noise:',counts_noise)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'100': 122, '000': 126, '110': 130, '101': 146, '010': 145, '011': 122, '001': 129, '111': 104}\n"
     ]
    }
   ],
   "source": [
    "#Increase measurement_noise probability\n",
    "noise_model = get_noise(0.5,0.0)\n",
    "counts = execute(qc1, Aer.get_backend('qasm_simulator'),noise_model=noise_model).result().get_counts()\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To have complete idea about Repetition code, check this link:\n",
    "#https://qiskit.org/textbook/ch-quantum-hardware/error-correction-repetition-code.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}