IBM_QGSS23/labs/lab4_iterative_phase_estimation.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lab 4 - Iterative Phase Estimation\n",
    "\n",
    "- In this lab, you'll implement a simple version of the iterative phase estimation algorithm. Using the recently introduced dynamic circuits capabilities, you'll be able to run the algorithm on an IBM quantum processor! This lab was adapted from the IBM Quantum Spring Challenge 2023, so if you participated in that challenge, it may look familiar. To encourage you to review the lab nevertheless, we added an extra exercise at the end."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Background\n",
    "\n",
    "The quantum phase estimation (QPE) algorithm is one of the most important and famous quantum algorithms. It is a key subroutine of Shor's factoring algorithm, as well as algorithms for quantum simulation. The textbook version of the algorithm uses a number of auxiliary qubits which scales with the desired precision, leading to circuits that are challenging to execute on today's noisy devices with limited qubit number and connectivity.\n",
    "\n",
    "Iterative phase estimation (IPE) is a variant of QPE which requires only one auxiliary qubit. In IPE, the auxiliary qubit is repeatedly measured, with the measurement results used to guide future quantum operations. Such classical feed-forward was previously impossible to execute on IBM's quantum processors, but with the recently introduced dynamic circuits capabilities, it is now possible.\n",
    "\n",
    "Like any phase estimation algorithm, IPE is designed to solve the following problem:\n",
    "\n",
    "**Problem statement:** Given a unitary matrix $U$ and an eigenstate $|\\Psi\\rangle$ of $U$ with an unknown eigenvalue $e^{i 2\\pi \\varphi}$, estimate the value of $\\varphi$.\n",
    "\n",
    "A few important details need to be clarified in this problem statement, namely, how $U$ and $|\\Psi\\rangle$ are specified. We assume that $U$ is given as a quantum circuit implementing $U$, and in fact, we assume we have the ability to efficiently implement the operations *controlled*-$U^{2^t}$ for positive integers $t$.\n",
    "This is the same assumption used in the original QPE algorithm.\n",
    "The eigenstate is also given as a quantum circuit: we assume we have the ability to efficiently prepare $|\\Psi\\rangle$.\n",
    "\n",
    "Let's first assume for simplicity that $\\varphi$ can have an exact binary expansion, that is, it can be written as\n",
    "$$\n",
    "\\varphi = \\varphi_1/2 + \\varphi_2/4 + \\cdots + \\varphi_m/2^m = 0.\\varphi_1 \\varphi_2 \\cdots \\varphi_m\n",
    "$$\n",
    "where in the final equality we are using \"decimal\" point notation in base 2.\n",
    "For simplicity, suppose $U$ is a unitary operator acting on one qubit (everything we say here also applies to the case where $U$ acts on multiple qubits). Since IPE requires an auxiliary qubit, we need a system of two qubits, $q_0$ and $q_1$, where $q_0$ is the auxiliary qubit and $q_1$ represents the physical system on which $U$ operates.\n",
    "\n",
    "Now, suppose that we initialize $q_0$ in the state $|+\\rangle = \\frac{|0\\rangle + |1\\rangle}{\\sqrt{2}}$ and $q_1$ in the state $|\\Psi \\rangle$.\n",
    "What happens if we apply the *controlled*-$U^{2^t}$ gate, with $q_0$ being the control and $q_1$ being the target?\n",
    "Since $|\\Psi \\rangle$ is an eigenstate of $U$ with eigenvalue $e^{i 2\\pi \\varphi}$, we have\n",
    "$$\n",
    "\\begin{align}\n",
    "|+\\rangle |\\Psi \\rangle &= \\left(\\frac{|0\\rangle + |1\\rangle}{\\sqrt{2}}\\right) |\\Psi \\rangle \\\\\n",
    "&= \\frac{|0\\rangle |\\Psi \\rangle + |1\\rangle |\\Psi \\rangle}{\\sqrt{2}} \\\\\n",
    "&\\xrightarrow{\\text{controlled-}U^{2^t}} \\frac{|0\\rangle |\\Psi \\rangle + e^{i 2 \\pi 2^{t} \\varphi} |1\\rangle |\\Psi \\rangle}{\\sqrt{2}} \\\\\n",
    "&= \\left(\\frac{|0\\rangle  + e^{i 2 \\pi 2^{t} \\varphi} |1\\rangle}{\\sqrt{2}}\\right) |\\Psi \\rangle.\n",
    "\\end{align}\n",
    "$$\n",
    "That is, the state of the system qubit remains unchanged, while a phase of $e^{i 2 \\pi 2^{t} \\varphi}$ has been \"kicked back\" into the state of the auxiliary qubit.\n",
    "\n",
    "Now, note that\n",
    "$$\n",
    "e^{i 2 \\pi 2^{t} \\varphi} = e^{i 2 \\pi 2^{t} (0.\\varphi_1 \\varphi_2 \\cdots \\varphi_m)}\n",
    "= e^{i 2 \\pi (\\varphi_1 \\cdots \\varphi_t . \\varphi_{t + 1} \\cdots \\varphi_m)}\n",
    "= e^{i 2 \\pi (0. \\varphi_{t + 1} \\cdots \\varphi_m)},\n",
    "$$\n",
    "where in the last equality, the whole number part of the \"decimal\" representation of the phase has disappeared because $e^{i 2\\pi n} = 1$ for any integer $n$.\n",
    "For example:\n",
    "- for $t=0$, the phase would be $e^{i 2 \\pi 2^{0} \\varphi} = e^{i 2 \\pi \\varphi} = e^{i 2 \\pi 0.\\varphi_1 \\varphi_2 ... \\varphi_m}$\n",
    "- for $t=1$, the phase would be $e^{i 2 \\pi 2^{1} \\varphi}= e^{i 2 \\pi \\varphi_1} e^{i 2 \\pi 0.\\varphi_2 \\varphi_3 ... \\varphi_m} = e^{i 2 \\pi 0.\\varphi_2 \\varphi_3 ... \\varphi_m}$\n",
    "- for $t=2$, the phase would be $e^{i 2 \\pi 2^{2} \\varphi} = e^{i 2 \\pi 0.\\varphi_3 \\varphi_4 ... \\varphi_m}$\n",
    "- for $t=m-1$, the phase would be $e^{i 2 \\pi 2^{m-1} \\varphi} = e^{i 2 \\pi 0.\\varphi_m}$.\n",
    "\n",
    "In the last case where $t = m - 1$, the phase is $e^{i 2 \\pi 0.\\varphi_m}$, which is equal to $1$ if $\\varphi_m = 0$ and $-1$ if $\\varphi_m = 1$.\n",
    "In the first case, the auxiliary qubit $q_0$ would be in the state $|+\\rangle = \\frac{|0\\rangle + |1\\rangle}{\\sqrt{2}}$, and in the second case it would be\n",
    "in the state $|-\\rangle = \\frac{|0\\rangle - |1\\rangle}{\\sqrt{2}}$. Therefore, measuring the qubit in the Pauli $X$ basis would distinguish these cases with a 100\\% success rate.\n",
    "This is done by performing a Hadamard gate on the qubit before measuring it. In the first case we would measure 0 and in the second case we would measure 1;\n",
    "in other words, the measured bit would be equal to $\\varphi_m$.\n",
    "\n",
    "### The algorithm\n",
    "\n",
    "In the first step of the IPE algorithm, we directly measure the least significant bit of the phase $\\varphi$, $\\varphi_m$, by initializing the 2-qubit registers as described above ( $q_0 \\rightarrow |+\\rangle$ and $q_1 \\rightarrow |\\Psi \\rangle$ ), performing a *controlled*-$U^{2^{m-1}}$ operation, and measuring $q_0$ in the Pauli $X$ basis.\n",
    "\n",
    "In the second step, we initialize the systems in the same way and apply a *controlled*-$U^{2^{m-2}}$ operation. The relative phase in $q_0$ after these operations is now $e^{i 2 \\pi 0.\\varphi_{m-1}\\varphi_{m}}= e^{i 2 \\pi 0.\\varphi_{m-1}} e^{i 2 \\pi \\varphi_m/4}$. \n",
    "To extract the phase bit $\\varphi_{m-1}$, first perform a phase correction by rotating around the $Z$-axis by an angle $-2 \\pi \\varphi_m/4=-\\pi \\varphi_m/2$, which results in the state of  $q_0$ to be $|0\\rangle + e^{i 2 \\pi 0.\\varphi_{m-1}} | 1 \\rangle$. Perform a measurement on $q_0$ in the Pauli $X$ basis to obtain the phase bit $\\varphi_{m-1}$. \n",
    "\n",
    "Therefore, the $k$-th step of the IPE, getting $\\varphi_{m-k+1}$, consists of the register initialization ($q_0$ in $|+\\rangle$, $q_1$ in $|\\Psi\\rangle$), the application of a *controlled*-$U^{2^{m-k}}$, a rotation around $Z$ of angle $\\omega_k = -2 \\pi 0.0\\varphi_{m-k+2} ... \\varphi_m$, and a measurement of $q_0$ in the Pauli $X$ basis: a Hadamard transform to $q_0$, and a measurement of $q_0$ in the computational basis. Note that $q_1$ remains in the state $|\\Psi\\rangle$ throughout the algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implementation\n",
    "\n",
    "In this lab, we will perform IPE on the single-qubit $S$-gate. The $S$ gate is given by the matrix\n",
    "\n",
    "$$ S =\n",
    "\\begin{pmatrix}\n",
    "1 & 0\\\\\n",
    "0 & e^{i\\pi / 2}\n",
    "\\end{pmatrix}$$\n",
    "\n",
    "We will use the eigenstate $|\\Psi\\rangle = |1\\rangle$, which has eigenvalue $e^{i\\pi / 2}= e^{i2\\pi \\cdot 1/4}$. So we have $\\varphi = 1/4 = 0.01 = 0.\\varphi_1 \\varphi_2$. Since $\\varphi$ can be represented exactly with 2 bits, our quantum circuit implementation will use a classical register with two bits to store the result.\n",
    "\n",
    "The controlled-$S$ gate can be implemented using the controlled phase gate, available in IBM's Qiskit as `CPhaseGate`, which can also be applied by calling the `cp` method of a `QuantumCircuit`. The controlled phase gate is parameterized by an angle $\\theta$ and has the matrix\n",
    "$$\n",
    "        \\text{CPhase}(\\theta) =\n",
    "            \\begin{pmatrix}\n",
    "                1 & 0 & 0 & 0 \\\\\n",
    "                0 & 1 & 0 & 0 \\\\\n",
    "                0 & 0 & 1 & 0 \\\\\n",
    "                0 & 0 & 0 & e^{i\\theta}\n",
    "            \\end{pmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 1 - Measure the least significant bit of the phase $\\varphi$, i.e., the bit of ${\\varphi}_{1}$. </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Step 1\n",
    "\n",
    "In the first step of the algorithm, we measure the least significant bit of $\\varphi$.\n",
    "\n",
    "#### Exercise 1\n",
    "\n",
    "Obtain the least significant bit of $\\varphi$ by performing the following steps:\n",
    "<br>\n",
    "1. Initialize the qubits:\n",
    "   - Apply a Hadamard on the auxiliary qubit;\n",
    "   - Apply an X gate on the system qubit to put it in the $|1\\rangle$ state.\n",
    "<br>\n",
    "<br>\n",
    "2. Apply a *controlled*-$S^{2}$ gate by applying a `CPhaseGate` with the appropriate angle.\n",
    "<br>\n",
    "<br>\n",
    "3. Measure the auxiliary qubit in the $X$ basis:\n",
    "   - Apply a Hadamard gate on the auxiliary qubit;\n",
    "   - Measure it in the computational basis.\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "The resulting circuit should look something like this:\n",
    "\n",
    "![step-1-circuit](resources/step-1-circuit.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 454.517x284.278 with 1 Axes>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import the quantum circuit, quantum register, and classical register\n",
    "# from the IBM's Qiskit library\n",
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "\n",
    "# import the numpy library\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "# define the function to generate the quantum circuit\n",
    "# for the 1st step of the Iterative Phase Estimation (IPE) of the S gate\n",
    "def step_1_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
    "  \n",
    "    # notes:\n",
    "    # - qr is a quantum register with 2 qubits\n",
    "    # - cr is a classical register with 2 bits\n",
    "\n",
    "    # create a quantum circuit with the quantum register and with\n",
    "    # the classical register defined before, to implement\n",
    "    # the 1st step of the Iterative Phase Estimation (IPE) of the S gate\n",
    "    qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "    \n",
    "    ####### your code goes here #######\n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(0)\n",
    "    \n",
    "    # apply the Pauli-X gate to the 1st qubit (auxiliary qubit)\n",
    "    qc.x(1)\n",
    "    \n",
    "    \n",
    "    # apply the Controlled-Phase gate for the theta angle equal to pi,\n",
    "    # with control on the 1st qubit and target on the 2nd qubit\n",
    "    qc.cp( np.pi, 0, 1 )\n",
    "    \n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(0)\n",
    "    \n",
    "    \n",
    "    # measure the state of the 1st qubit (system's qubit),\n",
    "    # storing the classical outcome on the 1st bit of\n",
    "    # the classical register\n",
    "    qc.measure(0, 0)\n",
    "    \n",
    "    \n",
    "    # return the quantum circuit\n",
    "    # for the Iterative Phase Estimation (IPE) of the S gate\n",
    "    return qc\n",
    "\n",
    "\n",
    "# create the quantum register for\n",
    "# the quantum circuit to implement the 1st step of\n",
    "# the Iterative Phase Estimation (IPE) of the S gate\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "\n",
    "# create the classical register for\n",
    "# the quantum circuit to implement the 1st step of\n",
    "# the Iterative Phase Estimation (IPE) of the S gate\n",
    "cr = ClassicalRegister(2, \"c\")\n",
    "\n",
    "\n",
    "# create the quantum circuit to implement the 1st step of\n",
    "# the Iterative Phase Estimation (IPE) of\n",
    "# the S gate, with the quantum register\n",
    "# and the classical register defined before\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "\n",
    "# create the quantum circuit implementing the 1st step of\n",
    "# the Iterative Phase Estimation (IPE) of the S gate\n",
    "qc = step_1_circuit(qr, cr)\n",
    "\n",
    "\n",
    "# draw the quantum circuit implementing the 1st step of\n",
    "# the Iterative Phase Estimation (IPE) of the S gate\n",
    "qc.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# submit your circuit\n",
    "\n",
    "# import the grader for the exercise 1 of the lab 4\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab4_ex1\n",
    "\n",
    "# grade the exercise 1 of the lab 4\n",
    "grade_lab4_ex1( qc )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 2 - Measure the next least significant bit of the phase $\\varphi$, i.e., the bit of ${\\varphi}_{2}$. </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2\n",
    "\n",
    "In the first step, we measured the least significant bit $\\varphi_2$. In the second (and final) step, we extract the next bit $\\varphi_1$, which will involve applying a phase correction to cancel out the phase contribution from $\\varphi_2$. The phase correction depends on the value of the classical register holding $\\varphi_2$. We need dynamic circuits to perform this classical feedback! The phase correction can be applied using `PhaseGate` or by directly calling the `p` method of a QuantumCircuit.\n",
    "\n",
    "#### Exercise 2\n",
    "\n",
    "In this exercise, we begin with the circuit from Step 1, which you should have constructed in Exercise 1.\n",
    "\n",
    "Obtain the next bit of $\\varphi$ by performing the following steps:\n",
    "1. Reset and re-initialize the auxiliary qubit;\n",
    "2. Apply the controlled unitary gate;\n",
    "3. Measure the auxiliary qubit in the $X$ basis.\n",
    "\n",
    "Here and in the rest of the lab, please use the [`QuantumCircuit.if_else`](https://qiskit.org/documentation/stubs/qiskit.circuit.QuantumCircuit.if_else.html) method to apply operations controlled on classical measurement results.\n",
    "\n",
    "The resulting circuit should look something like the one in the drawing below. Note that in the drawing, the instructions inside the `if_else` instruction are not shown. Therefore, even if your circuit looks the same as the drawing, it may still be different.\n",
    "\n",
    "![step-2-circuit](resources/step-2-circuit.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1123.41x367.889 with 1 Axes>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# define the function to generate the quantum circuit\n",
    "# for the 2nd step of the Iterative Phase Estimation (IPE) of the S gate\n",
    "def step_2_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
    "  \n",
    "    # notes:\n",
    "    # - qr is a quantum register with 2 qubits\n",
    "    # - cr is a classical register with 2 bits\n",
    "\n",
    "    # retrieve the quantum circuit implementing the 1st step of\n",
    "    # the Iterative Phase Estimation (IPE) of the S gate\n",
    "    qc = step_1_circuit(qr, cr)\n",
    "\n",
    "    \n",
    "    ####### your code goes here #######\n",
    "    \n",
    "    # reset the state of the 1st qubit (system's qubit)\n",
    "    qc.reset(0)\n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(0)\n",
    "    \n",
    "    \n",
    "    # if the 1st bit of the classical register of\n",
    "    # the dynamic quantum circuit has the classical state 1\n",
    "    with qc.if_test( ( cr[0], True ) ):\n",
    "    \n",
    "        # apply the phase correction of -pi / 2 to\n",
    "        # the 1st qubit of the quantum register with a P gate    \n",
    "        qc.p( -np.pi / 2, 0 )\n",
    "    \n",
    "    \n",
    "    # apply the Controlled-Phase gate for the theta angle equal to pi / 2,\n",
    "    # with control on the 1st qubit and target on the 2nd qubit\n",
    "    qc.cp( np.pi / 2, 0, 1 )\n",
    "    \n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(0)\n",
    "    \n",
    "    \n",
    "    # measure the state of the 1st qubit (system's qubit),\n",
    "    # storing the classical outcome on the 2nd bit of\n",
    "    # the classical register\n",
    "    qc.measure(0, 1)\n",
    "    \n",
    "    \n",
    "    # return the quantum circuit implementing the 2nd step of\n",
    "    # the Iterative Phase Estimation (IPE) of the S gate\n",
    "    return qc\n",
    "\n",
    "\n",
    "# create the quantum register for\n",
    "# the quantum circuit to implement the 2nd step of\n",
    "# the Iterative Phase Estimation (IPE) of the S gate\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "\n",
    "# create the classical register for\n",
    "# the quantum circuit to implement the 2nd step of\n",
    "# the Iterative Phase Estimation (IPE) of the S gate\n",
    "cr = ClassicalRegister(2, \"c\")\n",
    "\n",
    "\n",
    "# create the quantum circuit to implement the 2nd step of\n",
    "# the Iterative Phase Estimation (IPE) of\n",
    "# the S gate, with the quantum register\n",
    "# and the classical register defined before\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "\n",
    "# create the quantum circuit implementing the 2nd step of\n",
    "# the Iterative Phase Estimation (IPE) of the S gate\n",
    "qc = step_2_circuit(qr, cr)\n",
    "\n",
    "\n",
    "# draw the quantum circuit implementing the 2nd step of\n",
    "# the Iterative Phase Estimation (IPE) of the S gate\n",
    "qc.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# submit your circuit\n",
    "\n",
    "# import the grader for the exercise 2 of the lab 4\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab4_ex2\n",
    "\n",
    "# grade the exercise 2 of the lab 4\n",
    "grade_lab4_ex2( qc )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run on simulator\n",
    "\n",
    "Now that we have the complete circuit, let's first run it on a local simulator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'01': 1000}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import the Aer Simulator from the IBM's Qiskit Aer module\n",
    "from qiskit_aer import AerSimulator\n",
    "\n",
    "\n",
    "# create an Aer Simulator object\n",
    "sim = AerSimulator()\n",
    "\n",
    "\n",
    "# create a job for the quantum circuit implementing\n",
    "# the IPE for the S gate, running the Aer Simulator\n",
    "job = sim.run(qc, shots=1000)\n",
    "\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "result = job.result()\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "counts = result.get_counts()\n",
    "\n",
    "\n",
    "# show the result counts of the quantum simulation\n",
    "counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If your circuit is correct, you should have gotten the bitstring `01` with 100% probability. This value corresponds to the phase written in binary as $\\varphi = 0.01 = 1/4$. Indeed, this is the correct phase!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 3 - Build a quantum circuit for Iterative Phase Estimation (IPE) for the $T$ gate. </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3\n",
    "\n",
    "Construct an IPE circuit to estimate the phase of the T gate, whose matrix is given by\n",
    "\n",
    "$$ T =\n",
    "\\begin{pmatrix}\n",
    "1 & 0\\\\\n",
    "0 & e^{i\\pi / 4}\n",
    "\\end{pmatrix}$$\n",
    "\n",
    "How many bits are needed to represent the phase in this case?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1792.29x451.5 with 1 Axes>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import the quantum circuit, quantum register, and classical register\n",
    "# from the IBM's Qiskit library\n",
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "\n",
    "# import the numpy library\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "# define the function to generate the quantum circuit\n",
    "# for the Iterative Phase Estimation (IPE) of the T gate\n",
    "def t_gate_ipe_circuit( qr: QuantumRegister, cr: ClassicalRegister ) -> QuantumCircuit:\n",
    "  \n",
    "    # notes:\n",
    "    # - qr is a quantum register with 2 qubits\n",
    "    # - cr is a classical register with 3 bits\n",
    "\n",
    "    # create a quantum circuit with the quantum register and with\n",
    "    # the classical register defined before, to implement\n",
    "    # the Iterative Phase Estimation (IPE) of the T gate\n",
    "    qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "    \n",
    "    ####### your code goes here #######\n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(0)\n",
    "    \n",
    "    # apply the Pauli-X gate to the 1st qubit (auxiliary qubit)\n",
    "    qc.x(1)\n",
    "    \n",
    "    \n",
    "    # apply the Controlled-Phase gate for the theta angle equal to pi,\n",
    "    # with control on the 1st qubit and target on the 2nd qubit\n",
    "    qc.cp( np.pi, 0, 1 )\n",
    "    \n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(0)\n",
    "    \n",
    "    \n",
    "    # measure the state of the 1st qubit (system's qubit),\n",
    "    # storing the classical outcome on the 1st bit of\n",
    "    # the classical register\n",
    "    qc.measure(0, 0)\n",
    "    \n",
    "    \n",
    "    # reset the state of the 1st qubit (system's qubit)\n",
    "    qc.reset(0)\n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(0)\n",
    "    \n",
    "    \n",
    "    # if the 1st bit of the classical register of\n",
    "    # the dynamic quantum circuit has the classical state 1\n",
    "    with qc.if_test( ( cr[0], True ) ):\n",
    "    \n",
    "        # apply the phase correction of -pi / 2 to\n",
    "        # the 1st qubit of the quantum register with a P gate    \n",
    "        qc.p( -np.pi / 2, 0 )\n",
    "    \n",
    "    \n",
    "    # apply the Controlled-Phase gate for the theta angle equal to pi / 2,\n",
    "    # with control on the 1st qubit and target on the 2nd qubit\n",
    "    qc.cp( np.pi / 2, 0, 1 )\n",
    "    \n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(0)\n",
    "    \n",
    "    \n",
    "    # measure the state of the 1st qubit (system's qubit),\n",
    "    # storing the classical outcome on the 2nd bit of\n",
    "    # the classical register\n",
    "    qc.measure(0, 1)\n",
    "    \n",
    "    \n",
    "    # reset the state of the 1st qubit (system's qubit)\n",
    "    qc.reset(0)\n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(0)\n",
    "\n",
    "    \n",
    "    # if the 1st bit of the classical register of\n",
    "    # the dynamic quantum circuit has the classical state 1\n",
    "    with qc.if_test( ( cr[0], True ) ):\n",
    "    \n",
    "        # apply the phase correction of -pi / 2 to\n",
    "        # the 1st qubit of the quantum register with a P gate   \n",
    "        qc.p(-np.pi / 4, 0)\n",
    "    \n",
    "    \n",
    "    # apply the Controlled-Phase gate for the theta angle equal to pi / ,\n",
    "    # with control on the 1st qubit and target on the 2nd qubit\n",
    "    qc.cp( np.pi / 4, 0, 1 )\n",
    "    \n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(0)\n",
    "    \n",
    "    \n",
    "    # measure the state of the 1st qubit (system's qubit),\n",
    "    # storing the classical outcome on the 3rd bit of\n",
    "    # the classical register\n",
    "    qc.measure(0, 2)\n",
    "    \n",
    "    \n",
    "    # return the quantum circuit\n",
    "    # for the Iterative Phase Estimation (IPE) of the T gate\n",
    "    return qc\n",
    "\n",
    "\n",
    "# create the quantum register for the quantum circuit to\n",
    "# implement the Iterative Phase Estimation (IPE) of the T gate\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "\n",
    "# create the classical register for the quantum circuit to\n",
    "# implement the Iterative Phase Estimation (IPE) of the T gate\n",
    "cr = ClassicalRegister(3, \"c\")\n",
    "\n",
    "\n",
    "# create the quantum circuit to implement\n",
    "# the Iterative Phase Estimation (IPE) of\n",
    "# the T gate, with the quantum register\n",
    "# and the classical register defined before\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "\n",
    "# create the quantum circuit implementing\n",
    "# the Iterative Phase Estimation (IPE) of the T gate\n",
    "qc = t_gate_ipe_circuit(qr, cr)\n",
    "\n",
    "\n",
    "# draw the quantum circuit implementing\n",
    "# the Iterative Phase Estimation (IPE) of the T gate\n",
    "qc.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'001': 1000}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import the Aer Simulator from the IBM's Qiskit Aer module\n",
    "from qiskit_aer import AerSimulator\n",
    "\n",
    "\n",
    "# create an Aer Simulator object\n",
    "sim = AerSimulator()\n",
    "\n",
    "\n",
    "# create a job for the quantum circuit implementing\n",
    "# the IPE for the T gate, running the Aer Simulator\n",
    "job = sim.run(qc, shots=1000)\n",
    "\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "result = job.result()\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "counts = result.get_counts()\n",
    "\n",
    "\n",
    "# show the result counts of the quantum simulation\n",
    "counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# submit your circuit\n",
    "\n",
    "# import the grader for the exercise 3 of the lab 4\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab4_ex3\n",
    "\n",
    "# grade the exercise 3 of the lab 4\n",
    "grade_lab4_ex3( qc )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### When the phase does not have an exact binary expansion\n",
    "\n",
    "Let's consider the case when the phase does not have an exact binary expansion, for example, $\\varphi = 1/3$.\n",
    "In this case, the single-qubit gate has the unitary\n",
    "\n",
    "$$ U =\n",
    "\\begin{pmatrix}\n",
    "1 & 0\\\\\n",
    "0 & e^{i2\\pi / 3}\n",
    "\\end{pmatrix}\n",
    "$$\n",
    "\n",
    "The angle $\\varphi = 1/3$ does not have an exact finite binary expansion. In contrast, it has the infinite binary expansion\n",
    "\n",
    "$$\n",
    "1/3 = 0.010101\\ldots\n",
    "$$\n",
    "\n",
    "In practice we work with a fixed number of bits of precision, so our goal is to obtain the closest value that can be represented with those bits. In the following example, we will use two bits of precision. In this case, the closest value is $0.01 = 1/4$. Because this value does not represent the exact phase, there is some probability that we will obtain a different, less precise result.\n",
    "\n",
    "In the following code cells, we construct and simulate an IPE circuit to measure the phase of this gate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1207.02x367.889 with 1 Axes>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import the quantum circuit, quantum register, and classical register\n",
    "# from the IBM's Qiskit library\n",
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "\n",
    "# import the numpy library\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "# define the function to generate the quantum circuit\n",
    "# for the Iterative Phase Estimation (IPE) of an U gate\n",
    "def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
    "  \n",
    "    # notes:\n",
    "    # - qr is a quantum register with 2 qubits\n",
    "    # - cr is a classical register with 2 bits\n",
    "\n",
    "    # create a quantum circuit with the quantum register and with\n",
    "    # the classical register defined before, to implement\n",
    "    # the Iterative Phase Estimation (IPE) of the U gate\n",
    "    qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "    # retrieve the two qubits of the quantum register\n",
    "    q0, q1 = qr\n",
    "\n",
    "    # retrieve the two bits of the classical register\n",
    "    c0, c1 = cr\n",
    "    \n",
    "    \n",
    "    ####### your code goes here #######\n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(q0)\n",
    "    \n",
    "    # apply the Pauli-X gate to the 1st qubit (auxiliary qubit)\n",
    "    qc.x(q1)\n",
    "    \n",
    "    \n",
    "    # define the theta angle of the U gate as 2 * pi / 3\n",
    "    u_angle = 2 * np.pi / 3\n",
    "    \n",
    "    # define the number of the current iteration for\n",
    "    # the Iterative Phase Estimation (IPE) of the U gate\n",
    "    k = 1\n",
    "    \n",
    "    \n",
    "    # define the theta angle of the Controlled-Phase gate,\n",
    "    # according to the current iteration of\n",
    "    # the Iterative Phase Estimation (IPE) of the U gate\n",
    "    cphase_angle = u_angle * 2**k\n",
    "    \n",
    "    \n",
    "    # apply the Controlled-Phase gate for the kth theta angle,\n",
    "    # with control on the 1st qubit and target on the 2nd qubit\n",
    "    qc.cp( cphase_angle, q0, q1 )\n",
    "    \n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(q0)\n",
    "    \n",
    "    \n",
    "    # measure the state of the 1st qubit (system's qubit),\n",
    "    # storing the classical outcome on the 1st bit of\n",
    "    # the classical register\n",
    "    qc.measure(q0, c0)\n",
    "    \n",
    "    \n",
    "    # reset the state of the 1st qubit (system's qubit)\n",
    "    qc.reset(q0)\n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(q0)\n",
    "\n",
    "        \n",
    "    # define the number of the current iteration for\n",
    "    # the Iterative Phase Estimation (IPE) of the U gate\n",
    "    k = 0\n",
    "    \n",
    "    # define the theta angle of the Controlled-Phase gate,\n",
    "    # according to the current iteration of\n",
    "    # the Iterative Phase Estimation (IPE) of the U gate\n",
    "    cphase_angle = u_angle * 2**k\n",
    "    \n",
    "    \n",
    "    # if the 1st bit of the classical register of\n",
    "    # the dynamic quantum circuit has the classical state 1\n",
    "    with qc.if_test( ( cr[0], True ) ):\n",
    "    \n",
    "        # apply the phase correction of the kth theta angle to\n",
    "        # the 1st qubit of the quantum register with a P gate   \n",
    "        qc.p( -cphase_angle, q0 )\n",
    "    \n",
    "    \n",
    "    # apply the Controlled-Phase gate for the kth theta angle,\n",
    "    # with control on the 1st qubit and target on the 2nd qubit\n",
    "    qc.cp( cphase_angle, q0, q1 )\n",
    "    \n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(q0)\n",
    "    \n",
    "    \n",
    "    # measure the state of the 1st qubit (system's qubit),\n",
    "    # storing the classical outcome on the 2nd bit of\n",
    "    # the classical register\n",
    "    qc.measure(q0, c1)\n",
    "\n",
    "    \n",
    "    # return the quantum circuit\n",
    "    # for the Iterative Phase Estimation (IPE) of an U gate\n",
    "    return qc\n",
    "\n",
    "\n",
    "\n",
    "# create the quantum register for the quantum circuit to\n",
    "# implement the Iterative Phase Estimation (IPE) of the U gate\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "\n",
    "# create the classical register for the quantum circuit to\n",
    "# implement the Iterative Phase Estimation (IPE) of the U gate\n",
    "cr = ClassicalRegister(2, \"c\")\n",
    "\n",
    "\n",
    "# create the quantum circuit to implement\n",
    "# the Iterative Phase Estimation (IPE) of\n",
    "# the U gate, with the quantum register\n",
    "# and the classical register defined before\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "\n",
    "# create the quantum circuit implementing\n",
    "# the Iterative Phase Estimation (IPE) of the U gate\n",
    "qc = u_circuit(qr, cr)\n",
    "\n",
    "\n",
    "# draw the quantum circuit implementing\n",
    "# the Iterative Phase Estimation (IPE) of the U gate\n",
    "qc.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'10': 190, '00': 53, '01': 757}\n",
      "Success probability: 0.757\n"
     ]
    }
   ],
   "source": [
    "# import the Aer Simulator from the IBM's Qiskit Aer module\n",
    "from qiskit_aer import AerSimulator\n",
    "\n",
    "\n",
    "# create an Aer Simulator object\n",
    "sim = AerSimulator()\n",
    "\n",
    "\n",
    "# create a job for the quantum circuit implementing\n",
    "# the IPE for the U gate, running the Aer Simulator\n",
    "job = sim.run(qc, shots=1000)\n",
    "\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "result = job.result()\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "counts = result.get_counts()\n",
    "\n",
    "\n",
    "# print the result counts of the quantum simulation\n",
    "print(counts)\n",
    "\n",
    "\n",
    "# compute the success probability of the correct outcome\n",
    "success_probability = counts[\"01\"] / counts.shots()\n",
    "\n",
    "\n",
    "# print the success probability of the correct outcome\n",
    "print(f\"Success probability: {success_probability}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, this time, we are not guaranteed to obtain the desired result. A natural question to ask is: How can we boost the success probability?\n",
    "\n",
    "One way that the algorithm fails is that the first measured bit is incorrect. In this case, the phase correction applied before measuring the second bit is also incorrect, causing the rest of the bits to be likely incorrect as well. A simple way to mitigate this problem is to repeat the measurement of the first few bits several times and take a majority vote to increase the likelihood that we measure the bit correctly. Implementing this procedure within a single circuit requires performing arithmetic on the measured outcomes. Due to a temporary limitation in IBM's Qiskit, it is currently not possible to perform arithmetic on measured bits and condition future circuit operations on the results. So, here we will measure each bit using separate circuits.\n",
    "\n",
    "The following code cells construct and simulate an IPE circuit for measuring just the first bit of the phase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 538.128x284.278 with 1 Axes>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import the quantum circuit, quantum register, and classical register\n",
    "# from the IBM's Qiskit library\n",
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "\n",
    "# import the numpy library\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "# define the function to generate the quantum circuit\n",
    "# for the Iterative Phase Estimation (IPE) of an U gate\n",
    "def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
    "  \n",
    "    # notes:\n",
    "    # - qr is a quantum register with 2 qubits\n",
    "    # - cr is a classical register with 1 bit\n",
    "\n",
    "    # create a quantum circuit with the quantum register and with\n",
    "    # the classical register defined before, to implement\n",
    "    # the Iterative Phase Estimation (IPE) of the U gate\n",
    "    qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "    # retrieve the two qubits of the quantum register\n",
    "    q0, q1 = qr\n",
    "\n",
    "    # retrieve bit of the classical register\n",
    "    c0 = cr\n",
    "    \n",
    "    \n",
    "    ####### your code goes here #######\n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(q0)\n",
    "    \n",
    "    # apply the Pauli-X gate to the 1st qubit (auxiliary qubit)\n",
    "    qc.x(q1)\n",
    "    \n",
    "    \n",
    "    # define the theta angle of the U gate as 2 * pi / 3\n",
    "    u_angle = 2 * np.pi / 3\n",
    "    \n",
    "    # define the number of the current iteration for\n",
    "    # the Iterative Phase Estimation (IPE) of the U gate\n",
    "    k = 1\n",
    "    \n",
    "    \n",
    "    # define the theta angle of the Controlled-Phase gate,\n",
    "    # according to the current iteration of\n",
    "    # the Iterative Phase Estimation (IPE) of the U gate\n",
    "    cphase_angle = u_angle * 2**k\n",
    "    \n",
    "    \n",
    "    # apply the Controlled-Phase gate for the kth theta angle,\n",
    "    # with control on the 1st qubit and target on the 2nd qubit\n",
    "    qc.cp( cphase_angle, q0, q1 )\n",
    "    \n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(q0)\n",
    "    \n",
    "    \n",
    "    # measure the state of the 1st qubit (system's qubit),\n",
    "    # storing the classical outcome on the 1st bit of\n",
    "    # the classical register\n",
    "    qc.measure(q0, c0)\n",
    "\n",
    "    \n",
    "    # return the quantum circuit\n",
    "    # for the Iterative Phase Estimation (IPE) of an U gate\n",
    "    return qc\n",
    "\n",
    "\n",
    "# create the quantum register for the quantum circuit to\n",
    "# implement the Iterative Phase Estimation (IPE) of the U gate\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "\n",
    "# create the classical register for the quantum circuit to\n",
    "# implement the Iterative Phase Estimation (IPE) of the U gate\n",
    "cr = ClassicalRegister(1, \"c\")\n",
    "\n",
    "\n",
    "# create the quantum circuit to implement\n",
    "# the Iterative Phase Estimation (IPE) of\n",
    "# the U gate, with the quantum register\n",
    "# and the classical register defined before\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "\n",
    "# create the quantum circuit implementing\n",
    "# the Iterative Phase Estimation (IPE) of the U gate\n",
    "qc = u_circuit(qr, cr)\n",
    "\n",
    "\n",
    "# draw the quantum circuit implementing\n",
    "# the Iterative Phase Estimation (IPE) of the U gate\n",
    "qc.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'0': 7, '1': 8}\n"
     ]
    }
   ],
   "source": [
    "# create a job for the quantum circuit implementing\n",
    "# the IPE for the U gate, running the Aer Simulator\n",
    "job = sim.run(qc, shots=15)\n",
    "\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "result = job.result()\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "counts = result.get_counts()\n",
    "\n",
    "\n",
    "# print the result counts of the quantum simulation\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 4 - Determine the value for the bit of the step 1 of the quantum circuit, i.e., ${\\varphi}_{1}$, for a Iterative Phase Estimation (IPE) of the phase $\\varphi = 1/3$. </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4\n",
    "\n",
    "Examine the counts dictionary from the output of the last code cell. What is the correct value for the first bit? Was it measured more often than not? If not, rerun the last code cell until it is. Then, write some code in the code cell below that sets the variable `step1_bit` equal to the value of the bit that was measured the majority of the time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "# define the variable for\n",
    "# the bit resulting from the 1st step of\n",
    "# the Iterative Phase Estimation (IPE)\n",
    "step1_bit: int\n",
    "\n",
    "\n",
    "####### your code goes here #######\n",
    "\n",
    "# define the bit resulting from the 1st step of\n",
    "# the Iterative Phase Estimation (IPE)\n",
    "step1_bit = 1\n",
    "\n",
    "# print the bit resulting from the 1st step of\n",
    "# the Iterative Phase Estimation (IPE)\n",
    "print(step1_bit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# submit your result\n",
    "\n",
    "# import the grader for the exercise 4 of the lab 4\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab4_ex4\n",
    "\n",
    "# grade the exercise 4 of the lab 4\n",
    "grade_lab4_ex4( step1_bit )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 5 - Build a quantum circuit to measure the bit of the step 2, i.e., ${\\varphi}_{2}$, for the Iterative Phase Estimation (IPE) of the phase $\\varphi = 1/3$. </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5\n",
    "\n",
    "Now construct the circuit to measure the second bit of the phase. Replace the first stage of the circuit with one which simply sets the auxiliary bit to the value we measured above, so that we always measure the correct value for the first bit of the phase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 621.739x367.889 with 1 Axes>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import the quantum circuit, quantum register, and classical register\n",
    "# from the IBM's Qiskit library\n",
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "\n",
    "# import the numpy library\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "# define the function to generate the quantum circuit\n",
    "# for the Iterative Phase Estimation (IPE) of an U gate,\n",
    "# based on the classical bit obtained from the 1st step\n",
    "def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
    "    \n",
    "    # notes:\n",
    "    # - qr is a quantum register with 2 qubits\n",
    "    # - cr is a classical register with 1 bit\n",
    "\n",
    "    # create a quantum circuit with the quantum register and with\n",
    "    # the classical register defined before, to implement\n",
    "    # the Iterative Phase Estimation (IPE) of the U gate\n",
    "    qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "    # retrieve the two qubits of the quantum register\n",
    "    q0, q1 = qr\n",
    "\n",
    "    # retrieve the two bit of the classical register\n",
    "    c0, c1 = cr\n",
    "    \n",
    "    \n",
    "    ####### your code goes here #######\n",
    "\n",
    "    # if the classical bit obtained from\n",
    "    # the 1st step is the classical state 1\n",
    "    with qc.if_test( ( step1_bit, True ) ):\n",
    "    \n",
    "        # apply the Pauli-X gate to the 1st qubit (system's qubit)\n",
    "        qc.x(q0)\n",
    "    \n",
    "    \n",
    "    # apply the Pauli-X gate to the 2nd qubit (auxiliary qubit)\n",
    "    qc.x(q1)\n",
    "    \n",
    "    \n",
    "    # define the theta angle of the U gate as pi / 3\n",
    "    u_angle = np.pi / 3\n",
    "    \n",
    "    \n",
    "    # define the number of the current iteration for\n",
    "    # the Iterative Phase Estimation (IPE) of the U gate\n",
    "    k = 1\n",
    "    \n",
    "    \n",
    "    # define the theta angle of the Controlled-Phase gate,\n",
    "    # according to the current iteration of\n",
    "    # the Iterative Phase Estimation (IPE) of the U gate\n",
    "    cphase_angle = u_angle * 2**k\n",
    "\n",
    "\n",
    "    # apply the Controlled-Phase gate for the kth theta angle,\n",
    "    # with control on the 1st qubit and target on the 2nd qubit\n",
    "    qc.cp( cphase_angle, q0, q1 )\n",
    "    \n",
    "\n",
    "    # measure the state of the 2nd qubit (auxiliary qubit),\n",
    "    # storing the classical outcome on the 1st bit of\n",
    "    # the classical register   \n",
    "    qc.measure(q1, c0)\n",
    "    \n",
    "    \n",
    "    # return the quantum circuit\n",
    "    # for the Iterative Phase Estimation (IPE) of an U gate,\n",
    "    # based on the classical bit obtained from the 1st step\n",
    "    return qc\n",
    "\n",
    "\n",
    "# create the quantum register for the quantum circuit to\n",
    "# implement the Iterative Phase Estimation (IPE) of the U gate,\n",
    "# based on the classical bit obtained from the 1st step\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "\n",
    "# create the classical register for the quantum circuit to\n",
    "# implement the Iterative Phase Estimation (IPE) of the U gate,\n",
    "# based on the classical bit obtained from the 1st step\n",
    "cr = ClassicalRegister(2, \"c\")\n",
    "\n",
    "\n",
    "# create the quantum circuit to implement\n",
    "# the Iterative Phase Estimation (IPE) of\n",
    "# the U gate, based on the classical bit\n",
    "# obtained from the 1st step,\n",
    "# with the quantum register and\n",
    "# the classical register defined before\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "\n",
    "# create the quantum circuit implementing\n",
    "# the Iterative Phase Estimation (IPE) of the U gate,\n",
    "# based on the classical bit obtained from the 1st step\n",
    "qc = u_circuit(qr, cr)\n",
    "\n",
    "\n",
    "# draw the quantum circuit implementing\n",
    "# the Iterative Phase Estimation (IPE) of the U gate,\n",
    "# based on the classical bit obtained from the 1st step\n",
    "qc.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# submit your result\n",
    "\n",
    "# import the grader for the exercise 5 of the lab 4\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab4_ex5\n",
    "\n",
    "# grade the exercise 5 of the lab 4\n",
    "grade_lab4_ex5( qc )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'01': 1000}\n",
      "Success probability: 1.0\n"
     ]
    }
   ],
   "source": [
    "# import the Aer Simulator from the IBM's Qiskit Aer module\n",
    "from qiskit_aer import AerSimulator\n",
    "\n",
    "\n",
    "# create an Aer Simulator object\n",
    "sim = AerSimulator()\n",
    "\n",
    "\n",
    "# create a job for the quantum circuit implementing\n",
    "# the IPE for the U gate, running the Aer Simulator\n",
    "job = sim.run(qc, shots=1000)\n",
    "\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "result = job.result()\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "counts = result.get_counts()\n",
    "\n",
    "\n",
    "# print the result counts of the quantum simulation\n",
    "print(counts)\n",
    "\n",
    "\n",
    "# compute the success probability of the correct outcome\n",
    "success_probability = counts[\"01\"] / counts.shots()\n",
    "\n",
    "\n",
    "# print the success probability of the correct outcome\n",
    "print(f\"Success probability: {success_probability}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 6 (ungraded) - Build a quantum circuit for a general Iterative Phase Estimation (IPE). </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 6 (ungraded)\n",
    "\n",
    "So far, the IPE circuits we constructed were designed for a specific gate and a specific number of bits of precision. Let's now generalize your code to implement a general IPE routine that can handle different gates and levels of precision.\n",
    "\n",
    "Complete the following function to implement a generalized IPE routine. It takes the following inputs:\n",
    "- `qr`: The quantum register. The first qubit is assumed to be the auxiliary qubit, and the rest of them the system qubits.\n",
    "- `cr`: The classical register. Its length indicates the desired number of bits of precision.\n",
    "- `controlled_unitaries`: A list of gates implementing *controlled*-$U^{2^t}$ for $t = 0, \\ldots, m-1$, where $m$ is the number of bits of precision.\n",
    "- `state_prep`: A gate used to initialize the state of the system qubits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's build the quantum circuit for a general Iterative Phase Estimation (IPE) routine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the Gate from the IBM's Qiskit Circuit module\n",
    "from qiskit.circuit import Gate\n",
    "\n",
    "\n",
    "# define the function to generate the dynamic quantum circuit\n",
    "# for a general Iterative Phase Estimation (IPE)\n",
    "def iterative_phase_estimation(\n",
    "    qr: QuantumRegister,\n",
    "    cr: ClassicalRegister,\n",
    "    controlled_unitaries: list[Gate],\n",
    "    state_prep: Gate,\n",
    ") -> QuantumCircuit:\n",
    "    qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "    \n",
    "    ####### your code goes here #######\n",
    "    \n",
    "    # retrieve the number of the Controlled-U gates\n",
    "    m = len( controlled_unitaries )\n",
    "    \n",
    "    \n",
    "    # create a copy of the list of the Controlled-U gates\n",
    "    controlled_unitaries_reversed = controlled_unitaries.copy()\n",
    "\n",
    "    # retrieve the reverse list of the Controlled-U gates\n",
    "    controlled_unitaries_reversed.reverse()\n",
    "    \n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(0)\n",
    "    \n",
    "    \n",
    "    # initialize the preparation of the state\n",
    "    # with the eigenstate |1>\n",
    "    qc.append( state_prep, [1] )\n",
    "    \n",
    "    \n",
    "    # apply the Controlled-U gate for t = (m - 1)\n",
    "    qc.append( controlled_unitaries_reversed[0], [0, 1] )\n",
    "    \n",
    "    \n",
    "    # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "    qc.h(0)\n",
    "    \n",
    "    \n",
    "    # measure the state of the 1st qubit (system's qubit),\n",
    "    # storing the classical outcome on the 1st bit\n",
    "    qc.measure(0, 0)\n",
    "   \n",
    "\n",
    "    # for the remaining (m - 1) iterations\n",
    "    for k in range(1, m):\n",
    "    \n",
    "        # reset the state of the 1st qubit (system's qubit)\n",
    "        qc.reset(0)\n",
    "\n",
    "        \n",
    "        # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "        qc.h(0)\n",
    "\n",
    "        \n",
    "        # if the 1st bit of the classical register of\n",
    "        # the dynamic quantum circuit has the classical state 1\n",
    "        with qc.if_test( ( cr[0], 1 ) ):\n",
    "            \n",
    "            # apply the phase correction to the 1st qubit of\n",
    "            # the quantum register with a P gate\n",
    "            qc.p( -controlled_unitaries[ ( m - k - 1 ) ].params[0], 0 )\n",
    "\n",
    "        \n",
    "        # apply the Controlled-U gate for t = (m - k)\n",
    "        qc.append( controlled_unitaries_reversed[k], [0, 1] )\n",
    "\n",
    "        \n",
    "        # apply the Hadamard gate to the 1st qubit (system's qubit)\n",
    "        qc.h(0)\n",
    "\n",
    "        \n",
    "        # measure the state of the 1st qubit (system's qubit),\n",
    "        # storing the classical outcome on the kth bit\n",
    "        qc.measure(0, k)\n",
    "\n",
    "    \n",
    "    # return the dynamic quantum circuit\n",
    "    # for a general Iterative Phase Estimation (IPE)\n",
    "    return qc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The example below shows how one would use this function to generate the IPE circuit for the $Z$ gate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'1': 1000}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import the Controlled-Phase and Pauli-X gates\n",
    "# from the IBM's Qiskit Circuit Library module\n",
    "from qiskit.circuit.library import CPhaseGate, XGate\n",
    "\n",
    "\n",
    "# create the quantum register with two qubits\n",
    "# for the quantum circuit to implement IPE on the Z gate\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "\n",
    "# create the quantum register with three bits\n",
    "# for the quantum circuit to implement IPE on the Z gate\n",
    "cr = ClassicalRegister(1, \"c\")\n",
    "\n",
    "\n",
    "# define the theta angle for the Z gate\n",
    "z_angle = np.pi\n",
    "\n",
    "\n",
    "# create the list of Controlled-U/Controlled-Phases gates,\n",
    "# considering the theta angle for the Z gate\n",
    "controlled_unitaries = [ CPhaseGate( z_angle * 2**k ) for k in range(1) ]\n",
    "\n",
    "\n",
    "# generate the quantum circuit implementing\n",
    "# the IPE for the Z gate\n",
    "qc = iterative_phase_estimation( qr, cr, controlled_unitaries, XGate() )\n",
    "\n",
    "\n",
    "# draw the quantum circuit implementing\n",
    "# the IPE for the Z gate\n",
    "qc.draw(\"mpl\")\n",
    "\n",
    "\n",
    "# create an Aer Simulator object\n",
    "sim = AerSimulator()\n",
    "\n",
    "\n",
    "# create a job for the quantum circuit implementing\n",
    "# the IPE for the Z gate, running the Aer Simulator\n",
    "job = sim.run(qc, shots=1000)\n",
    "\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "result = job.result()\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "counts = result.get_counts()\n",
    "\n",
    "\n",
    "# show the result counts of the quantum simulation\n",
    "counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The example below shows how one would use this function to generate the IPE circuit for the $S$ gate. The simulation results should match what you got above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'01': 1000}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import the Controlled-Phase and Pauli-X gates\n",
    "# from the IBM's Qiskit Circuit Library module\n",
    "from qiskit.circuit.library import CPhaseGate, XGate\n",
    "\n",
    "\n",
    "# create the quantum register with two qubits\n",
    "# for the quantum circuit to implement IPE on the S gate\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "\n",
    "# create the quantum register with three bits\n",
    "# for the quantum circuit to implement IPE on the S gate\n",
    "cr = ClassicalRegister(2, \"c\")\n",
    "\n",
    "\n",
    "# define the theta angle for the S gate\n",
    "s_angle = np.pi / 2\n",
    "\n",
    "\n",
    "# create the list of Controlled-U/Controlled-Phase gates,\n",
    "# considering the theta angle for the S gate\n",
    "controlled_unitaries = [ CPhaseGate( s_angle * 2**k ) for k in range(2) ]\n",
    "\n",
    "\n",
    "# generate the quantum circuit implementing\n",
    "# the IPE for the S gate\n",
    "qc = iterative_phase_estimation( qr, cr, controlled_unitaries, XGate() )\n",
    "\n",
    "\n",
    "# draw the quantum circuit implementing\n",
    "# the IPE for the S gate\n",
    "qc.draw(\"mpl\")\n",
    "\n",
    "\n",
    "# create an Aer Simulator object\n",
    "sim = AerSimulator()\n",
    "\n",
    "\n",
    "# create a job for the quantum circuit implementing\n",
    "# the IPE for the S gate, running the Aer Simulator\n",
    "job = sim.run(qc, shots=1000)\n",
    "\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "result = job.result()\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "counts = result.get_counts()\n",
    "\n",
    "\n",
    "# show the result counts of the quantum simulation\n",
    "counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The example below shows how one would use this function to generate the IPE circuit for the $T$ gate. The simulation results should match what you got above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'001': 1000}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import the Controlled-Phase and Pauli-X gates\n",
    "# from the IBM's Qiskit Circuit Library module\n",
    "from qiskit.circuit.library import CPhaseGate, XGate\n",
    "\n",
    "\n",
    "# create the quantum register with two qubits\n",
    "# for the quantum circuit to implement IPE on the T gate\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "\n",
    "# create the quantum register with three bits\n",
    "# for the quantum circuit to implement IPE on the T gate\n",
    "cr = ClassicalRegister(3, \"c\")\n",
    "\n",
    "\n",
    "# define the theta angle for the T gate\n",
    "t_angle = np.pi / 4\n",
    "\n",
    "\n",
    "# create the list of Controlled-U/Controlled-Phase gates,\n",
    "# considering the theta angle for the T gate\n",
    "controlled_unitaries = [ CPhaseGate( t_angle * 2**k ) for k in range(3) ]\n",
    "\n",
    "\n",
    "# generate the quantum circuit implementing\n",
    "# the IPE for the T gate\n",
    "qc = iterative_phase_estimation( qr, cr, controlled_unitaries, XGate() )\n",
    "\n",
    "\n",
    "# draw the quantum circuit implementing\n",
    "# the IPE for the T gate\n",
    "qc.draw(\"mpl\")\n",
    "\n",
    "\n",
    "# create an Aer Simulator object\n",
    "sim = AerSimulator()\n",
    "\n",
    "\n",
    "# create a job for the quantum circuit implementing\n",
    "# the IPE for the T gate, running the Aer Simulator\n",
    "job = sim.run(qc, shots=1000)\n",
    "\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "result = job.result()\n",
    "\n",
    "# retrieve the result counts of the quantum simulation\n",
    "counts = result.get_counts()\n",
    "\n",
    "\n",
    "# show the result counts of the quantum simulation\n",
    "counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run on hardware\n",
    "\n",
    "In the final part of this lab, we will run some circuits on real hardware! The code cells below initialize and run the circuit you created in Exercise 2 to measure the phase of the $S$ gate. Because current quantum hardware suffers from noise, the results will not be as good as what you got on the simulator. Feel free to try running the other circuits you created in this lab, though be aware that larger circuits, like the one from Exercise 3 for measuring the phase of the $T$ gate, will suffer from even more noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the IBMps Provider from Qiskit IBM Provider module\n",
    "from qiskit_ibm_provider import IBMProvider\n",
    "\n",
    "# create an IBM's Provider object\n",
    "provider = IBMProvider()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the hub for the IBM's Provider\n",
    "hub = \"summer-school-6\"\n",
    "\n",
    "# define the group for the IBM's Provider\n",
    "group = \"group-3\"\n",
    "\n",
    "# define the project for the IBM's Provider\n",
    "project = \"7048813929\"\n",
    "\n",
    "\n",
    "# define the backend's name for the IBM's Provider\n",
    "backend_name = \"ibmq_manila\"\n",
    "\n",
    "\n",
    "# retrieve the backend from the IBM's Provider\n",
    "backend = provider.get_backend( backend_name, instance=f\"{hub}/{group}/{project}\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2255.74x618.722 with 1 Axes>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import the transpile feature\n",
    "# from the IBM's Qiskit library\n",
    "from qiskit import transpile\n",
    "\n",
    "\n",
    "# create the quantum register with two qubits\n",
    "# for the quantum circuit to implement IPE on the S gate\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "\n",
    "# create a classical register with two bits\n",
    "# for the quantum circuit to implement IPE on the S gate\n",
    "cr = ClassicalRegister(2, \"c\")\n",
    "\n",
    "\n",
    "# create the quantum circuit with\n",
    "# the quantum and classical registers\n",
    "# defined before to implement IPE on the S gate\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "\n",
    "# perform the 2nd step of the IPE on the S gate to\n",
    "# the quantum circuit created before\n",
    "qc = step_2_circuit(qr, cr)\n",
    "\n",
    "# create the transpiled quantum circuit\n",
    "# to implement IPE on the S gate\n",
    "qc_transpiled = transpile(qc, backend)\n",
    "\n",
    "\n",
    "# draw the quantum circuit implementing\n",
    "# an IPE on the S gate\n",
    "qc_transpiled.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# OPTIONAL: run the job of the IPE for the S gate\n",
    "\n",
    "# run the transpiled dynamic quantum circuit of\n",
    "# the IPE for the S gate\n",
    "#job = backend.run(qc_transpiled, shots=1000, dynamic=True)\n",
    "\n",
    "# retrieve the id of the job of the quantum simulation\n",
    "# for the IPE for the S gate\n",
    "#job_id = job.job_id()\n",
    "\n",
    "# print the id of the job of the quantum simulation\n",
    "# for the IPE for the S gate\n",
    "#print(job_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# OPTIONAL: retrieve and show the job's status of the IPE for the S gate\n",
    "\n",
    "# retrieve the job of the quantum simulation\n",
    "# for the IPE for the S gate\n",
    "#retrieve_job = provider.retrieve_job(job_id)\n",
    "\n",
    "# show the job's status of the quantum simulation\n",
    "# for the IPE for the S gate\n",
    "#retrieve_job.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# OPTIONAL: plot the histogram of the results of the IPE for the S gate\n",
    "\n",
    "# import the plot histogram from\n",
    "# the IBM's Qiskit Tools' Visualization module\n",
    "#from qiskit.tools.visualization import plot_histogram\n",
    "\n",
    "# retrieve the counts of the results of the job\n",
    "# for the quantum simulation for the IPE for the S gate\n",
    "#counts = retrieve_job.result().get_counts()\n",
    "\n",
    "# plot the historgram of the count results of\n",
    "# the quantum simulation for the IPE for the S gate\n",
    "#plot_histogram(counts)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.8"
  },
  "vscode": {
   "interpreter": {
    "hash": "c2040b9df22fb8e6f552d9b589c97ff536ffe03a0da1ea2949f78b5a0e303bb6"
   }
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "144ae26c0e9a46319ab03e0c8263c5cb": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_250853245ff9450a889b79eed64000f9",
       "style": "IPY_MODEL_de5d1a4e7778477e93c647a9ee46e706",
       "value": "<h5>Backend</h5>"
      }
     },
     "1b7e01ab26a7474cac73624a234cdc5b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "1cd6f6d031044b10bfdceea781c59817": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_template_areas": "\n                                       \". . . . right \"\n                                        ",
       "grid_template_columns": "20% 20% 20% 20% 20%",
       "width": "100%"
      }
     },
     "21ba6738417d4c22a8b1b545ea65b078": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "222636307b4c4253a7b59cefb51f40d6": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_727a4331321a4ff09cc37d66a8f53523",
       "style": "IPY_MODEL_26f78f0de748495e9002d485a86ff42f",
       "value": "<h5>Job ID</h5>"
      }
     },
     "250853245ff9450a889b79eed64000f9": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "width": "145px"
      }
     },
     "26f78f0de748495e9002d485a86ff42f": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "388cf5adcc764a24aa1109d3b00f50f8": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "GridBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_b6340ba88d5a49b69976b126d42ad6eb"
       ],
       "layout": "IPY_MODEL_1cd6f6d031044b10bfdceea781c59817"
      }
     },
     "3a6cb7f4770447f99be6f7d9c65a6572": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "3e574070e3274fe5a4b88e0b88a61e15": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "width": "95px"
      }
     },
     "5cb90d7e36db403cb5a773016fcfdf50": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_a314b14c36c44b86806629ed24ce532a",
       "style": "IPY_MODEL_6e2ad41e709f4ff9adc14b62c1722be8",
       "value": "<h5>Queue</h5>"
      }
     },
     "62ff977ff0f44425b3114ca2829f11f6": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "margin": "0px 0px 10px 0px"
      }
     },
     "6e2ad41e709f4ff9adc14b62c1722be8": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "727a4331321a4ff09cc37d66a8f53523": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "width": "190px"
      }
     },
     "95043da6620746d08eda12f75e134010": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_222636307b4c4253a7b59cefb51f40d6",
        "IPY_MODEL_144ae26c0e9a46319ab03e0c8263c5cb",
        "IPY_MODEL_b7b748be5c694f7a9beace6857e4cc3b",
        "IPY_MODEL_5cb90d7e36db403cb5a773016fcfdf50",
        "IPY_MODEL_d684d258d89f48ca8f30e1be07ac3449"
       ],
       "layout": "IPY_MODEL_d1be4d1515274e73988a664624cca26f"
      }
     },
     "a314b14c36c44b86806629ed24ce532a": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "width": "70px"
      }
     },
     "a5e904843e4440e79fa6b65586f622e4": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_62ff977ff0f44425b3114ca2829f11f6",
       "style": "IPY_MODEL_de79d65b9e9e4e4cb7668ce008cfe65e",
       "value": "<p style='font-family: IBM Plex Sans, Arial, Helvetica, sans-serif; font-size: 20px; font-weight: medium;'>Circuit Properties</p>"
      }
     },
     "a9996cf653444529bc6ceb34a04125c1": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "ButtonStyleModel",
      "state": {
       "font_family": null,
       "font_size": null,
       "font_style": null,
       "font_variant": null,
       "font_weight": null,
       "text_color": null,
       "text_decoration": null
      }
     },
     "b6340ba88d5a49b69976b126d42ad6eb": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "primary",
       "description": "Clear",
       "layout": "IPY_MODEL_e1fc7fd15cf046928b3dfefe3545ce4d",
       "style": "IPY_MODEL_a9996cf653444529bc6ceb34a04125c1",
       "tooltip": null
      }
     },
     "b7b748be5c694f7a9beace6857e4cc3b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_3e574070e3274fe5a4b88e0b88a61e15",
       "style": "IPY_MODEL_1b7e01ab26a7474cac73624a234cdc5b",
       "value": "<h5>Status</h5>"
      }
     },
     "d1be4d1515274e73988a664624cca26f": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "margin": "0px 0px 0px 37px",
       "width": "600px"
      }
     },
     "d684d258d89f48ca8f30e1be07ac3449": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_3a6cb7f4770447f99be6f7d9c65a6572",
       "style": "IPY_MODEL_21ba6738417d4c22a8b1b545ea65b078",
       "value": "<h5>Message</h5>"
      }
     },
     "de5d1a4e7778477e93c647a9ee46e706": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "de79d65b9e9e4e4cb7668ce008cfe65e": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "e1fc7fd15cf046928b3dfefe3545ce4d": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "right",
       "padding": "0px 0px 0px 0px",
       "width": "70px"
      }
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}