Qiskit_102_ntb.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Qiskit 102: Learning to use Qiskit\n",
    "\n",
    "The fundamental unit you will primarily work with in Qiskit is the `QuantumCircuit` object. The basic workflow to using Qiskit consists of two stages: build and execute. Building involves making different quantum circuits which represent the problem/algorithm you are solving. Executing takes care of the, well, *execution* of those circuits as a job or set of jobs to be run on either real or simulated hardware. After the jobs have been run, the data is collected and must be postprocessed depending on the desired output.  We can do most of this post-processing using Qiskit Runtime.\n",
    "\n",
    "\n",
    "## Qiskit Runtime Overview\n",
    "<img src=\"./resources/qiskit-runtime.png\" alt=\"Qiskit Runtime Overview\" style=\"width: 1000px;\"/>\n",
    "\n",
    "\n",
    "Qiskit Runtime is a cloud-based quantum computing service developed by IBM. It offers computational primitives to perform foundational quantum computing tasks that use built-in error suppression and mitigation techniques. Primitives can be executed inside of sessions, allowing collections of circuits to be jointly run on a quantum computer without being interrupted by other users’ jobs. The combination of primitives, error suppression / mitigation, and sessions paves the way to efficiently build and execute scalable quantum applications.\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "## Getting Started\n",
    "\n",
    "The Qiskit packages you will need to get started are:\n",
    "\n",
    "- `qiskit`\n",
    "- `qiskit-ibm-runtime`\n",
    "- `numpy` (optional)\n",
    "- `matplotlib` (optional)\n",
    "\n",
    "We'll first walk through the anatomy of a `QuantumCircuit` object and the process of using primitives."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
    "from qiskit.compiler import transpile\n",
    "from qiskit_ibm_runtime import QiskitRuntimeService\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "################# MAKE SURE YOUR API TOKEN IS SAVED ##########################\n",
    "\n",
    "#Store your API token locally (only need to do once)\n",
    "#QiskitRuntimeService.save_account(channel='ibm_quantum', token='$API_TOKEN')\n",
    "\n",
    "##############################################################################\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Software</th><th>Version</th></tr><tr><td><code>qiskit</code></td><td>0.45.0</td></tr><tr><td><code>qiskit_ibm_provider</code></td><td>0.7.2</td></tr><tr><td><code>qiskit_ibm_runtime</code></td><td>0.15.1</td></tr><tr><td><code>qiskit_aer</code></td><td>0.12.0</td></tr><tr><th colspan='2'>System information</th></tr><tr><td>Python version</td><td>3.9.13</td></tr><tr><td>Python compiler</td><td>Clang 12.0.0 </td></tr><tr><td>Python build</td><td>main, Oct 13 2022 16:12:19</td></tr><tr><td>OS</td><td>Darwin</td></tr><tr><td>CPUs</td><td>8</td></tr><tr><td>Memory (Gb)</td><td>16.0</td></tr><tr><td colspan='2'>Thu Nov 30 14:28:53 2023 EST</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#make sure your qiskit version is up to date\n",
    "import qiskit.tools.jupyter\n",
    "%qiskit_version_table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 0.1 Building the circuit \n",
    "\n",
    "The basic element needed for your first program is the QuantumCircuit. We begin by creating a QuantumCircuit comprised of two qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     \n",
      "q_0: \n",
      "     \n",
      "q_1: \n",
      "     \n"
     ]
    }
   ],
   "source": [
    "# Create a Quantum Circuit acting on a quantum register of two qubits\n",
    "circ = QuantumCircuit(2)\n",
    "print(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 0.2 Adding Gates\n",
    "\n",
    "We can then add gates to the circuit. We start with a Hadamard gate acting on qubit $0$ and then add a $C_X$ (CNOT) gate using $0$ as the control qubit and $1$ as the target. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<qiskit.circuit.instructionset.InstructionSet at 0x10696efd0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add a H gate on qubit 0, putting this qubit in superposition.\n",
    "circ.h(0)\n",
    "# Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting\n",
    "# the qubits in a Bell state.\n",
    "circ.cx(0, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 0.3 Circuit Visualization\n",
    "\n",
    "You can visualize your circuit using the `QuantumCircuit.draw()` method, which plots the circuit in the form found in many textbooks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 206.852x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circ.draw('mpl', style=\"iqp\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">     ┌───┐     \n",
       "q_0: ┤ H ├──■──\n",
       "     └───┘┌─┴─┐\n",
       "q_1: ─────┤ X ├\n",
       "          └───┘</pre>"
      ],
      "text/plain": [
       "     ┌───┐     \n",
       "q_0: ┤ H ├──■──\n",
       "     └───┘┌─┴─┐\n",
       "q_1: ─────┤ X ├\n",
       "          └───┘"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#One can also draw this as an ascii drawing\n",
    "circ.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\n",
    "A few of the basic gates which can be added to a quantum circuit are the:\n",
    "\n",
    "* Pauli $X$, $Y$, $Z$ gates - `.x()` `.y()`\n",
    "* Hadamard $H$ gate \n",
    "* $S$ (or $\\pi/2$) phase gate\n",
    "* $T$ (or $\\pi/4$) phase gate\n",
    "* Controlled-NOT (or Controlled-$X$) gate - `.cx`\n",
    "* Controlled-$H$ gate - `.ch`\n",
    "* CCX or Toffoli gate - `.ccx`\n",
    "\n",
    "among many others.  See the documentation for the full list of supported gates."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 1.0 Using Primitives\n",
    "\n",
    "There are two main approaches within Qiskit to execute and measure your quantum circuits called `Primitives`.  The first is the `Estimator` which computes the expectation values of observables.  Users generally specify a list of circuits, observables, and a few other optional configurations, with which the program can efficiently evaluate expectation values and variances.  The second is the `Sampler` primitive which with calculate the probabilities (or quasi-probabilities if using error mitigation) of bitstrings from quantum circuits.\n",
    "\n",
    "Primitives work most effectively when they are supported by both Qiskit and the backend provider. The Qiskit module qiskit.primitives provides the required support on the Qiskit side, and providers like IBM Qiskit Runtime enable access to appropriate backends through native implementations of their own primitives.\n",
    "\n",
    "We'll learn to use these objects by utilizing a small example circuit which will fully entangle two qubits together and then measure them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 219.833x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Create the circuit\n",
    "qr = QuantumRegister(2)\n",
    "cr = ClassicalRegister(2)\n",
    "\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "# we can also write \"qc = QuantumCircuit(2,2)\"\n",
    "\n",
    "#Add the hadamard and CNOT gates to the circuit\n",
    "qc.h(0)\n",
    "qc.cx(0, 1)\n",
    "\n",
    "qc.draw('mpl', style=\"iqp\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 The Estimator Primitive"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Let's begin with understanding how to use the `Estimator` primitive.  To start, we'll need to define the observable(s) we want to measure the expectation values of.  They can be constructed from any `BaseOperator` object, like the operators from `qiskit.quantum_info`.  For this example we'll use the `qiskit.quantum_info.SparesPauliOp` object.  We'll construct four observables to measure our entangling circuit, $\\langle II +XX -YY + ZZ\\rangle$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Import the SparesPauliOp class and create our observables variable\n",
    "from qiskit.quantum_info import SparsePauliOp\n",
    " \n",
    "observable = SparsePauliOp([\"II\", \"XX\", \"YY\", \"ZZ\"], coeffs=[1, 1, -1, 1])\n",
    "\n",
    "# Import qiskit primitives\n",
    "from qiskit.primitives import Estimator\n",
    "\n",
    "estimator = Estimator()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once the observable and `Estimator` object are defined, we can go ahead and run our estimation by calling the `qiskit.primitives.Estimator.run()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EstimatorResult(values=array([4.]), metadata=[{}])\n",
      "Expectation Value of <II+XX-YY+ZZ> = 4.000\n"
     ]
    }
   ],
   "source": [
    "\n",
    "job = estimator.run(qc, observable)\n",
    "result = job.result()\n",
    "print(result)\n",
    "print(f\"Expectation Value of <II+XX-YY+ZZ> = {result.values[0]:.3f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1.1 Using the Runtime Estimator\n",
    "\n",
    "A subtle difference here is that there are actually *two* `Estimator` objects in our environment.  One within `qiskit.primitives` and one within our ecosystem package `qiskit-ibm-runtime`.  The Runtime Primitives are best used for submitting jobs to a backend while the Qiskit Primitives are useful for doing sanity checks on your workflows and ensuring everything is working as intended.\n",
    "\n",
    "We'll now execute this circuit using the Runtime Service.  To do so, we'll need to initialize a `QiskitRuntimeService` object and select a backend to run the circuit on.  For this example we'll use the 127-qubit `ibm_nazca` backend.  We'll then instantiate a new `Estimator` object from the Runtime package. We have two options here: we can instantiate the `Estimator` object with the `backend`, *or* we can start a `Session` that we can send multiple jobs to without waiting in the queue for subsequent jobs, and pass the `Session` object to the `Estimator`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit_ibm_runtime import Estimator, Session\n",
    "\n",
    "#Initialize a QiskitRuntimeService object\n",
    "service = QiskitRuntimeService()\n",
    "\n",
    "#We will use the 127-qubit ibm_nazca backend\n",
    "backend = service.get_backend('ibm_nazca')\n",
    "\n",
    "# create a Runtime session for efficient execution (optional)\n",
    "session = Session(service=service, backend=backend)\n",
    "\n",
    "# estimator = Estimator(backend=backend) \n",
    "estimator = Estimator(session=session)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The access your institution has obtained will determine which backends are available to you.  You can list all of your available backends and obtain information about its status, the number of pending jobs, and detailed configuration information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Operational?: True \n",
      " Jobs in Queue: 17\n",
      "\n",
      "################################################################ \n",
      "Configuration for: ibm_nazca, version: 1.0.15\n",
      "  Number of Qubits: 127\n",
      "  Basis Gates: ['ecr', 'id', 'rz', 'sx', 'x']\n",
      "  OpenPulse Enabled: True\n"
     ]
    }
   ],
   "source": [
    "#Here we can get some status information about the backend\n",
    "status = backend.status()\n",
    "is_operational = status.operational\n",
    "jobs_in_queue = status.pending_jobs\n",
    "print('Operational?: {} \\n Jobs in Queue: {}\\n'.format(is_operational, jobs_in_queue))\n",
    "\n",
    "\n",
    "# We can also obtain some configuration information\n",
    "config = backend.configuration()\n",
    "print(64*\"#\",\"\\nConfiguration for: {}, version: {}\".format(config.backend_name, config.backend_version))\n",
    "print(\"  Number of Qubits: {}\".format(config.n_qubits))\n",
    "print(\"  Basis Gates: {}\".format(config.basis_gates))\n",
    "print(\"  OpenPulse Enabled: {}\".format(config.open_pulse))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "---\n",
    "\n",
    "Now we'll run our job on the hardware.  We can get also get some information about its status while we wait"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>> Job ID: cnme59db4zk00082a4h0\n",
      ">>> Session ID: cnme59db4zk00082a4h0\n",
      ">>> Job Status: JobStatus.QUEUED\n"
     ]
    }
   ],
   "source": [
    "job = estimator.run(qc, observable)\n",
    "print(f\">>> Job ID: {job.job_id()}\")\n",
    "print(f\">>> Session ID: {job.session_id}\")\n",
    "print(f\">>> Job Status: {job.status()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also check on the status on the online platform: [https://quantum-computing.ibm.com/jobs](https://quantum-computing.ibm.com/jobs)\n",
    "\n",
    "Another useful feature is to be able to pull data from previous jobs you've run if you're running analysis on your results in a separate notebook or python script.  All that's needed is the Job ID"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use a job id from a previous result\n",
    "job = service.job(\"cncfk64xswgg0087jbj0\")\n",
    "print(f\">>> Job Status: {job.status()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Examine our results once the job has completed\n",
    "result = job.result()\n",
    "print(f\">>> {result}\")\n",
    "print(f\"  > Expectation value: {result.values[0]}\")\n",
    "print(f\"  > Metadata: {result.metadata[0]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 The Sampler Primitive\n",
    "\n",
    "Next we'll demonstrate using the `Sampler` primitive (both the `qiskit.primitives` version as well as the managed `qiskit-ibm-runtime` version).  Recall the `Sampler` is primarily useful for when you want to measure (quasi-)probability distributions.  We'll use the same quantum circuit, `qc` which prepares a Bell state (i.e., fully entangle two-qubits together).\n",
    "\n",
    "First we'll initialize the sampler from `qiskit.primitives` to demonstrate what the output looks like and then add measurement instructions to our circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 417.879x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.primitives import Sampler\n",
    "\n",
    "#Instantiate a new Sampler object\n",
    "sampler = Sampler()\n",
    "\n",
    "\n",
    "#We'll also need to add measurement\n",
    "circ = QuantumCircuit(2)\n",
    "\n",
    "circ.h(0)\n",
    "circ.cx(0, 1)\n",
    "# Insert measurements on all qubits\n",
    "circ.measure_all()\n",
    "circ.draw('mpl', style='iqp')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Result:\n",
      ">>> SamplerResult(quasi_dists=[{0: 0.5, 3: 0.5}], metadata=[{}])\n",
      "  > Quasi-probability distribution (integer): {0: 0.5, 3: 0.5}\n",
      "  > Quasi-probability distribution (bits): {'00': 0.4999999999999999, '11': 0.4999999999999999}\n",
      "  > Metadata: {}\n"
     ]
    }
   ],
   "source": [
    "# Now run the job and examine the results\n",
    "sampler_job = sampler.run(circ)\n",
    "result = sampler_job.result()\n",
    "print(f\"Job Result:\\n>>> {result}\")\n",
    "print(f\"  > Quasi-probability distribution (integer): {result.quasi_dists[0]}\")\n",
    "print(f\"  > Quasi-probability distribution (bits): {result.quasi_dists[0].binary_probabilities(2)}\")\n",
    "print(f\"  > Metadata: {result.metadata[0]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "---\n",
    "\n",
    "\n",
    "Next we'll use the Runtime Sampler to run our circuit on a backend.  Recall that we still need to specify an `IBMBackend` object through the `QisktiRuntimeService`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_ibm_runtime import Sampler\n",
    " \n",
    "#Initialize a QiskitRuntimeService object\n",
    "service = QiskitRuntimeService()\n",
    "\n",
    "#We will use the 127-qubit ibm_nazca backend\n",
    "backend = service.get_backend('ibm_nazca')\n",
    "\n",
    "# sampler = Sampler(backend=backend)\n",
    "sampler = Sampler(session=session)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>> Job ID: cnme5geb4zk00082a4hg\n",
      ">>> Session ID: cnme59db4zk00082a4h0\n",
      ">>> Job Status: JobStatus.QUEUED\n"
     ]
    }
   ],
   "source": [
    "job = sampler.run(circ)\n",
    "print(f\">>> Job ID: {job.job_id()}\")\n",
    "print(f\">>> Session ID: {job.session_id}\")\n",
    "print(f\">>> Job Status: {job.status()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also obtain a previous result in the same way as the `Estimator`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>> Job Status: JobStatus.DONE\n"
     ]
    }
   ],
   "source": [
    "# Use a job id from a previous result\n",
    "job = service.job(\"cncfm89hga30008f2660\")\n",
    "print(f\">>> Job Status: {job.status()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Result:\n",
      ">>> SamplerResult(quasi_dists=[{0: 0.500216756192343, 1: 0.018130479836529, 2: -0.009745479238165, 3: 0.491398243209293}], metadata=[{'shots': 4000, 'circuit_metadata': {}, 'readout_mitigation_overhead': 1.3906290541317785, 'readout_mitigation_time': 0.036765546072274446}])\n",
      "  > Quasi-probability distribution (integer): {0: 0.500216756192343, 1: 0.018130479836529, 2: -0.009745479238165, 3: 0.491398243209293}\n",
      "  > Quasi-probability distribution (bits): {'00': 0.5002167561923428, '01': 0.018130479836528622, '10': -0.009745479238164975, '11': 0.49139824320929343}\n",
      "  > Metadata: {'shots': 4000, 'circuit_metadata': {}, 'readout_mitigation_overhead': 1.3906290541317785, 'readout_mitigation_time': 0.036765546072274446}\n"
     ]
    }
   ],
   "source": [
    "result = job.result()\n",
    "print(f\"Job Result:\\n>>> {result}\")\n",
    "print(f\"  > Quasi-probability distribution (integer): {result.quasi_dists[0]}\")\n",
    "print(f\"  > Quasi-probability distribution (bits): {result.quasi_dists[0].binary_probabilities(2)}\")\n",
    "print(f\"  > Metadata: {result.metadata[0]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're also able to visualize the probability distribution of this circuit on a histogram.  Plotting this gives us a quick visual tool to help us understand what the states with the highest measurement probability are. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.visualization import plot_distribution\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('dark_background')\n",
    "\n",
    "#plot_distribution(result.quasi_dists[0])\n",
    "plot_distribution(result.quasi_dists[0].binary_probabilities(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Transpilation & Error Mitigation\n",
    "\n",
    "Oftentimes, the quantum circuits constructed for utility scale algorithms are not well optimized to run on noisy quantum hardware.  In fact, it may even be important to post-process your results using error mitigation techniques.  Fortunately, there are a few ways to implement both error mitigation as well as optimizations of your quantum circuits.\n",
    "\n",
    "The first is to simply set a few Runtime configuration options; specifically the `optimization_level` and `resilience_level`.  These are both managed and included in a Runtime Primitive using the `Options` object.\n",
    "\n",
    "The options for `optimization_level` are:\n",
    "\n",
    "| Optimization Level | Estimator & Sampler |\n",
    "| :--- | :--- |\n",
    "| 0 | No optimization: typically used for hardware characterization or debugging <br />    - Basis translation <br /> - Layout (`TrivialLayout`: virtual -> physical)  <br /> - Routing: `StochasticSwap` |\n",
    "| 1, 2, 3 | Light optimization: (TODO: update this w/ current docs) <br /> - Layout (trivial → vf2 → SabreLayout if routing is required) <br /> - Routing (SabreSwap if needed) <br /> - 1Q gate optimization <br /> - Error suppression: dynamical decoupling |\n",
    "\n",
    "\n",
    "And the options for `resilience_level` are different between the `Sampler` and `Estimator` primitives\n",
    "\n",
    "| Resilience Level | Definition | Estimator | Sampler |\n",
    "| :--- | :--- | :--- | :---\n",
    "|0 | No mitigation\t| None | None |\n",
    "|1 [Default] |\tMinimal mitigation costs: Mitigate error associated with readout errors | Twirled Readout Error eXtinction (TREX interpreted-text readout errors )\t| M3 |\n",
    "| 2 | Medium mitigation costs. Typically reduces bias in estimators, but is not guaranteed to be zero bias. | Zero Noise Extrapolation (ZNE interpreted-text) |\t- |\n",
    "| 3| Heavy mitigation with layer sampling. Theoretically expected to deliver zero bias estimators. | Probabilistic Error cancelation (PEC interpreted-text)\t| - |\n",
    "\n",
    "\n",
    "Let's look at a quick example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_ibm_runtime import Options\n",
    "\n",
    "\n",
    "# To set our resilience and optimization level we need to create this `Options` object\n",
    "options = Options()\n",
    "options.resilience_level = 2\n",
    "options.optimization_level = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We'll prepare the same example circuit as before\n",
    "qr = QuantumRegister(2)\n",
    "cr = ClassicalRegister(2)\n",
    "\n",
    "qc = QuantumCircuit(qr, cr)\n",
    "# we can also write \"qc = QuantumCircuit(2,2)\"\n",
    "\n",
    "#Add the hadamard and CNOT gates to the circuit\n",
    "qc.h(0)\n",
    "qc.cx(0, 1)\n",
    "\n",
    "\n",
    "# We'll also instantiate a new Runtime Estimator() object\n",
    "# estimator = Estimator(options=options, backend=backend)\n",
    "estimator = Estimator(options=options, session=session)\n",
    "\n",
    "# and use the same observable as before\n",
    "observable = SparsePauliOp([\"II\", \"XX\", \"YY\", \"ZZ\"], coeffs=[1, 1, -1, 1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>> Job ID: cncfmyvnekzg008nr2rg\n",
      ">>> Session ID: cncfk64xswgg0087jbj0\n",
      ">>> Job Status: JobStatus.QUEUED\n"
     ]
    }
   ],
   "source": [
    "job = estimator.run(circuits=qc, observables=observable)\n",
    "print(f\">>> Job ID: {job.job_id()}\")\n",
    "print(f\">>> Session ID: {job.session_id}\")\n",
    "print(f\">>> Job Status: {job.status()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use a job id from a previous result\n",
    "job = service.job(\"cn9ee48q2k7g0088qvzg\")\n",
    "print(f\">>> Job Status: {job.status()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Examine our results once the job has completed\n",
    "result = job.result()\n",
    "print(f\">>> {result}\")\n",
    "print(f\"  > Expectation value: {result.values[0]}\")\n",
    "print(f\"  > Metadata: {result.metadata[0]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transpilation Stages\n",
    "\n",
    "TODO: update this with content from newer docs.\n",
    "The next approach to optimizing our quantum circuits is to use Qiskit's `transpiler` features.  This includes both a preset approach to optimization as well as functionality to use a custom pipeline.  The quick and easy way we'll go over is to use the `qiskit.compiler.transpile()` method.  This function will take quite a few parameters as input, but the only *required* argument(s) are the circuit(s) to be optimized.  Once the `transpile()` function is called, several stages of optimization are prepared:\n",
    "\n",
    "1. `init` - This pass runs any initial passes that are required before we start embedding the circuit to the backend.  This typically involves unrolling custom instructions and converting the circuit to all single- and two-qubit gates. (By default this will just validate the circuit instructions and translate multi-qubit gates into 1 and 2 qubit gates)\n",
    "1. `layout` - This pass applies a *layout*, mapping/assigning the virtual qubits in your circuit to the physical qubits of a backend.\n",
    "1. `routing` - This pass runs after a layout has been applied and will inject gates (i.e., SWAPs) in the original circuit in order to make it compatible with the backend's connectivity/coupling map.\n",
    "1. `translation` - This pass translates the gates in the circuit to the backend's basis set of instructions.\n",
    "1. `optimization` - This pass runs an optimization loop to find more efficient decompositions of your quantum circuit until a condition is met (such as a fixed depth).\n",
    "1. `scheduling` - This pass is for any hardware-aware optimizations that improve the efficiency of the executed microwave pulse instructions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Init stage\n",
    "\n",
    "This first stage does very little by default and is primarily useful if you want to include your own initial optimizations.  Because most layout and routing algorithms are only designed to work with single- and two-qubit gates, this stage is also used to translate any gates that operate on more than two qubits into gates that only operate on one or two qubits.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Layout stage\n",
    "In the next stage, we start considering the layout or connectivity of the backend a circuit will be sent to.  In general, quantum circuits are abstract entities whose qubits are \"virtual\" or \"logical\" representations of actual qubits used in computations.  To execute a sequence of gates, a one-to-one mapping from the \"virtual\" qubits to the \"physical\" qubits in an actual quantum device is necesary.  This mapping is stored as a `Layout` object.\n",
    "\n",
    "\n",
    "![Qubit mapping](./resources/layout-mapping.png)\n",
    "\n",
    "The choice of mapping is extremely important for minimizing the number of SWAP operations needed to map the input circuit onto the device topology and ensure the most well-calibrated qubits are used.  Due to the improtance of this stage, the preset pass managers try a few different methods to find the best layout.  Typically this involves two steps: first, try to find a \"perfect\" layout (a layout that does not require any SWAP operations), and then, a heuristic pass that tries to find the best layout to use if a perfect layout cannot be found.  There are two `Passes` typically used for this first step:\n",
    "\n",
    "- `TrivialLayout`: Naively maps each virtual qubit to the same numbered physical qubit on the device (i.e. [`0`,`1`,`1`,`3`] -> [`0`,`1`,`1`,`3`]).  This is historical behavior only used in `optimzation_level=1` to try to find a perfect layout.  If it fails, `VF2Layout` is tried next.\n",
    "- `VF2Layout`: This is an `AnalysisPass` that selects an ideal layout by treating this stage as a subgraph isomorphism problem, solved by the VF2++ algorithm.  If more than one layout is found, a scoring heuristic is run to select the mapping with the lowest average error.\n",
    "\n",
    "Then for the heuristic stage, two passes are used by default:\n",
    "\n",
    "- `DenseLayout`: Findsthe sub-graph of the device with the greatest connectivity and that has the same number of qubits as the circuit.  (Used for optimization level 1 if there are control flow operations (such as IfElseOp) present in the circuit).\n",
    "- `SabreLayout`: This pass selects a layout by starting from an initial random layout and repeatedly running the `SabreSwap` algorithm.  This pass is only used in optimization levels 1, 2, and 3 if a perfect layout isn't found via the `VF2Layout` pass.  For more details on this algorithm, refer to the paper: [arXiv:1809.02573](https://arxiv.org/abs/1809.02573)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Routing stage\n",
    "\n",
    "In order to implement a two-qubit gate between qubits that are not directly connected on a quantum device, one or more SWAP gates must be inserted into the circuit to move the qubit states around until they are adjacent on the device gate map.  Each SWAP gate represents an expensive and noisy operation to perform.  Thus, finding the minimum number of SWAP gates needed to map a circuit onto a given device is an important step in the whole transpilation process.  For efficiency, this stage is typically computed alongside the Layout stage by default, but they are logically distinct from one another.  The *Layout* stage selects the hardware qubits to be used, while the *Routing* stage inserts the appropriate amount of SWAP gates in order to execute the circuits using the selected layout.\n",
    "\n",
    "However this may come as no surprise that there's no free lunch here and that finding the optimal SWAP mapping is hard.  In fact, it is an NP-hard problem, and is thus prohibitively expensive to compute for all but the smallest quantum devices and input circuits.  To work around this, Qiskit uses a stochastic heuristic algorithm called `SabreSwap` to compute a good, but not necessarily optimal, SWAP mapping. The use of a stochastic method means that the circuits generated by `transpile()` are not guaranteed to be the same over repeated runs.  Indeed, running the same circuit repeatedly results in a distribution of circuit depths and gate counts at the output.  It is for this reason that many users choose to run the routing function (or the entire `StagedPassManager`) many times and select the lowest-depth circuits from the distribution of outputs.\n",
    "\n",
    "It's also important to point out here that the `SabreSwap` algorithm is different from the larger `SabreLayout` method in the previous stage.  By default, `SabreLayout` runs both layout and routing, and returns the transformed circuit.  This is done for a few particular technical reasons specified in the pass's [API reference page](../api/qiskit/qiskit.transpiler.passes.SabreLayout). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Translation stage\n",
    "\n",
    "When writing a quantum circuit, you are free to use any quantum gate (unitary operation) that you like, along with a collection of non-gate operations such as qubit measurement or reset instructions.  However, most quantum devices only natively support a handful of quantum gate and non-gate operations. This stage of the preset `PassManagers`  translates (or *unrolls*) the gates specified in a circuit to the native basis gates of a specified backend.  This is an important step, as it allows the circuit to be executed by the backend, but typically leads to an increase in the depth and number of gates.\n",
    "\n",
    "There two special cases which are especially important to highlight, and which help illustrate what this stage does:\n",
    "\n",
    "1. If a SWAP gate is not a native gate to the target backend, this requires three CNOT gates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['rz', 'sx', 'x', 'ecr', 'measure', 'delay']\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 146.652x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.providers.fake_provider import FakeSherbrooke\n",
    "from qiskit import QuantumCircuit\n",
    "\n",
    "backend = FakeSherbrooke()\n",
    "print(backend.operation_names)\n",
    "qc = QuantumCircuit(2)\n",
    "qc.swap(0, 1)\n",
    "qc.draw('mpl', style='iqp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qc.decompose().draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a product of three CNOT gates, SWAPs are expensive operations to perform on noisy quantum devices.  However, such operations are usually necessary for embedding a circuit into the limited gate connectivities of many devices.  Thus, minimizing the number of SWAP gates in a circuit is a primary goal in the process of transpilation.\n",
    "\n",
    "2. A Toffoli, or controlled-controlled-not gate (`ccx`), is a three-qubit gate.  Given that our basis gate set includes only single- and two-qubit gates, this operation must be decomposed.  However, it is quite costly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qc = QuantumCircuit(3)\n",
    "qc.ccx(0, 1, 2)\n",
    "qc.draw('mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qc.decompose().draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For every Toffoli gate in a quantum circuit, the hardware may execute up to six CNOT gates and a handful of single-qubit gates.  From this example, it should be clear that any algorithm that makes use of multiple Toffoli gates will end up as a circuit with large depth and will therefore be appreciably affected by noise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimization stage\n",
    "\n",
    "This stage centers around decomposing quantum circuits into the basis gate set of the target device, and must fight against the increased depth from the layout and routing stages.  Fortunately, there are many routines for optimizing circuits by either combining or eliminating gates.  In some cases, these methods are so effective that the output circuits have lower depth than the inputs, even after layout and routing to the hardware topology.  In other cases, not much can be done, and the computation may be difficult to perform on noisy devices.  This stage is where the various optimization levels begin to differ.\n",
    "\n",
    "- For `optimization_level=1`, this stage prepares the [`Optimize1qGatesDecomposition`](../api/qiskit/qiskit.transpiler.passes.Optimize1qGatesDecomposition) and [`CXCancellation`](../api/qiskit/qiskit.transpiler.passes.CXCancellation), which combine chains of single-qubit gates and cancel any back-to-back CNOT gates.\n",
    "- For `optimization_level=2`, this stage uses the [`CommutativeCancellation`](../api/qiskit/qiskit.transpiler.passes.CommutativeCancellation) pass instead of `CXCancellation`, which removes redundant gates by exploiting commutation relations.\n",
    "- For `optimization_level=3`, this stage prepares the following passes:\n",
    "  - [`Collect2qBlocks`](../api/qiskit/qiskit.transpiler.passes.Collect2qBlocks)\n",
    "  - [`ConsolidateBlocks`](../api/qiskit/qiskit.transpiler.passes.ConsolidateBlocks)\n",
    "  - [`UnitarySynthesis`](../api/qiskit/qiskit.transpiler.passes.UnitarySynthesis)\n",
    "  - [`Optimize1qGateDecomposition`](../api/qiskit/qiskit.transpiler.passes.Optimize1qGatesDecomposition)\n",
    "  - [`CommutativeCancellation`](../api/qiskit/qiskit.transpiler.passes.CommutativeCancellation)\n",
    "\n",
    "\n",
    "Additionally, this stage also executes a few final checks to make sure that all instructions in the circuit are composed of the basis gates available on the target backend."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scheduling\n",
    "\n",
    "This last stage is only run if it is explicitly called for (similar to the Init stage) and does not run by default (though a method can be specified by setting the `scheduling_method` argument when calling `transpile()`).  The scheduling stage is typically used once the circuit has been translated to the target basis, mapped to the device, and optimized.  These passes focus on accounting for all the idle time in a circuit.  At a high level, the scheduling pass can be thought of as explicitly inserting delay instructions to account for the idle time between gate executions and to inspect how long the circuit will be running on the backend.  Scheduling a circuit involves two parts: analysis and constraint mapping, followed by a padding pass.  The first part requires running a scheduling analysis pass (by default this is [`ALAPSchedulingAnalysis`](../api/qiskit/qiskit.transpiler.passes.ALAPScheduleAnalysis)), which analyzes the circuit and records the start time of each instruction in the circuit into a schedule.  Once the circuit has an initial schedule, additional passes can be run to account for any timing constraints on the target backend.  Finally, a padding pass, such as [`PadDelay`](../api/qiskit/qiskit.transpiler.passes.PadDelay) or [`PadDynamicalDecoupling`](../api/qiskit/qiskit.transpiler.passes.PadDynamicalDecoupling) can be executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "226.6px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}