tutorials/circuits/3_summary_of_quantum_operations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Summary of Quantum Operations "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " In this section we will go into the different operations that are available in Qiskit Terra. These are:\n",
    "\n",
    "- Single-qubit quantum gates\n",
    "- Multi-qubit quantum gates\n",
    "- Measurements\n",
    "- Reset\n",
    "- Conditionals\n",
    "- State initialization\n",
    "\n",
    "We will also show you how to use the three different simulators:\n",
    "\n",
    "- unitary_simulator\n",
    "- qasm_simulator\n",
    "- statevector_simulator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:10:06.399483Z",
     "start_time": "2021-07-31T05:10:06.113598Z"
    }
   },
   "outputs": [],
   "source": [
    "# Useful additional packages \n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from math import pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:10:07.863361Z",
     "start_time": "2021-07-31T05:10:06.401320Z"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, transpile\n",
    "from qiskit.tools.visualization import circuit_drawer\n",
    "from qiskit.quantum_info import state_fidelity\n",
    "from qiskit import BasicAer\n",
    "\n",
    "backend = BasicAer.get_backend('unitary_simulator')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Single Qubit Quantum states <a name=\"single_states\"/>\n",
    "\n",
    "A single qubit quantum state can be written as\n",
    "\n",
    "$$\\left|\\psi\\right\\rangle = \\alpha\\left|0\\right\\rangle + \\beta \\left|1\\right\\rangle$$\n",
    "\n",
    "\n",
    "where $\\alpha$ and $\\beta$ are complex numbers. In a measurement the probability of the bit being in $\\left|0\\right\\rangle$ is $|\\alpha|^2$ and $\\left|1\\right\\rangle$ is $|\\beta|^2$. As a vector this is\n",
    "\n",
    "$$\n",
    "\\left|\\psi\\right\\rangle =  \n",
    "\\begin{pmatrix}\n",
    "\\alpha \\\\\n",
    "\\beta\n",
    "\\end{pmatrix}.\n",
    "$$\n",
    "\n",
    "Note, due to the conservation of probability $|\\alpha|^2+ |\\beta|^2 = 1$ and since global phase is undetectable $\\left|\\psi\\right\\rangle := e^{i\\delta} \\left|\\psi\\right\\rangle$ we only require two real numbers to describe a single qubit quantum state.\n",
    "\n",
    "A convenient representation is\n",
    "\n",
    "$$\\left|\\psi\\right\\rangle = \\cos(\\theta/2)\\left|0\\right\\rangle + \\sin(\\theta/2)e^{i\\phi}\\left|1\\right\\rangle$$\n",
    "\n",
    "where $0\\leq \\phi < 2\\pi$, and $0\\leq \\theta \\leq \\pi$.  From this, it is clear that there is a one-to-one correspondence between qubit states ($\\mathbb{C}^2$) and the points on the surface of a unit sphere ($\\mathbb{S}^2$). This is called the Bloch sphere representation of a qubit state.\n",
    "\n",
    "Quantum gates/operations are usually represented as matrices. A gate which acts on a qubit is represented by a $2\\times 2$ unitary matrix $U$. The action of the quantum gate is found by multiplying the matrix representing the gate with the vector which represents the quantum state.\n",
    "\n",
    "$$\\left|\\psi'\\right\\rangle = U\\left|\\psi\\right\\rangle$$\n",
    "\n",
    "A general unitary must be able to take the $\\left|0\\right\\rangle$ to the above state. That is \n",
    "\n",
    "$$\n",
    "U = \\begin{pmatrix}\n",
    "\\cos(\\theta/2) & a \\\\\n",
    "e^{i\\phi}\\sin(\\theta/2) & b \n",
    "\\end{pmatrix}\n",
    "$$ \n",
    "\n",
    "where $a$ and $b$ are complex numbers constrained such that $U^\\dagger U = I$ for all $0\\leq\\theta\\leq\\pi$ and $0\\leq \\phi<2\\pi$. This gives 3 constraints and as such $a\\rightarrow -e^{i\\lambda}\\sin(\\theta/2)$ and $b\\rightarrow e^{i\\lambda+i\\phi}\\cos(\\theta/2)$ where $0\\leq \\lambda<2\\pi$ giving \n",
    "\n",
    "$$\n",
    "U(\\theta, \\phi, \\lambda) =\n",
    "    \\begin{pmatrix}\n",
    "        \\cos\\left(\\frac{\\theta}{2}\\right)          & -e^{i\\lambda}\\sin\\left(\\frac{\\theta}{2}\\right) \\\\\n",
    "        e^{i\\phi}\\sin\\left(\\frac{\\theta}{2}\\right) & e^{i(\\phi+\\lambda)}\\cos\\left(\\frac{\\theta}{2}\\right)\n",
    "    \\end{pmatrix}\n",
    "$$\n",
    "\n",
    "This is the most general form of a single qubit unitary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Single-Qubit Gates <a name=\"single_gates\"/>\n",
    "\n",
    "The single-qubit gates available are:\n",
    "- U gate\n",
    "- P gate\n",
    "- Identity gate\n",
    "- Pauli gates\n",
    "- Clifford gates\n",
    "- $C3$ gates\n",
    "- Standard rotation gates \n",
    "\n",
    "We have provided a backend: `unitary_simulator` to allow you to calculate the unitary matrices. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:10:08.577924Z",
     "start_time": "2021-07-31T05:10:08.575044Z"
    }
   },
   "outputs": [],
   "source": [
    "q = QuantumRegister(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### U gate\n",
    "\n",
    "In Qiskit we give you access to the general unitary using the $u$ gate, which has the following matrix form\n",
    "\n",
    "$$\n",
    "U(\\theta, \\phi, \\lambda) =\n",
    "    \\begin{pmatrix}\n",
    "        \\cos\\left(\\frac{\\theta}{2}\\right)          & -e^{i\\lambda}\\sin\\left(\\frac{\\theta}{2}\\right) \\\\\n",
    "        e^{i\\phi}\\sin\\left(\\frac{\\theta}{2}\\right) & e^{i(\\phi+\\lambda)}\\cos\\left(\\frac{\\theta}{2}\\right)\n",
    "    \\end{pmatrix}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:10:09.406278Z",
     "start_time": "2021-07-31T05:10:09.398661Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">    ┌────────────────┐\n",
       "q0: ┤ U(π/2,π/4,π/8) ├\n",
       "    └────────────────┘</pre>"
      ],
      "text/plain": [
       "    ┌────────────────┐\n",
       "q0: ┤ U(π/2,π/4,π/8) ├\n",
       "    └────────────────┘"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.u(pi/2,pi/4,pi/8,q)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:10:10.420628Z",
     "start_time": "2021-07-31T05:10:10.342207Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.707+0.j   , -0.653-0.271j],\n",
       "       [ 0.5  +0.5j  ,  0.271+0.653j]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "Note on U gate deprecation\n",
    "\n",
    "The QuantumCircuit methods $u1$, $u2$ and $u3$ are now deprecated. Instead, the following replacements should be used.\n",
    "\n",
    "- $u1(\\lambda) = p(\\lambda) = u(0, 0, \\lambda)$\n",
    "\n",
    "- $u2(\\phi, \\lambda) = u(\\frac{\\pi}{2}, \\phi, \\lambda) = p(\\frac{\\pi}{2} + \\phi) \\cdot sx \\cdot p(\\frac{\\pi}{2} - \\lambda)$\n",
    "\n",
    "- $u3(\\theta, \\phi, \\lambda) = u(\\theta, \\phi, \\lambda) = p(\\phi + \\pi) \\cdot sx \\cdot p(\\theta + \\pi) \\cdot sx \\cdot p(\\lambda)$\n",
    "\n",
    "```python\n",
    "# qc.u1(lambda) is now:\n",
    "qc.p(lambda)\n",
    "\n",
    "# qc.u2(phi, lambda) is now:\n",
    "qc.u(pi/2, phi, lambda)\n",
    "\n",
    "# qc.u3(theta, phi, lambda) is now:\n",
    "qc.u(theta, phi, lambda)\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### P gate\n",
    "\n",
    "The $p(\\lambda)= u(0, 0, \\lambda)$ gate has the matrix form\n",
    "\n",
    "$$\n",
    "p(\\lambda) = \n",
    "\\begin{pmatrix}\n",
    "1 & 0 \\\\\n",
    "0 & e^{i \\lambda}\n",
    "\\end{pmatrix},\n",
    "$$\n",
    "\n",
    "which is useful as it allows us to apply a quantum phase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:10:51.997454Z",
     "start_time": "2021-07-31T05:10:51.992620Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">    ┌────────┐\n",
       "q0: ┤ P(π/2) ├\n",
       "    └────────┘</pre>"
      ],
      "text/plain": [
       "    ┌────────┐\n",
       "q0: ┤ P(π/2) ├\n",
       "    └────────┘"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.p(pi/2,q)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:10:58.149042Z",
     "start_time": "2021-07-31T05:10:58.138158Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+1.j]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Identity gate\n",
    "\n",
    "The identity gate is $Id = p(0)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:00.799001Z",
     "start_time": "2021-07-31T05:11:00.794172Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">    ┌───┐\n",
       "q0: ┤ I ├\n",
       "    └───┘</pre>"
      ],
      "text/plain": [
       "    ┌───┐\n",
       "q0: ┤ I ├\n",
       "    └───┘"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.id(q)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:03.627749Z",
     "start_time": "2021-07-31T05:11:03.619164Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 1.+0.j]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pauli gates\n",
    "\n",
    "#### $X$: bit-flip gate\n",
    "\n",
    "The bit-flip gate $X$ is defined as:\n",
    "\n",
    "$$\n",
    "X   =  \n",
    "\\begin{pmatrix}\n",
    "0 & 1\\\\\n",
    "1 & 0\n",
    "\\end{pmatrix}= u(\\pi,0,\\pi)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:05.287138Z",
     "start_time": "2021-07-31T05:11:05.281859Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">    ┌───┐\n",
       "q0: ┤ X ├\n",
       "    └───┘</pre>"
      ],
      "text/plain": [
       "    ┌───┐\n",
       "q0: ┤ X ├\n",
       "    └───┘"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.x(q)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:07.285569Z",
     "start_time": "2021-07-31T05:11:07.276242Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.+0.j, 1.+0.j],\n",
       "       [1.+0.j, 0.+0.j]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### $Y$: bit- and phase-flip gate\n",
    "\n",
    "The $Y$ gate is defined as:\n",
    "\n",
    "$$\n",
    "Y  = \n",
    "\\begin{pmatrix}\n",
    "0 & -i\\\\\n",
    "i & 0\n",
    "\\end{pmatrix}=u(\\pi,\\pi/2,\\pi/2)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:09.274252Z",
     "start_time": "2021-07-31T05:11:09.270141Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">    ┌───┐\n",
       "q0: ┤ Y ├\n",
       "    └───┘</pre>"
      ],
      "text/plain": [
       "    ┌───┐\n",
       "q0: ┤ Y ├\n",
       "    └───┘"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.y(q)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:11.878524Z",
     "start_time": "2021-07-31T05:11:11.868931Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.+0.j, -0.-1.j],\n",
       "       [ 0.+1.j,  0.+0.j]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### $Z$: phase-flip gate\n",
    "\n",
    "The phase-flip gate $Z$ is defined as:\n",
    "\n",
    "$$\n",
    "Z = \n",
    "\\begin{pmatrix}\n",
    "1 & 0\\\\\n",
    "0 & -1\n",
    "\\end{pmatrix}=p(\\pi)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:13.903719Z",
     "start_time": "2021-07-31T05:11:13.898408Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">    ┌───┐\n",
       "q0: ┤ Z ├\n",
       "    └───┘</pre>"
      ],
      "text/plain": [
       "    ┌───┐\n",
       "q0: ┤ Z ├\n",
       "    └───┘"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.z(q)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:17.430999Z",
     "start_time": "2021-07-31T05:11:17.420906Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.+0.j,  0.+0.j],\n",
       "       [ 0.+0.j, -1.+0.j]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Clifford gates\n",
    "\n",
    "#### Hadamard gate\n",
    "\n",
    "$$\n",
    "H = \n",
    "\\frac{1}{\\sqrt{2}}\n",
    "\\begin{pmatrix}\n",
    "1 & 1\\\\\n",
    "1 & -1\n",
    "\\end{pmatrix}= u(\\pi/2,0,\\pi)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:24.374244Z",
     "start_time": "2021-07-31T05:11:24.369684Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">    ┌───┐\n",
       "q0: ┤ H ├\n",
       "    └───┘</pre>"
      ],
      "text/plain": [
       "    ┌───┐\n",
       "q0: ┤ H ├\n",
       "    └───┘"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.h(q)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:24.964793Z",
     "start_time": "2021-07-31T05:11:24.956019Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.707+0.j,  0.707-0.j],\n",
       "       [ 0.707+0.j, -0.707+0.j]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### $S$ (or, $\\sqrt{Z}$ phase) gate\n",
    "\n",
    "$$\n",
    "S = \n",
    "\\begin{pmatrix}\n",
    "1 & 0\\\\\n",
    "0 & i\n",
    "\\end{pmatrix}= p(\\pi/2)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:27.577029Z",
     "start_time": "2021-07-31T05:11:27.572229Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">    ┌───┐\n",
       "q0: ┤ S ├\n",
       "    └───┘</pre>"
      ],
      "text/plain": [
       "    ┌───┐\n",
       "q0: ┤ S ├\n",
       "    └───┘"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.s(q)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:30.150288Z",
     "start_time": "2021-07-31T05:11:30.141012Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+1.j]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### $S^{\\dagger}$ (or, conjugate of $\\sqrt{Z}$ phase) gate\n",
    "\n",
    "$$\n",
    "S^{\\dagger} = \n",
    "\\begin{pmatrix}\n",
    "1 & 0\\\\\n",
    "0 & -i\n",
    "\\end{pmatrix}= p(-\\pi/2)\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:31.674786Z",
     "start_time": "2021-07-31T05:11:31.669677Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">    ┌─────┐\n",
       "q0: ┤ Sdg ├\n",
       "    └─────┘</pre>"
      ],
      "text/plain": [
       "    ┌─────┐\n",
       "q0: ┤ Sdg ├\n",
       "    └─────┘"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.sdg(q)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:34.228098Z",
     "start_time": "2021-07-31T05:11:34.218323Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.-1.j]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $C3$ gates\n",
    "#### $T$ (or, $\\sqrt{S}$ phase) gate\n",
    "\n",
    "$$\n",
    "T = \n",
    "\\begin{pmatrix}\n",
    "1 & 0\\\\\n",
    "0 & e^{i \\pi/4}\n",
    "\\end{pmatrix}= p(\\pi/4) \n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:35.573569Z",
     "start_time": "2021-07-31T05:11:35.568858Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">    ┌───┐\n",
       "q0: ┤ T ├\n",
       "    └───┘</pre>"
      ],
      "text/plain": [
       "    ┌───┐\n",
       "q0: ┤ T ├\n",
       "    └───┘"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.t(q)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:38.030353Z",
     "start_time": "2021-07-31T05:11:38.020798Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.   +0.j   , 0.   +0.j   ],\n",
       "       [0.   +0.j   , 0.707+0.707j]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### $T^{\\dagger}$ (or, conjugate of $\\sqrt{S}$ phase) gate\n",
    "\n",
    "$$\n",
    "T^{\\dagger} =  \n",
    "\\begin{pmatrix}\n",
    "1 & 0\\\\\n",
    "0 & e^{-i \\pi/4}\n",
    "\\end{pmatrix}= p(-\\pi/4)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:39.747528Z",
     "start_time": "2021-07-31T05:11:39.742799Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">    ┌─────┐\n",
       "q0: ┤ Tdg ├\n",
       "    └─────┘</pre>"
      ],
      "text/plain": [
       "    ┌─────┐\n",
       "q0: ┤ Tdg ├\n",
       "    └─────┘"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.tdg(q)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:43.129450Z",
     "start_time": "2021-07-31T05:11:43.119304Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.   +0.j   , 0.   +0.j   ],\n",
       "       [0.   +0.j   , 0.707-0.707j]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Standard Rotations\n",
    "\n",
    "The standard rotation gates are those that define rotations around the Paulis $P=\\{X,Y,Z\\}$. They are defined as \n",
    "\n",
    "$$ R_P(\\theta) = \\exp(-i \\theta P/2) = \\cos(\\theta/2)I -i \\sin(\\theta/2)P$$\n",
    "\n",
    "#### Rotation around X-axis\n",
    "\n",
    "$$\n",
    "R_x(\\theta) = \n",
    "\\begin{pmatrix}\n",
    "\\cos(\\theta/2) & -i\\sin(\\theta/2)\\\\\n",
    "-i\\sin(\\theta/2) & \\cos(\\theta/2)\n",
    "\\end{pmatrix} = u(\\theta, -\\pi/2,\\pi/2)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:43.968605Z",
     "start_time": "2021-07-31T05:11:43.963670Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">    ┌─────────┐\n",
       "q0: ┤ Rx(π/2) ├\n",
       "    └─────────┘</pre>"
      ],
      "text/plain": [
       "    ┌─────────┐\n",
       "q0: ┤ Rx(π/2) ├\n",
       "    └─────────┘"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.rx(pi/2,q)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:47.140262Z",
     "start_time": "2021-07-31T05:11:47.128900Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.707+0.j   , -0.   -0.707j],\n",
       "       [ 0.   -0.707j,  0.707+0.j   ]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Rotation around Y-axis\n",
    "\n",
    "$$\n",
    "R_y(\\theta) =\n",
    "\\begin{pmatrix}\n",
    "\\cos(\\theta/2) & - \\sin(\\theta/2)\\\\\n",
    "\\sin(\\theta/2) & \\cos(\\theta/2).\n",
    "\\end{pmatrix} =u(\\theta,0,0)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:48.483090Z",
     "start_time": "2021-07-31T05:11:48.477062Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">    ┌─────────┐\n",
       "q0: ┤ Ry(π/2) ├\n",
       "    └─────────┘</pre>"
      ],
      "text/plain": [
       "    ┌─────────┐\n",
       "q0: ┤ Ry(π/2) ├\n",
       "    └─────────┘"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.ry(pi/2,q)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:51.011307Z",
     "start_time": "2021-07-31T05:11:51.001011Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.707+0.j, -0.707+0.j],\n",
       "       [ 0.707+0.j,  0.707+0.j]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Rotation around Z-axis\n",
    "\n",
    "$$\n",
    "R_z(\\phi) = \n",
    "\\begin{pmatrix}\n",
    "e^{-i \\phi/2} & 0 \\\\\n",
    "0 & e^{i \\phi/2}\n",
    "\\end{pmatrix}\\equiv p(\\phi)\n",
    "$$\n",
    "\n",
    "Note that here we have used an equivalent as it is different to $p$ by a global phase $e^{-i \\phi/2}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:51.729618Z",
     "start_time": "2021-07-31T05:11:51.724574Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">    ┌─────────┐\n",
       "q0: ┤ Rz(π/2) ├\n",
       "    └─────────┘</pre>"
      ],
      "text/plain": [
       "    ┌─────────┐\n",
       "q0: ┤ Rz(π/2) ├\n",
       "    └─────────┘"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.rz(pi/2,q)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:54.372720Z",
     "start_time": "2021-07-31T05:11:54.363623Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.707-0.707j, 0.   +0.j   ],\n",
       "       [0.   +0.j   , 0.707+0.707j]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note this is different due only to a global phase."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi-Qubit Gates <a name=\"multi_gates\"/>\n",
    "\n",
    "### Mathematical Preliminaries\n",
    "\n",
    "The space of a quantum computer grows exponentially with the number of qubits. For $n$ qubits the complex vector space has dimension $d=2^n$. To describe states of a multi-qubit system, the tensor product is used to \"glue together\" operators and basis vectors.\n",
    "\n",
    "Let's start by considering a 2-qubit system. Given two operators $A$ and $B$ that each act on one qubit, the joint operator $A \\otimes B$ acting on two qubits is\n",
    "\n",
    "$$\\begin{equation}\n",
    "\tA\\otimes B = \n",
    "\t\\begin{pmatrix} \n",
    "\t\tA_{00} \\begin{pmatrix} \n",
    "\t\t\tB_{00} & B_{01} \\\\\n",
    "\t\t\tB_{10} & B_{11}\n",
    "\t\t\\end{pmatrix} & A_{01} \t\\begin{pmatrix} \n",
    "\t\t\t\tB_{00} & B_{01} \\\\\n",
    "\t\t\t\tB_{10} & B_{11}\n",
    "\t\t\t\\end{pmatrix} \\\\\n",
    "\t\tA_{10} \t\\begin{pmatrix} \n",
    "\t\t\t\t\tB_{00} & B_{01} \\\\\n",
    "\t\t\t\t\tB_{10} & B_{11}\n",
    "\t\t\t\t\\end{pmatrix} & A_{11} \t\\begin{pmatrix} \n",
    "\t\t\t\t\t\t\tB_{00} & B_{01} \\\\\n",
    "\t\t\t\t\t\t\tB_{10} & B_{11}\n",
    "\t\t\t\t\t\t\\end{pmatrix}\n",
    "\t\\end{pmatrix},\t\t\t\t\t\t\n",
    "\\end{equation}$$\n",
    "\n",
    "where $A_{jk}$ and $B_{lm}$ are the matrix elements of $A$ and $B$, respectively.\n",
    "\n",
    "Analogously, the basis vectors for the 2-qubit system are formed using the tensor product of basis vectors for a single qubit:\n",
    "$$\\begin{equation}\\begin{split}\n",
    "\t\\left|{00}\\right\\rangle &= \\begin{pmatrix} \n",
    "\t\t1 \\begin{pmatrix} \n",
    "\t\t\t1  \\\\\n",
    "\t\t\t0\n",
    "\t\t\\end{pmatrix} \\\\\n",
    "\t\t0 \\begin{pmatrix} \n",
    "\t\t\t1  \\\\\n",
    "\t\t\t0 \n",
    "\t\t\\end{pmatrix}\n",
    "\t\\end{pmatrix} = \\begin{pmatrix} 1 \\\\ 0 \\\\ 0 \\\\0 \\end{pmatrix}~~~\\left|{01}\\right\\rangle = \\begin{pmatrix} \n",
    "\t1 \\begin{pmatrix} \n",
    "\t0 \\\\\n",
    "\t1\n",
    "\t\\end{pmatrix} \\\\\n",
    "\t0 \\begin{pmatrix} \n",
    "\t0  \\\\\n",
    "\t1 \n",
    "\t\\end{pmatrix}\n",
    "\t\\end{pmatrix} = \\begin{pmatrix}0 \\\\ 1 \\\\ 0 \\\\ 0 \\end{pmatrix}\\end{split}\n",
    "\\end{equation}$$\n",
    "    \n",
    "$$\\begin{equation}\\begin{split}\\left|{10}\\right\\rangle = \\begin{pmatrix} \n",
    "\t0\\begin{pmatrix} \n",
    "\t1  \\\\\n",
    "\t0\n",
    "\t\\end{pmatrix} \\\\\n",
    "\t1\\begin{pmatrix} \n",
    "\t1 \\\\\n",
    "\t0 \n",
    "\t\\end{pmatrix}\n",
    "\t\\end{pmatrix} = \\begin{pmatrix} 0 \\\\ 0 \\\\ 1 \\\\ 0 \\end{pmatrix}~~~ \t\\left|{11}\\right\\rangle = \\begin{pmatrix} \n",
    "\t0 \\begin{pmatrix} \n",
    "\t0  \\\\\n",
    "\t1\n",
    "\t\\end{pmatrix} \\\\\n",
    "\t1\\begin{pmatrix} \n",
    "\t0  \\\\\n",
    "\t1 \n",
    "\t\\end{pmatrix}\n",
    "\t\\end{pmatrix} = \\begin{pmatrix} 0 \\\\ 0 \\\\ 0 \\\\1 \\end{pmatrix}\\end{split}\n",
    "\\end{equation}.$$\n",
    "\n",
    "Note we've introduced a shorthand for the tensor product of basis vectors, wherein $\\left|0\\right\\rangle \\otimes \\left|0\\right\\rangle$ is written as $\\left|00\\right\\rangle$. The state of an $n$-qubit system can be described using the $n$-fold tensor product of single-qubit basis vectors. Notice that the basis vectors for a 2-qubit system are 4-dimensional; in general, the basis vectors of an $n$-qubit system are $2^{n}$-dimensional, as noted earlier.\n",
    "\n",
    "### Basis vector ordering in Qiskit\n",
    "\n",
    "Within the physics community, the qubits of a multi-qubit systems are typically ordered with the first qubit on the left-most side of the tensor product and the last qubit on the right-most side. For instance, if the first qubit is in state $\\left|0\\right\\rangle$ and second is in state $\\left|1\\right\\rangle$, their joint state would be $\\left|01\\right\\rangle$. Qiskit uses a slightly different ordering of the qubits, in which the qubits are represented from the most significant bit (MSB) on the left to the least significant bit (LSB) on the right (little-endian). This is similar to bitstring representation on classical computers, and enables easy conversion from bitstrings to integers after measurements are performed. For the example just given, the joint state would be represented as $\\left|10\\right\\rangle$. Importantly, *this change in the representation of multi-qubit states affects the way multi-qubit gates are represented in Qiskit*, as discussed below.\n",
    "\n",
    "The representation used in Qiskit enumerates the basis vectors in increasing order of the integers they represent. For instance, the basis vectors for a 2-qubit system would be ordered as $\\left|00\\right\\rangle$, $\\left|01\\right\\rangle$, $\\left|10\\right\\rangle$, and $\\left|11\\right\\rangle$. Thinking of the basis vectors as bit strings, they encode the integers 0,1,2 and 3, respectively.\n",
    "\n",
    "\n",
    "### Controlled operations on qubits\n",
    "\n",
    "A common multi-qubit gate involves the application of a gate to one qubit, conditioned on the state of another qubit. For instance, we might want to flip the state of the second qubit when the first qubit is in $\\left|0\\right\\rangle$. Such gates are known as _controlled gates_. The standard multi-qubit gates consist of two-qubit gates and three-qubit gates. The two-qubit gates are:\n",
    "- controlled Pauli gates\n",
    "- controlled Hadamard gate\n",
    "- controlled rotation gates\n",
    "- controlled phase gate\n",
    "- controlled u3 gate\n",
    "- swap gate\n",
    "\n",
    "The three-qubit gates are: \n",
    "- Toffoli gate \n",
    "- Fredkin gate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two-qubit gates <a name=\"two_gates\"/>\n",
    "\n",
    "Most of the two-qubit gates are of the controlled type (the SWAP gate being the exception). In general, a controlled two-qubit gate $C_{U}$ acts to apply the single-qubit unitary $U$ to the second qubit when the state of the first qubit is in $\\left|1\\right\\rangle$. Suppose $U$ has a matrix representation\n",
    "\n",
    "$$U = \\begin{pmatrix} u_{00} & u_{01} \\\\ u_{10} & u_{11}\\end{pmatrix}.$$\n",
    "\n",
    "We can work out the action of $C_{U}$ as follows. Recall that the basis vectors for a two-qubit system are ordered as $\\left|00\\right\\rangle, \\left|01\\right\\rangle, \\left|10\\right\\rangle, \\left|11\\right\\rangle$. Suppose the **control qubit** is **qubit 0** (which, according to Qiskit's convention, is one the _right-hand_ side of the tensor product). If the control qubit is in $\\left|1\\right\\rangle$, $U$ should be applied to the **target** (qubit 1, on the _left-hand_ side of the tensor product). Therefore, under the action of $C_{U}$, the basis vectors are transformed according to\n",
    "\n",
    "$$\\begin{align*}\n",
    "C_{U}: \\underset{\\text{qubit}~1}{\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|0\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|0\\right\\rangle}\\\\\n",
    "C_{U}: \\underset{\\text{qubit}~1}{\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|1\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{U\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|1\\right\\rangle}\\\\\n",
    "C_{U}: \\underset{\\text{qubit}~1}{\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|0\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|0\\right\\rangle}\\\\\n",
    "C_{U}: \\underset{\\text{qubit}~1}{\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|1\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{U\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|1\\right\\rangle}\\\\\n",
    "\\end{align*}.$$\n",
    "\n",
    "In matrix form, the action of $C_{U}$ is\n",
    "\n",
    "$$\\begin{equation}\n",
    "\tC_U = \\begin{pmatrix}\n",
    "\t1 & 0 & 0 & 0 \\\\\n",
    "\t0 & u_{00} & 0 & u_{01} \\\\\n",
    "\t0 & 0 & 1 & 0 \\\\\n",
    "\t0 & u_{10} &0 & u_{11}\n",
    "\t\t\\end{pmatrix}.\n",
    "\\end{equation}$$\n",
    "\n",
    "To work out these matrix elements, let\n",
    "\n",
    "$$C_{(jk), (lm)} = \\left(\\underset{\\text{qubit}~1}{\\left\\langle j \\right|} \\otimes \\underset{\\text{qubit}~0}{\\left\\langle k \\right|}\\right) C_{U} \\left(\\underset{\\text{qubit}~1}{\\left| l \\right\\rangle} \\otimes \\underset{\\text{qubit}~0}{\\left| m \\right\\rangle}\\right),$$\n",
    "\n",
    "compute the action of $C_{U}$ (given above), and compute the inner products.\n",
    "\n",
    "As shown in the examples below, this operation is implemented in Qiskit as `cU(q[0],q[1])`.\n",
    "\n",
    "\n",
    "If **qubit 1 is the control and qubit 0 is the target**, then the basis vectors are transformed according to\n",
    "$$\\begin{align*}\n",
    "C_{U}: \\underset{\\text{qubit}~1}{\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|0\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|0\\right\\rangle}\\\\\n",
    "C_{U}: \\underset{\\text{qubit}~1}{\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|1\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|1\\right\\rangle}\\\\\n",
    "C_{U}: \\underset{\\text{qubit}~1}{\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|0\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{U\\left|0\\right\\rangle}\\\\\n",
    "C_{U}: \\underset{\\text{qubit}~1}{\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|1\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{U\\left|1\\right\\rangle}\\\\\n",
    "\\end{align*},$$\n",
    "\n",
    "\n",
    "which implies the matrix form of $C_{U}$ is\n",
    "$$\\begin{equation}\n",
    "\tC_U = \\begin{pmatrix}\n",
    "\t1 & 0 & 0  & 0 \\\\\n",
    "\t0 & 1 & 0 & 0 \\\\\n",
    "\t0 & 0 & u_{00} & u_{01} \\\\\n",
    "\t0 & 0 & u_{10} & u_{11}\n",
    "\t\t\\end{pmatrix}.\n",
    "\\end{equation}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:57.864527Z",
     "start_time": "2021-07-31T05:11:57.861603Z"
    }
   },
   "outputs": [],
   "source": [
    "q = QuantumRegister(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Controlled Pauli Gates\n",
    "\n",
    "#### Controlled-X (or, Controlled-NOT) gate\n",
    "The Controlled-NOT gate flips the `target` qubit when the control qubit is in the state $\\left|1\\right\\rangle$. If we take the MSB as the control qubit (e.g. `cx(q[1],q[0])`), then the matrix would look like\n",
    "\n",
    "$$\n",
    "C_X = \n",
    "\\begin{pmatrix}\n",
    "1 & 0 & 0 & 0\\\\\n",
    "0 & 1 & 0 & 0\\\\\n",
    "0 & 0 & 0 & 1\\\\\n",
    "0 & 0 & 1 & 0\n",
    "\\end{pmatrix}. \n",
    "$$\n",
    "\n",
    "However, when the LSB is the control qubit, (e.g. `cx(q[0],q[1])`), this gate is equivalent to the following matrix:\n",
    "\n",
    "$$\n",
    "C_X = \n",
    "\\begin{pmatrix}\n",
    "1 & 0 & 0 & 0\\\\\n",
    "0 & 0 & 0 & 1\\\\\n",
    "0 & 0 & 1 & 0\\\\\n",
    "0 & 1 & 0 & 0\n",
    "\\end{pmatrix}. \n",
    "$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:11:59.251955Z",
     "start_time": "2021-07-31T05:11:59.245837Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">            \n",
       "q60_0: ──■──\n",
       "       ┌─┴─┐\n",
       "q60_1: ┤ X ├\n",
       "       └───┘</pre>"
      ],
      "text/plain": [
       "            \n",
       "q60_0: ──■──\n",
       "       ┌─┴─┐\n",
       "q60_1: ┤ X ├\n",
       "       └───┘"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.cx(q[0],q[1])\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:12:02.300793Z",
     "start_time": "2021-07-31T05:12:02.292637Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Controlled $Y$ gate\n",
    "\n",
    "Apply the $Y$ gate to the target qubit if the control qubit is the MSB\n",
    "\n",
    "$$\n",
    "C_Y = \n",
    "\\begin{pmatrix}\n",
    "1 & 0 & 0 & 0\\\\\n",
    "0 & 1 & 0 & 0\\\\\n",
    "0 & 0 & 0 & -i\\\\\n",
    "0 & 0 & i & 0\n",
    "\\end{pmatrix},\n",
    "$$\n",
    "\n",
    "or when the LSB is the control\n",
    "\n",
    "$$\n",
    "C_Y = \n",
    "\\begin{pmatrix}\n",
    "1 & 0 & 0 & 0\\\\\n",
    "0 & 0 & 0 & -i\\\\\n",
    "0 & 0 & 1 & 0\\\\\n",
    "0 & i & 0 & 0\n",
    "\\end{pmatrix}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:12:04.293988Z",
     "start_time": "2021-07-31T05:12:04.285941Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">            \n",
       "q60_0: ──■──\n",
       "       ┌─┴─┐\n",
       "q60_1: ┤ Y ├\n",
       "       └───┘</pre>"
      ],
      "text/plain": [
       "            \n",
       "q60_0: ──■──\n",
       "       ┌─┴─┐\n",
       "q60_1: ┤ Y ├\n",
       "       └───┘"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.cy(q[0],q[1])\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:12:07.042556Z",
     "start_time": "2021-07-31T05:12:07.031367Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 0.+0.j, 0.-1.j],\n",
       "       [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+1.j, 0.+0.j, 0.+0.j]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Controlled $Z$ (or, controlled Phase-Flip) gate\n",
    "\n",
    "Similarly, the controlled Z gate flips the phase of the target qubit if the control qubit is $\\left|1\\right\\rangle$. The matrix looks the same regardless of whether the MSB or LSB is the control qubit:\n",
    "\n",
    "$$\n",
    "C_Z = \n",
    "\\begin{pmatrix}\n",
    "1 & 0 & 0 & 0\\\\\n",
    "0 & 1 & 0 & 0\\\\\n",
    "0 & 0 & 1 & 0\\\\\n",
    "0 & 0 & 0 & -1\n",
    "\\end{pmatrix}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:12:08.397786Z",
     "start_time": "2021-07-31T05:12:08.392065Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">          \n",
       "q60_0: ─■─\n",
       "        │ \n",
       "q60_1: ─■─\n",
       "          </pre>"
      ],
      "text/plain": [
       "          \n",
       "q60_0: ─■─\n",
       "        │ \n",
       "q60_1: ─■─\n",
       "          "
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.cz(q[0],q[1])\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:12:10.259460Z",
     "start_time": "2021-07-31T05:12:10.246478Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.-0.j,  0.+0.j,  0.+0.j,  0.+0.j],\n",
       "       [ 0.+0.j,  1.-0.j,  0.+0.j,  0.+0.j],\n",
       "       [ 0.+0.j,  0.+0.j,  1.-0.j,  0.+0.j],\n",
       "       [ 0.+0.j,  0.+0.j,  0.+0.j, -1.+0.j]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Controlled Hadamard gate\n",
    "\n",
    "Apply $H$ gate to the target qubit if the control qubit is $\\left|1\\right\\rangle$. Below is the case where the control is the LSB qubit.\n",
    "\n",
    "$$\n",
    "C_H = \n",
    "\\begin{pmatrix}\n",
    "1 & 0 & 0 & 0\\\\\n",
    "0 & \\frac{1}{\\sqrt{2}} & 0 & \\frac{1}{\\sqrt{2}}\\\\\n",
    "0 & 0 & 1 & 0\\\\\n",
    "0 & \\frac{1}{\\sqrt{2}}  & 0& -\\frac{1}{\\sqrt{2}}\n",
    "\\end{pmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:12:11.524751Z",
     "start_time": "2021-07-31T05:12:11.518946Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">            \n",
       "q60_0: ──■──\n",
       "       ┌─┴─┐\n",
       "q60_1: ┤ H ├\n",
       "       └───┘</pre>"
      ],
      "text/plain": [
       "            \n",
       "q60_0: ──■──\n",
       "       ┌─┴─┐\n",
       "q60_1: ┤ H ├\n",
       "       └───┘"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.ch(q[0],q[1])\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:12:13.607426Z",
     "start_time": "2021-07-31T05:12:13.594156Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.   +0.j,  0.   +0.j,  0.   +0.j,  0.   +0.j],\n",
       "       [ 0.   +0.j,  0.707+0.j,  0.   +0.j,  0.707-0.j],\n",
       "       [ 0.   +0.j,  0.   +0.j,  1.   -0.j,  0.   +0.j],\n",
       "       [ 0.   +0.j,  0.707+0.j,  0.   +0.j, -0.707+0.j]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Controlled rotation gates\n",
    "\n",
    "#### Controlled rotation around Z-axis\n",
    "\n",
    "Perform rotation around Z-axis on the target qubit if the control qubit (here LSB) is $\\left|1\\right\\rangle$.\n",
    "\n",
    "$$\n",
    "C_{Rz}(\\lambda) = \n",
    "\\begin{pmatrix}\n",
    "1 & 0 & 0 & 0\\\\\n",
    "0 & e^{-i\\lambda/2} & 0 & 0\\\\\n",
    "0 & 0 & 1 & 0\\\\\n",
    "0 & 0 & 0 & e^{i\\lambda/2}\n",
    "\\end{pmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:12:14.970661Z",
     "start_time": "2021-07-31T05:12:14.961038Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">                  \n",
       "q60_0: ─────■─────\n",
       "       ┌────┴────┐\n",
       "q60_1: ┤ Rz(π/2) ├\n",
       "       └─────────┘</pre>"
      ],
      "text/plain": [
       "                  \n",
       "q60_0: ─────■─────\n",
       "       ┌────┴────┐\n",
       "q60_1: ┤ Rz(π/2) ├\n",
       "       └─────────┘"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.crz(pi/2,q[0],q[1])\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:12:17.186696Z",
     "start_time": "2021-07-31T05:12:17.171628Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.   +0.j   , 0.   +0.j   , 0.   +0.j   , 0.   +0.j   ],\n",
       "       [0.   +0.j   , 0.707-0.707j, 0.   +0.j   , 0.   +0.j   ],\n",
       "       [0.   +0.j   , 0.   +0.j   , 1.   +0.j   , 0.   +0.j   ],\n",
       "       [0.   +0.j   , 0.   +0.j   , 0.   +0.j   , 0.707+0.707j]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Controlled phase rotation\n",
    "\n",
    "Perform a phase rotation if both qubits are in the $\\left|11\\right\\rangle$ state. The matrix looks the same regardless of whether the MSB or LSB is the control qubit.\n",
    "\n",
    "$$\n",
    "C_{p}(\\lambda) = \n",
    "\\begin{pmatrix}\n",
    "1 & 0 & 0 & 0\\\\\n",
    "0 & 1 & 0 & 0\\\\\n",
    "0 & 0 & 1 & 0\\\\\n",
    "0 & 0 & 0 & e^{i\\lambda}\n",
    "\\end{pmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:12:36.826264Z",
     "start_time": "2021-07-31T05:12:36.820988Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">                \n",
       "q60_0: ─■───────\n",
       "        │P(π/2) \n",
       "q60_1: ─■───────\n",
       "                </pre>"
      ],
      "text/plain": [
       "                \n",
       "q60_0: ─■───────\n",
       "        │P(π/2) \n",
       "q60_1: ─■───────\n",
       "                "
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.cp(pi/2,q[0], q[1])\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:12:39.234989Z",
     "start_time": "2021-07-31T05:12:39.222992Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 0.+0.j, 0.+1.j]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Controlled $u$ rotation\n",
    "\n",
    "Perform controlled-$u$ rotation on the target qubit if the control qubit (here LSB) is $\\left|1\\right\\rangle$. \n",
    "\n",
    "$$\n",
    "C_{u}(\\theta, \\phi, \\lambda) \\equiv \n",
    "\\begin{pmatrix}\n",
    "1 & 0 & 0 & 0\\\\\n",
    "0 & e^{-i(\\phi+\\lambda)/2}\\cos(\\theta/2) & 0 & -e^{-i(\\phi-\\lambda)/2}\\sin(\\theta/2)\\\\\n",
    "0 & 0 & 1 & 0\\\\\n",
    "0 & e^{i(\\phi-\\lambda)/2}\\sin(\\theta/2) & 0 & e^{i(\\phi+\\lambda)/2}\\cos(\\theta/2)\n",
    "\\end{pmatrix}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:19.155213Z",
     "start_time": "2021-07-31T05:13:19.148466Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">                           \n",
       "q60_0: ─────────■──────────\n",
       "       ┌────────┴─────────┐\n",
       "q60_1: ┤ U(π/2,π/2,π/2,0) ├\n",
       "       └──────────────────┘</pre>"
      ],
      "text/plain": [
       "                           \n",
       "q60_0: ─────────■──────────\n",
       "       ┌────────┴─────────┐\n",
       "q60_1: ┤ U(π/2,π/2,π/2,0) ├\n",
       "       └──────────────────┘"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.cu(pi/2, pi/2, pi/2, 0, q[0], q[1])\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:24.393740Z",
     "start_time": "2021-07-31T05:13:24.378958Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.   +0.j   ,  0.   +0.j   ,  0.   +0.j   ,  0.   +0.j   ],\n",
       "       [ 0.   +0.j   ,  0.707+0.j   ,  0.   +0.j   ,  0.   -0.707j],\n",
       "       [ 0.   +0.j   ,  0.   +0.j   ,  1.   -0.j   ,  0.   +0.j   ],\n",
       "       [ 0.   +0.j   ,  0.   +0.707j,  0.   +0.j   , -0.707+0.j   ]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SWAP gate\n",
    "\n",
    "The SWAP gate exchanges the two qubits. It transforms the basis vectors as\n",
    "\n",
    "$$\\left|00\\right\\rangle \\rightarrow \\left|00\\right\\rangle~,~\\left|01\\right\\rangle \\rightarrow \\left|10\\right\\rangle~,~\\left|10\\right\\rangle \\rightarrow \\left|01\\right\\rangle~,~\\left|11\\right\\rangle \\rightarrow \\left|11\\right\\rangle,$$\n",
    "\n",
    "which gives a matrix representation of the form\n",
    "\n",
    "$$\n",
    "\\mathrm{SWAP} = \n",
    "\\begin{pmatrix}\n",
    "1 & 0 & 0 & 0\\\\\n",
    "0 & 0 & 1 & 0\\\\\n",
    "0 & 1 & 0 & 0\\\\\n",
    "0 & 0 & 0 & 1\n",
    "\\end{pmatrix}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:26.189896Z",
     "start_time": "2021-07-31T05:13:26.184311Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">          \n",
       "q60_0: ─X─\n",
       "        │ \n",
       "q60_1: ─X─\n",
       "          </pre>"
      ],
      "text/plain": [
       "          \n",
       "q60_0: ─X─\n",
       "        │ \n",
       "q60_1: ─X─\n",
       "          "
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.swap(q[0], q[1])\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:28.555864Z",
     "start_time": "2021-07-31T05:13:28.545777Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Three-qubit gates <a name=\"three_gates\"/>\n",
    "\n",
    "\n",
    "There are two commonly-used three-qubit gates. For three qubits, the basis vectors are ordered as\n",
    "\n",
    "$$\\left|000\\right\\rangle, \\left|001\\right\\rangle, \\left|010\\right\\rangle, \\left|011\\right\\rangle, \\left|100\\right\\rangle, \\left|101\\right\\rangle, \\left|110\\right\\rangle, \\left|111\\right\\rangle,$$\n",
    "\n",
    "which, as bitstrings, represent the integers $0,1,2,\\cdots, 7$. Again, Qiskit uses a representation in which the first qubit is on the right-most side of the tensor product and the third qubit is on the left-most side:\n",
    "\n",
    "$$\\left|abc\\right\\rangle : \\underset{\\text{qubit 2}}{\\left|a\\right\\rangle}\\otimes \\underset{\\text{qubit 1}}{\\left|b\\right\\rangle}\\otimes \\underset{\\text{qubit 0}}{\\left|c\\right\\rangle}.$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Toffoli gate ($ccx$ gate)\n",
    "\n",
    "The [Toffoli gate](https://en.wikipedia.org/wiki/Quantum_logic_gate#Toffoli_(CCNOT)_gate) flips the third qubit if the first two qubits (LSB) are both $\\left|1\\right\\rangle$:\n",
    "\n",
    "$$\\left|abc\\right\\rangle \\rightarrow \\left|bc\\oplus a\\right\\rangle \\otimes \\left|b\\right\\rangle \\otimes \\left|c\\right\\rangle.$$\n",
    "\n",
    "In matrix form, the Toffoli gate is\n",
    "$$\n",
    "C_{CX} = \n",
    "\\begin{pmatrix}\n",
    "1 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
    "0 & 1 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
    "0 & 0 & 1 & 0 & 0 & 0 & 0 & 0\\\\\n",
    "0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\\\\\n",
    "0 & 0 & 0 & 0 & 1 & 0 & 0 & 0\\\\\n",
    "0 & 0 & 0 & 0 & 0 & 1 & 0 & 0\\\\\n",
    "0 & 0 & 0 & 0 & 0 & 0 & 1 & 0\\\\\n",
    "0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\n",
    "\\end{pmatrix}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:31.317251Z",
     "start_time": "2021-07-31T05:13:31.314100Z"
    }
   },
   "outputs": [],
   "source": [
    "q = QuantumRegister(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:31.638567Z",
     "start_time": "2021-07-31T05:13:31.633001Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">             \n",
       "q105_0: ──■──\n",
       "          │  \n",
       "q105_1: ──■──\n",
       "        ┌─┴─┐\n",
       "q105_2: ┤ X ├\n",
       "        └───┘</pre>"
      ],
      "text/plain": [
       "             \n",
       "q105_0: ──■──\n",
       "          │  \n",
       "q105_1: ──■──\n",
       "        ┌─┴─┐\n",
       "q105_2: ┤ X ├\n",
       "        └───┘"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.ccx(q[0], q[1], q[2])\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:33.704467Z",
     "start_time": "2021-07-31T05:13:33.686210Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j],\n",
       "       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Controlled swap gate (Fredkin Gate)\n",
    "\n",
    "The [Fredkin gate](https://en.wikipedia.org/wiki/Quantum_logic_gate#Fredkin_(CSWAP)_gate), or the *controlled swap gate*, exchanges the second and third qubits if the first qubit (LSB) is $\\left|1\\right\\rangle$:\n",
    "\n",
    "$$ \\left|abc\\right\\rangle \\rightarrow \\begin{cases} \\left|bac\\right\\rangle~~\\text{if}~c=1 \\cr \\left|abc\\right\\rangle~~\\text{if}~c=0 \\end{cases}.$$\n",
    "\n",
    "In matrix form, the Fredkin gate is\n",
    "\n",
    "$$\n",
    "C_{\\mathrm{SWAP}} = \n",
    "\\begin{pmatrix}\n",
    "1 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
    "0 & 1 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n",
    "0 & 0 & 1 & 0 & 0 & 0 & 0 & 0\\\\\n",
    "0 & 0 & 0 & 0 & 0 & 1 & 0 & 0\\\\\n",
    "0 & 0 & 0 & 0 & 1 & 0 & 0 & 0\\\\\n",
    "0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\\\\\n",
    "0 & 0 & 0 & 0 & 0 & 0 & 1 & 0\\\\\n",
    "0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\n",
    "\\end{pmatrix}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:35.557144Z",
     "start_time": "2021-07-31T05:13:35.551515Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">           \n",
       "q105_0: ─■─\n",
       "         │ \n",
       "q105_1: ─X─\n",
       "         │ \n",
       "q105_2: ─X─\n",
       "           </pre>"
      ],
      "text/plain": [
       "           \n",
       "q105_0: ─■─\n",
       "         │ \n",
       "q105_1: ─X─\n",
       "         │ \n",
       "q105_2: ─X─\n",
       "           "
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q)\n",
    "qc.cswap(q[0], q[1], q[2])\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:38.233786Z",
     "start_time": "2021-07-31T05:13:38.215070Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_unitary(qc, decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Non-unitary operations <a name=\"non_unitary\"/>\n",
    "\n",
    "Now that we have gone through all the unitary operations in quantum circuits, we also have access to non-unitary operations. These include measurements, reset of qubits, and classical conditional operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:39.580221Z",
     "start_time": "2021-07-31T05:13:39.576248Z"
    }
   },
   "outputs": [],
   "source": [
    "q = QuantumRegister(1)\n",
    "c = ClassicalRegister(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measurements\n",
    "\n",
    "We don't have access to all the information when we make a measurement in a quantum computer. The quantum state is projected onto the standard basis. Below are two examples showing a circuit that is prepared in a basis state and the quantum computer prepared in a superposition state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:40.203535Z",
     "start_time": "2021-07-31T05:13:40.197117Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">      ┌─┐\n",
       "q124: ┤M├\n",
       "      └╥┘\n",
       "c0: 1/═╩═\n",
       "       0 </pre>"
      ],
      "text/plain": [
       "      ┌─┐\n",
       "q124: ┤M├\n",
       "      └╥┘\n",
       "c0: 1/═╩═\n",
       "       0 "
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q, c)\n",
    "qc.measure(q, c)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:47.891765Z",
     "start_time": "2021-07-31T05:13:47.879060Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0': 1024}"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backend = BasicAer.get_backend('qasm_simulator')\n",
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_counts(qc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The simulator predicts that 100 percent of the time the classical register returns 0. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:49.501725Z",
     "start_time": "2021-07-31T05:13:49.495404Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">      ┌───┐┌─┐\n",
       "q124: ┤ H ├┤M├\n",
       "      └───┘└╥┘\n",
       "c0: 1/══════╩═\n",
       "            0 </pre>"
      ],
      "text/plain": [
       "      ┌───┐┌─┐\n",
       "q124: ┤ H ├┤M├\n",
       "      └───┘└╥┘\n",
       "c0: 1/══════╩═\n",
       "            0 "
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q, c)\n",
    "qc.h(q)\n",
    "qc.measure(q, c)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:51.913804Z",
     "start_time": "2021-07-31T05:13:51.902540Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'1': 532, '0': 492}"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_counts(qc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The simulator predicts that 50 percent of the time the classical register returns 0 or 1. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reset\n",
    "It is also possible to `reset` qubits to the $\\left|0\\right\\rangle$ state in the middle of computation. Note that `reset` is not a Gate operation, since it is irreversible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:55.048748Z",
     "start_time": "2021-07-31T05:13:55.043325Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">           ┌─┐\n",
       "q124: ─|0>─┤M├\n",
       "           └╥┘\n",
       "c0: 1/══════╩═\n",
       "            0 </pre>"
      ],
      "text/plain": [
       "           ┌─┐\n",
       "q124: ─|0>─┤M├\n",
       "           └╥┘\n",
       "c0: 1/══════╩═\n",
       "            0 "
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q, c)\n",
    "qc.reset(q[0])\n",
    "qc.measure(q, c)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:57.317513Z",
     "start_time": "2021-07-31T05:13:57.305706Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0': 1024}"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_counts(qc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:13:57.866910Z",
     "start_time": "2021-07-31T05:13:57.860240Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">      ┌───┐     ┌─┐\n",
       "q124: ┤ H ├─|0>─┤M├\n",
       "      └───┘     └╥┘\n",
       "c0: 1/═══════════╩═\n",
       "                 0 </pre>"
      ],
      "text/plain": [
       "      ┌───┐     ┌─┐\n",
       "q124: ┤ H ├─|0>─┤M├\n",
       "      └───┘     └╥┘\n",
       "c0: 1/═══════════╩═\n",
       "                 0 "
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q, c)\n",
    "qc.h(q)\n",
    "qc.reset(q[0])\n",
    "qc.measure(q, c)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:14:01.210349Z",
     "start_time": "2021-07-31T05:14:01.065350Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0': 1024}"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_counts(qc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we see that for both of these circuits the simulator always predicts that the output is 100 percent in the 0 state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional operations\n",
    "It is also possible to do operations conditioned on the state of the classical register"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:14:03.421890Z",
     "start_time": "2021-07-31T05:14:03.416090Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">       ┌───┐ ┌─┐\n",
       "q124: ─┤ X ├─┤M├\n",
       "       └─╥─┘ └╥┘\n",
       "      ┌──╨──┐ ║ \n",
       "c0: 1/╡ 0x0 ╞═╩═\n",
       "      └─────┘ 0 </pre>"
      ],
      "text/plain": [
       "       ┌───┐ ┌─┐\n",
       "q124: ─┤ X ├─┤M├\n",
       "       └─╥─┘ └╥┘\n",
       "      ┌──╨──┐ ║ \n",
       "c0: 1/╡ 0x0 ╞═╩═\n",
       "      └─────┘ 0 "
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q, c)\n",
    "qc.x(q[0]).c_if(c, 0)\n",
    "qc.measure(q,c)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the classical bit always takes the value 0 so the qubit state is always flipped. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:14:05.763405Z",
     "start_time": "2021-07-31T05:14:05.753665Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'1': 1024}"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_counts(qc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:14:07.187387Z",
     "start_time": "2021-07-31T05:14:07.180366Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">      ┌───┐┌─┐ ┌───┐ ┌─┐\n",
       "q124: ┤ H ├┤M├─┤ X ├─┤M├\n",
       "      └───┘└╥┘ └─╥─┘ └╥┘\n",
       "            ║ ┌──╨──┐ ║ \n",
       "c0: 1/══════╩═╡ 0x0 ╞═╩═\n",
       "            0 └─────┘ 0 </pre>"
      ],
      "text/plain": [
       "      ┌───┐┌─┐ ┌───┐ ┌─┐\n",
       "q124: ┤ H ├┤M├─┤ X ├─┤M├\n",
       "      └───┘└╥┘ └─╥─┘ └╥┘\n",
       "            ║ ┌──╨──┐ ║ \n",
       "c0: 1/══════╩═╡ 0x0 ╞═╩═\n",
       "            0 └─────┘ 0 "
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(q, c)\n",
    "qc.h(q)\n",
    "qc.measure(q,c)\n",
    "qc.x(q[0]).c_if(c, 0)\n",
    "qc.measure(q,c)\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:14:09.366351Z",
     "start_time": "2021-07-31T05:14:09.199972Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'1': 1024}"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job = backend.run(transpile(qc, backend))\n",
    "job.result().get_counts(qc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the classical bit by the first measurement is random but the conditional operation results in the qubit being deterministically put into $\\left|1\\right\\rangle$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arbitrary initialization <a name=\"initialization\"/>\n",
    "What if we want to initialize a qubit register to an arbitrary state? An arbitrary state for $n$ qubits may be specified by a vector of $2^n$ amplitudes, where the sum of amplitude-norms-squared equals 1. For example, the following three-qubit state can be prepared:\n",
    "\n",
    "$$\\left|\\psi\\right\\rangle = \\frac{i}{4}\\left|000\\right\\rangle + \\frac{1}{\\sqrt{8}}\\left|001\\right\\rangle + \\frac{1+i}{4}\\left|010\\right\\rangle + \\frac{1+2i}{\\sqrt{8}}\\left|101\\right\\rangle + \\frac{1}{4}\\left|110\\right\\rangle$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:14:12.127664Z",
     "start_time": "2021-07-31T05:14:12.118291Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌───────────────────────────────────────────────────────────────────┐\n",
       "q233_0: ┤0                                                                  ├\n",
       "        │                                                                   │\n",
       "q233_1: ┤1 Initialize(0.25j,0.35355,0.25+0.25j,0,0,0.35355+0.70711j,0.25,0) ├\n",
       "        │                                                                   │\n",
       "q233_2: ┤2                                                                  ├\n",
       "        └───────────────────────────────────────────────────────────────────┘</pre>"
      ],
      "text/plain": [
       "        ┌───────────────────────────────────────────────────────────────────┐\n",
       "q233_0: ┤0                                                                  ├\n",
       "        │                                                                   │\n",
       "q233_1: ┤1 Initialize(0.25j,0.35355,0.25+0.25j,0,0,0.35355+0.70711j,0.25,0) ├\n",
       "        │                                                                   │\n",
       "q233_2: ┤2                                                                  ├\n",
       "        └───────────────────────────────────────────────────────────────────┘"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Initializing a three-qubit quantum state\n",
    "import math\n",
    "desired_vector = [\n",
    "    1 / math.sqrt(16) * complex(0, 1),\n",
    "    1 / math.sqrt(8) * complex(1, 0),\n",
    "    1 / math.sqrt(16) * complex(1, 1),\n",
    "    0,\n",
    "    0,\n",
    "    1 / math.sqrt(8) * complex(1, 2),\n",
    "    1 / math.sqrt(16) * complex(1, 0),\n",
    "    0]\n",
    "\n",
    "\n",
    "q = QuantumRegister(3)\n",
    "\n",
    "qc = QuantumCircuit(q)\n",
    "\n",
    "qc.initialize(desired_vector, [q[0],q[1],q[2]])\n",
    "qc.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:14:16.873547Z",
     "start_time": "2021-07-31T05:14:16.800233Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.52655666e-16+2.50000000e-01j, 3.53553391e-01+5.55111512e-17j,\n",
       "       2.50000000e-01+2.50000000e-01j, 0.00000000e+00+0.00000000e+00j,\n",
       "       0.00000000e+00+0.00000000e+00j, 3.53553391e-01+7.07106781e-01j,\n",
       "       2.50000000e-01-9.02056208e-17j, 0.00000000e+00+0.00000000e+00j])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backend = BasicAer.get_backend('statevector_simulator')\n",
    "job = backend.run(transpile(qc, backend))\n",
    "qc_state = job.result().get_statevector(qc)\n",
    "qc_state "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Fidelity](https://en.wikipedia.org/wiki/Fidelity_of_quantum_states) is useful to check whether two states are the same or not.\n",
    "For quantum (pure) states $\\left|\\psi_1\\right\\rangle$ and $\\left|\\psi_2\\right\\rangle$, the fidelity is\n",
    "\n",
    "$$\n",
    "F\\left(\\left|\\psi_1\\right\\rangle,\\left|\\psi_2\\right\\rangle\\right) = \\left|\\left\\langle\\psi_1\\middle|\\psi_2\\right\\rangle\\right|^2.\n",
    "$$\n",
    "\n",
    "The fidelity is equal to $1$ if and only if two states are equal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:14:19.163449Z",
     "start_time": "2021-07-31T05:14:19.157945Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0000000000000004"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state_fidelity(desired_vector,qc_state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Further details:\n",
    "\n",
    "How does the desired state get generated behind the scenes? There are multiple methods for doing this. Qiskit uses a [method proposed by Shende et al](https://arxiv.org/abs/quant-ph/0406176). Here, the idea is to assume the quantum register to have started from our desired state, and construct a circuit that takes it to the $\\left|00..0\\right\\rangle$ state. The initialization circuit is then the reverse of such circuit.\n",
    "\n",
    "To take an arbitrary quantum state to the zero state in the computational basis, we perform an iterative procedure that disentangles qubits from the register one-by-one. We know that any arbitrary single-qubit state $\\left|\\rho\\right\\rangle$ can be taken to the $\\left|0\\right\\rangle$ state using a $\\phi$-degree rotation about the Z axis followed by a $\\theta$-degree rotation about the Y axis:\n",
    "\n",
    "$$R_y(-\\theta)R_z(-\\phi)\\left|\\rho\\right\\rangle = re^{it}\\left|0\\right\\rangle$$\n",
    "\n",
    "Since now we are dealing with $n$ qubits instead of just 1, we must factorize the state vector to separate the Least Significant Bit (LSB):\n",
    "\n",
    "$$\\begin{align*}\n",
    " \\left|\\psi\\right\\rangle =& \\alpha_{0_0}\\left|00..00\\right\\rangle + \\alpha_{0_1}\\left|00..01\\right\\rangle + \\alpha_{1_0}\\left|00..10\\right\\rangle + \\alpha_{1_1}\\left|00..11\\right\\rangle + ... \\\\&+ \\alpha_{(2^{n-1}-1)_0}\\left|11..10\\right\\rangle + \\alpha_{(2^{n-1}-1)_1}\\left|11..11\\right\\rangle \\\\\n",
    "=& \\left|00..0\\right\\rangle (\\alpha_{0_0}\\left|0\\right\\rangle + \\alpha_{0_1}\\left|1\\right\\rangle) + \\left|00..1\\right\\rangle (\\alpha_{1_0}\\left|0\\right\\rangle + \\alpha_{1_1}\\left|1\\right\\rangle) + ... \\\\&+ \\left|11..1\\right\\rangle (\\alpha_{(2^{n-1}-1)_0}(\\left|0\\right\\rangle + \\alpha_{(2^{n-1}-1)_1}\\left|1\\right\\rangle) \\\\\n",
    "=& \\left|00..0\\right\\rangle\\left|\\rho_0\\right\\rangle + \\left|00..1\\right\\rangle\\left|\\rho_1\\right\\rangle + ... + \\left|11..1\\right\\rangle\\left|\\rho_{2^{n-1}-1}\\right\\rangle\n",
    "\\end{align*}$$\n",
    "\n",
    "Now each of the single-qubit states $\\left|\\rho_0\\right\\rangle, ..., \\left|\\rho_{2^{n-1}-1}\\right\\rangle$ can be taken to $\\left|0\\right\\rangle$ by finding appropriate $\\phi$ and $\\theta$ angles per the equation above. Doing this simultaneously on all states amounts to the following unitary, which disentangles the LSB:\n",
    "\n",
    "$$U = \\begin{pmatrix} \n",
    "R_{y}(-\\theta_0)R_{z}(-\\phi_0) & & & &\\\\  \n",
    "& R_{y}(-\\theta_1)R_{z}(-\\phi_1) & & &\\\\\n",
    "& . & & &\\\\\n",
    "& & . & &\\\\\n",
    "& & & & R_y(-\\theta_{2^{n-1}-1})R_z(-\\phi_{2^{n-1}-1})\n",
    "\\end{pmatrix} $$\n",
    "\n",
    "Hence,\n",
    "\n",
    "$$U\\left|\\psi\\right\\rangle = \\begin{pmatrix} r_0e^{it_0}\\\\ r_1e^{it_1}\\\\ . \\\\ . \\\\ r_{2^{n-1}-1}e^{it_{2^{n-1}-1}} \\end{pmatrix}\\otimes\\left|0\\right\\rangle$$\n",
    "\n",
    "\n",
    "U can be implemented as a \"quantum multiplexor\" gate, since it is a block diagonal matrix. In the quantum multiplexor formalism, a block diagonal matrix of size $2^n \\times 2^n$, and consisting of $2^s$ blocks, is equivalent to a multiplexor with $s$ select qubits and $n-s$ data qubits. Depending on the state of the select qubits, the corresponding blocks are applied to the data qubits. A multiplexor of this kind can be implemented after recursive decomposition to primitive gates of cx, rz and ry."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-07-31T05:14:22.630626Z",
     "start_time": "2021-07-31T05:14:21.651868Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td><code>qiskit-terra</code></td><td>0.20.2</td></tr><tr><td><code>qiskit-aer</code></td><td>0.10.4</td></tr><tr><td><code>qiskit-ignis</code></td><td>0.7.1</td></tr><tr><td><code>qiskit-ibmq-provider</code></td><td>0.19.1</td></tr><tr><td><code>qiskit</code></td><td>0.36.2</td></tr><tr><td><code>qiskit-optimization</code></td><td>0.3.2</td></tr><tr><td><code>qiskit-machine-learning</code></td><td>0.4.0</td></tr><tr><th>System information</th></tr><tr><td>Python version</td><td>3.10.4</td></tr><tr><td>Python compiler</td><td>MSC v.1916 64 bit (AMD64)</td></tr><tr><td>Python build</td><td>main, Mar 30 2022 08:38:02</td></tr><tr><td>OS</td><td>Windows</td></tr><tr><td>CPUs</td><td>6</td></tr><tr><td>Memory (Gb)</td><td>15.869640350341797</td></tr><tr><td colspan='2'>Sat May 28 10:03:32 2022 Eastern Daylight Time</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2022.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import qiskit.tools.jupyter\n",
    "%qiskit_version_table\n",
    "%qiskit_copyright"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.7"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}