quantum_parallelism_Deutsch_Jozsa.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "[<img src=\"images/quantum_algorithms_tutorials.png\" alt=\"drawing\" width=\"100\" align=\"left\" />][5]\n",
    "\n",
    "<h2 align=\"center\">\n",
    "Quantum parallelism and Deutsch–Jozsa algorithm\n",
    "</h2>\n",
    "\n",
    "**[[Homepage][5]]**\n",
    "**[[Open with the nbviewer][6]]**\n",
    "\n",
    "<h3 align=\"left\">\n",
    "1. Quantum parallelism\n",
    "</h3>\n",
    "\n",
    "In this tutorial, we are going to introduce 3 separate problems and we will mainly follow the [[1]] book's approach of describing them. After giving descriptions we will implement them with Qiskit. Apart from addressing these problems, we will try to show some of the main \"tools\" of the quantum computers that are absent in the classical computation. This \"tools\" are important for understanding the specifics of the constructions of quantum algorithms. Namely, the quantum algorithms are widely using the following \"tools\": quantum interference, quantum entanglement, and quantum parallelism. How one can deduce from the name of this tutorial we will mainly focus on the quantum parallelism and how to gain some advantage from it, neverteless all mentioned \"tools\" are involved in this tutorial. Now, let's start discussing the quantum parallelism. Quantum parallelism enables to compute (with some caveats) the outputs of a function for given several inputs simultaneously. \n",
    "\n",
    "Suppose we have two registers one for the input the other one for the output. The initial state is given by $\\left| x \\right\\rangle \\left| 0 \\right\\rangle$ combined state of the two quantum registers, where $\\left| x \\right\\rangle$ is the register that takes $x$ input and $\\left| 0 \\right\\rangle$ is the output register where the value of the $f(x)$ function will be stored. After applying the circuit that corresponds to the given function the combined state is equal to $\\left| x \\right\\rangle \\left| f(x) \\right\\rangle$. Here is the circuit:\n",
    "\n",
    "<img src=\"images/qparallel.png\" alt=\"drawing\" width=\"300\"/>\n",
    "\n",
    "The $U_{f(x)}$ is the unitary operator that acts on both  registers and does the described transformation. Let's see what happens when instead of one $\\left| x \\right\\rangle$ bit string, we have a superposition state of all possible bit strings:\n",
    "\n",
    "$$\\frac{1}{2}\\sum_{x} \\left| x \\right\\rangle = \\frac{1}{2} \\left[ \\left| 00 \\right\\rangle + \\left| 01 \\right\\rangle + \\left| 10 \\right\\rangle + \\left| 11 \\right\\rangle \\right]$$\n",
    "\n",
    "The coefficient $\\frac{1}{2}$ is for the normalization of the state (sum of all bit string probabilities in the superposition state must be unity). This superposition state will let us witness the quantum parallelism in action. Now let's write down the initial state of the two registers:\n",
    "\n",
    "$$\\left| \\psi_{initial} \\right\\rangle = \\frac{1}{2} \\left| 0 \\right\\rangle \\sum_{x}  \\left| x \\right\\rangle = \\frac{1}{2}  \\left[ \\left| 0 \\right\\rangle \\left| 00 \\right\\rangle + \\left| 0 \\right\\rangle \\left| 01 \\right\\rangle + \\left| 0 \\right\\rangle \\left| 10 \\right\\rangle + \\left| 0 \\right\\rangle \\left| 11 \\right\\rangle \\right]$$\n",
    "\n",
    "After $U_{f(x)}$ unitary operator:\n",
    "\n",
    "$$\\left| \\psi_{final} \\right\\rangle = \\frac{1}{2}  \\left[ \\left| f(00) \\right\\rangle \\left| 00 \\right\\rangle + \\left| f(01) \\right\\rangle \\left| 01 \\right\\rangle + \\left| f(10) \\right\\rangle \\left| 10 \\right\\rangle + \\left| f(11) \\right\\rangle \\left| 11 \\right\\rangle \\right]$$\n",
    "\n",
    "We are already there. So, we have applied one $U_{f(x)}$ unitary operator, but, in fact, the $f(x)$ function was evaluated 4 times for each term from the superposition state. This effect is called quantum parallelism, and this quantum computing \"tool\" has an important role in constructing quantum algorithms. Let's see how it works for a specific function. Suppose we have a function that for those $\\left| x \\right\\rangle$ bit strings that have even number of $1$s the function $f(x) = 0$ and when the number of $1$s is odd the function $f(x) = 1$ (parity function). To make things more interesting we will use 3 qubits for the input register. Here is the circuit:\n",
    "\n",
    "<img src=\"images/qparallel_example.png\" alt=\"drawing\" width=\"400\"/>\n",
    "\n",
    "where $i$ indices denote the input qubits and $o$ denotes the output qubit. Here the first 3 Hadamard gates are for preparing a 3 qubit superposition state with equal probabilities. The CNOT gates combined represent our given function $f(x)$ (unitary $U_{f(x)}$) that has an output $0$ if there are even number of $1$s in the input register and $1$ otherwise. Now let's go step by step and see how the quantum state changes and check if the given circuit implements the desired transformation. The initial $\\left| \\psi_{0} \\right\\rangle$ quantum state:\n",
    "\n",
    "$$\\left| \\psi_{0} \\right\\rangle = \\left| 0 \\right\\rangle_o \\left| 000 \\right\\rangle_i$$\n",
    "\n",
    "After 3 Hadamard gates we will have the $\\left| \\psi_{1} \\right\\rangle$ quantum state (omitting the qubit indices):\n",
    "\n",
    "\\begin{align*}\n",
    "\\left| \\psi_{1} \\right\\rangle = \\frac{1}{\\sqrt{2^3}}\\left| 0 \\right\\rangle &\\big[ \\left| 000 \\right\\rangle + \\left| 001 \\right\\rangle + \\left| 010 \\right\\rangle + \\left| 011 \\right\\rangle +\n",
    "\\\\\n",
    "&+ \\left| 100 \\right\\rangle + \\left| 101 \\right\\rangle + \\left| 110 \\right\\rangle + \\left| 111 \\right\\rangle \\big]\n",
    "\\end{align*}\n",
    "\n",
    "Or in a more compact form:\n",
    "\n",
    "$$\\left| \\psi_{1} \\right\\rangle = \\frac{1}{\\sqrt{2^3}}\\left| 0 \\right\\rangle \\sum_x \\left| x \\right\\rangle,$$\n",
    "\n",
    "where $x$ changes from $000$ to $111$. Here is the Hadamard gate and its actions on $\\left| 0 \\right\\rangle$ and $\\left| 1 \\right\\rangle$ states: \n",
    "\n",
    "\\begin{align*}\n",
    "&H \\left| 0 \\right\\rangle = \\frac{1}{\\sqrt{2}}\n",
    "\\begin{pmatrix}\n",
    "1 & 1 \\\\\n",
    "1 & -1\n",
    "\\end{pmatrix} \n",
    "\\begin{pmatrix}\n",
    "1 \\\\\n",
    "0 \n",
    "\\end{pmatrix} = \\frac{1}{\\sqrt{2}}\n",
    "\\begin{pmatrix}\n",
    "1 \\\\\n",
    "1\n",
    "\\end{pmatrix} = \n",
    "\\frac{1}{\\sqrt{2}} \\left( \\left| 0 \\right\\rangle + \\left| 1 \\right\\rangle \\right) \n",
    "\\\\\n",
    "&H \\left| 1 \\right\\rangle = \\frac{1}{\\sqrt{2}}\n",
    "\\begin{pmatrix}\n",
    "1 & 1 \\\\\n",
    "1 & -1\n",
    "\\end{pmatrix} \n",
    "\\begin{pmatrix}\n",
    "0 \\\\\n",
    "1 \n",
    "\\end{pmatrix} = \\frac{1}{\\sqrt{2}}\n",
    "\\begin{pmatrix}\n",
    "1 \\\\\n",
    "-1\n",
    "\\end{pmatrix} = \n",
    "\\frac{1}{\\sqrt{2}} \\left( \\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle \\right) \n",
    "\\end{align*}\n",
    "\n",
    "If one applies Hadamard gates on $n$ qubits in the $\\left| 0 \\right\\rangle$ initial state, it creates the $\\frac{1}{\\sqrt{2^n}}\\sum_x \\left| x \\right\\rangle$ superposition state with equal probabilities for each bit string. Here $x$ changes from $00...0$ to $11...1$.\n",
    "\n",
    "After CNOT gates that implements the $f(x)$ function the quantum state $\\left| \\psi_2 \\right\\rangle$ will become:\n",
    "\n",
    "$$\\left| \\psi_2 \\right\\rangle = \\frac{1}{\\sqrt{2^3}} \\sum_x \\left| f(x) \\right\\rangle  \\left| x \\right\\rangle$$\n",
    "\n",
    "Or in a more explicit form:\n",
    "\n",
    "\\begin{align*}\n",
    "\\left| \\psi_2 \\right\\rangle = \\frac{1}{\\sqrt{2^3}} \\big[ \\left| 0 \\right\\rangle \\left| 000 \\right\\rangle + \\left| 1 \\right\\rangle \\left| 001 \\right\\rangle + \\left| 1 \\right\\rangle \\left| 010 \\right\\rangle + \\left| 0 \\right\\rangle \\left| 011 \\right\\rangle +\n",
    "\\\\\n",
    "+ \\left| 1 \\right\\rangle \\left| 100 \\right\\rangle + \\left| 0 \\right\\rangle \\left| 101 \\right\\rangle + \\left| 0 \\right\\rangle \\left| 110 \\right\\rangle + \\left| 1 \\right\\rangle \\left| 111 \\right\\rangle \\big]\n",
    "\\end{align*}\n",
    "\n",
    "So, it is easy to check that the circuit implements the described $f(x)$ parity function. To check this calculation one should know the action of CNOT gate. For example, if CNOT is acting on an arbitrary two-qubit state $a \\left| 00 \\right\\rangle + b \\left| 01 \\right\\rangle + c \\left| 10 \\right\\rangle + d \\left| 11 \\right\\rangle$, where $a$, $b$, $c$ and $d$ are some arbitrary complex numbers that satisfy $\\left| a \\right|^2 + \\left| b \\right|^2 + \\left| c \\right|^2 + \\left| d \\right|^2 = 1$ (normalization). After applying CNOT gate controlled from the first qubit, we will obtain the following state $\\left| 00 \\right\\rangle + b \\left| 01 \\right\\rangle + c \\left| 11 \\right\\rangle + d \\left| 10 \\right\\rangle$, where we changed the second qubit state when the first qubit was in $\\left|1\\right\\rangle$ state.\n",
    "\n",
    "Also, it is interesting to note that the state $\\left| \\psi_2 \\right\\rangle = \\frac{1}{\\sqrt{2^3}} \\sum_x \\left| f(x) \\right\\rangle  \\left| x \\right\\rangle$ is an example of the quantum entanglement. The state of the input register $\\left| x \\right\\rangle$ has a correlation with the output register's $\\left| f(x) \\right\\rangle$ state and we cannot describe two register (one for $\\left| x \\right\\rangle$ and the other for $\\left| f(x) \\right\\rangle$) with seperate quantum states for general $f(x)$ function. Here we should note that for specific $f(x)$ functions (e.g. $f(x) = 0$) they will not be entangled and we will be able to describe the quantum states of the registers separately, but our parity function is not one of that specific cases (we have entanglement). In our case, if we will measure $\\left| x \\right\\rangle$ in the first register, then we will know with certanty that in the output register the state is the corresponding $\\left| f(x) \\right\\rangle$, because of the correlations between two registers originated from the quantum entanglement. As was mentioned at the beginning like quantum parallelism the quantum entanglement is another example of the QC \"tools\" that is absent in the arsenal of classical computation.\n",
    "\n",
    "Now let's write a code for this circuit:\n",
    "\n",
    "  [1]: https://www.cambridge.org/am/academic/subjects/physics/quantum-physics-quantum-information-and-quantum-computation/quantum-computation-and-quantum-information-10th-anniversary-edition?format=HB\n",
    "  [2]: https://quantumcomputing.stackexchange.com/questions/9566/implementing-four-oracles-for-the-deutsch-algorithm-preferably-on-ibm-q-experie\n",
    "  [3]: https://www.youtube.com/watch?v=awpnsGl08bc&list=LLEPoMdv-DZViRaaObznY_-A&index=113&t=0s\n",
    "  [4]: https://courses.edx.org/courses/course-v1:MITx+8.370.2x+1T2018/course/\n",
    "  [5]: https://github.com/DavitKhach/quantum-algorithms-tutorials\n",
    "  [6]: https://nbviewer.jupyter.org/github/DavitKhach/quantum-algorithms-tutorials/blob/master/quantum_parallelism_Deutsch_Jozsa.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 636.615x385.28 with 1 Axes>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import *\n",
    "%matplotlib inline\n",
    "\n",
    "# Initialization of quantum and classical registers \n",
    "# and the quantum circuit acting on those registers\n",
    "input_register = QuantumRegister(3, \"i\")\n",
    "output_register = QuantumRegister(1, \"o\")\n",
    "classical_input_register = ClassicalRegister(3, \"c_i\")\n",
    "classical_output_register = ClassicalRegister(1, \"c_o\")\n",
    "parallelism_circuit = QuantumCircuit(input_register, output_register,\n",
    "                                     classical_input_register, classical_output_register)\n",
    "\n",
    "# Hadamard gates acting on qubits in the input register\n",
    "parallelism_circuit.h(input_register[0])\n",
    "parallelism_circuit.h(input_register[1])\n",
    "parallelism_circuit.h(input_register[2])\n",
    "\n",
    "# CNOTs controlled by qubits from the input register \n",
    "# and applied on the qubit from the output register\n",
    "parallelism_circuit.cx(input_register[0], output_register[0])\n",
    "parallelism_circuit.cx(input_register[1], output_register[0])\n",
    "parallelism_circuit.cx(input_register[2], output_register[0])\n",
    "\n",
    "# Just for a nice drawing of the circuit add a barrier\n",
    "parallelism_circuit.barrier()\n",
    "\n",
    "# Measurements on the qubits from the output register \n",
    "# and input register. The results are stored in the \n",
    "# classical bits from the classical register\n",
    "parallelism_circuit.measure(output_register[0], classical_output_register[0])\n",
    "parallelism_circuit.measure(input_register[0], classical_input_register[0])\n",
    "parallelism_circuit.measure(input_register[1], classical_input_register[1])\n",
    "parallelism_circuit.measure(input_register[2], classical_input_register[2])\n",
    "\n",
    "# Draw the circuit \n",
    "parallelism_circuit.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will run this circuit on a quantum computer simulator and plot the results in the histogram."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAc0AAAFPCAYAAAAvPZXOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAAwf0lEQVR4nO3dfZxVZb338c8PRlAC4kF5RgEFlGfGMaQQfKbQNK076/hYpvmQ3tgrj3VrnWOZaVpZeTwalaKWmJaaKWUdAsQ44ICigIIKKM8IYkjCIDO/+49rzbgZ9gxrM3vvtdfM9/16zYu911qz57vX3uzfXte6rmuZuyMiIiL71irpACIiImmhoikiIhKTiqaIiEhMKpoiIiIxqWiKiIjEpKIpIiISU1nSAZJ08MEHe79+/ZKOISIiJWTBggWb3f2QbOtadNHs168flZWVSccQEZESYmZvNrROzbMiIiIxqWiKiIjEpKIpIiISk4qmiIhITCqaIiIiMaloioiIxKSiKSIiEpOKpoiISEwqmiIiIjGpaIqIiMSkoikiIhKTiqaIiEhMKpoiIiIxqWiKiIjEpKIpIiISk4qmiIhITCqaIiIiMaloioiIxKSiKSIiEpOKpoiISEwqmiIiIjGpaIqIiMSkoimSgD//+c8MHjyYI444gltuuWWv9bNnz6a8vJyysjIeffTRuuVvvvkm5eXljBo1iqFDh3L33XcD8P7773Paaadx5JFHMnToUL75zW8W7bmItCQqmiJFVl1dzZVXXsn06dNZunQpDz30EEuXLt1jm0MPPZT77ruPf/u3f9tjec+ePZk7dy4vvvgi8+bN45ZbbmHdunUAfOMb3+DVV1/lhRde4LnnnmP69OlFe04iLUVZ0gFEWpr58+dzxBFHMGDAAAC+8IUv8MQTTzBkyJC6bfr16wdAq1Z7fq9t06ZN3e2qqipqamoAaNeuHSeccELdNuXl5axZs6aQT0OkRdKRpkiRrV27lr59+9bd79OnD2vXro39+6tXr2bEiBH07duX6667jl69eu2x/t133+XJJ5/kpJNOyltmEQlUNEVSpm/fvrz00ku8/vrrTJ06lY0bN9at2717N1/84he5+uqr645kRSR/VDRFiqx3796sXr267v6aNWvo3bt3zo/Tq1cvhg0bxrPPPlu37NJLL2XgwIFMnjw5H1FFpB4VzRZsf3twvvjii4wdO5ahQ4cyYsQIHn744bp1M2bMoLy8nGHDhnHhhReye/fuojyXNDnmmGN47bXXWLlyJbt27WLatGmcccYZsX53zZo17NixA4CtW7cyZ84cBg8eDMANN9zAP//5T+64445CRRcRd2+xP0cffbS3VLt37/YBAwb4G2+84VVVVT5ixAhfsmTJHtusXLnSFy1a5Oeff74/8sgjdcuXLVvmy5cvd3f3tWvXeo8ePXzr1q1eXV3tffr08WXLlrm7+7e//W3/5S9/WbwnlSJPPfWUDxw40AcMGOA33XSTu4f99cQTT7i7+/z58713797erl0779Kliw8ZMsTd3Z955hkfPny4jxgxwocPH+733HOPu7uvXr3aAT/yyCN95MiRPnLkSJ8yZUoyT04k5YBKb6BuJF64kvxpyUXzH//4h5966ql192+++Wa/+eabs2574YUX7lE06xsxYoQvX77cN23a5AMGDKhbPnv2bP/Upz6Vv9AieTB9+nQfNGiQH3744f6DH/xgr/WzZs3y0aNHe+vWrfd437/wwgt+7LHH+pAhQ3z48OE+bdq0unXjxo2r+7LSs2dPP/PMM4vxVKRAGiuaap5toZrag7PW/Pnz2bVrF4cffjgHH3wwu3fvprKyEoBHH310j3N3+VaI5uXjjjuOUaNGMWrUKHr16sVnPvOZguWX4mvKGNl27dpx//33s2TJEv785z8zefJk3n33XQCeffZZXnzxxbr31tlnn12spyRFpnGast/Wr1/P+eefz9SpU+vGE06bNo1rrrmGqqoqTj31VFq3bl2Qv1374ffXv/6VPn36cMwxx3DGGWfsMdax9sPv9ttv3+N3az/8Bg4cyLp16zj66KOZOHEinTp12qNTzWc/+1nOPPPMguSXZDRljOygQYPqbvfq1Ytu3brx9ttv06lTp7rl27ZtY8aMGdx7772FexKSKBXNFqqpPTi3bdvGaaedxve//32OPfbYuuVjx46tKzzPPPMMy5cvz1/oDPrwk/2RrYVl3rx5OT9OZgtLpscff5yTTjqJjh07NjmrlCY1z7ZQTenBuWvXLs466ywuuOACPve5z+2xbtOmTUCYrebWW2/lsssuy3t2KEzzciZ9+ElDaltY7r333r2+kD300EN88YtfLNjfLsQpiYsuuoj+/fvXnZZ48cUXC5a/OVDRbKHKysq48847mThxIkcddRSf//znGTp0KN/5znf44x//CMDzzz9Pnz59eOSRR/jqV7/K0KFDAfjd737H7Nmzue+++/b6j3bbbbdx1FFHMWLECD796U9z4oknJvUU9ynJDz9JRqFaWAA2b97M/PnzOe200/KWN1OhzsdC+H9be0521KhRBcnfXKh5tgWbNGkSkyZN2mPZd7/73brbxxxzTNb5S8877zzOO++8rI952223cdttt+U3aBbF+PB77LHH8pZXSkNmC0vv3r2ZNm0av/3tb2P9bmMtLBA6vp1++ukceOCB+Y4NFP6UhMSjI01JpUI1L0PhP/wkOYVqYYHQCa6QrROFPCVx/fXXM2LEiLpOfNKIhsaitISfljxOsznY3wkCHnjgAS8rK6sbVzdy5Eh/4YUX6h53woQJPn369KI/H5HGPPLII37xxRfX3b///vv9yiuvzLptQ2Or161b54MGDfK5c+fusaympsZ37tzpF1xwgd944435D58yNDJOU82zklqFaF4GmDlzZt4yiuRLoU5J9OzZE4C2bdvypS99aa8hWrInNc+KiKRAoU5JrF+/Hgitjo8//jjDhg3Le/bmREWziQrRBfzOO+/kiCOOwMzYvHlzUZ6HiJS2Qp2PPffccxk+fDjDhw9n8+bN3HDDDUk9xVSw0HzbMlVUVHjtlG/7o7q6mkGDBu0xK81DDz20R2+2VatWsW3bNm6//XbOOOOMum95y5cvx8z2mJXmlVdeoVOnTrzwwgt07tyZ448/nsrKSg4++OAmP1cREYnHzBa4e0W2dTqn2QSF6gI+evTowoeXxF1yR2Eff8rkwj6+SEuk5tkmKPSsNCKlqhCnJVauXMmYMWM44ogjOOecc9i1a1dRnotILlQ0E9bYrDQipahQM9Ncd911XHPNNbz++ut07tyZX/3qV8V6SlIk+/tlC+CTn/wknTp14vTTT99jebEvfK9P6SYo5Kw0IqUq87REmzZt6k5LZOrXrx8jRozIelpi4MCBwJ6nJdydGTNm1J3zv/DCC3n88ceL8nykOJryZQvg2muv5YEHHthjWU1NDRdeeCHTpk1j8eLFHHbYYUydOrWgz0NFswkKOSuNSKkqxGmJLVu20KlTJ8rKypr0mFK6mvJlC+Ckk06iQ4cOeyzbsmULbdq0qesjcsopp/D73/++cE8CdQRqkswu4NXV1Xz5y1+u6wJeUVHBGWecwfPPP89ZZ53F1q1befLJJ/mP//gPlixZUtcFfMuWLdx3330Add3Bf/azn/HDH/6QDRs2MGLECCZNmsQvf/nLgjwHdUaRJGS7Fqs0b/m6LFumzAvfV1RUFPzC96Ci2WSFmJXm6quv5uqrr85vUJE8KcRpia5du/Luu++ye/duysrKcn5MaZnMrGgXvq+lr3gikpNCnJYwM0444YS6zh9Tp07lzDPPLEh+SUZTv2w1pPbC9/Pnz2f8+PF7DOcrBB1pikhOCnVa4tZbb+ULX/gCN9xwA6NHj+biiy8u2HMo5GkJnZLIrimXZWvMpk2b6NatW92F76+//vo8pG2YZgRqwoxAzUHaz2mm+cMv7fs+zdL8vkmzp59+msmTJ9d92br++usb/LJ14IEH0qNHD5YsWQLAcccdx6uvvsr27dvp2rUrv/rVr5g4cSLXXnstf/rTn6ipqeHyyy9n8uTJTc6pGYFERCRx+9sHBODZZ5/NurxYF76vpaIpIpIiaqFIljoCiYiIxKSiKSIiEpOKpoiISEwqmiIiIjEVvWia2RVmttLMdprZAjM7rpFte5rZb83sVTOrNrP7smxziZk9a2ZbzexdM/u7mY0r6JMQEZEWqahF08zOAX4K3AyMBv4BTDezQxv4lbbAZuAWoKFJCo8HHgZOBMYAy4C/mNnA/CUXEREp/pCTrwP3ufuU6P5VZvZJ4HLgW/U3dvdVwNUAZpb1UiDufm7mfTO7HPgM8EngtXwFb4y6gIuItAxFO9I0szbA0cAz9VY9A3w8j3+qDXAgsDWPjykiIlLUI82DgdbAxnrLNwIn5/Hv3ARsB/6YbaWZXQpcCuEiuDNnzgRgwIABdOjQgUWLFgHhqgtDhw5l9uzZQJhvc9y4cSxcuJBt27YBUFFRwcaNG4HD8xh/b1VVVcydOxeAgw46iDFjxjBv3jx27NgBhAmLV65cyYYNGwAYMmQI1dXVLFu2DAgTJWdehqd9+/ZUVFREjzm2oNnfeustVqxYAYRr5XXp0oWFCxcC0LlzZ0aOHMmsWbNwd8yMCRMmsGjRIrZuDd95ysvLeeedd1i1ahWw9+sUWucLo7Kyku3btwMwZswY1qxZU3eNx8GDB9O6deu6i+j26NGD/v375/Q6FTI7wMyZM+nYsSPl5eXMmTOn7or248ePZ8mSJWzZsgWAkSNH8t577xX0dcrl/1PtpN4DBw6kbdu2LF68GIBu3boxaNAg5syZA0Dbtm0ZO3bsfr1O4cxPYcycOZNx48axfPlyNm3aBMCwYcOoqqritddC41ffvn3p3r07tdN45vI6QUNns/KjpqamZF6nQn3uVVVVATT4OjWmaHPPmlkvYC0wwd1nZyz/DnCuuw/ex+//Cdjs7hc1ss3/Bb4HnOzu8/eVKV9zz6a5eTbN2SHdc4imed+nOTvofdMYnQ4qnblnNwPVQPd6y7sDG/bePDdmNplQMD8Vp2CKiEhxNYeCX7Rzmu6+C1gAnFJv1SmEXrT7zcy+TiiYp7n7nKY8loiISEOK3Xv2x8ADZjYfeA64DOgF3A1gZvcDuPsFtb9gZqOimx2Bmuj+LndfGq2/Fvg+cB6w3Mx6RNvvcPd/FvoJiYhIy1HUounuD5tZV+AGoCewGJjk7m9Gm2Q7w/1CvfufBt4E+kX3rwQOIIzVzDQVuKjpqUVERIKiXxrM3e8C7mpg3fFZltk+Hq9fXoKJiIjsg+aeFRERiUlFU0REJCYVTRERkZhUNEVERGJS0RQREYlJRVNERCQmFU0REZGYVDRFRERiUtEUERGJSUVTREQkJhVNERGRmFQ0RUREYlLRFBERiUlFU0REJCYVTRERkZhUNEVERGJS0RQREYlJRVNERCQmFU0REZGYVDRFRERiUtEUERGJSUVTREQkJhVNERGRmFQ0RUREYsqpaJpZKzNrlXG/h5l9xcw+kf9oIiIipSXXI82ngKsAzKw9UAncBsw0swvynE1ERKSk5Fo0K4AZ0e2zgW1AN+AS4Bt5zCUiIlJyci2a7YF3o9unAo+5+weEQnp4HnOJiIiUnFyL5lvAJ8zsI8BE4K/R8i7A+/kMJiIiUmrKctz+x8ADwHbgTWB2tHw88HIec4mIiJScnIqmu99jZguAvsBf3b0mWvUG8O18hxMRESkluR5p4u6VhF6zmcueylsiERGREpXz5AZmdoWZLTGz981sQLTsOjP7fP7jiYiIlI5cJzeYDNwA/AKwjFXrgK/lL5aIiEjpyfVI8zLgEnf/KbA7Y/lCYGjeUomIiJSgXIvmYcDiLMs/AA5qehwREZHSlWvRXAGUZ1k+CVja9DgiIiKlK9fes7cDd5pZO8I5zbFmdj7w78CX8x1ORESklOQ6TvNeMysDbgbaESY6WAdc7e4PFyCfiIhIydifcZpTgClmdjDQyt035T+WiIhI6cm5aNZy9835DCIiIlLq9lk0zewlYIK7bzWzlwFvaFt3H5HPcCIiIqUkzpHm74GqjNsNFk0REZHmbJ9F091vzLj9nwVNIyIiUsJynUZvhpl1yrK8o5nNyFsqERGREpTr5AbHA22yLD8QOK7JaUREREpYrN6zZpY5C9AIM3sn435rYCKwNp/BRERESk3cISeVhA5ADjyTZf0O4Kp8hRIRESlFcYtmf8K0eSuAjwFvZ6zbBWxy9+o8ZxMRESkpsYqmu78Z3cz5otUiIiLNRZzJDc4GnnT3D6LbDXL3P+QtmYiISImJc6T5KNAD2BTdbogTOgWJiIg0S3EmN2iV7baIiEhLoyIoIiISU9xzmrHonKaIiDRncc9pxqFzmiIi0qzldE5TRESkJVNBFBERiWmfRdPMzjazAzJuN/gT5w+a2RVmttLMdprZAjNrdKJ3M5sQbbfTzFaY2WX11rc2s+9lPOZKM7vJzOLOdiQiIhJLUcdpmtk5wE+BK4A50b/TzWyIu7+VZfv+wNPAr4HzgHHAXWb2trv/PtrsOuBK4ELgZWAEMJVw4ezvxXh+IiIisRR7nObXgfvcfUp0/yoz+yRwOfCtLNtfBqxz99rJ4F8xszHAN4DaovlxwoxFT0b3V5nZH4ExTcwqIiKyh6Kd0zSzNsDR7H2VlGcIhS+bsVm2/wtQUdtkTDhiPcHMjoz+zhDgRMIRqoiISN7kfN4vurbmZGBItOgV4CfuvnAfv3owofl2Y73lG4GTG/idHsDfsmxfFj3eeuBWoAOw1Myqo3Xfd/e7Gsh/KXApQK9evZg5cyYAAwYMoEOHDixatAiArl27MnToUGbPng1AWVkZ48aNY+HChWzbtg2AiooKNm7cCBy+j6feNFVVVcydOxeAgw46iDFjxjBv3jx27NgBwNixY1m5ciUbNmwAYMiQIVRXV7Ns2TIAevfuTZ8+fZg3bx4A7du3p6KiInrMsQXN/tZbb7FixQoA+vXrR5cuXVi4MLxVOnfuzMiRI5k1axbujpkxYcIEFi1axNatWwEoLy/nnXfeYdWqVcDer1O4LnphVFZWsn37dgDGjBnDmjVrWLs2XDZ28ODBtG7dmqVLlwLQo0cP+vfvn9PrVMjsADNnzqRjx46Ul5czZ84cdu/eDcD48eNZsmQJW7ZsAWDkyJG89957Ob1OMKHg2QcOHEjbtm1ZvHgxAN26dWPQoEHMmTMHgLZt2zJ27Nj9ep2gbUGzjxs3juXLl7Np0yYAhg0bRlVVFa+99hoAffv2pXv37lRWVgLk9DrBoQXLDlBTUxPrc2/16tUAOb1OUFHQ7OvXr4/1uVdVVQXQ4OvUGHP32IHM7FzgfmAGMDdafCzhyO4id3+wkd/tRbhQ9QR3n52x/DvAue4+OMvvLAcedPfvZiwbD8wCern7ejP7AnAbcC2wBBhFOG96rbv/qrHnU1FR4bVv2qa45I4mP0Sjpkwu3GOnOTsUNn+as4PeN43R+6Zhet+AmS1w96wVPtcjze8D33b3m+v9gW8BNwENFk1gM1ANdK+3vDuwYe/NIVqebfvd0eNBKJi3u/u06P7LZnYY4Rxpo0VTREQkF7me0zwE+F2W5Y8A3Rr7RXffBSwATqm36hTgHw382twGtq909w+i++0IxThTNRqDKiIieZZrYfk72U/EHE9oMt2XHwMXmdlXzOwoM/sp0Au4G8DM7jez+zO2vxvobWZ3RNt/BbgIuD1jmyeBb5rZaWbWz8zOIvTSfSy3pyYiItK4XCdsnw78wMwqgP+Nlh0LnA38574ey90fNrOuwA1AT2AxMMnd34w2ObTe9ivNbBLwE8KwlHXA1RljNAGuIozHvItwtLsemAJ8FxERkTza3wnb63qgZvg5oXA1KurVmnU7dz8+y7JZQHkjj/ceoTfv5H39bRERkabQhO0iIiIxqSCKiIjEtD+TG3QGPkU4/9gmc13meEoREZHmJqeiaWbHAk8RJkM/hDBZQc/o/irU+UZERJqxXJtnbwN+A/QGdhJmAjoUqCRMZyciItJs5Vo0RwB3eph7rxpo6+4bCZfn+s88ZxMRESkpuRbNXRm3NwKHRbe3EyYpEBERabZy7Qi0EDgGWA7MBG4ys+6EC0S/lN9oIiIipSXXI83rCbPyQJjV523CpAad2XuyAxERkWYlpyNNd6/MuP02YeiJiIhIi5DzOE0AMzscOCq6u9TdV+QvkoiISGnKdZxmV8I1Ks8Aaj5cbH8CvuzuW/KcT0REpGTkek7zl8ARwHHAgdHPeKA/4coiIiIizVauzbMTgZPcfW7GsufM7KvA3/IXS0REpPTkeqT5NvCvLMvfB9Q0KyIizVquRfO7wB1m1rt2QXT7R2jeWRERaeb22TxrZi8DnrGoP7DKzNZG92vnoe1GOOcpIiLSLMU5p/lowVOIiIikwD6LprvfWIwgIiIipW5/Jzc4ERhCaLZd4u4z8xlKRESkFOU6uUFv4DHgaD6cg7aXmVUCZ7n7ugZ/WUREJOVy7T37M8J1NI9w977u3hcYGC37Wb7DiYiIlJJcm2dPAY5395W1C9x9hZldDfxPXpOJiIiUmFyPNGHP4SeNLRMREWlWci2a/wP83Mz61i4ws0OBO9CRpoiINHO5Fs2rgY8AK8zsTTN7E3gjWnZ1vsOJiIiUklzPaW4BPgYcDxwZLXvF3TVZu4iINHuxi6aZtQb+CYx0978Cfy1YKhERkRIUu3nW3auBN4E2hYsjIiJSunI9p/k94BYzO7gQYUREREpZruc0v0G4yslaM1tDvWtruvuIfAUTEREpNbkWzUcJYzKtAFlERERKWqyiaWbtgNuAzwAHEMZkXuXumwsXTUREpLTEPad5I3AR8BTwEHAy8N8FyiQiIlKS4jbPng1c7O7TAMzsN8BzZtY66lUrIiLS7MU90uwLPFt7x93nA7uBXoUIJSIiUoriFs3WwK56y3aznxexFhERSaO4Rc+AB82sKmPZgcAUM3u/doG7n5HPcCIiIqUkbtGcmmXZg/kMIiIiUupiFU13/1Khg4iIiJS6/bkItYiISIukoikiIhKTiqaIiEhMKpoiIiIxqWiKiIjEpKIpIiISk4qmiIhITCqaIiIiMaloioiIxKSiKSIiEpOKpoiISEwqmiIiIjGpaIqIiMSkoikiIhKTiqaIiEhMKpoiIiIxqWiKiIjEpKIpIiISU9GLppldYWYrzWynmS0ws+P2sf2EaLudZrbCzC5rZNtvmZmb2Z35Ty4iIi1dUYummZ0D/BS4GRgN/AOYbmaHNrB9f+DpaLvRwA+An5vZZ7NseyxwKfBSYdKLiEhLV+wjza8D97n7FHd/xd2vAtYDlzew/WXAOne/Ktp+CjAV+EbmRmb2UeA3wJeBrYWLLyIiLVnRiqaZtQGOBp6pt+oZ4OMN/NrYLNv/BagwswMylv0CeNTd/56PrCIiItmUFfFvHQy0BjbWW74ROLmB3+kB/C3L9mXR4603s0uAI4Dz4oQws0sJzbj06tWLmTNnAjBgwAA6dOjAokWLAOjatStDhw5l9uzZAJSVlTFu3DgWLlzItm3bAKioqGDjxo3A4XH+9H6rqqpi7ty5ABx00EGMGTOGefPmsWPHDgDGjh3LypUr2bBhAwBDhgyhurqaZcuWAdC7d2/69OnDvHnzAGjfvj0VFRXRY44taPa33nqLFStWANCvXz+6dOnCwoULAejcuTMjR45k1qxZuDtmxoQJE1i0aBFbt4YGg/Lyct555x1WrVoF7P06wfEFy15ZWcn27dsBGDNmDGvWrGHt2rUADB48mNatW7N06VIAevToQf/+/XN6nQqZHWDmzJl07NiR8vJy5syZw+7duwEYP348S5YsYcuWLQCMHDmS9957L6fXCSYUPPvAgQNp27YtixcvBqBbt24MGjSIOXPmANC2bVvGjh27X68TtC1o9nHjxrF8+XI2bdoEwLBhw6iqquK1114DoG/fvnTv3p3KykqAnF4nyHo2K29qampife6tXr0aIKfXCSoKmn39+vWxPveqqqoAGnydGmPuXsCnkPGHzHoBa4EJ7j47Y/l3gHPdfXCW31kOPOju381YNh6YBfQCOgJzgHHuvixaPxNY7O5f21emiooKr33TNsUldzT5IRo1ZXLhHjvN2aGw+dOcHfS+aYzeNw3T+wbMbIG7Z63wxTynuRmoBrrXW94d2LD35hAtz7b97ujxxhKOOJeY2W4z2034CnxFdL9wXydFRKTFKVrRdPddwALglHqrTiH0js1mbgPbV7r7B8DjwHBgVMZPJTAtur2rqblFRERqFfOcJsCPgQfMbD7wHKF3bC/gbgAzux/A3S+Itr8b+JqZ3QHcA3wCuAj4YrTdu8C7mX/AzP4FvOPuiwv6TEREpMUpatF094fNrCtwA9ATWAxMcvc3o00Orbf9SjObBPyEMCxlHXC1u/++iLFFRESA4h9p4u53AXc1sO74LMtmAeU5PP5ejyEiIpIPmntWREQkJhVNERGRmFQ0RUREYlLRFBERiUlFU0REJCYVTRERkZhUNEVERGJS0RQREYlJRVNERCQmFU0REZGYVDRFRERiUtEUERGJSUVTREQkJhVNERGRmFQ0RUREYlLRFBERiUlFU0REJCYVTRERkZhUNEVERGJS0RQREYlJRVNERCQmFU0REZGYVDRFRERiUtEUERGJSUVTREQkJhVNERGRmFQ0RUREYlLRFBERiUlFU0REJCYVTRERkZhUNEVERGJS0RQREYlJRVNERCQmFU0REZGYVDRFRERiUtEUERGJSUVTREQkJhVNERGRmFQ0RUREYlLRFBERiUlFU0REJCYVTRERkZhUNEVERGJS0RQREYlJRVNERCQmFU0REZGYVDRFRERiUtEUERGJSUVTREQkJhVNERGRmFQ0RUREYlLRFBERiUlFU0REJCYVTRERkZhUNEVERGJS0RQREYlJRVNERCSmohdNM7vCzFaa2U4zW2Bmx+1j+wnRdjvNbIWZXdbUxxQREdkfRS2aZnYO8FPgZmA08A9gupkd2sD2/YGno+1GAz8Afm5mn93fxxQREdlfxT7S/Dpwn7tPcfdX3P0qYD1weQPbXwasc/erou2nAFOBbzThMUVERPZL0YqmmbUBjgaeqbfqGeDjDfza2Czb/wWoMLMD9vMxRURE9ou5e3H+kFkvYC0wwd1nZyz/DnCuuw/O8jvLgQfd/bsZy8YDs4BegO3HY14KXBrdHQwsy8PTy9XBwOYE/m4+KHty0pw/zdkh3fmVPXeHufsh2VaUFTtJ0tz9F8AvksxgZpXuXpFkhv2l7MlJc/40Z4d051f2/Cpm0dwMVAPd6y3vDmxo4Hc2NLD97ujxbD8eU0REZL8U7Zymu+8CFgCn1Ft1CqHHazZzG9i+0t0/2M/HFBER2S/Fbp79MfCAmc0HniP0ju0F3A1gZvcDuPsF0fZ3A18zszuAe4BPABcBX4z7mCUq0ebhJlL25KQ5f5qzQ7rzK3seFa0jUN0fNLsC+HegJ7AYuKa2E4+ZzQRw9+Mztp8A/AQYCqwDbnX3u+M+poiISL4UvWiKiIikleaeFRERiUlFU0REJCYVzYSYmSWdQUREctPiJjcoBWbWyt1rzKwLUOXu/0o6k5Q+M+sAtAcGAcvcXWORiyDt+z3t+SEcZHiJdMBRR6AiM7NRwFXAycBK4HVgKTATeDEqpiXzBslkZm2isbGpk+bsAGb2aeCbhF7kbxK+8L4B/BZ4zN2rEozXqDTv+zTvd0h3fjM7DNjo7jszlhlAkp+PKppFZGadgOeBVcATwJGE+W+7Au8Av3X3XyeVrzFm1p5w+bW/AJXA2+5ek2W7ru6+pdj5GpPm7ABm1hl4DbgfeAroARwKHAscDiwCrnP3NYmFbECa932a9zukO390dPwUYYKbecCLwMrMYhkV0MPd/fWihnN3/RTph/CNbx7QLmNZK+BE4AHClIA/AVolnTVL9q8DNcBOYAVwO+EqNB/N2OaQ6Hn0Sjpvc8mekf/5+u8LoD9wCbCccGWfjklnbU77Ps37Pe35ga9F75tFwKvAH4H/R5jtrUe0TSfCBTeOKmY2dQQqrsOA1939fQvauHuNu89w9/MJsx2dTvg2WGrGAT8CRgL3AmcCc4AZZnatmR0FXACc6e7rkouZVZqzQ/hi9U/goMyF7r7SwzVm/w0YQLgIe6lJ875P836HdOcfA/ycUCT/H7ADuJDwpetH0YQ23wG6uPsrxQymollcTwKnmtmpHuwys9Zm1jZa/xSwCxifXMS9mdlHCOdet7r7Mnf/nrsPJLyxnweuIxxB3wb8V3JJ95bm7Bn+CpQDN5hZjyzrFwDvRtuUjGaw71O53zOkMr+ZHUCYO3yzu29y9z+4+znA8cAUQsvE1cBkkpguNenD8Jb0A3wUeIzQVPUjoG/GutaE8ww7gf5JZ62XuxUwBBgZ3S+rt94Ic/7WAH2SzttA9lFpy14v5xXARuB/CEcIhwGdgY8AxxG+iQ9IOmdz2/dp3O/18l+ZxvxAR6B7dPsAov43Ges/Hb1v+hY7m4acFEnUI/afwFlm9n8JPWgnm9li4G+E9vlPAE+6+8rkku7NQ8eNpRn3d8OePdnMrCew1kusU0Fm9syxsWnInsnd7zKzFwhNVb8G3iccrXUHugD3uPuKBCPupTns+zTud/hwiIa7/5eZvUzoT5Ga/O6+DdgW3f4A6t43rdy9GvgYoVPZ6mJnU+/ZIqs3RvMU4CRCc9UW4DfA0+6+PsmM9ZlZK6j7EGxo/c2EMWD3FjNbHGZ2IPBB9J+tdlkZoeOVUdrZMz8oapf1ILx3TiA0f/4v8L/u/n4yKRuW1n2f9v0OYGbdCE3jtUWnO3AaMIHQgaYk85tZa8J3qqyfN9E25wO73P3h4iWL/raKZuFFXb8vAo4gNDusJYyRmpexTVntEVwpa2gMqZn1AjY09kYvNjM7lND8N5DQ3X4N8IC7P11vu+40MBSilETFpqbUc0Lz2vdp2u8AZjaC0Cw7mHDKZyXhC/kDtQWyVMeC1xd9IfdSyqqiWQRmNgPoDWwA3iY0jfQjjKGaQiigO2uPQhMLmoWZnU1oYnur1L6R7ouZzSOcK14OrAdGEJrANwE/A37h7tuTS9g4M7uG0OX+ZXd/O2O5EQapV5fa+6VWmvd9mvc7gJm9RPiceZ6w7z9OOEJuS/i8+YG7byzRz5s7CB2UnnX3VRnLjVCvks9b7JOoLe2H0J1+BVHnHqADMJxw5DkNeJnQ3T7xrFmyf55wsn0+8ENgItAXOCBjm3bAtcAhSeetl/38aL93je63JXxZqb0+60vAFUnnjLHv5wFTCUdtxwDtM7b5CHAHpTe+MbX7Ps37Pcp2LqHpuG10vxWhI03/6P/pIkLRTDxrluz/J9r3c4HpwK2EDj9dM7ZpDzxKgp0ldaRZYGZ2D6HX4MVZ1h0M3EIYmznKS2xOSDP7HXAg4Yj4s4SZi14gDI15lnBe5ETgLnc/JKmc2ZhZbe/kz2dZ157QMeJrwLHu/mqx8+2LmT1A+ICYx4dfVjYCCwkfKpXAKODX7t4+oZhZpXnfp3m/A5jZjcBYdz81y7oy4FLCZ85Ed59b7HyNMbNfE05fPU1olTiScGS/lnD0+XfCGPYH3T25TqxJf7to7j+EAblbgOMbWF9biL6QdNZ6udoCDwPfylg2Hngwej5vE77xLQOmJZ03S/5PEXoKfq6R5/cc8JWks2bJ1oYw9dlNGcuOJnzzriQ0eT5N+DB5MOm8zWXfp32/R3k/RhhG8lUamFmMMPxkctJZ62U6gNB0/JOMZUcSxmM+SvgSM5PQo/a+RLMmvbOa+w9hKMkTwAzgLMIYKctY35kwwPhjSWetl/tA4JOEb6RkZo7unxO9iWuA0UnnzZK/LWHgcyVhEPRQoEPG+p6E2VKOTTprluytCUcz4xrY9xMJE27XAOVJ520u+z7a76PTut8zcv5nVOB/HH2B6ZOxbmD0eTM26ZxZcvfiwzG99ff9sYRJMBLf92qeLaCM4SVHE84JngAsJswM9BLhDXwMcKi7l+JUVpjZgR5dZSDqCm7+4TjN84Db3L1nkhkbYmb9gBsIBf5dwjybbwB9gKOAA919bFL59iWzo0bUi9A8GgJhZhcRzk2V1L7PeM8fQRjb+H8IBfIvpGTfm1lbj67+keU9fxEluN8zRcPZriS87w8AlhDe/50IzZvvuvvJSeWLq/6wHzO7mNAKkOi+V9EsIjMbDnyFcMR5AOFcyQLgp+7+UpLZchVNdfUHQq/aK5PO0xgz60qYoPpMQhPcdkJzz397iU0kAfseDhDt+4cJl026vHjJchd9gF8MnE0K9n1jSn2/13/fmNlHgc8RLkP4EcJR2nOE5s23sz9KMmK858sIw2a2uvtlxUuWJYuKZmFEg7pHARVAN+Ap33NcZj9gt5fgTCj1sncm9GR7IeMbXyvCwPSjgFVegkMHMoYH1PieA9QPAba7+47EwsWwry72ZtaRMLh7Z7b1SYg+pMcSmgTbEjpuzHT3jdH6nsA/vQSHLmVk/yThffN3QuefVe7uGUfQHQiTNZTMfs8UvW8OIAyLyXzfd/Qwy07JijOsxMwO8GiyhqSoaBaImf2UMNzkTcK5kiGEMVO/ITRpbk4wXqPqZW9FOCe1ntAF/3Z335pgvEaZ2SeAxR6mLKxdVkZ4DXY19m22FDSQv3TGqDUi6nk6kTCM6kDC+cEPCKcjbnT31xKM16gGslcBjxOaBN9ILt2+mdnpwDzfc1xpKt73DWRvdBayRCV5QrW5/hCaQzYRept2I0xsUE44Qb+CMITj5KRz5pj9PwjnpF4DTko6ZwPZxxKavKcB/07oPHBAvW0OAo5LOmsT8h9Yivmj981GwiQG7QlHa12ALxNOQWwDLk46ZxOyfznpnI3kH8eHTa93EabKa1tvm3ZEnfpK6SeN2XWkWQBmdjdhsP9n6y1vRehGfSNheqtTvPSuVp/m7L8ATiU0q/UhHCm8RjiHNtvdXzGz0YRene29xJpo05zfzH4CDHT306P7rf3D5vyPEr50nQac4CV23cw0Zwcws/8iXLHk74QWrUOAdwiX13rS3edF75sFhF7M/0osbD1pzK6iWQBmdilhJpHjsr3IZjaU0HX9Bnd/stj5GpPy7H8hTLrwI8LR8STCedkuhB6cLxF6K3/g7icmlbMhac5vZp8jTL5+nEfnMKPlrd29OpqL9jHg5+5+X0Ixs0pzdgAz+xOhWfl7hOk5xxHeJ0cSjpxXEXrNbvEskx4kKY3ZdWmwwphJuKr4k2Z2GzDX3d/NWP86YVKDUvzGMpMUZo86Lz1IGMqwg9Dc81x0pHA8Ye7NCsJMI59OKmdD0p6fkHc3MMfMfgBMd/f1/mFnlA2E5v5SPB+e2uzRkJh7CNeefJ8wT/RSM3uQ0Jnv44SrKI0mzDxWMtKaXUeaBRJ16LiJ0NV7AaFJbSWwmdDJ5nx3755cwoalNXttz0F33xV1gqj2jDe4mV0C/NDdOycWshHNIH9/wvtmILCOMCZ5cXT7K4RZsQ5NLmHD0pw9U1SIauq9b74E/MzdOySXbN/Skl1Fs4CiYSUXAJ8hdEBxwuV6ZhHGZj6RWLh9SHP2+jKGC/wd2Onun0o6Uy7SkD8jY3fgDEJP1O6Ey4IdTuiFeqe7z0guZXZpzt6Y2rGPZvZ7wmf92UlniquUs6toFomZVRA6dywltM+XVCeaxqQ5eyYzmwS84e7Lks6yP9KW38wGE67qs4JQ7EtufGZD0py9PjMbD6z2lE0mAaWZXUWzgKze1Gdpkubskpy0jCnNJs3ZpXhUNItkX9NElbI0Z8+U9ueRtvxpy5spzdnrS/NzKcXsKpoFEn1rbZXGIzVlT07a84s0d62SDtDcmNlAM+vmQe0AaUs6VxzKnpy05xdpKXSkmQdm1g04H7iGcHHm3YS5Wh8B/lAKs1g0RNmTk+b8Fq744R5dMitN0pwd0p0/zdlrqWjmgZndR5jU/EnCFFBdCANyjwTWECZofyaxgI1Q9uSkOb+ZXU6YseXvwAp3fyfLNu1KsddpmrNDuvOnOXstFc0miprQ3gMmufvsjGV9CBNuXwIcBpzj7i8mlTMbZU9OmvNHOasJR8abgNnA04Q5c1e7+3vRdtcBVe5+R0JR95Lm7JDu/GnOnknT6DXdEMJsObtqF0S9vVYDq83sCcLkw+cALyYRsBHKnpw05z+VMA/upcAwwow5vyBkf8bMniEcKV8PXJRQxoakOTukO3+as9dRR6CmW0H41vSTqDPHHvvU3XcRrkNZcrO4oOxJSnP+NoQp5ra5+6/d/eOE6eceJMyR+1vCLDo17v6HxFJml+bskO78ac5eR82zeWBmxwJ3AzsIExD/D7DV3bebWTvgfsKsIuclGDMrZU9OWvObWVfClIrPu/sHlnEprWj9KOBvwEPuflVCMbNKc3ZId/40Z8+kopknZjYM+DZh7sp/AXMJPSJPJvSI/Iq7v5xcwoYpe3LSnr9WdL6qtbvvNrPOwBbgE+4+N+Fo+5Tm7JDu/GnMrqKZZ9EwgtMIE53vJDRHPOLuryaZKw5lT07a82eKjqBvdPeJSWfJVZqzQ7rzpyW7imYBWXT1hKRz7A9lT04zyH8A8BHf8zqsqZDm7JDu/GnJrqIpIiISk3rPioiIxKSiKSIiEpOKpoiISEwqmiIiIjGpaIqIiMSkoikiIhKTiqaIiEhM/x8zvLOD0zDgZgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.visualization import plot_histogram\n",
    "\n",
    "# Simulator of a quantum computer\n",
    "simulator = BasicAer.get_backend('qasm_simulator')\n",
    "\n",
    "# The execution of the circuit with a given number  \n",
    "# of shots (number of the circuit executions)\n",
    "job = execute(parallelism_circuit, simulator, shots=8096)\n",
    "result = job.result()\n",
    "counts = result.get_counts()\n",
    "\n",
    "# Plot the results in the histogram\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the first bit in the histogram is the measurement result of the qubit from the output register and the rest bits are obtained by measuring the input register. One can notice that the output register is $0$ when we have an even number of $1$s in the input register and, otherwise, the output register is $1$ (as was expected because of the correlation/entanglement between the registers). Also, the probability of each measurement outcome is equal to $\\approx 0.125 = \\left|\\frac{1}{\\sqrt{2^3}}\\right|^2$, and here we have an agreement with the presented formulas describing the superposition state. This procedure of the measurements is not the best thing that we can do with quantum parallelism. The number of repetitions (`shots`) of given circuit execution will demolish the possible advantage that possibly can be achieved with quantum parallelism. So we should use quantum parallelism more wisely in order to not lose the speedup that it can provide. In the next paragraphs, we will show how we can efficiently gain information about some specific $f(x)$ functions by using quantum parallelism."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 align=\"left\">\n",
    "2. Deutsch's algorithm\n",
    "</h3>\n",
    "\n",
    "In the Deutsch algorithm, we are solving a problem with two qubits. The problem can be described in this way [[1]]: Alice and Bob live in different cities and they are playing a game. Alice prepares her qubits and sends them to Bob. Bob applies a function on Alice's qubits and sends them back to Alice. Bob is allowed to choose only one of the 4 possible functions, that are either constant ($f(0) = f(1)$) or balanced ($f(0) \\ne f(1)$), and input and output of the function is one bit ($0$ or $1$). Alice should find out from the measurement result was the chosen function balanced or constant. In the course of this algorithm, we will use the concept of quantum parallelism. Here is the circuit for the algorithm (a modified version of the Fig. 1.19 from [[1]]):\n",
    "\n",
    "<img src=\"images/Deutsch.png\" alt=\"drawing\" width=\"500\"/>\n",
    "\n",
    "where $\\left| x \\right\\rangle$ is the input register with one qubit, $\\left| y \\right\\rangle$ is the output register also with one qubit, $M$ denotes the measurement. The initial state is $\\left| \\psi_0 \\right\\rangle = \\left| 0 \\right\\rangle \\left| 1 \\right\\rangle$. Alice applies Hadamard gates on both input and output registers and obtains the $\\left| \\psi_1 \\right\\rangle$ state:\n",
    "\n",
    "$$\n",
    "\\left| \\psi_1 \\right\\rangle = \\frac{1}{2} \n",
    "\\left( \\left| 0 \\right\\rangle + \\left| 1 \\right\\rangle \\right)\n",
    "\\left( \\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle \\right).\n",
    "$$\n",
    "\n",
    "Then Alice sends the qubits to Bob. Now Bob should make a decision which $f(x)$ function to use. 4 possible functions can be chosen. Two of them are constant functions ($f(0) = f(1) = 0$ or $f(0) = f(1) = 1$) and the other two are balanced ($f(0) = 0$ and $f(1) = 1$ or $f(0) = 1$ and $f(1) = 0$). After choosing one of them Bob acts the corresponding $U_{f(x)}$ circuit on the qubits. The result of the function is stored in the output register by mmodulo 2 addition $\\left| y \\oplus f(x)\\right\\rangle$. Let's rewrite the $\\left| \\psi_1 \\right\\rangle$ in this way:\n",
    "\n",
    "$$\n",
    "\\left| \\psi_1 \\right\\rangle = \\frac{1}{2} \n",
    "\\left( \\left| 0 \\right\\rangle + \\left| 1 \\right\\rangle \\right)\n",
    "\\left( \\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle \\right) = \n",
    "\\frac{1}{2} \n",
    "\\left( \\left| 0 \\right\\rangle \\left( \\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle \\right) + \\left| 1 \\right\\rangle \\left( \\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle \\right) \\right)\n",
    "$$\n",
    "\n",
    "After applying the circuit $U_{f(x)}$ one will obtain $\\left| \\psi_2 \\right\\rangle$ state that Bob will send back to Alice:\n",
    "\n",
    "\\begin{align*}\n",
    "\\left| \\psi_2 \\right\\rangle = \\frac{1}{2} \n",
    "\\big( \\left| 0 \\right\\rangle \\left( \\left| 0 \\oplus f(0) \\right\\rangle - \\left| 1 \\oplus f(0) \\right\\rangle \\right) + \n",
    "\\left| 1 \\right\\rangle \\left( \\left| 0 \\oplus f(1) \\right\\rangle - \\left| 1 \\oplus f(1) \\right\\rangle \\right) \\big)\n",
    "\\end{align*}\n",
    "\n",
    "How one can see the $f(0)$ and $f(1)$ were calculated at the same time by executing the circuit once (quantum parallelism). Although the values of $f(0)$ and $f(1)$ are computed, but they are \"hidden\" in the quantum state. By saying \"hidden\" means that we don't know a direct way to extract the values from them efficiently. Now Bob sends the qubits back to Alice. Alice applies Hadamard gate on the input qubit and obtains the final $\\left| \\psi_3 \\right\\rangle$ quantum state before the measurement:\n",
    "\n",
    "\\begin{align*}\n",
    "\\left| \\psi_3 \\right\\rangle = \\frac{1}{\\sqrt{2^3}} \n",
    "\\big( &\\left( \\left| 0 \\right\\rangle + \\left| 1 \\right\\rangle \\right) \\left( \\left| 0 \\oplus f(0) \\right\\rangle - \\left| 1 \\oplus f(0) \\right\\rangle \\right) + \n",
    "\\\\\n",
    "+ &\\left( \\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle \\right) \\left( \\left| 0 \\oplus f(1) \\right\\rangle - \\left| 1 \\oplus f(1) \\right\\rangle \\right) \\big)\n",
    "\\end{align*}\n",
    "\n",
    "Let's regroup superposition states:\n",
    "\n",
    "\\begin{align*}\n",
    "\\left| \\psi_3 \\right\\rangle = \\frac{1}{\\sqrt{2^3}} \n",
    "\\big( \n",
    "& \n",
    "\\left| 0 \\right\\rangle \\left( \\left| 0 \\oplus f(0) \\right\\rangle - \\left| 1 \\oplus f(0) \\right\\rangle  + \\left| 0 \\oplus f(1) \\right\\rangle - \\left| 1 \\oplus f(1) \\right\\rangle \\right) + \n",
    "\\\\\n",
    "& \n",
    "\\left| 1 \\right\\rangle \\left( \\left| 0 \\oplus f(0) \\right\\rangle - \\left| 1 \\oplus f(0) \\right\\rangle - \\left| 0 \\oplus f(1) \\right\\rangle +  \\left| 1 \\oplus f(1) \\right\\rangle \\right) \n",
    "\\big)\n",
    "\\end{align*}\n",
    "\n",
    "Here we are going to show that, when the function was balanced the terms in the first bracket cancel each other and final state of the first qubit becomes $\\left| 1 \\right\\rangle$. Otherwise, if the function was constant the terms of the second bracket cancel each other and the final state of the first qubit will be $\\left| 0 \\right\\rangle$. So, by just measuring the first qubit, Alice can understand was the function balanced or constant. To see this let's consider one of the examples. Suppose Bob has chosen a balanced function for which $f(0) = 0$ and $f(1) = 1$. In that case:\n",
    "\n",
    "\\begin{align*}\n",
    "\\left| \\psi_3 \\right\\rangle = \\frac{1}{\\sqrt{2^3}} \n",
    "\\big( \n",
    "& \n",
    "\\left| 0 \\right\\rangle \\left( \\left| 0 \\oplus 0 \\right\\rangle - \\left| 1 \\oplus 0 \\right\\rangle  + \\left| 0 \\oplus 1 \\right\\rangle - \\left| 1 \\oplus 1 \\right\\rangle \\right) + \n",
    "\\\\\n",
    "& \n",
    "\\left| 1 \\right\\rangle \\left( \\left| 0 \\oplus 0 \\right\\rangle - \\left| 1 \\oplus 0 \\right\\rangle - \\left| 0 \\oplus 1 \\right\\rangle +  \\left| 1 \\oplus 1 \\right\\rangle \\right) \n",
    "\\big)\n",
    "\\end{align*}\n",
    "\n",
    "Note that $\\left|1 \\oplus 1\\right\\rangle = \\left|0\\right\\rangle$. $\\left|0 \\oplus 1\\right\\rangle = \\left|1\\right\\rangle$, $\\left|1 \\oplus 0\\right\\rangle = \\left|1\\right\\rangle$ and $\\left|0 \\oplus 0\\right\\rangle = \\left|0\\right\\rangle$. So:\n",
    "\n",
    "\\begin{align*}\n",
    "\\left| \\psi_3 \\right\\rangle = \\frac{1}{\\sqrt{2^3}} \n",
    "\\big( \n",
    "& \n",
    "\\left| 0 \\right\\rangle \\left( \\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle  + \\left| 1 \\right\\rangle - \\left| 0 \\right\\rangle \\right) + \n",
    "\\\\\n",
    "& \n",
    "\\left| 1 \\right\\rangle \\left( \\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle - \\left| 1 \\right\\rangle +  \\left| 0 \\right\\rangle \\right) \n",
    "\\big) =\n",
    "\\\\\n",
    "& = \\frac{1}{\\sqrt{2}}\\left| 1 \\right\\rangle \\left( \\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle \\right)\n",
    "\\end{align*}\n",
    "\n",
    "Similar calculations can be done for the other functions:\n",
    "\n",
    "\\begin{align*}\n",
    "&\\text{f(0) = 0, f(1) = 0:} \\;\\; \\left| \\psi_3 \\right\\rangle = \\frac{1}{\\sqrt{2}}\\left| 0 \\right\\rangle \\left( \\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle \\right)\n",
    "\\\\\n",
    "&\\text{f(0) = 1, f(1) = 1:} \\;\\; \\left| \\psi_3 \\right\\rangle = -\\frac{1}{\\sqrt{2}}\\left| 0 \\right\\rangle \\left( \\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle \\right)\n",
    "\\\\\n",
    "&\\text{f(0) = 0, f(1) = 1:} \\;\\; \\left| \\psi_3 \\right\\rangle = \\frac{1}{\\sqrt{2}}\\left| 1 \\right\\rangle \\left( \\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle \\right)\n",
    "\\\\\n",
    "&\\text{f(0) = 1, f(1) = 0:} \\;\\; \\left| \\psi_3 \\right\\rangle = -\\frac{1}{\\sqrt{2}}\\left| 1 \\right\\rangle \\left( \\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle \\right)\n",
    "\\end{align*}\n",
    "\n",
    "One can see that if the function is constant (the first two cases) the qubit in the input register is in the $\\left| 0 \\right\\rangle$ state and if the function is balanced (the last two cases) the qubit is in the $\\left| 1 \\right\\rangle$ state. Here we encounter one more useful property of quantum computation called quantum interference. It arises from the fact that probability amplitudes are complex numbers and they can be subtracted from (added to) each other (in our example: destructive interference $ \\left| 0 \\right\\rangle -  \\left| 0 \\right\\rangle = (1 - 1) \\left| 0 \\right\\rangle = 0$; constructive interference $ \\left| 0 \\right\\rangle +  \\left| 0 \\right\\rangle = (1 + 1) \\left| 0 \\right\\rangle = 2 \\left| 0 \\right\\rangle$). Like the quantum parallelism and quantum entanglement, quantum interference also is an important \"tool\" that is widely used in quantum algorithms.\n",
    "\n",
    "Now we are ready to write the code. In the code, we will implement all 4 possible functions and let Bob choose what he likes (actually we will choose one of the circuits randomly in order to simulate free will of the imaginary person Bob). But, before that Alice should prepare the qubits:\n",
    "\n",
    "  [1]: https://www.cambridge.org/am/academic/subjects/physics/quantum-physics-quantum-information-and-quantum-computation/quantum-computation-and-quantum-information-10th-anniversary-edition?format=HB\n",
    "  [2]: https://quantumcomputing.stackexchange.com/questions/9566/implementing-four-oracles-for-the-deutsch-algorithm-preferably-on-ibm-q-experie\n",
    "  [3]: https://www.youtube.com/watch?v=awpnsGl08bc&list=LLEPoMdv-DZViRaaObznY_-A&index=113&t=0s\n",
    "  [4]: https://courses.edx.org/courses/course-v1:MITx+8.370.2x+1T2018/course/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANcAAACoCAYAAABzCXuhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAAK7ElEQVR4nO3df0wUZwLG8WcWhcYWKylX2lVZNG0PpLZqqzUS2CUx9Q+9YIQVG8+gZwIVuEaiZxtBjBdqaqysTRXx1F6PNPVU6A9MySWasKBZ4y+wsf64tHaFdtvjaEoTbauH7NwfRi7ktewsty/vzPT5/Dm7yz5N83WHYWE1Xdd1EFHMOVQPILIrxkUkCeMikoRxEUnCuIgkYVxEkjAuIkkYF5EkjItIEsZFJAnjIpKEcRFJwriIJGFcRJIwLiJJGBeRJIyLSBLGRSQJ4yKSZIzqAURGXL16ddjbd+3ahfLy8mHvk56eHstJEfGVi2xh9+7dqicIGBeRJIyLSBLGRbbQ2NioeoKAcRFJwrjIFgoKClRPEPBSfAQfnANCfaP/vBOTgCXPj/7zUuwwrghCfcC1f6teQVbE00KyhbKyMtUTBIyLbCHSuzNUYFxkCzk5OaonCBgX2UJvb6/qCQLGRSQJ4yJbmDZtmuoJAsZFttDU1KR6gsBycX322WfQNA0tLS2qp5CJVFdXq54gsFxcjz/+OE6dOoX58+ernkImcuTIEdUTBJaL65FHHsHcuXMRHx+vesp9NdZ4cOajGsPHyb4sF9cLL7wAr9eregZRRJaKa2BgABcvXsSsWbNUTyGTaWtrUz1BYKm4rl69ip9//hkzZ85UPYVM5tKlS6onCCz1rviOjg4AGIzr+vXrKCoqwrfffouEhATU1dUhOzvb0NfSNM3Q/fIrWzEpwxPVzjMfv47zLW8OOdZ/6yZSnzZ+EaatzY9XXsyN6nntrKKiYtjbfT6fofvEgq7rhu5nqbg6OzvhdDqRkpICACgpKUFhYSFKS0sRCATg9XoRDAaVX+yYk1eJOYurhhxrrPGoGUPKWC6ue69a3333HU6ePInm5mYAwLx58+B0OtHa2ooFCxZE/FpG//V5+5ia3+dyuz1orDG28dcg0t8t9Pl8KC4uHvY+tbW1sZwUkaW+57pw4cJgXN3d3UhJSUFCQsLg7VOmTEFXV5eqeaTQli1bVE8QWCauL7/8Ej/88AOvFNJ9LV26VPUEgWVOCzs7OwH872JGamoqenp6cPv27cFXr2AwCJfLpWwjABRU+aM6TrGRkZGBK1euqJ4xhGVeufLz86HrOtLS0gAAycnJyMrKwoEDBwAAgUAAoVAIubm8wkbmYJlXrvupr6/HypUrsXPnTsTHx+PgwYPKrxQS3WPpuKZOnYr29nbVM8gEPB6P6gkCy5wWEg1nz549qicIGBfZwpo1a1RPEDAusgW/3696goBxEUnCuIgkYVxkC2b7ATJg8Uvxo2Fi0q/rea3q8OHDpnsLlKYbfXs4kUKR3hVv5O1P6enpsZwUEU8LiSRhXESSMC6yhbq6OtUTBIyLbCEzM1P1BAHjIltwu92qJwgYF5EkjItsYfbs2aonCBgX2cLZs2dVTxAwLiJJGBeRJIyLbKGxsVH1BAHjIpKEcZEtFBQUqJ4g4K+cRLDun5fx6Y0bo/68zyYmYsdvR/YJ9R+cA0J9MR5k0MQkYMnzap7bbBhXBJ/euIH2vu9Vz4hKqE/Nh0fQUDwtJFsoKytTPUHAuMgWysvLVU8QMC6yhZycHNUTBIyLbKG3t1f1BAHjIpKEcZEtTJs2sh9byMS4yBaamppUTxAwLrKF6upq1RMEjIts4ciRI6onCEwbl67rqK+vx6xZszBu3DikpqZi7dq1uHnzpuppRIaYMq5wOIzly5dj/fr18Hq9+OSTT7Bx40a8++67WL16tep5v0jv70f/y+UY2LtvyPGBDz9C/++LoJv0H4bGGg/OfFRj+DgZY8r3Fu7evRuHDh2C3+9HdnY2ACA3Nxe9vb2orq7G3r17MWHCBLUj70MbOxZjXvsT7vxxLbQ5s+GYOQN6MIjwO39D3Ot/hvbQQ6on2lZbW5vqCQJTvnLt2LEDixYtGgzrnieeeAIA8PXXX+P69etwu9146qmnMH36dJw4cULFVIGW5oLjD0UYeNMH/fvvceeN7XDk/Q6OZ6arnmZrly5dUj1BYLpXrmvXrqGrqwsbN24Ubvvqq68AAE6nEy+99BIKCwtRWlqKQCAAr9eLYDCI+Ph4Q8+jaZqh+8VtfwOOZ58x/h8AwLE4D/qZc7hTUgb8JhmOohVRPR64+0mJ2uy5UT8OAPIrWzEpwzOix/6/2tr8eOXF3Jh/3YqKimFv9/l8hu4TC0Y/u8R0cd17G4vT6RRuO3bsGGbMmIFwOIyTJ0+iubkZADBv3jw4nU60trZiwYIFo7r3fjRNg/bMdOjnO+BYthTa2LGqJ0V05uPXcb7lzSHH+m/dROrT8xUtsj7TxZWWlgYA+OKLL4Ycb2lpwfHjx9HQ0IDu7m6kpKQgISFh8PYpU6agq6vL8PMY/ddn/rnTUf8+lx4MIvz+3+Eo9CL83vtwZGdBe/TRqL6Gx+PB8RF+utPbx6L/fa45eZWYs7hqyLHGGk/Uz+12e9BYE/tPpYr0EUI+nw/FxcXD3qe2tjaWkyIyXVyPPfYYFi1ahK1bt2L8+PGYOnUq2tvbsW3bNpSUlGDFihXo6OhQPfMX6f/pv/t91pLFiFtVBL2vDwPbaxG3bSs0hym/xbWFLVu2qJ4gMOX/7YaGBuTl5aGqqgoLFy7E0aNHsWvXLtTX1wMAUlNT0dPTg9u3bw8+JhgMwuVyqZo8KPzOX6GNGQPHiuUAgLjSl6H/qwfhpg8VL7M3s32qJGDSuJKSkrBv3z588803+PHHH3H27FmsWrVq8Pbk5GRkZWXhwIEDAIBAIIBQKITc3Nh/Ix2NcOcFhFv+gbjXNkAbc/ekQBs3DnGvrke44T3owaDSfXaWkZGheoLAdKeFRtXX12PlypXYuXMn4uPjcfDgQcNXCmVxzJwBR/MH4vGnM+E4at5XroIqf1THyRjLxnXvezEiszLlaSFRtDwej+oJAsZFtrBnzx7VEwSMi2xhzZo1qicIGBfZgt/vVz1BwLiIJGFcRJIwLrKFK1euqJ4gYFxkC4cPH1Y9QWDZHyKPlmcTEy33vBOTYjjEIs+9efNm072/kHFFMNLPyFKJn49lDjwtJJKEcZEt1NXVqZ4gYFxkC5mZmaonCBgX2YLb7VY9QcC4iCRhXESS8FI8WUJ6evqwt2/evDnifUabphv9G2NEFBWeFhJJwriIJGFcRJIwLiJJGBeRJIyLSBLGRSQJ4yKShHERScK4iCRhXESSMC4iSRgXkSSMi0gSxkUkCeMikoRxEUli+bguXryI/Px8JCcn44EHHsCTTz6JyspK1bOIrP03NM6fP4+cnBxMnjwZ27dvh8vlQjAYRCAQiPjY17b9ZRQWkh298WqxoftZOq5169bhwQcfxOnTp/Hwww8PHl+9erXCVUR3WfYP1Pz0009ITExEeXk53nrrLdVziASWfeXq6+tDOBzGpEmTRvR4nhbSSBk9LbTsBY2kpCQ4HA6EQiHVU4juy7KnhQCQm5uLy5cv4/PPP8f48eNVzyEawtJx3bta6HK5sGHDBrhcLnR3d+PEiRPYv3+/6nn0K2fZ77kA4LnnnsOpU6ewadMmVFRU4NatW5g8eTKWLVumehqRtV+5iMzMshc0iMyOcRFJwriIJGFcRJIwLiJJGBeRJIyLSBLGRSQJ4yKShHERScK4iCRhXESSMC4iSRgXkSSMi0gSxkUkCeMikoRxEUnCuIgkYVxEkjAuIkkYF5EkjItIEsZFJAnjIpKEcRFJwriIJGFcRJL8FxX3vYJmREU3AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 266.47x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Alice prepares the qubits\n",
    "input_register = QuantumRegister(1, \"i\")\n",
    "output_register = QuantumRegister(1, \"o\")\n",
    "classical_register = ClassicalRegister(1, \"c\")\n",
    "\n",
    "circuit_Deutsch = QuantumCircuit(input_register, output_register, classical_register)\n",
    "\n",
    "# Prepare the qubit in the output register in the |1> state\n",
    "circuit_Deutsch.x(output_register[0])\n",
    "\n",
    "# Hadamard gates applied on input and output registers\n",
    "circuit_Deutsch.h(input_register[0])\n",
    "circuit_Deutsch.h(output_register[0])\n",
    "\n",
    "# Add a barrier\n",
    "circuit_Deutsch.barrier()\n",
    "\n",
    "# Draw the circuit\n",
    "circuit_Deutsch.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now Alice sends to Bob the qubits and Bob should choose one of the four functions [[2](https://quantumcomputing.stackexchange.com/questions/9566/implementing-four-oracles-for-the-deutsch-algorithm-preferably-on-ibm-q-experie)] ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<qiskit.circuit.instructionset.InstructionSet at 0x7fd503f20be0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Bob's four functions/circuits\n",
    "\n",
    "# The first option: constant f(0) = f(1) = 0\n",
    "circuit_Bob1 = QuantumCircuit(input_register, output_register)\n",
    "circuit_Bob1.barrier()\n",
    "\n",
    "# The second option: constant f(0) = f(1) = 1\n",
    "circuit_Bob2 = QuantumCircuit(input_register, output_register)\n",
    "circuit_Bob2.cx(input_register[0], output_register)\n",
    "circuit_Bob2.x(input_register[0])\n",
    "circuit_Bob2.cx(input_register[0], output_register)\n",
    "circuit_Bob2.x(input_register[0])\n",
    "circuit_Bob2.barrier()\n",
    "\n",
    "# The third option: balanced f(0) = 0 & f(1) = 1\n",
    "circuit_Bob3 = QuantumCircuit(input_register, output_register)\n",
    "circuit_Bob3.cx(input_register[0], output_register)\n",
    "circuit_Bob3.barrier()\n",
    "\n",
    "# The fourth option: balanced f(0) = 1 & f(1) = 0\n",
    "circuit_Bob4 = QuantumCircuit(input_register, output_register)\n",
    "circuit_Bob4.x(input_register[0])\n",
    "circuit_Bob4.cx(input_register[0], output_register)\n",
    "circuit_Bob4.x(input_register[0])\n",
    "circuit_Bob4.barrier()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now Bob will choose randomly which circuit to implement. Note that for Alice the applied circuit will be unknown: for her, it is a black box."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The circuit with Bob's chosen function\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 507.27x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "list_options_Bob = [circuit_Bob1, circuit_Bob2, circuit_Bob3, circuit_Bob4]\n",
    "circuit_Bob_choice = random.choice(list_options_Bob)\n",
    "\n",
    "# Add the chosen circuit to the main circuit\n",
    "circuit_Deutsch += circuit_Bob_choice\n",
    "\n",
    "# Draw the circuit \n",
    "print(\"The circuit with Bob's chosen function\")\n",
    "circuit_Deutsch.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After applying the chosen function/circuit, Bob sends back the qubits to Alice. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The final version of the circuit\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAegAAACoCAYAAAArf33UAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAAV1ElEQVR4nO3de3CUhb3G8Wc35AISLpoWDSQBRAgB5O4FhCRcyjmjPfFw7wCDiIII7UC1QL1gPWMtFCXYKgYh2jJUWwG1WDhOyZEEKBzkklgQUgQjgSAXTQSCXEJ2zx85BENIshve7Hv7fmYYk913333c+c0+ed999309fr/fLwAAYCleswMAAIDqKGgAACyIggYAwIIoaAAALIiCBgDAgihoAAAsiIIGAMCCKGgAACyIggYAwIIoaAAALIiCBgDAgihoAAAsiIIGAMCCKGgAACyIggYAwIIoaAAALIiCBgDAgihoAAAsiIIGAMCCGpkdAAhEfn5+rfe/+uqrmjFjRq3LJCYmGhkJuCF1zbTEXLsdW9BwhNdee83sCIDhmGt3o6ABALAgChoAAAuioOEIq1evNjsCYDjm2t0oaAAALIiChiOMHDnS7AiA4Zhrd+NrVnV4b6dUVBL6523dUhreJ/TPi+A88a99+vTsWVOeu3t0tF7ulGTKc5uB1zp07Pi+N3PmTOXl5RmaJ1A9evTQ4sWLDV8vBV2HohLp0EmzU8CqPj17VptKis2O4Qq81qFjx/e9vLw85eTkmB3DUOzihiNMnz7d7AiA4Zhrd6Og4Qh1nW0JsCPm2t0oaDjCwIEDzY4AGI65djcKGo5w6tQpsyMAhmOu3Y2CBgDAgihoOEJSknu+AgP3YK7djYKGI6xZs8bsCIDhmOuG5fF41KlTJw0ePFhDhgxR9+7dFR4eXuPyUVFRmjlzprze0FSn7Qp679698ng8Wr9+vdlRYCHz5s0zOwJgOObaeB6PR8OGDdMHH3yg06dPKz8/X1lZWdqwYYPy8vJ09uxZ5eTkaNy4cYqIiKh8XFRUlNauXav09HT99re/DUlW2xX0bbfdpm3btmnIkCFmR4GFrFq1yuwIjldUIn30T2ntbukfn0vnL5mdyPmYa2MlJSVp+/bt+uijj5SWlqbo6GgdOXJEH3/8sbKysnTgwAFFRkZq4MCBWrlypQ4cOKDBgwdXlvPQoUN1/PhxZWZmhiSv7Qr6lltu0T333FPlLxsrWf1Cij754IWAb4e7+MvKVPbYDJUvXVbl9vL3P1DZ+Inyl5aalKxmpRek17Kkheulj/ZIH++XVn0izXtPysk3O13N7Pha25Ud3vcmTJig3bt3q2/fvioqKtIvf/lLtW7dWvHx8Ro8eLCGDh2qTp06qUWLFnr00Ue1d+9eJSQkKCsrS/v27ass50GDBmn//v0hyWy7gr777rs1atQos2MA9eIJD1ejub+Q72/r5cvNkyT5Cwrke/OPCpv9pDxNm5ob8BqXLkuvfywdPFH9vrJy6f1d0pYDoc8VCLu91mg448eP14oVKxQZGally5apc+fOmj9/vo4dO1Zt2dOnT2v58uXq2bOn5s2bJ5/Pp3bt2uncuXMhLWfJZgVdXl6uPXv2qFevXmZHgcXY6Ry8nrYJ8j48UeUvpctfXKzL8xfKm/Zjee/sZna0anIPV+za9teyzLq8iiK3Iju91tdjp7m2qsTERC1bVrEXZfbs2ZoyZYrOBnDRlUaNGmnAgAHyer3y+/266aab1LFjx4aOW4WtCjo/P1/nz59Xz549zY4Ci/nss8/MjhAU74Np8sTH6fLU6VJYmLwTJ5gd6bq2HZQ8dSxzvkzaezQkcerFLq/19dhtrq3ozTffVFRUlDIzM7Vw4cKAHnPtZ86/+c1vJEkZGRlq3rx5Q8atwlZXs9q9e7ckVRb0l19+qYkTJ+qrr75SZGSklixZogEDBgS0Lo+nrredCiOe3qg2nVOCyvnJX3+tXetfqnJb2YVSxXcN/MC2nJxs/exHqUE9r5PNmjWr1vvT09MDWsZoYQvny9v9zqAf5/F45Lmzm/y7dss7drQ8tXy1oybZ2dny9L0n6McFY/LvjqjpzW3qXO7RGb/Q7nUv1bncjXDaa13XvErmzbVT3vdSU1N177336vjx4/r5z38e0GOuLedBgwYpPz9fycnJ6t+/vyZNmlTt0pI5OTkBd4ok+f217ZO6ylZb0Lm5uYqNjVWrVq0kSVOnTtWYMWN04MABLV26VGPHjtWlS+YfWnpX2tOa9sa3Vf7FdrzP7FiwEH9BgXxv/1neMaPkW/m2/CeteW2/i999K7/PV+dyl747HYI09WOX19rurPi+N23aNEnSkiVLdObMmTqXv14579+/X36/v/KrVVfWGQq22oLOzc2t3Hr++uuvtWXLFq1du1aS1K9fP8XGxmrjxo0aNmxYnesK9C+Y328w57qoyckpWv1CYBndID+/9sOF09PTNWXKlFqXWbRokZGRJElDdm4P+hrF/ktlFZ+FDn9QYZMmyl9SovKFixS24EV5gjgBQkpKirICnOP6+vseaf0/a1/G65G2rn9D0VFvNGgWp73Wdc20ZN5c2/F9LyUlpdpn9oMHD5YkrVixos7H11TOV6xbt04lJSXq2LGj2rRpo6NHr36uk5ycrOzs7Hrlro2ttqDz8vIqC7qwsFCtWrVSZGRk5f3t2rXT4cOHzYoHEz3//PNmRwiY78235GnUSN4J4yRJYY8/Jv/xE/Kted/kZNXd20FqHF7759D3dJCio0IWKSh2eq2vx05zbTVt27bVzTffrJMnT9bZC3WVs1RxkPLOnTslSb17926w3N9nm4L+4osv9O2333IEN65r9OjRZkcIiC83T771Hyls7mx5GlXswPI0aaKwOU/Kt2Kl/AUFJiesKrqx9NggKeqa0w5c+bitaxtpeGjeq4Jmt9f6euwy11YUGxsrSTp06FCtywVSzlccPHiwyrobmm12cefm5kq6eoBYfHy8Tpw4oYsXL1ZuRRcUFCghIcG0jJI08pnsoG6HMTp37hzS7yfWl7dnD3nXvlf99q5d5P3Qmlt1CTHSs2nSji8qvvcsST3iK7au72h1taytxo6v9bXsMtdWfN/btm2boqOjFRYWVutyjRs3VkxMTEAnIZk9e7bmzp2rc+fOGR33umyzBT1ixAj5/X61bdtWkhQTE6P+/ftXnnJt69atKioqUmoqRz4DRmsSISUnXv194n1Sx1utW86A3+9XaWmpTp+u/QDGkpISDRkyRMnJyXX+MVRaWqozZ86ovLzcyKg1ss0W9PVkZGTooYce0uLFixUREaF33nnHsqcABQBYU3FxsYqLgzsAMRRsXdDt27fXpk2bzI4BC0hJSTE7AmA45trdbLOLG6jN66+/bnYEwHDMtbtR0HCEUJ48AAgV5trdKGg4QkOcJAAwG3PtbhQ0AAAWREEDAGBBFDQcwQ4ncwCCxVy7m62/ZhUKrVu663nt6t133zXltIjdo6ND/pxWeG4zuPG1Nmuu7fi+16NHj3o97ovCryRJ7eNvq/JzKJ67Lh5/oJd1AkxU15V/AjklYmJiYq33o24z/1Tx38XjzM3hBIFczYq5bnhzF1RchW3+nClVfrYCdnEDAGBBFDQAABZEQcMRlixZYnYEwHDMtbtR0HCELl26mB0BMBxz7W4UNBwhOTnZ7AiA4Zhrd6OgAQCwIAoajtC3b1+zIwCGY67djYKGI+zYscPsCIDhmGt3o6ABALAgChoAAAuioOEIq1evNjsCYDjm2t0oaAAALIiChiOMHDnS7AiA4Zhrd+Nyk3V44l/79OnZsyF/3u7R0Xq5U1K9HvveTqmoxOBAAWrdUhrex5znBgAnoaDr8OnZs9pUUmx2jKAUlUiHTpqdAgBwI9jFDUeYPn262REAwzHX7kZBwxFmzJhhdgTAcMy1u1HQcISBAweaHcHxTp+/+vORYqms3LwsbsFcuxufQcMRTp06ZXYERyoqkf5xQNpbJJ35XkG//N+S11NxUOBd7aW+7aWocPNyOhVz7W4UNIBqSi9Ia3ZKuYdrXsbnr9iSPlIsrftU+s/eFWXt8YQuJ+BkFDQcISmpfl9JQ3WHv5aW5VSUdKAulEnv/K+075g0vp8UHtZw+dyEuXY3PoOGI6xZs8bsCI5w5Btpyf8EV87f92mh9NYmqdxnbC63Yq7djYKGI8ybN8/sCLZ3sUx6a7N08XLNyyweV/GvNvuOSRs+MzabWzHX7kZBwxFWrVpldgTb+1ueVHzOmHX9fY90zKSz2TkJc+1uli1ov9+vjIwM9erVS02aNFF8fLxmzpyp0tJSs6MBjnP2grT1oHHr8/mljfuNWx/gRpYsaJ/Pp3HjxunJJ5/UqFGjtG7dOj311FP6wx/+oMmTJ5sdr0b+sjKVPTZD5UuXVbm9/P0PVDZ+ovwW/eNi9Qsp+uSDFwK+Hc6z/ZDxnxvnHpbOXTR2nYCbWPIo7tdee01/+ctflJ2drQEDBkiSUlNTderUKc2bN09Lly5VixYtzA15HZ7wcDWa+wtd/ulMee7qK2/PHvIXFMj35h8V9uv/kqdpU7MjOlZOTo7ZEWztwHHj13nZJxWckrq2MX7dbsFcu5slt6BffvllPfDAA5XlfEWHDh0kSUePHtWXX36p5ORkdezYUd26ddPmzZvNiFqNp22CvA9PVPlL6fIXF+vy/IXypv1Y3ju7mR3N0T77jKOS6svvl4420PVgCr9pmPW6BXPtbpbbgj506JAOHz6sp556qtp9R44ckSTFxsbqJz/5icaMGaPHH39cW7du1ahRo1RQUKCIiIiAnscT4NkUwhbOl7f7nYH/D0jyPpgm/yc7dXnqdOkHMfJOnBDU4yUpOztbnr73BP04SRrx9Ea16ZxSr8feqJycbP3sR6mGr3fWrFm13p+enh7QMqguLDxKM946X+W2uo7Urun+mX+q+vuiV5fr/uWP3kA656prXiXmOhTmzF8qqaITvv9zQ/L7/QEtZ7mCvnJqu9jY2Gr3bdiwQT169JDP59OWLVu0du1aSVK/fv0UGxurjRs3atiwYSHNez0ej0eeO7vJv2u3vGNHyxNu/XMgfvLXX2vX+peq3FZ2oVTxXYeYlAih0pBvRh6PJXfSAbZguYJu27atJOngwaqHlK5fv15ZWVlasWKFCgsL1apVK0VGRlbe365dOx0+XMt5Ca8R6F8wQ3ZuD/p60P6CAvne/rO8Y0bJt/JteQf0l+eHPwxqHSkpKcoKMOO1fr8h+OtB35X2tO568Jkqt61+ISXo505OTtHqF+qXuzb5+fm13p+enq4pU6bUusyiRYuMjOQYfr80992q33++dkv4iitbzjXdf62fTntYG954+MYCOlRdMy0x16Ewd8Ebkio64fs/W4HlCvrWW2/VAw88oBdffFHNmjVT+/bttWnTJi1YsEBTp07VhAkTtHv3brNj1sh/qazic+fhDyps0kT5S0pUvnCRwha8KI+XrYmG8vzzz5sdwbY8/3/Riy8a4LoMcTcbv043Ya7dzZKNsWLFCqWlpemZZ57R/fffrw8//FCvvvqqMjIyJEnx8fE6ceKELl68+h2OgoICJSQkmBW5ku/Nt+Rp1EjeCRWbGmGPPyb/8RPyrXnf5GTONnr0aLMj2Nrtwe3gCYhHUrsfGL9eN2Gu3c2SBd2yZUstW7ZMx44d07lz57Rjxw5NmjSp8v6YmBj1799fmZmZkqStW7eqqKhIqanGH5wUDF9unnzrP1LY3NnyNKrYOeFp0kRhc56Ub8VK+QsKTM3nZJ07dzY7gq3dfXtFoRopqbXUoonBK3UZ5trdLLeLO1AZGRl66KGHtHjxYkVEROidd94J+AjuhuLt2UPete9Vv71rF3k/tO4W9MhnsoO6Hc4TEy3dGV9xsQujpNItwA2xbUFf+WwagDGG96k4Ycn5Sze+rns7SB1a3fh6ADezbUED35eSkmJ2BNtr3lgaf6+UuaniXNrXE8jR261bSmm9jM3mVsy1u1nyM2ggWK+//rrZERyhSxtp4n1SWD3fGeJulqYNkqKs/9V/W2Cu3Y2ChiNMmzbN7AiO0T1eevLfg/uKlEfS4CTpZz+SmkY1WDTXYa7djV3ccITs7GyzIzjKbS2kmcOkPUekzQdqPvFNVLjUt73U/w7p1uYhjegKzLW7UdAArivMK/VIqPh3/lLFBTW+Lq24LGVUeMVnza2aSZx/B2gYFDSAOjWOkO64VbrD7CCAi/C3Lxxh//79ZkcADMdcuxsFDUd49913zY4AGI65djd2cdehe3S07Z63dUsDg9jkuZ977jnOWwzHYa7djYKuw8udksyOELThfcxOAAC4UeziBgDAgihoOMKSJUvMjgAYjrl2NwoajtClSxezIwCGY67djYKGIyQnJ5sdATAcc+1uFDQAABZEQQMAYEF8zQq2kJiYWOv9zz33XJ3LAFYSyLwy1+7GFjQc4Ve/+pXZEQDDMdfuRkEDAGBBFDQAABZEQQMAYEEUNAAAFkRBAwBgQRQ0AAAWREEDAGBBFDQAAPWQnZ2tLl26qEOHDnrkkUdUXl5u6PopaAAAguTz+fTII49o1apVOnjwoM6cOaOVK1ca+hwUNAAAQdqxY4diY2OVlJQkSZo8ebLWrFlj6HNwLm4AgGts2bFHu/YeqHb7K2+tqfZzQutWShvaXx6Pp9ryR48eVVxcXOXv8fHxOnLkiKFZ2YIGALhG3+6Junjpkr46+Y2+OvlN5e3X/vxNyWnd17fbdctZkvx+f4NnpaABAK4RGRGu0fen1li8V9w/6F7FtGxe4/1xcXFVtpgLCwvVpk0bw3JKFDQAwGXatrlVyXd3r/H+xNvjdVf32i/z2adPHx09elT79u2TJGVmZmr48OGG5qSgAQCuM+S+3rrth7dUu71J40iN+LeBdW5hh4WFafny5Ro5cqRuv/12NW3aVBMmTDA0o8cfih3pAABYzIlTxfr9H9/X5e99f3n8g0PVtVM7E1NdxRY0AMCVWv3gZg1L7lv5e6+uHS1TzpIDCnrPnj0aMWKEYmJiFBUVpTvuuENPP/202bEAADbQv083tY+PVYtmTfUfQ/qZHacKW+/i3rVrlwYOHKi4uDjNmTNHCQkJKigo0NatW5WZmVnrY+cueCNEKQEAuGr+nCkBLWfrE5U88cQTuummm7R9+3Y1b371cPjJkyebmAoAgBtn2y3o7777TtHR0ZoxY4ZeeeUVs+MAAGAo225Bl5SUyOfz1fuL4eziBgCYIdBd3LY9SKxly5byer0qKioyOwoAAIaz7S5uSUpNTdW+ffv0+eefq1mzZmbHAQDAMLYu6CtHcSckJGj27NlKSEhQYWGhNm/erOXLl5sdDwCAerPtZ9CS1Lt3b23btk3PPvusZs2apQsXLiguLk5jx441OxoAADfE1lvQAAA4lW0PEgMAwMkoaAAALIiCBgDAgihoAAAsiIIGAMCCKGgAACyIggYAwIIoaAAALIiCBgDAgihoAAAsiIIGAMCCKGgAACyIggYAwIIoaAAALIiCBgDAgihoAAAsiIIGAMCCKGgAACyIggYAwIIoaAAALIiCBgDAgihoAAAsiIIGAMCCKGgAACyIggYAwIIoaAAALIiCBgDAgihoAAAs6P8AmWLiN+RMkEUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 627.67x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Alice's final operations\n",
    "circuit_Deutsch.h(input_register[0])\n",
    "circuit_Deutsch.measure(input_register[0], classical_register[0])\n",
    "\n",
    "# Draw the final version of the circuit \n",
    "print(\"The final version of the circuit\")\n",
    "circuit_Deutsch.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The results of the measurements: {'1': 1}\n",
      "The final result is: 1\n",
      "Bob's chosen function was balanced\n"
     ]
    }
   ],
   "source": [
    "# The execution of the circuit\n",
    "counts = execute(circuit_Deutsch, simulator, shots=1).result().get_counts()\n",
    "\n",
    "# Finding the only key/measurement outcome\n",
    "measurement_result = list(counts.keys())[0]\n",
    "print(\"The results of the measurements: {}\".format(counts))\n",
    "print(\"The final result is: {}\".format(measurement_result))\n",
    "\n",
    "# From the final measurement result, Alice understands if \n",
    "# the Bob's chosen function balanced or constant\n",
    "if measurement_result == '0':\n",
    "    print(\"Bob's chosen function was constant\")\n",
    "elif measurement_result == '1':\n",
    "    print(\"Bob's chosen function was balanced\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that if Alice and Bob will choose to play their \"game\" not with a quantum computer, but with a classical computer, then Bob should execute separately the $f(x)$ function twice for the two possible inputs. In contrast, the quantum computer can do the job with only one execution of $f(x)$. This seems not a big improvement, but suppose that the cost of running the $f(x)$ function is $1m$ dollars [[3]] (Bob rents some computation time from some company that has quantum computers and classical computers). If they are using quantum computer Bob will spend only $1m$ dollars, and if they are using the classical computer they will spend $2m$ dollars. So, the quantum computer is preferable than the classical one for playing this \"game\". More importantly, the Deutsch algorithm shows us the possibility of obtaining an advantage by using quantum computers. As was shown the demonstrated advantage comes from two important \"tools\" of quantum computation: quantum parallelism and quantum interference.\n",
    "\n",
    "  [1]: https://www.cambridge.org/am/academic/subjects/physics/quantum-physics-quantum-information-and-quantum-computation/quantum-computation-and-quantum-information-10th-anniversary-edition?format=HB\n",
    "  [2]: https://quantumcomputing.stackexchange.com/questions/9566/implementing-four-oracles-for-the-deutsch-algorithm-preferably-on-ibm-q-experie\n",
    "  [3]: https://www.youtube.com/watch?v=awpnsGl08bc&list=LLEPoMdv-DZViRaaObznY_-A&index=113&t=0s\n",
    "  [4]: https://courses.edx.org/courses/course-v1:MITx+8.370.2x+1T2018/course/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 align=\"left\">\n",
    "3. The Deutsch-Jozsa algorithm\n",
    "</h3>\n",
    "\n",
    "Deutsch-Jozsa algorithm is the $n$ qubit version of the Deutsch algorithm. The functions now take $n$ bit strings (e.g. \"0101011\") as an input and return one bit output ($0$ or $1$). Bob still is allowed only to use either balanced or constant functions and Alice should find out the property of that function. Bob has two options for constant functions (for all input bit strings $x$ the $f(x) = 0$ or $f(x) = 1$) and $\\begin{pmatrix} 2^n \\\\ 2^{n - 1} \\end{pmatrix}$ options to choose a balanced function. The main steps of the algorithm are presented in the following circuit (a modified version of the Fig.1.20 from the [[1]]):\n",
    "\n",
    "<img src=\"images/Deutsch_Jozsa.png\" alt=\"drawing\" width=\"600\"/>\n",
    "\n",
    "where $\\left| 0 \\right\\rangle^{\\otimes n}$ presents $n$ qubits in the input register all in the $\\left| 0 \\right\\rangle$ state, $H^{\\otimes n}$ is the tensor product of $n$ Hadamard gates that are applied on each qubit in that register, $M^{\\otimes n}$ is $n$ measurements executed on $n$ (all) qubits in the input register. As you can see the circuit is very similar to the circuit from Deutsch algorithm. Now we will go through the steps of the Deutsch-Jozsa algorithm. After $n$ Hadamard gates applied on the input register and one Hadamard gate applied on the output register we will have [[1]]:\n",
    "\n",
    "$$\n",
    "\\left| \\psi_1 \\right\\rangle = \\frac{1}{\\sqrt{2^n}} \\sum_{x} \\left| x \\right\\rangle  \n",
    "\\frac{\\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle}{\\sqrt{2}}\n",
    "$$\n",
    "\n",
    "where the sum is over all possible $x$ bit stings. Then Bob applies chosen $f(x)$ function and obtains the $\\left| \\psi_2 \\right\\rangle$ state:\n",
    "\n",
    "$$\n",
    "\\left| \\psi_2 \\right\\rangle = \\frac{1}{\\sqrt{2^n}} \\sum_{x} \\left| x \\right\\rangle  \n",
    "\\frac{\\left| 0 \\oplus f(x) \\right\\rangle - \\left| 1 \\oplus f(x) \\right\\rangle}{\\sqrt{2}}\n",
    "$$\n",
    "\n",
    "Note that $f(x)$ is either $0$ or $1$ for a given $x$, so:\n",
    "\n",
    "\\begin{align*}\n",
    "&\\text{if f(x) = 0}\\;\\;\\;  (+1)\\left| x \\right\\rangle  \n",
    "\\frac{\\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle}{\\sqrt{2}}\n",
    "\\\\\n",
    "&\\text{if f(x) = 1}\\;\\;\\;  (-1)\\left| x \\right\\rangle  \n",
    "\\frac{\\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle}{\\sqrt{2}}\n",
    "\\end{align*}\n",
    "\n",
    "By taking into account these expressions the $\\left| \\psi_2 \\right\\rangle$ state can be presented in the following form:\n",
    "\n",
    "$$\n",
    "\\left| \\psi_2 \\right\\rangle = \\frac{1}{\\sqrt{2^n}} \\sum_{x} (-1)^{f(x)}\\left| x \\right\\rangle  \n",
    "\\frac{\\left| 0 \\right\\rangle - \\left| 1 \\right\\rangle}{\\sqrt{2}} = \n",
    "\\frac{1}{\\sqrt{2^n}} \\sum_{x} (-1)^{f(x)}\\left| x \\right\\rangle  \n",
    "\\left| - \\right\\rangle\n",
    "$$\n",
    "\n",
    "Bob sends back the qubits to Alice. She applies Hadamard gates on the input register and obtains $H^{\\otimes n} \\frac{1}{\\sqrt{2^n}}\\sum_{x} (-1)^{f(x)}\\left| x \\right\\rangle$ state. This is enough to calculate what is the probability of measuring $\\left|00...0 \\right\\rangle = \\left| 0^{\\otimes n} \\right\\rangle$ state, that will indicate whether the function is balanced or constant. For that, firstly, we should take the inner product between $\\left| 0^{\\otimes n} \\right\\rangle$ state and $H^{\\otimes n} \\frac{1}{\\sqrt{2^n}}\\sum_{x} (-1)^{f(x)}\\left| x \\right\\rangle$ state (similar to [[4]]) in order to calculate the overlap between the states:\n",
    "\n",
    "\\begin{align*}\n",
    "\\left\\langle 0^{\\otimes n} \\right| H^{\\otimes n} \\frac{1}{\\sqrt{2^n}} &\\sum_{x} (-1)^{f(x)}\\left| x \\right\\rangle = \\frac{1}{2^n}\\sum_{y} \\left\\langle y \\right|  \\sum_{x} (-1)^{f(x)}\\left| x \\right\\rangle =\n",
    "\\\\\n",
    "= \n",
    "\\frac{1}{2^n} &\\sum_{x,y} (-1)^{f(x)} \\delta_{x,y}  = \\frac{1}{2^n}\\sum_{x} (-1)^{f(x)}\n",
    "\\end{align*}\n",
    "\n",
    "where we took into account that $\\left\\langle 0^{\\otimes n} \\right| H^{\\otimes n} =  \\frac{1}{\\sqrt{2^n}} \\sum_{y} \\left\\langle y \\right|$ and $\\left\\langle y \\right| \\left| x \\right\\rangle = \\delta_{x,y}$, $\\delta_{x=y} = 1$ and $\\delta_{x \\ne y} = 0$, because of the orthonormality of the states. The probability of measuring $\\left| 0 \\right\\rangle^{\\otimes n}$ state is equal to the square of the absolute value of the calculated overlap:\n",
    "\n",
    "$$p_{0^{\\otimes n}} = \\left| \\frac{1}{2^n}\\sum_{x} (-1)^{f(x)} \\right|^2$$\n",
    "\n",
    "If we have a constant function ($f(x) = 1$ for all $x$ or $f(x) = 0$ for all $x$) then $p_{0^{\\otimes n}} = 1$. Therefore, if the function is constant then Alice always will measure $\\left| 0^{\\otimes n} \\right\\rangle$. Otherwise, if Bob's chosen function is balanced then half of the $(-1)^{f(x)}$ terms in the sum will be equal to $-1$, and the other half will be equal to $+1$. Consequently, $p_{0^{\\otimes n}} = 0$ if we have a balanced function and Alice will never measure $\\left| 0^{\\otimes n} \\right\\rangle$. If the measurement outcome yields $\\left| 0^{\\otimes n} \\right\\rangle$, Alice with certainty will know that the function was constant, otherwise, she will know that the function was balanced.\n",
    "\n",
    "For this procedure, Bob will need to execute the circuit that corresponds to the chosen function only one time (like in the Deutsch algorithm). Classical deterministic approach for this problem will require to execute $f(x)$ function $2^{n-1} + 1$ times in the worst-case scenario. Thus Alice and Bob are happy with their quantum computer. Here we should note that if they have the possibility to play the \"game\" with a probabilistic classical computer, then the advantage of choosing quantum computer will not be as dramatic as it is in comparison with the classical deterministic approach [[1]].\n",
    "\n",
    "For simplicity, in the implementation, we will allow Bob to use only two functions: one is a constant $f(x) = 1$ function, that can be implemented by applying $X$ gate on the output qubit, and the second one is the function that we have used in the quantum parallelism paragraph that is actually an example of a balanced function. The implementation is done for 4 qubits:\n",
    "\n",
    "  [1]: https://www.cambridge.org/am/academic/subjects/physics/quantum-physics-quantum-information-and-quantum-computation/quantum-computation-and-quantum-information-10th-anniversary-edition?format=HB\n",
    "  [2]: https://quantumcomputing.stackexchange.com/questions/9566/implementing-four-oracles-for-the-deutsch-algorithm-preferably-on-ibm-q-experie\n",
    "  [3]: https://www.youtube.com/watch?v=awpnsGl08bc&list=LLEPoMdv-DZViRaaObznY_-A&index=113&t=0s\n",
    "  [4]: https://courses.edx.org/courses/course-v1:MITx+8.370.2x+1T2018/course/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<qiskit.circuit.instructionset.InstructionSet at 0x7fd503d11fd0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Alice: qubit preparation\n",
    "input_register = QuantumRegister(3, \"i\")\n",
    "output_register = QuantumRegister(1, \"o\")\n",
    "classical_register = ClassicalRegister(3, \"c\")\n",
    "\n",
    "circuit_Deutsch_Jozsa = QuantumCircuit(input_register, output_register, classical_register)\n",
    "\n",
    "# Prepare the qubit in the output register in the |1> state\n",
    "circuit_Deutsch_Jozsa.x(output_register[0])\n",
    "\n",
    "# Hadamard gates on both input and output registers\n",
    "circuit_Deutsch_Jozsa.h(input_register) # Hadamard gate is applied to all qubits in the input_register\n",
    "circuit_Deutsch_Jozsa.h(output_register[0])\n",
    "\n",
    "# Add a barrier\n",
    "circuit_Deutsch_Jozsa.barrier()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alice sends the qubits to Bob. Bob applies $f(x) = 1$ constant function and sends back the qubits to Alice. Alice measures the qubits in the input register and finds out the property of the function (constant or balanced):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A function that will help Alice to define if\n",
    "# the chosen function was balanced or constant \n",
    "def is_balanced_or_constant(circuit, bakend):\n",
    "    \"\"\"\n",
    "    checks if the given circuit implements\n",
    "    a balanced function or balanced\n",
    "    \n",
    "    :param circuit: QuantumCircuit that implements either \n",
    "                    balanced or constant function\n",
    "    :param bakend: specifies the quantum simulator or \n",
    "                   hardware that will be used\n",
    "    \"\"\"\n",
    "    # The execution of the circuit\n",
    "    counts = execute(circuit, bakend, shots=1).result().get_counts()\n",
    "\n",
    "    # Finding the only key/measurement outcome\n",
    "    measurement_result = list(counts.keys())[0]\n",
    "    print(\"The results of the measurements: {}\".format(counts))\n",
    "    print(\"The final result is: {}\".format(measurement_result))\n",
    "\n",
    "    # Alice checks if Bob's function was constant or balanced\n",
    "    if '000' in counts:\n",
    "        print(\"Bob's chosen function was constant\")\n",
    "    else:\n",
    "        print(\"Bob's chosen function was balanced\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 627.67x325.08 with 1 Axes>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Circuit for the constant function\n",
    "circtuit_Deutsch_Jozsa_constant  = QuantumCircuit(input_register, output_register, classical_register)\n",
    "circtuit_Deutsch_Jozsa_constant += circuit_Deutsch_Jozsa\n",
    "\n",
    "# Implementing the f(x) = 1 constant function\n",
    "circtuit_Deutsch_Jozsa_constant.x(output_register[0])\n",
    "\n",
    "# Add a barrier\n",
    "circtuit_Deutsch_Jozsa_constant.barrier()\n",
    "\n",
    "# Final Hadamard gates applied on all qubits in the input register\n",
    "circtuit_Deutsch_Jozsa_constant.h(input_register)\n",
    "\n",
    "# Measurements executed for all qubits in the input register\n",
    "circtuit_Deutsch_Jozsa_constant.measure(input_register, classical_register)\n",
    "\n",
    "# Draw the circuit\n",
    "circtuit_Deutsch_Jozsa_constant.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The results of the measurements: {'000': 1}\n",
      "The final result is: 000\n",
      "Bob's chosen function was constant\n"
     ]
    }
   ],
   "source": [
    "# Alice uses is_balanced_or_constant() function\n",
    "is_balanced_or_constant(circtuit_Deutsch_Jozsa_constant, simulator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will do the same calculations but for a balanced $f(x)$ function that we have used in the quantum parallelism paragraph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 748.07x325.08 with 1 Axes>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Circuit for the balanced case\n",
    "circtuit_Deutsch_Jozsa_balanced  = QuantumCircuit(input_register, output_register, classical_register)\n",
    "circtuit_Deutsch_Jozsa_balanced += circuit_Deutsch_Jozsa\n",
    "\n",
    "# implementing the balanced function\n",
    "circtuit_Deutsch_Jozsa_balanced.cx(input_register[0], output_register[0])\n",
    "circtuit_Deutsch_Jozsa_balanced.cx(input_register[1], output_register[0])\n",
    "circtuit_Deutsch_Jozsa_balanced.cx(input_register[2], output_register[0])\n",
    "\n",
    "# add a barrier\n",
    "circtuit_Deutsch_Jozsa_balanced.barrier()\n",
    "\n",
    "# final Hadamard gates applied on all qubits in the input register\n",
    "circtuit_Deutsch_Jozsa_balanced.h(input_register)\n",
    "\n",
    "\n",
    "# measurements executed for all qubits in the input register\n",
    "circtuit_Deutsch_Jozsa_balanced.measure(input_register, classical_register)\n",
    "\n",
    "# draw the circuit\n",
    "circtuit_Deutsch_Jozsa_balanced.draw(output=\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The results of the measurements: {'111': 1}\n",
      "The final result is: 111\n",
      "Bob's chosen function was balanced\n"
     ]
    }
   ],
   "source": [
    "# Alice uses is_balanced_or_constant() function\n",
    "is_balanced_or_constant(circtuit_Deutsch_Jozsa_balanced, simulator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[[Homepage][5]]**\n",
    "\n",
    "<h3 align=\"left\">\n",
    "References\n",
    "</h3>\n",
    "\n",
    "[[1]] [M.A. Nielsen, I.L. Chuang, Cambridge University Press New York, \"Quantum Computation and Quantum Information: 10th Anniversary Edition\n",
    "10th\" (2011)][1]\n",
    "\n",
    "[[2]] [A question about implementing four oracles for the Deutsch algorithm in the Quantum Computing Stack Exchange][2]\n",
    "\n",
    "[[3]] [Video lecture \"24. Entanglement — QComputing, EPR, and Bell\" by Allan Adams: starting from 50:20 the Deutsch algorithm][3]\n",
    "\n",
    "[[4]] [edx course: Quantum Information Science I, Part 2][4]\n",
    "\n",
    "\n",
    "  [1]: https://www.cambridge.org/am/academic/subjects/physics/quantum-physics-quantum-information-and-quantum-computation/quantum-computation-and-quantum-information-10th-anniversary-edition?format=HB\n",
    "  [2]: https://quantumcomputing.stackexchange.com/questions/9566/implementing-four-oracles-for-the-deutsch-algorithm-preferably-on-ibm-q-experie\n",
    "  [3]: https://www.youtube.com/watch?v=awpnsGl08bc&list=LLEPoMdv-DZViRaaObznY_-A&index=113&t=0s\n",
    "  [4]: https://courses.edx.org/courses/course-v1:MITx+8.370.2x+1T2018/course/\n",
    "  [5]: https://github.com/DavitKhach/quantum-algorithms-tutorials\n",
    "  [6]: https://nbviewer.jupyter.org/github/DavitKhach/quantum-algorithms-tutorials/blob/master/quantum_parallelism_Deutsch_Jozsa.ipynb"
   ]
  }
 ],
 "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}