lab3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 3: Iterative phase estimation\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. Until the introduction of dynamic circuits, such classical feed-forward was impossible to execute on IBM's quantum hardware.\n",
    "\n",
    "In this lab, we will use the recently introduced dynamic circuits capabilities to implement IPE."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Background\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 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": {
    "tags": []
   },
   "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",
    "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",
    "2. Apply a *controlled*-$S^{2}$ gate by applying a `CPhaseGate` with the appropriate angle.\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",
    "\n",
    "The resulting circuit should look something like this:\n",
    "\n",
    "![step1-circuit](resources/step1-circuit.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 454.517x284.278 with 1 Axes>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def step_1_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
    "    # qr is a quantum register with 2 qubits\n",
    "    # cr is a classical register with 2 bits\n",
    "\n",
    "    qc = QuantumCircuit(qr, cr)\n",
    "    q0,q1=qr\n",
    "    c,_=cr\n",
    "    ####### your code goes here #######\n",
    "    qc.h(q0)\n",
    "    qc.x(q1)\n",
    "    qc.cp(np.pi,q0,q1)\n",
    "    qc.h(q0)\n",
    "    qc.measure(q0,c)\n",
    "\n",
    "    return qc\n",
    "\n",
    "\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "cr = ClassicalRegister(2, \"c\")\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "qc = step_1_circuit(qr, cr)\n",
    "qc.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# Submit your circuit\n",
    "\n",
    "from qc_grader.challenges.spring_2023 import grade_ex3a\n",
    "\n",
    "grade_ex3a(qc)"
   ]
  },
  {
   "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",
    "The resulting circuit should look something like this:\n",
    "\n",
    "![step1-circuit](resources/step2-circuit.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1123.41x367.889 with 1 Axes>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def step_2_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
    "    # qr is a quantum register with 2 qubits\n",
    "    # cr is a classical register with 2 bits\n",
    "\n",
    "    # begin with the circuit from Step 1\n",
    "    qc = step_1_circuit(qr, cr)\n",
    "    q0,q1=qr\n",
    "    c0,c1=cr\n",
    "    ####### your code goes here #######\n",
    "    qc.reset(q0)\n",
    "    qc.h(q0)\n",
    "    with qc.if_test((c0,1)):\n",
    "        qc.p(-np.pi/2,q0)\n",
    "    qc.cp(np.pi/2,q0,q1)\n",
    "    qc.h(q0)\n",
    "    qc.measure(q0,c1)\n",
    "    \n",
    "    return qc\n",
    "\n",
    "\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "cr = ClassicalRegister(2, \"c\")\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "qc = step_2_circuit(qr, cr)\n",
    "qc.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# Submit your circuit\n",
    "\n",
    "from qc_grader.challenges.spring_2023 import grade_ex3b\n",
    "\n",
    "grade_ex3b(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": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'01': 1000}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit_aer import AerSimulator\n",
    "\n",
    "sim = AerSimulator()\n",
    "job = sim.run(qc, shots=1000)\n",
    "result = job.result()\n",
    "counts = result.get_counts()\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": [
    "### 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": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1959.52x451.5 with 1 Axes>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def t_gate_ipe_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
    "    # qr is a quantum register with 2 qubits\n",
    "    # cr is a classical register with 3 bits\n",
    "\n",
    "    qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "    ####### your code goes here #######\n",
    "    q0,q1=qr\n",
    "    c0,c1,c2=cr\n",
    "    \n",
    "    qc.h(q0)\n",
    "    qc.x(q1)\n",
    "    \n",
    "    qc.cp(np.pi,q0,q1)\n",
    "    \n",
    "    qc.h(q0)\n",
    "    qc.measure(q0,c0)\n",
    "    \n",
    "    qc.reset(q0)\n",
    "    qc.h(q0)\n",
    "    \n",
    "    with qc.if_test((c0,1)):\n",
    "        qc.p(-np.pi/2,q0)\n",
    "        \n",
    "    qc.cp(np.pi/2,q0,q1)\n",
    "    \n",
    "    qc.h(q0)\n",
    "    qc.measure(q0,c1)\n",
    "    \n",
    "    qc.reset(q0)\n",
    "    qc.h(q0)\n",
    "    \n",
    "    with qc.if_test((c0,1)):\n",
    "        qc.p(-np.pi/4,q0)\n",
    "    with qc.if_test((c1,1)):\n",
    "        qc.p(-np.pi/4,q0)\n",
    "        \n",
    "    qc.cp(np.pi/4,q0,q1)\n",
    "    \n",
    "    qc.h(q0)\n",
    "    qc.measure(q0,c2)\n",
    "    \n",
    "    return qc\n",
    "\n",
    "\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "cr = ClassicalRegister(3, \"c\")\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "qc = t_gate_ipe_circuit(qr, cr)\n",
    "qc.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'001': 1000}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit_aer import AerSimulator\n",
    "\n",
    "sim = AerSimulator()\n",
    "job = sim.run(qc, shots=1000)\n",
    "result = job.result()\n",
    "counts = result.get_counts()\n",
    "counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# Submit your circuit\n",
    "\n",
    "from qc_grader.challenges.spring_2023 import grade_ex3c\n",
    "\n",
    "grade_ex3c(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": 17,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1207.02x367.889 with 1 Axes>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
    "    # qr is a quantum register with 2 qubits\n",
    "    # cr is a classical register with 2 bits\n",
    "\n",
    "    qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "    # Initialization\n",
    "    q0, q1 = qr\n",
    "    qc.h(q0)\n",
    "    qc.x(q1)\n",
    "\n",
    "    # Apply control-U operator as many times as needed to get the least significant phase bit\n",
    "    u_angle = np.pi / 3\n",
    "    k = 1\n",
    "    cphase_angle = u_angle * 2**k\n",
    "    qc.cp(cphase_angle, q0, q1)\n",
    "\n",
    "    # Measure the auxiliary qubit in x-basis into the first classical bit\n",
    "    qc.h(q0)\n",
    "    c0, c1 = cr\n",
    "    qc.measure(q0, c0)\n",
    "\n",
    "    # Reset and re-initialize the auxiliary qubit\n",
    "    qc.reset(q0)\n",
    "    qc.h(q0)\n",
    "\n",
    "    # Apply phase correction conditioned on the first classical bit\n",
    "    with qc.if_test((c0, 1)):\n",
    "        qc.p(-np.pi / 2, q0)\n",
    "\n",
    "    # Apply control-U operator as many times as needed to get the next phase bit\n",
    "    k = 0\n",
    "    cphase_angle = u_angle * 2**k\n",
    "    qc.cp(cphase_angle, q0, q1)\n",
    "\n",
    "    # Measure the auxiliary qubit in x-basis into the second classical bit\n",
    "    qc.h(q0)\n",
    "    qc.measure(q0, c1)\n",
    "\n",
    "    return qc\n",
    "\n",
    "\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "cr = ClassicalRegister(2, \"c\")\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "qc = u_circuit(qr, cr)\n",
    "qc.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'11': 51, '01': 690, '10': 67, '00': 192}\n",
      "Success probability: 0.69\n"
     ]
    }
   ],
   "source": [
    "from qiskit_aer import AerSimulator\n",
    "\n",
    "sim = AerSimulator()\n",
    "job = sim.run(qc, shots=1000)\n",
    "result = job.result()\n",
    "counts = result.get_counts()\n",
    "print(counts)\n",
    "success_probability = counts[\"01\"] / counts.shots()\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 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": 21,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 538.128x284.278 with 1 Axes>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
    "    # qr is a quantum register with 2 qubits\n",
    "    # cr is a classical register with 1 bits\n",
    "\n",
    "    qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "    # Initialization\n",
    "    q0, q1 = qr\n",
    "    qc.h(q0)\n",
    "    qc.x(q1)\n",
    "\n",
    "    # Apply control-U operator as many times as needed to get the least significant phase bit\n",
    "    u_angle = np.pi / 3\n",
    "    k = 1\n",
    "    cphase_angle = u_angle * 2**k\n",
    "    qc.cp(cphase_angle, q0, q1)\n",
    "\n",
    "    # Measure the auxiliary qubit in x-basis\n",
    "    qc.h(q0)\n",
    "    (c0,) = cr\n",
    "    qc.measure(q0, c0)\n",
    "\n",
    "    return qc\n",
    "\n",
    "\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "cr = ClassicalRegister(1, \"c\")\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "qc = u_circuit(qr, cr)\n",
    "qc.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'0': 3, '1': 12}\n"
     ]
    }
   ],
   "source": [
    "job = sim.run(qc, shots=15)\n",
    "result = job.result()\n",
    "counts = result.get_counts()\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hopefully, the correct bit was measured more often than not.\n",
    "\n",
    "### 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": 22,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "step1_bit: int\n",
    "\n",
    "####### your code goes here #######\n",
    "step1_bit = 1\n",
    "print(step1_bit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# Submit your result\n",
    "\n",
    "from qc_grader.challenges.spring_2023 import grade_ex3d\n",
    "\n",
    "grade_ex3d(step1_bit)"
   ]
  },
  {
   "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": 89,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 788.961x367.889 with 1 Axes>"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
    "    # qr is a quantum register with 2 qubits\n",
    "    # cr is a classical register with 2 bits\n",
    "\n",
    "    qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "    ####### your code goes here #######\n",
    "    # Initialization\n",
    "    q0, q1 = qr\n",
    "    c0,c1=cr\n",
    "    \n",
    "    qc.initialize('1',q0)\n",
    "    qc.measure(q1,c1)\n",
    "    qc.h(q0)\n",
    "\n",
    "    # Apply phase correction conditioned on the first classical bit\n",
    "    with qc.if_test((c1, 1)):\n",
    "        qc.p(-np.pi / 2, q0)\n",
    "\n",
    "    # Apply control-U operator as many times as needed to get the next phase bit\n",
    "    u_angle = np.pi / 3\n",
    "    k = 0\n",
    "    cphase_angle = u_angle * 2**k\n",
    "    qc.cp(cphase_angle, q0, q1)\n",
    "\n",
    "    # Measure the auxiliary qubit in x-basis into the second classical bit\n",
    "    qc.h(q0)\n",
    "    qc.measure(q0, c0)\n",
    "\n",
    "    return qc\n",
    "\n",
    "\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "cr = ClassicalRegister(2, \"c\")\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "qc = u_circuit(qr, cr)\n",
    "qc.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting your answer. Please wait...\n",
      "Congratulations 🎉! Your answer is correct and has been submitted.\n"
     ]
    }
   ],
   "source": [
    "# Submit your result\n",
    "\n",
    "from qc_grader.challenges.spring_2023 import grade_ex3e\n",
    "\n",
    "grade_ex3e(qc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'01': 1000}\n",
      "Success probability: 1.0\n"
     ]
    }
   ],
   "source": [
    "from qiskit_aer import AerSimulator\n",
    "\n",
    "sim = AerSimulator()\n",
    "job = sim.run(qc, shots=1000)\n",
    "result = job.result()\n",
    "counts = result.get_counts()\n",
    "print(counts)\n",
    "success_probability = counts[\"01\"] / counts.shots()\n",
    "print(f\"Success probability: {success_probability}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, the success probability is much higher than before!"
   ]
  },
  {
   "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": 92,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from qiskit_ibm_provider import IBMProvider\n",
    "\n",
    "provider = IBMProvider()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "hub = \"qc-spring-23-5\"\n",
    "group = \"group-1\"\n",
    "project = \"recLNG4XjMAmc5y0j\"\n",
    "\n",
    "backend_name = \"ibm_peekskill\"\n",
    "backend = provider.get_backend(backend_name, instance=f\"{hub}/{group}/{project}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from qiskit import transpile\n",
    "\n",
    "qr = QuantumRegister(2, \"q\")\n",
    "cr = ClassicalRegister(2, \"c\")\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "qc = step_2_circuit(qr, cr)\n",
    "qc_transpiled = transpile(qc, backend)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "chjpil6pqnphtdtlj65g\n"
     ]
    }
   ],
   "source": [
    "job = backend.run(qc_transpiled, shots=1000, dynamic=True)\n",
    "job_id = job.job_id()\n",
    "print(job_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<JobStatus.QUEUED: 'job is queued'>"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "retrieve_job = provider.retrieve_job(job_id)\n",
    "retrieve_job.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.tools.visualization import plot_histogram\n",
    "\n",
    "counts = retrieve_job.result().get_counts()\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This lab was adapted from the [Qiskit Textbook lab](https://learn.qiskit.org/course/ch-labs/lab-6-iterative-phase-estimation-algorithm) on iterative phase estimation as well as material from the [dynamic circuits documentation](https://quantum-computing.ibm.com/services/resources/docs/resources/manage/systems/dynamic-circuits/Getting-started-with-Dynamic-Circuits)."
   ]
  }
 ],
 "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": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}