lab1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dfb2ccb8",
   "metadata": {},
   "source": [
    "# IBM Quantum Challenge: Spring 2023"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5055920",
   "metadata": {},
   "source": [
    "## First Steps"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb7408b2",
   "metadata": {},
   "source": [
    "Welcome to the IBM Quantum Challenge: Spring 2023!\n",
    "\n",
    "This iteration of the IBM Quantum Challenge is dedicated to dynamic circuits. You're currently in the first lab of the challenge. As work through the labs, you will be required to complete some exercises. In this introductory section, we will give you a brief overview of how to complete the exercises. Even if you have participated in previous challenges, you may want to review this material.\n",
    "\n",
    "All the labs will contain a mixture of tutorial content, pre-written code blocks, and exercise code blocks which will require you to fill in your own Qiskit code. The code required to complete the exercise should be typed under the line which has the _\"### Your code goes here ###\"_ comment. \n",
    "\n",
    "If you've never been part of a Challenge before, it's important to note that you should run every code cell, even if you didn't write any new code within. This makes sure that when you submit your answers by running the grader, everything is up to date. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46e89268",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Sample Exercise\n",
    "\n",
    "In the cell below, we construct a circuit with a single qubit and a single classical bit. Your first task is to perform a Hadamard gate on the qubit and then measure it, storing the result in the classical bit. We've filled in the code for you, all you need to do is remove the `#` at the start of both lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3195c89",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "\n",
    "qr = QuantumRegister(1)\n",
    "cr = ClassicalRegister(1)\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "####### your code goes here #######\n",
    "\n",
    "# qc.h(qr[0])\n",
    "# qc.measure(qr[0], cr[0])\n",
    "\n",
    "\n",
    "qc.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1e56990",
   "metadata": {},
   "source": [
    "Nice job! After each exercise we'll need to figure out if what you wrote is correct. To do this, you simply run a grader cell.\n",
    "\n",
    "Let's try it out. In the next cell, we ask you to set an integer value for the variable `answer_0`. If the integer is between 1 and 5, the grader will give back a message congratulating you for finding the right answer. If you enter any other number, you will get the opposite message. \n",
    "\n",
    "Set the answer to whatever you'd like, then run the grader cell to see your results. You can try this a few times with different numbers for fun."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5100dd1",
   "metadata": {},
   "outputs": [],
   "source": [
    "answer_0: int\n",
    "answer_0 = 500\n",
    "\n",
    "##### Hint: Remember to run this cell after changing your value ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35f09765",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Grader Cell: Run this to submit your answer\n",
    "\n",
    "from qc_grader.challenges.spring_2023 import grade_ex1a\n",
    "\n",
    "grade_ex1a(answer_0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a95432dc",
   "metadata": {},
   "source": [
    "Now you're all set to start this challenge. Good luck and have fun!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "312c9431-a3fc-4448-9001-fb9d41ea6a44",
   "metadata": {},
   "source": [
    "# Introduction to Dynamic Circuits and Repeat until success"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7212735",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3fb8748",
   "metadata": {},
   "source": [
    "According to the [Qiskit textbook,](https://learn.qiskit.org/course/ch-algorithms/quantum-circuits) \n",
    ">_\"A quantum circuit is a computational routine consisting of coherent quantum operations on qubits ... It is an ordered sequence of quantum gates, measurements and resets, all of which may be conditioned on and use data from the real-time classical computation.\"_\n",
    "\n",
    "You might not be familiar with the last part of the definition, but it has everything to do with dynamic circuits. Usually when we talk about quantum circuits, we're referring to _static_ quantum circuits, even if we don't explicitly say it. So what are dynamic circuits?\n",
    "\n",
    "**Dynamic circuits** are quantum circuits that contain mid-circuit measurements where the results of those measurements are used to condition quantum gates later in the circuit. The ability to condition future quantum operations on the classical measurement results is known as classical feedforward.\n",
    "\n",
    "Why do we need classical feedforward? An example may help: Consider the conditional reset operation, which may sound familiar if you've ever used the [`reset`](https://qiskit.org/documentation/stubs/qiskit.circuit.QuantumCircuit.reset.html) operation in Qiskit. While the reset operation is a non-unitary operation that resets the qubit to the zero state no matter the initial state, the conditional reset operation is performed on an already measured qubit to reset it to zero by applying a bit-flip X gate only if the qubit is in the one state, as determined from its measured value. The conditional reset can be a faster and less error-prone way to reset a qubit if it has already been measured."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60ea3680",
   "metadata": {},
   "source": [
    "<center>\n",
    "<img src=\"resources/sketch-1.png\" width=\"50%\">\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "caea194a",
   "metadata": {},
   "source": [
    "Put another way, dynamic circuits are quantum circuits that include control flow such as if statements and while loops, where the predicates are computed from the results of previous qubit measurements and the conditional operations include quantum gates."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b52cef83-0393-4aba-9df0-ff54dff0bc04",
   "metadata": {},
   "source": [
    "## Hello Dynamic Circuit World"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1291e604",
   "metadata": {},
   "source": [
    "IBM Quantum hardware has already supported mid-circuit measurements and reset for some time. However, adding support for classical feedforward required a significant redesign of the control-systems and the associated software stack. Full support for dynamic circuits was introduced only last year (2022).\n",
    "\n",
    "In Qiskit, the syntax for programming dynamic circuits has gone through several iterations, and full support has not yet been implemented. Currently, the only way to access the full capabilities of dynamic circuits is to submit programs written in OpenQASM 3. Nevertheless, in this challenge we will be working with what is currently available in Qiskit.\n",
    "\n",
    "An earlier version of Qiskit introduced the [`c_if()`](https://qiskit.org/documentation/stubs/qiskit.circuit.Instruction.c_if.html) instruction, but this syntax will be deprecated in favor of the more flexible [`if_test()`](https://qiskit.org/documentation/stubs/qiskit.circuit.QuantumCircuit.if_test.html) method of QuantumCircuit, which is the method we'll be mostly using in this challenge.\n",
    "\n",
    "To get you started, we're going to review a simple example where we'll use this function. We'll build a circuit that demonstrates the conditional reset operation by taking the following steps:\n",
    "\n",
    "1. Initialize a circuit with 1 qubit and 2 classical bits. ($q_{0}$, $b_{0}$  and $b_{1}$)\n",
    "2. Apply a Hadamard gate to $q_{0}$.\n",
    "3. Measure that qubit and save the result in $b_{0}$.\n",
    "4. Begin an `if_test` block conditioned on $b_{0}$ being equal to 1.\n",
    "5. In the `if_test` block, specify the operation to do if the condition is met, in this case, flipping $q_{0}$ to 0 state.\n",
    "6. Measure $q_0$ again into $b_{1}$ to check that we always get 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10d6953d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit\n",
    "from qiskit.circuit import QuantumRegister, ClassicalRegister\n",
    "\n",
    "qr = QuantumRegister(1)\n",
    "cr = ClassicalRegister(2)\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "# unpack the qubit and classical bits from the registers\n",
    "(q0,) = qr\n",
    "b0, b1 = cr\n",
    "\n",
    "# apply Hadamard\n",
    "qc.h(q0)\n",
    "# measure\n",
    "qc.measure(q0, b0)\n",
    "\n",
    "# begin if test block. the contents of the block are executed if b0 == 1\n",
    "with qc.if_test((b0, 1)):\n",
    "    # if the condition is satisfied (b0 == 1), then flip the bit back to 0\n",
    "    qc.x(q0)\n",
    "# finally, measure q0 again\n",
    "qc.measure(q0, b1)\n",
    "\n",
    "qc.draw(output=\"mpl\", idle_wires=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa3da6a2",
   "metadata": {},
   "source": [
    "Now that our circuit is built, let's run it several times to see if we always get the expected output. The first measurement could be either 0 or 1, but the second measurement should always be 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06a4eee8",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_aer import AerSimulator\n",
    "\n",
    "# initialize the simulator\n",
    "backend_sim = AerSimulator()\n",
    "\n",
    "# run the circuit\n",
    "reset_sim_job = backend_sim.run(qc)\n",
    "# get the results\n",
    "reset_sim_result = reset_sim_job.result()\n",
    "# retrieve the bitstring counts\n",
    "reset_sim_counts = reset_sim_result.get_counts()\n",
    "\n",
    "print(f\"Counts: {reset_sim_counts}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "388ce901",
   "metadata": {},
   "source": [
    "As expected, the first bit is sometimes 0 and sometimes 1, but the second bit is always 0 (recall that Qiskit uses little-endian bit-ordering, so that the right-most bit is the first bit and the left-most bit is the last bit)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "439359c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.visualization import *\n",
    "\n",
    "# plot histogram\n",
    "plot_histogram(reset_sim_counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de501c69",
   "metadata": {},
   "source": [
    "Now you're ready to build your first dynamic circuit!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f62264b8",
   "metadata": {},
   "source": [
    "### **Exercise 1**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da73cc7b",
   "metadata": {},
   "source": [
    "Let's level things up. Your first assignment will be to design a two qubit circuit. In this case, the aim will be to act differently on $q_{1}$ depending on the value of $q_{0}$. If the measurement on $q_{0}$ reads 0, apply an $X$ gate on $q_{1}$. If it reads 1, apply a Hadamard on $q_{1}$ instead.\n",
    "\n",
    "To make the value of $q_{0}$ random, the first thing we'll do is apply a Hadamard on that qubit. Next, we'll measure $q_{0}$ into $b_{0}$. After that, the dynamic magic should happen, and finally, $q_{1}$ gets measured."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd70af27",
   "metadata": {},
   "source": [
    "For this exercise we encourage you to read the [`if_test()`](https://qiskit.org/documentation/stubs/qiskit.circuit.QuantumCircuit.if_test.html) documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97acd850",
   "metadata": {},
   "outputs": [],
   "source": [
    "qr = QuantumRegister(2)\n",
    "cr = ClassicalRegister(2)\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "\n",
    "q0, q1 = qr\n",
    "b0, b1 = cr\n",
    "\n",
    "qc.h(q0)\n",
    "qc.measure(q0, b0)\n",
    "\n",
    "####### your code goes here #######\n",
    "\n",
    "\n",
    "qc.measure(q1, b1)\n",
    "qc.draw(output=\"mpl\", idle_wires=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fff212ad",
   "metadata": {},
   "source": [
    "Optionally, you can run next cell to check if your circuit behaves as expected. \n",
    ">Tip: Think of the possible outcomes of the circuit before running it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e25f4018",
   "metadata": {},
   "outputs": [],
   "source": [
    "backend_sim = AerSimulator()\n",
    "\n",
    "job_1 = backend_sim.run(qc)\n",
    "result_1 = job_1.result()\n",
    "counts_1 = result_1.get_counts()\n",
    "\n",
    "print(f\"Counts: {counts_1}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52ffa93c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Submit your circuit\n",
    "\n",
    "from qc_grader.challenges.spring_2023 import grade_ex1b\n",
    "\n",
    "grade_ex1b(qc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "accf02df-d743-4550-a165-eb7fa5563b92",
   "metadata": {},
   "source": [
    "## Repeat until success"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b636a19",
   "metadata": {},
   "source": [
    "Sometimes the outcome of a process is random and the result you get isn't what you wanted. What can you do in this case? Well, you can try again! As long as there is some nonzero probability of your desired outcome, repeating the process is guaranteed to return the result you wanted, eventually. Often, only a few repetitions will be needed.\n",
    "\n",
    "In this section, we will use the repeat-until-success idea to build an $R_X(\\theta)$ gate from the finite gate set $\\{H,\\,X,\\,S,\\,\\text{Toffoli}\\}$, where $\\theta / \\pi$ is an irrational number. Specifically, we will have $\\cos\\theta = \\frac35$. This construction is adapted from Nielsen and Chuang, _Quantum Computation and Quantum Information_, 10<sup>th</sup> anniversary edition, Exercise 4.41, and it demonstrates the universality of the finite gate set given above.\n",
    "\n",
    "The way the construction works is that we will build a circuit that acts on 3 qubits. One of the qubits is the target qubit and our goal is to perform the $R_X(\\theta)$ on this target qubit. The other two qubits are \"syndrome\" qubits that we will measure and the measurement results will tell us whether our operation was successful or not. If both syndrome qubits read 0, then we will know the gate was performed successfully. Otherwise, we will reset the qubits and try again. We will need dynamic circuits in order to condition the repetitions of the circuit on the measurement results."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "319aa2d5",
   "metadata": {},
   "source": [
    "### Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e744fd1b",
   "metadata": {},
   "source": [
    "Your first task of this section will be to create a function that returns that circuit. Here there's an image of how the circuit should look like:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1eaf0de0",
   "metadata": {},
   "source": [
    "<center>\n",
    "<img src=\"resources/circuitRx.png\">\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0057b5c",
   "metadata": {},
   "source": [
    "To make things easier for you, we'll set up the \"base\" circuit for you with the required elements. The functions we'll write in this lab will take a circuit as input and modify it in place. Whenever we need a fresh circuit, we'll just make a copy of the base circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5587d76",
   "metadata": {},
   "outputs": [],
   "source": [
    "controls = QuantumRegister(2, name=\"control\")\n",
    "target = QuantumRegister(1, name=\"target\")\n",
    "\n",
    "mid_measure = ClassicalRegister(2, name=\"mid\")\n",
    "final_measure = ClassicalRegister(1, name=\"final\")\n",
    "\n",
    "base = QuantumCircuit(controls, target, mid_measure, final_measure)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "976de85c",
   "metadata": {},
   "source": [
    "In the next cell, fill in the `trial` function so that it constructs the circuit by taking the following steps:\n",
    "\n",
    "1. Apply a Hadamard gate to each qubit of the control register as well as the target qubit.\n",
    "2. Apply the Toffoli (controlled-controlled-not) gate between the control register and the target qubit. This can be achieved using either the `ccx` method of QuantumCircuit, or by importing and using `CCXGate` from `qiskit.circuit.library`.\n",
    "3. Apply an $S$ gate to the target qubit.\n",
    "4. Apply another Toffoli gate, with the same controls and target as Step 2.\n",
    "5. Again, apply Hadamard to the control and target registers.\n",
    "6. Measure the control register into the classical register."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc47a87d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def trial(\n",
    "    circuit: QuantumCircuit,\n",
    "    target: QuantumRegister,\n",
    "    controls: QuantumRegister,\n",
    "    measures: ClassicalRegister,\n",
    "):\n",
    "    \"\"\"Probabilistically perform Rx(theta) on the target, where cos(theta) = 3/5.\"\"\"\n",
    "\n",
    "    ####### your code goes here #######\n",
    "\n",
    "\n",
    "qc = base.copy_empty_like()\n",
    "trial(qc, target, controls, mid_measure)\n",
    "qc.draw(\"mpl\", cregbundle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "029c1c44",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Submit your circuit\n",
    "from qc_grader.challenges.spring_2023 import grade_ex1c\n",
    "\n",
    "grade_ex1c(qc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72855e8b",
   "metadata": {},
   "source": [
    "### Exercise 3"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e421924e",
   "metadata": {},
   "source": [
    "Your next task will be to check the measurements. If both measurements of the control bits return $|0\\rangle$, the applied gate is $R_X(\\theta)$ where $\\cos(\\theta) = \\frac{3}{5}$. If any of the measurements is $|1\\rangle$, then the applied gate is simply $X$, which indicates a failure. Therefore, we can tell from the measurements whether we applied the correct gate, without disturbing the coherence of the target qubit. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c1a4ee1",
   "metadata": {},
   "source": [
    "If there is a failure, we should reset the qubit and start again.  Since we know what is applied in the case of a failure, we can use this knowledge to perform the reset efficiently, without using a general hardware reset. For the two auxiliary qubits, this is just an $X$ gate conditioned on its respective measurement being $1$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a40077b6",
   "metadata": {},
   "source": [
    "In the next cell, fill in the `reset_controls` function so that it modifies the circuit by taking the following steps:\n",
    "\n",
    "1. If the first bit of the `measures` register is equal to 1, apply an $X$ gate to the first control qubit.\n",
    "2. If the second bit of the `measures` register is equal to 1, apply an $X$ gate to the second control qubit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73ba4506",
   "metadata": {},
   "outputs": [],
   "source": [
    "def reset_controls(\n",
    "    circuit: QuantumCircuit, controls: QuantumRegister, measures: ClassicalRegister\n",
    "):\n",
    "    \"\"\"Reset the control qubits if they are in |1>.\"\"\"\n",
    "\n",
    "    ####### your code goes here #######\n",
    "\n",
    "\n",
    "qc = base.copy_empty_like()\n",
    "trial(qc, target, controls, mid_measure)\n",
    "reset_controls(qc, controls, mid_measure)\n",
    "qc.measure(controls, mid_measure)\n",
    "qc.draw(\"mpl\", cregbundle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6443405",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Submit your circuit\n",
    "from qc_grader.challenges.spring_2023 import grade_ex1d\n",
    "\n",
    "grade_ex1d(qc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c2c844e",
   "metadata": {},
   "source": [
    "Now all that is left to do is repeat the execution of the circuit if the conditions weren't satisfied.\n",
    "In the final exercise, we will need to work around two issues in our current support for dynamic circuits.\n",
    "\n",
    "The first issue is that Qiskit currently does not support performing any arithmetic or logical operations on classical bits. In particular, it does not support checking that a classical register does *not* have a certain value. In our situation, we need to repeat the trial only if the mid-circuit measurement was *not* the bitstring `00`. To work around this issue, we will create an if statement conditioned on the measurement being equal to `00`, **pass** an empty block, and then use the **else** branch to perform the logic we want for the case that the measurement is *not* `00`.\n",
    "\n",
    "The second issue is that our hardware currently does not support loops. Therefore, we cannot execute a true repeat-until-success loop. We will work around this issue by simply repeating our trial circuit a fixed number of times."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a3c5b4e",
   "metadata": {},
   "source": [
    "### Exercise 4\n",
    "\n",
    "In the code cell below, fill in the `else` block with the logic that should be performed in case the syndrome measurement indicates we need to repeat the trial:\n",
    "\n",
    "1. Reset the target qubit to the zero state. Remember, we already know that it is in the 1 state.\n",
    "2. Call the `trial` function on the circuit again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4be1b959",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the maximum number of trials\n",
    "max_trials = 2\n",
    "\n",
    "# Create a clean circuit with the same structure (bits, registers, etc)\n",
    "# as the initial base we set up.\n",
    "circuit = base.copy_empty_like()\n",
    "\n",
    "# The first trial does not need to reset its inputs, since the controls\n",
    "# are guaranteed to start in the |0> state.\n",
    "trial(circuit, target, controls, mid_measure)\n",
    "\n",
    "# Manually add the rest of the trials.  In the future, we will be\n",
    "# able to use a dynamic `while` loop to do this, but for now, we\n",
    "# statically add each loop iteration with a manual condition check\n",
    "# on each one.  This involves more classical synchronizations than\n",
    "# the while loop, but will suffice for now.\n",
    "for _ in range(max_trials - 1):\n",
    "    reset_controls(circuit, controls, mid_measure)\n",
    "    with circuit.if_test((mid_measure, 0b00)) as else_:\n",
    "        # This is the success path, but Qiskit can't directly\n",
    "        # represent a negative condition yet, so we have an\n",
    "        # empty `true` block in order to use the `else` branch.\n",
    "        pass\n",
    "    with else_:\n",
    "        ####### your code goes here #######\n",
    "\n",
    "\n",
    "# We need to measure the control qubits again to ensure we\n",
    "# get their final results; this is a hardware limitation.\n",
    "circuit.measure(controls, mid_measure)\n",
    "\n",
    "# Finally, let's measure our target, to check that we're\n",
    "# getting the rotation we desired.\n",
    "circuit.measure(target, final_measure)\n",
    "\n",
    "circuit.draw(\"mpl\", cregbundle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "973b441d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Submit your circuit\n",
    "from qc_grader.challenges.spring_2023 import grade_ex1e\n",
    "\n",
    "grade_ex1e(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f84bb06",
   "metadata": {},
   "source": [
    "Let's run the circuit on a simulator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f576413c",
   "metadata": {},
   "outputs": [],
   "source": [
    "sim = AerSimulator()\n",
    "job = sim.run(circuit, shots=1000)\n",
    "result = job.result()\n",
    "counts = result.get_counts()\n",
    "\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1971f98e",
   "metadata": {},
   "source": [
    "A successful result is one in which the measurements on the two controls end in the `00` state. If you're having trouble, we encourage you to post about your results on the Discord Channel, and try to understand in collaboration with other participants what your results mean and why you are getting them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17cb07ef",
   "metadata": {},
   "source": [
    "## Run on hardware\n",
    "\n",
    "Let's try running the circuit we made on real hardware! For this, we'll be using the 27-qubit Peekskill device, which has been tuned specifically for dynamic circuits. But please remember, running on real hardware takes time, and sometimes has errors. Please **do not** run these cells over and over, since that will cause a backup for all the other Challenge participants."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f917e10b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_ibm_provider import IBMProvider\n",
    "\n",
    "provider = IBMProvider()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "691dd8d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "hub = \"YOUR_HUB\"\n",
    "group = \"YOUR_GROUP\"\n",
    "project = \"YOUR_PROJECT\"\n",
    "\n",
    "backend_name = \"ibm_peekskill\"\n",
    "backend = provider.get_backend(backend_name, instance=f\"{hub}/{group}/{project}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57735462",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import transpile\n",
    "\n",
    "qc_transpiled = transpile(circuit, backend)\n",
    "job = backend.run(qc_transpiled, shots=1000, dynamic=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ee1c832",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "counts = job.result().get_counts()\n",
    "\n",
    "plot_histogram(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6acb6b58",
   "metadata": {},
   "source": [
    "## Congratulations!\n",
    "\n",
    "You've made it to the end of the first lab! Now that you know more about dynamic circuits, it is time to move onto the next lab and start learning about some applications and more advanced properties. Good luck!"
   ]
  }
 ],
 "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.9.15"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}