IBM_QGSS23/labs/lab5_error_mitigation_with_qiskit_runtime.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lab 5 - Error Mitigation with Qiskit Runtime:\n",
    "\n",
    "- In this lab, we'll explore a few of the error mitigation options available through IBM's Qiskit Runtime. Specifically, we'll define a simple observable and initial state and use the Estimator primitive to measure the expectation value. Using noisy simulations, we'll explore the effect of different error mitigation strategies."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup\n",
    "\n",
    "We'll define a simple Heisenberg Hamiltonian model to use as an example. We'll also construct a simple state preparation circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# import the quantum circuit and the quantum register\n",
    "# from the IBM's Qiskit library\n",
    "from qiskit import QuantumCircuit, QuantumRegister\n",
    "\n",
    "# import the Sparse Pauli operator from\n",
    "# the IBM's Qiskit quantum information module\n",
    "from qiskit.quantum_info import SparsePauliOp\n",
    "\n",
    "\n",
    "# defome the function to generate a Sparse Pauli operator\n",
    "# for the Heisenberg's Hamiltonian\n",
    "def heisenberg_hamiltonian(\n",
    "    length: int, jx: float = 1.0, jy: float = 0.0, jz: float = 0.0\n",
    ") -> SparsePauliOp:\n",
    "  \n",
    "    # create an empty list for the terms\n",
    "    terms = []\n",
    "    \n",
    "    \n",
    "    # for each index ranged for the number of qubits on\n",
    "    # the Heisenberg's Hamiltonian\n",
    "    for i in range( ( length - 1 ) ):\n",
    "        \n",
    "        # if it is pretended to append a XX operator term to\n",
    "        # the Heisenberg's Hamiltonian operator\n",
    "        if jx:\n",
    "            \n",
    "            # append a XX operator term to\n",
    "            # the Heisenberg's Hamiltonian operator\n",
    "            terms.append( ( \"XX\", [i, i + 1], jx ) )\n",
    "        \n",
    "        # if it is pretended to append a YY operator term to\n",
    "        # the Heisenberg's Hamiltonian operator\n",
    "        if jy:\n",
    "            \n",
    "            # append a YY operator term to\n",
    "            # the Heisenberg's Hamiltonian operator\n",
    "            terms.append( ( \"YY\", [i, i + 1], jy ) )\n",
    "    \n",
    "        # if it is pretended to append a ZZ operator term to\n",
    "        # the Heisenberg's Hamiltonian operator\n",
    "        if jz:\n",
    "            \n",
    "            # append a ZZ operator term to\n",
    "            # the Heisenberg's Hamiltonian operator\n",
    "            terms.append( ( \"ZZ\", [i, i + 1], jz ) )\n",
    "    \n",
    "    \n",
    "    # return the Sparse Pauli operator\n",
    "    # for the Heisenberg's Hamiltonian\n",
    "    return SparsePauliOp.from_sparse_list(terms, num_qubits=length)\n",
    "\n",
    "\n",
    "# define a function to generate the quantum circuit for the state preparation\n",
    "def state_prep_circuit( num_qubits: int, layers: int = 1 ) -> QuantumCircuit:\n",
    " \n",
    "    # create a quantum register with the number of qubits pretended\n",
    "    qubits = QuantumRegister(num_qubits, name=\"q\")\n",
    "\n",
    "    # create a quantum circuit with the quantum register defined before\n",
    "    circuit = QuantumCircuit(qubits)\n",
    "    \n",
    "    # apply a Hadamard gate to\n",
    "    # the quantum circuit, on all the qubits\n",
    "    circuit.h(qubits)\n",
    "    \n",
    "    \n",
    "    # for each layer of the quantum circuit\n",
    "    for _ in range(layers):\n",
    "    \n",
    "        # for each 2n-th qubit\n",
    "        for i in range(0, ( num_qubits - 1 ), 2):\n",
    "            \n",
    "            # apply a CX/CNOT gate to\n",
    "            # the quantum circuit,\n",
    "            # with control on the current qubit\n",
    "            # and target on the next qubit\n",
    "            circuit.cx( qubits[i], qubits[ ( i + 1 ) ] )\n",
    "        \n",
    "        # apply a RY (Rotation-Y) gate to\n",
    "        # the quantum circuit, on the 1st qubit,\n",
    "        # with the theta angle equal to 0.1\n",
    "        # on all the qubits\n",
    "        circuit.ry( 0.1, qubits )\n",
    "    \n",
    "        # for each (2n + 1)-th qubit\n",
    "        for i in range(1, ( num_qubits - 1 ), 2):\n",
    "            \n",
    "            # apply a CX/CNOT gate to\n",
    "            # the quantum circuit,\n",
    "            # with control on the current qubit\n",
    "            # and target on the next qubit\n",
    "            circuit.cx( qubits[i], qubits[ ( i + 1 ) ] )\n",
    "        \n",
    "        # apply a RY (Rotation-Y) gate to\n",
    "        # the quantum circuit, on the 1st qubit,\n",
    "        # with the theta angle equal to 0.1\n",
    "        # on all the qubits\n",
    "        circuit.ry(0.1, qubits)\n",
    "    \n",
    "    \n",
    "    # return the quantum circuit for the state preparation\n",
    "    return circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SparsePauliOp(['IIIXX', 'IIIYY', 'IIXXI', 'IIYYI', 'IXXII', 'IYYII', 'XXIII', 'YYIII'],\n",
      "              coeffs=[1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 872.774x451.5 with 1 Axes>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# define the number of qubits for\n",
    "# the Heisenberg's Hamiltonian operator and\n",
    "# for the state preparation quantum circuit\n",
    "length = 5\n",
    "\n",
    "\n",
    "# create the Heisenberg's Hamiltonian operator\n",
    "# for the number of qubits defined before\n",
    "hamiltonian = heisenberg_hamiltonian( length, 1.0, 1.0 )\n",
    "\n",
    "# create the state preparation quantum circuit\n",
    "# for the number of qubits defined before\n",
    "circuit = state_prep_circuit( length, layers=2 )\n",
    "\n",
    "\n",
    "# print the Heisenberg's Hamiltonian operator\n",
    "print(hamiltonian)\n",
    "\n",
    "# draw the quantum circuit implementing\n",
    "# a state preparation\n",
    "circuit.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate exact expectation value (energy)\n",
    "\n",
    "First, we'll calculate the exact expectation value using a local simulator implementation of the Estimator primitive. The expectation value of a Hamiltonian is also referred to as \"energy.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exact energy: 4.290938711029713\n"
     ]
    }
   ],
   "source": [
    "# import estimator from IBM's Qiskit\n",
    "# Aer primitives module\n",
    "from qiskit_aer.primitives import Estimator\n",
    "\n",
    "\n",
    "# create an Estimator object with approximation\n",
    "estimator = Estimator( approximation=True )\n",
    "\n",
    "\n",
    "# create a job for the quantum circuit implementing\n",
    "# the Heisenberg's Hamiltonian, running the Estimator\n",
    "job = estimator.run( circuit, hamiltonian, shots=None )\n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "# retrieve the exact expectation value (energy)\n",
    "# from the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "exact_value = result.values[0]\n",
    "\n",
    "\n",
    "# print the exact expectation value (energy)\n",
    "# from the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "print( f\"Exact energy: {exact_value}\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run noisy simulation through Qiskit Runtime\n",
    "\n",
    "Next, we'll initialize the IBM's Qiskit Runtime service and switch to using its Estimator primitive, backed by a simulator that can handle noise. Even though our circuit acts on 5 qubits, we'll initialize a simulator with 6 qubits in order to later demonstrate the potential effects of qubit choice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, let's setup the IBM's Qiskit Runtime Service."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.10/site-packages/qiskit_ibm_runtime/qiskit_runtime_service.py:422: UserWarning: Default hub/group/project ibm-q-internal/deployed/default not found for the account and is ignored.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# import the IBM's Qiskit Runtime Service\n",
    "# from the Qiskit IBM's Runtime\n",
    "from qiskit_ibm_runtime import QiskitRuntimeService\n",
    "\n",
    "\n",
    "# define the hub for the IBM's Qiskit\n",
    "# Runtime Service\n",
    "hub = \"ibm-q-internal\"\n",
    "\n",
    "# define the group for the IBM's Qiskit\n",
    "# Runtime Service\n",
    "group = \"deployed\"\n",
    "\n",
    "# define the project for the IBM's Qiskit\n",
    "# Runtime Service\n",
    "project = \"default\"\n",
    "\n",
    "\n",
    "# create an IBM's Qiskit Runtime Service\n",
    "service = QiskitRuntimeService(instance=f\"{hub}/{group}/{project}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's configure the quantum simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# import the estimator, options and session\n",
    "# for quantum simulations from the Qiskit IBM Runtime module\n",
    "from qiskit_ibm_runtime import Estimator, Options, Session\n",
    "\n",
    "# import the coupling map from\n",
    "# the IBM's Qiskit Transpiler module\n",
    "from qiskit.transpiler import CouplingMap\n",
    "\n",
    "\n",
    "# define the backend to run the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime\n",
    "backend = service.get_backend(\"simulator_statevector\")\n",
    "\n",
    "\n",
    "# set the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime\n",
    "simulator = {\n",
    "    \"basis_gates\": [\"id\", \"rz\", \"sx\", \"cx\", \"reset\"],\n",
    "    \"coupling_map\": list(CouplingMap.from_line(length + 1)),\n",
    "}\n",
    "\n",
    "\n",
    "# define the number of shots for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime\n",
    "shots = 10000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### (Noiseless) Simulation with no noise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we'll run the (noiseless) simulation with no noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated energy: 4.2648\n",
      "Energy error: 0.02613871102971288\n",
      "Variance: 4.47627104\n",
      "Standard error: 0.021157199814720286\n"
     ]
    }
   ],
   "source": [
    "# import the built-in math module\n",
    "import math\n",
    "\n",
    "\n",
    "# define the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime,\n",
    "# with a resilience level of 0 (zero)\n",
    "options = Options(\n",
    "    simulator=simulator,\n",
    "    resilience_level=0,\n",
    ")\n",
    "\n",
    "\n",
    "# within the context of a session of the IBM's Qiskit Runtime \n",
    "with Session( service=service, backend=backend ):\n",
    "    \n",
    "    # create an estimator object with the options defined before\n",
    "    estimator = Estimator(options=options)\n",
    "    \n",
    "    # create a job for the quantum circuit implementing\n",
    "    # the Heisenberg's Hamiltonian, running the Estimator\n",
    "    job = estimator.run( circuit, hamiltonian, shots=shots )\n",
    "\n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "\n",
    "# retrieve the values of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "experiment_value = result.values[0]\n",
    "\n",
    "# compute the error as the distance between\n",
    "# the experiment value and the exact value\n",
    "error = abs(experiment_value - exact_value)\n",
    "\n",
    "# retrieve the variance from the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "variance = result.metadata[0][\"variance\"]\n",
    "\n",
    "# compute the standard deviation of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "std = math.sqrt( variance / shots )\n",
    "\n",
    "\n",
    "# print the statistics for the estimated energy,\n",
    "# the energy error, the variance, and the standard error\n",
    "print(f\"Estimated energy: {experiment_value}\")\n",
    "print(f\"Energy error: {error}\")\n",
    "print(f\"Variance: {variance}\")\n",
    "print(f\"Standard error: {std}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Readout error\n",
    "\n",
    "Next, let's run a simulation with readout error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 1 - Build a quantum noise model for a global readout error. </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 1\n",
    "\n",
    "In this exercise, you'll construct a noise model that has modest readout error on all qubits except for the first qubit, which will have really bad readout error.\n",
    "\n",
    "Specifically, construct a noise model with the following properties:\n",
    "- For the first qubit (qubit 0):\n",
    "  - A readout of 1 has a 50% probability of being erroneously read as 0.\n",
    "  - A readout of 0 has a 20% probability of being erroneously read as 1.\n",
    "- For the rest of the qubits:\n",
    "  - A readout of 1 has a 5% probability of being erroneously read as 0.\n",
    "  - A readout of 0 has a 2% probability of being erroneously read as 1.\n",
    "\n",
    "You may find it helpful to consult the following resources:\n",
    "  - https://qiskit.org/ecosystem/aer/apidocs/aer_noise.html\n",
    "  - https://qiskit.org/documentation/stable/0.24/tutorials/simulators/3_building_noise_models.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'id', 'rz', 'sx']\n",
      "  Instructions with noise: ['measure']\n",
      "  Qubits with noise: [0, 1, 2, 3, 4, 5]\n",
      "  Specific qubit errors: [('measure', (0,)), ('measure', (1,)), ('measure', (2,)), ('measure', (3,)), ('measure', (4,)), ('measure', (5,))]\n"
     ]
    }
   ],
   "source": [
    "# import the noise model and the readout error\n",
    "# from the IBM's Qiskit Aer Noise module\n",
    "from qiskit_aer.noise import NoiseModel, ReadoutError\n",
    "\n",
    "\n",
    "# create a noise model\n",
    "noise_model = NoiseModel()\n",
    "\n",
    "\n",
    "##### your code here #####\n",
    "\n",
    "# create the measurement miss-assignments and\n",
    "# correct measurement probabilities\n",
    "\n",
    "# create the measurement miss-assignment\n",
    "# probabilities for the 1st qubit,\n",
    "# for the erroneous measurement outcomes\n",
    "qubit0_p0_given1 = 0.2\n",
    "qubit0_p1_given0 = 0.5\n",
    "\n",
    "# create the correct measurement\n",
    "# probabilities for the 1st qubit\n",
    "qubit0_p0_given0 = (1 - qubit0_p0_given1)\n",
    "qubit0_p1_given1 = (1 - qubit0_p1_given0)\n",
    "\n",
    "\n",
    "# create the measurement miss-assignment\n",
    "# probabilities for the remaining qubits k_i,\n",
    "# for the erroneous measurement outcomes\n",
    "qubitk_p0_given1 = 0.02\n",
    "qubitk_p1_given0 = 0.05\n",
    "\n",
    "# create the correct measurement\n",
    "# probabilities for the remaining qubits k_i\n",
    "qubitk_p0_given0 = (1 - qubitk_p0_given1)\n",
    "qubitk_p1_given1 = (1 - qubitk_p1_given0)\n",
    "\n",
    "\n",
    "# create the readout error objects\n",
    "\n",
    "# create a readout error for the 1st qubit\n",
    "readout_error_qubit0 = ReadoutError( [ [ qubit0_p0_given0, qubit0_p0_given1 ],\n",
    "                                       [ qubit0_p1_given0, qubit0_p1_given1 ] ] )\n",
    "\n",
    "# ceeate a readout error for the remaining qubits k_i\n",
    "readout_error_qubitk = ReadoutError( [ [ qubitk_p0_given0, qubitk_p0_given1 ],\n",
    "                                       [ qubitk_p1_given0, qubitk_p1_given1 ] ] )\n",
    "\n",
    "\n",
    "# add a readout error to the noise model for the 1st qubit\n",
    "noise_model.add_readout_error( readout_error_qubit0, [0] )\n",
    "\n",
    "\n",
    "# for each of the remaining qubits k_i\n",
    "# note: recall that even though our circuit acts on 5 qubits,\n",
    "#       we will initialize a simulator with 6 qubits in order to\n",
    "#       later demonstrate the potential effects of qubit choice\n",
    "for k in range( 1, ( length + 1 ) ):\n",
    "    \n",
    "    # add a readout error to the noise model\n",
    "    # for the remaining qubits k_i\n",
    "    noise_model.add_readout_error( readout_error_qubitk, [k] )\n",
    "\n",
    "    \n",
    "# print the noise model created before\n",
    "print(noise_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# submit your answer\n",
    "\n",
    "# import the grader for the exercise 1 of the lab 5\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab5_ex1\n",
    "\n",
    "# grade the exercise 1 of the lab 5\n",
    "grade_lab5_ex1(noise_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, let's try running the simulation without doing anything to mitigate the readout error. We'll explicitly set `resilience_level = 0` to ensure that no error mitigation is applied by the Runtime service. To illustrate the effect of a poor choice of qubits, we'll explicitly specify an initial layout that includes qubit 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated energy: 3.5192\n",
      "Energy error: 0.7717387110297129\n",
      "Variance: 5.39996816\n",
      "Standard error: 0.023237831568371434\n"
     ]
    }
   ],
   "source": [
    "# define the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime,\n",
    "# considering the noise model defined before,\n",
    "# and a resilience level of 0 (zero)\n",
    "options = Options(\n",
    "    simulator=dict( noise_model=noise_model, **simulator ),\n",
    "    resilience_level=0,\n",
    "    transpilation=dict( initial_layout=list( range(length) ) ),\n",
    ")\n",
    "\n",
    "\n",
    "# within the context of a session of the IBM's Qiskit Runtime \n",
    "with Session( service=service, backend=backend ):\n",
    "    \n",
    "    # create an estimator object with the options defined before\n",
    "    estimator = Estimator(options=options)\n",
    "    \n",
    "    # create a job for the quantum circuit implementing\n",
    "    # the Heisenberg's Hamiltonian, running the Estimator\n",
    "    job = estimator.run( circuit, hamiltonian, shots=shots )\n",
    "    \n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "\n",
    "# retrieve the values of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "experiment_value = result.values[0]\n",
    "\n",
    "# compute the error as the distance between\n",
    "# the experiment value and the exact value\n",
    "error = abs(experiment_value - exact_value)\n",
    "\n",
    "# retrieve the variance from the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "variance = result.metadata[0][\"variance\"]\n",
    "\n",
    "# compute the standard deviation of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "std = math.sqrt( variance / shots )\n",
    "\n",
    "\n",
    "# print the statistics for the estimated energy,\n",
    "# the energy error, the variance, and the standard error\n",
    "print(f\"Estimated energy: {experiment_value}\")\n",
    "print(f\"Energy error: {error}\")\n",
    "print(f\"Variance: {variance}\")\n",
    "print(f\"Standard error: {std}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The error we get is pretty large. To improve things, let's pick a qubit layout that avoids qubit 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated energy: 3.9545999999999997\n",
      "Energy error: 0.33633871102971336\n",
      "Variance: 4.96369676\n",
      "Standard error: 0.02227935537667102\n"
     ]
    }
   ],
   "source": [
    "# define the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime,\n",
    "# considering the noise model defined before,\n",
    "# and a resilience level of 0 (zero),\n",
    "# but this time, with a layout where\n",
    "# the 1st qubit is not considered\n",
    "options = Options(\n",
    "    simulator=dict( noise_model=noise_model, **simulator ),\n",
    "    resilience_level=0,\n",
    "    transpilation=dict( initial_layout=list( range(1, ( length + 1 ) ) ) ),\n",
    ")\n",
    "\n",
    "\n",
    "# within the context of a session of the IBM's Qiskit Runtime \n",
    "with Session( service=service, backend=backend ):\n",
    "    \n",
    "    # create an estimator object with the options defined before\n",
    "    estimator = Estimator(options=options)\n",
    "    \n",
    "    # create a job for the quantum circuit implementing\n",
    "    # the Heisenberg's Hamiltonian, running the Estimator\n",
    "    job = estimator.run( circuit, hamiltonian, shots=shots )\n",
    "\n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "\n",
    "# retrieve the values of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "experiment_value = result.values[0]\n",
    "\n",
    "# compute the error as the distance between\n",
    "# the experiment value and the exact value\n",
    "error = abs(experiment_value - exact_value)\n",
    "\n",
    "# retrieve the variance from the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "variance = result.metadata[0][\"variance\"]\n",
    "\n",
    "# compute the standard deviation of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "std = math.sqrt( variance / shots )\n",
    "\n",
    "\n",
    "# print the statistics for the estimated energy,\n",
    "# the energy error, the variance, and the standard error\n",
    "print(f\"Estimated energy: {experiment_value}\")\n",
    "print(f\"Energy error: {error}\")\n",
    "print(f\"Variance: {variance}\")\n",
    "print(f\"Standard error: {std}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The error is smaller now, but still significant. Let's now enable readout error mitigation by setting `resilience_level = 1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated energy: 4.283775783303248\n",
      "Energy error: 0.007162927726464652\n",
      "Variance: 7.094957540982811\n",
      "Standard error: 0.026636361502620456\n"
     ]
    }
   ],
   "source": [
    "# define the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime,\n",
    "# considering the noise model defined before,\n",
    "# and a resilience level of 1 (one),\n",
    "# but this time, with a layout where\n",
    "# the 1st qubit is not considered\n",
    "options = Options(\n",
    "    simulator=dict( noise_model=noise_model, **simulator ),\n",
    "    resilience_level=1,\n",
    "    transpilation=dict( initial_layout=list( range( 1, ( length + 1 ) ) ) ),\n",
    ")\n",
    "\n",
    "\n",
    "# within the context of a session of the IBM's Qiskit Runtime \n",
    "with Session( service=service, backend=backend ):\n",
    "    \n",
    "    # create an estimator object with the options defined before\n",
    "    estimator = Estimator(options=options)\n",
    "    \n",
    "    # create a job for the quantum circuit implementing\n",
    "    # the Heisenberg's Hamiltonian, running the Estimator\n",
    "    job = estimator.run( circuit, hamiltonian, shots=shots )\n",
    "\n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "\n",
    "# retrieve the values of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "experiment_value = result.values[0]\n",
    "\n",
    "# compute the error as the distance between\n",
    "# the experiment value and the exact value\n",
    "error = abs(experiment_value - exact_value)\n",
    "\n",
    "# retrieve the variance from the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "variance = result.metadata[0][\"variance\"]\n",
    "\n",
    "# compute the standard deviation of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "std = math.sqrt( variance / shots )\n",
    "\n",
    "\n",
    "# print the statistics for the estimated energy,\n",
    "# the energy error, the variance, and the standard error\n",
    "print(f\"Estimated energy: {experiment_value}\")\n",
    "print(f\"Energy error: {error}\")\n",
    "print(f\"Variance: {variance}\")\n",
    "print(f\"Standard error: {std}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, the effect of readout error has been almost completely mitigated! This mitigation did not come for free. In particular,\n",
    "- To perform readout error mitigation, the Runtime service has to run additional calibration circuits, so the overall running time may be longer.\n",
    "- The variance of the estimator has increased, leading to a larger standard error of the mean. As a consequence, a larger number of shots needs to be specified in order to achieve a given standard error.\n",
    "\n",
    "Typically, these costs are relatively small, so it is almost always worthwhile to enable readout error mitigation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 2 - Determine the required number of shots that keep the same standard error, if the readout error mitigation increases the variance by a factor of 2. </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 2\n",
    "\n",
    "Suppose that turning on readout error mitigation increases the variance of your estimator by a factor of 2. If you originally ran your experiment with 10,000 shots, how many shots should you now use to achieve the same standard error of the mean?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# define the variable for\n",
    "# the new number of shots\n",
    "new_shots: int\n",
    "\n",
    "\n",
    "##### your code here #####\n",
    "\n",
    "# define the new number of shots\n",
    "new_shots = 20000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# submit your answer\n",
    "\n",
    "# import the grader for the exercise 2 of the lab 5\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab5_ex2\n",
    "\n",
    "# grade the exercise 2 of the lab 5\n",
    "grade_lab5_ex2(new_shots)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Depolarizing error and zero-noise extrapolation\n",
    "\n",
    "In this section, we will see how depolarizing error can be mitigated using zero-noise extrapolation. Because the zero-noise extrapolation feature of IBM's Qiskit Runtime is still in beta, it currently has a few limitations. In particular, as of the time of this writing, the zero-noise extrapolation feature does not mitigate readout error. Therefore, in the examples below, we will remove readout error from our noise model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 3 - Build a quantum noise model for a two-qubit depolarizing error after each $CNOT$/$CX$ gate. </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 3\n",
    "\n",
    "Construct a noise model that adds two-qubit depolarizing error after each CNOT gate, such that the error channel maps the input quantum state to the completely mixed state with 1% probability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'id', 'rz', 'sx']\n",
      "  Instructions with noise: ['cx']\n",
      "  All-qubits errors: ['cx']\n"
     ]
    }
   ],
   "source": [
    "# import the noise model and the depolarizing error\n",
    "# from the IBM's Qiskit Aer Noise module\n",
    "from qiskit_aer.noise import depolarizing_error\n",
    "\n",
    "\n",
    "# creata a noise model\n",
    "noise_model = NoiseModel()\n",
    "\n",
    "\n",
    "##### your code here #####\n",
    "\n",
    "# create the depolarizaation probability\n",
    "depolarization_prob = 0.01\n",
    "\n",
    "\n",
    "# create the depolarization error objects\n",
    "\n",
    "# create a two-qubit depolarization error for two qubits\n",
    "depolarizing_error_two_quits = depolarizing_error( depolarization_prob, 2 )\n",
    "\n",
    "\n",
    "# add the two-qubit depolarization error after each CNOT/CX gate\n",
    "noise_model.add_all_qubit_quantum_error( depolarizing_error_two_quits, ['cx'] )\n",
    "\n",
    "\n",
    "# print the noise model created before\n",
    "print(noise_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# submit your answer\n",
    "\n",
    "# import the grader for the exercise 3 of the lab 5\n",
    "from qc_grader.challenges.qgss_2023 import grade_lab5_ex3\n",
    "\n",
    "# grade the exercise 3 of the lab 5\n",
    "grade_lab5_ex3(noise_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run the estimator with `resilience_level = 1`, which turns on readout error mitigation. Because our noise model doesn't include readout error mitigation, we don't expect this to help."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated energy: 4.1152\n",
      "Energy error: 0.17573871102971328\n",
      "Variance: 4.8137908\n",
      "Standard error: 0.021940352777473745\n"
     ]
    }
   ],
   "source": [
    "# define the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime,\n",
    "# with a resilience level of 1 (one)\n",
    "options = Options(\n",
    "    simulator=dict( noise_model=noise_model, **simulator ),\n",
    "    resilience_level=1,\n",
    ")\n",
    "\n",
    "\n",
    "# within the context of a session of the IBM's Qiskit Runtime \n",
    "with Session( service=service, backend=backend ):\n",
    "    \n",
    "    # create an estimator object with the options defined before\n",
    "    estimator = Estimator(options=options)\n",
    "    \n",
    "    # create a job for the quantum circuit implementing\n",
    "    # the Heisenberg's Hamiltonian, running the Estimator\n",
    "    job = estimator.run( circuit, hamiltonian, shots=shots )\n",
    "\n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "\n",
    "# retrieve the values of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "experiment_value = result.values[0]\n",
    "\n",
    "# compute the error as the distance between\n",
    "# the experiment value and the exact value\n",
    "error = abs(experiment_value - exact_value)\n",
    "\n",
    "# retrieve the variance from the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "variance = result.metadata[0][\"variance\"]\n",
    "\n",
    "# compute the standard deviation of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "std = math.sqrt( variance / shots )\n",
    "\n",
    "\n",
    "# print the statistics for the estimated energy,\n",
    "# the energy error, the variance, and the standard error\n",
    "print(f\"Estimated energy: {experiment_value}\")\n",
    "print(f\"Energy error: {error}\")\n",
    "print(f\"Variance: {variance}\")\n",
    "print(f\"Standard error: {std}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, the error we get is pretty significant.\n",
    "\n",
    "Now, let's turn on zero-noise extrapolation by setting `resilience_level = 2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated energy: 4.214833333333336\n",
      "Energy error: 0.07610537769637737\n",
      "Variances: [4.805336319999999, 5.47060428, 5.8813592]\n"
     ]
    }
   ],
   "source": [
    "# define the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime,\n",
    "# with a resilience level of 2 (two)\n",
    "options = Options(\n",
    "    simulator=dict( noise_model=noise_model, **simulator ),\n",
    "    resilience_level=2,\n",
    ")\n",
    "\n",
    "\n",
    "# within the context of a session of the IBM's Qiskit Runtime \n",
    "with Session( service=service, backend=backend ):\n",
    "    \n",
    "    # create an estimator object with the options defined before\n",
    "    estimator = Estimator(options=options)\n",
    "    \n",
    "    # create a job for the quantum circuit implementing\n",
    "    # the Heisenberg's Hamiltonian, running the Estimator\n",
    "    job = estimator.run( circuit, hamiltonian, shots=shots )\n",
    "    \n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "\n",
    "# retrieve the values of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "experiment_value = result.values[0]\n",
    "\n",
    "# compute the error as the distance between\n",
    "# the experiment value and the exact value\n",
    "error = abs(experiment_value - exact_value)\n",
    "\n",
    "# retrieve the variances of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian,\n",
    "# applying Zero-Noise Extrapolation with Noise Amplification\n",
    "variances = result.metadata[0][\"zne\"][\"noise_amplification\"][\"variance\"]\n",
    "\n",
    "\n",
    "# print the statistics for the estimated energy,\n",
    "# the energy error, and the variances\n",
    "print(f\"Estimated energy: {experiment_value}\")\n",
    "print(f\"Energy error: {error}\")\n",
    "print(f\"Variances: {variances}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, the effect of depolarizing noise has been almost completely mitigated! Note that instead of getting a single variance value for the estimator, we are now returned a list of variances, one for each data point measured for the extrapolation. In a future version of IBM's Qiskit Runtime, these variances will also be extrapolated to return a single variance for the final estimator."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\"> Ex. 4 - Build other quantum noise models to be mitigated with zero-noise extrapolation. </div>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 4 \n",
    "\n",
    "Besides depolarizing error, what other kinds of noise can be mitigated by zero-noise extrapolation? Test your proposals by constructing other noise models, and then simulating them with and without zero-noise extrapolation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define the noise model for the bit flip error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'h', 'id', 'rz', 'sx', 'x', 'y', 'z']\n",
      "  Instructions with noise: ['y', 'h', 'x', 'z']\n",
      "  All-qubits errors: ['x', 'y', 'z', 'h']\n"
     ]
    }
   ],
   "source": [
    "# import Pauli error from\n",
    "# the IBM's Qiskit Aer Noise module\n",
    "from qiskit_aer.noise import pauli_error\n",
    "\n",
    "\n",
    "# create a noise model\n",
    "noise_model = NoiseModel()\n",
    "\n",
    "\n",
    "##### your code here #####\n",
    "\n",
    "# create the Pauli error probability\n",
    "pauli_error_prob = 0.1\n",
    "\n",
    "\n",
    "# create the Pauli error objects\n",
    "\n",
    "# create a bit flip error for a qubit\n",
    "bit_flip_error = pauli_error( [ ( \"X\", pauli_error_prob ),\n",
    "                                ( \"I\", ( 1 - pauli_error_prob ) ) ] )\n",
    "\n",
    "\n",
    "# add a bit flip error for a qubit,\n",
    "# after each Pauli-X, Pauli-Y, Pauli-Z, and Hadamard gate\n",
    "noise_model.add_all_qubit_quantum_error( bit_flip_error, [\"x\", \"y\", \"z\", \"h\"] )\n",
    "\n",
    "\n",
    "# print the noise model created before\n",
    "print(noise_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run the estimator with `resilience_level = 0` to ensure that no error mitigation is applied by the Runtime service."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated energy: 4.272399999999999\n",
      "Energy error: 0.018538711029713717\n",
      "Variance: 4.4645373600000005\n",
      "Standard error: 0.021129451862270353\n"
     ]
    }
   ],
   "source": [
    "# define the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime,\n",
    "# with a resilience level of 0 (zero)\n",
    "options = Options(\n",
    "    simulator=dict( noise_model=noise_model, **simulator ),\n",
    "    resilience_level=0,\n",
    ")\n",
    "\n",
    "\n",
    "# within the context of a session of the IBM's Qiskit Runtime \n",
    "with Session( service=service, backend=backend ):\n",
    "    \n",
    "    # create an estimator object with the options defined before\n",
    "    estimator = Estimator(options=options)\n",
    "    \n",
    "    # create a job for the quantum circuit implementing\n",
    "    # the Heisenberg's Hamiltonian, running the Estimator\n",
    "    job = estimator.run( circuit, hamiltonian, shots=shots )\n",
    "    \n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "\n",
    "# retrieve the values of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "experiment_value = result.values[0]\n",
    "\n",
    "# compute the error as the distance between\n",
    "# the experiment value and the exact value\n",
    "error = abs(experiment_value - exact_value)\n",
    "\n",
    "# retrieve the variance from the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "variance = result.metadata[0][\"variance\"]\n",
    "\n",
    "# compute the standard deviation of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "std = math.sqrt( variance / shots )\n",
    "\n",
    "\n",
    "# print the statistics for the estimated energy,\n",
    "# the energy error, the variance, and the standard error\n",
    "print(f\"Estimated energy: {experiment_value}\")\n",
    "print(f\"Energy error: {error}\")\n",
    "print(f\"Variance: {variance}\")\n",
    "print(f\"Standard error: {std}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run the estimator with `resilience_level = 1`, which turns on readout error mitigation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated energy: 4.274824595814142\n",
      "Energy error: 0.016114115215571267\n",
      "Variance: 8.56100274406175\n",
      "Standard error: 0.029259191280795422\n"
     ]
    }
   ],
   "source": [
    "# define the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime,\n",
    "# with a resilience level of 1 (one)\n",
    "options = Options(\n",
    "    simulator=dict(noise_model=noise_model, **simulator),\n",
    "    resilience_level=1,\n",
    ")\n",
    "\n",
    "\n",
    "# within the context of a session of the IBM's Qiskit Runtime \n",
    "with Session( service=service, backend=backend ):\n",
    "    \n",
    "    # create an estimator object with the options defined before\n",
    "    estimator = Estimator(options=options)\n",
    "    \n",
    "    # create a job for the quantum circuit implementing\n",
    "    # the Heisenberg's Hamiltonian, running the Estimator\n",
    "    job = estimator.run( circuit, hamiltonian, shots=shots )\n",
    "    \n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "\n",
    "# retrieve the values of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "experiment_value = result.values[0]\n",
    "\n",
    "# compute the error as the distance between\n",
    "# the experiment value and the exact value\n",
    "error = abs(experiment_value - exact_value)\n",
    "\n",
    "# retrieve the variance from the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "variance = result.metadata[0][\"variance\"]\n",
    "\n",
    "# compute the standard deviation of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "std = math.sqrt( variance / shots )\n",
    "\n",
    "\n",
    "# print the statistics for the estimated energy,\n",
    "# the energy error, the variance, and the standard error\n",
    "print(f\"Estimated energy: {experiment_value}\")\n",
    "print(f\"Energy error: {error}\")\n",
    "print(f\"Variance: {variance}\")\n",
    "print(f\"Standard error: {std}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's turn on zero-noise extrapolation by setting `resilience_level = 2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated energy: 4.290283333333335\n",
      "Energy error: 0.0006553776963782454\n",
      "Variances: [4.46540188, 4.48098736, 4.47434272]\n"
     ]
    }
   ],
   "source": [
    "# define the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime,\n",
    "# with a resilience level of 2 (two)\n",
    "options = Options(\n",
    "    simulator=dict(noise_model=noise_model, **simulator),\n",
    "    resilience_level=2,\n",
    ")\n",
    "\n",
    "\n",
    "# within the context of a session of the IBM's Qiskit Runtime \n",
    "with Session( service=service, backend=backend ):\n",
    "    \n",
    "    # create an estimator object with the options defined before\n",
    "    estimator = Estimator(options=options)\n",
    "    \n",
    "    # create a job for the quantum circuit implementing\n",
    "    # the Heisenberg's Hamiltonian, running the Estimator\n",
    "    job = estimator.run( circuit, hamiltonian, shots=shots )\n",
    "\n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "\n",
    "# retrieve the values of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "experiment_value = result.values[0]\n",
    "\n",
    "# compute the error as the distance between\n",
    "# the experiment value and the exact value\n",
    "error = abs(experiment_value - exact_value)\n",
    "\n",
    "# retrieve the variances of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian,\n",
    "# applying Zero-Noise Extrapolation with Noise Amplification\n",
    "variances = result.metadata[0][\"zne\"][\"noise_amplification\"][\"variance\"]\n",
    "\n",
    "\n",
    "# print the statistics for the estimated energy,\n",
    "# the energy error, and the variances\n",
    "print(f\"Estimated energy: {experiment_value}\")\n",
    "print(f\"Energy error: {error}\")\n",
    "print(f\"Variances: {variances}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define the noise model for the phase flip error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'h', 'id', 'rz', 'sx', 'x', 'y', 'z']\n",
      "  Instructions with noise: ['y', 'h', 'x', 'z']\n",
      "  All-qubits errors: ['x', 'y', 'z', 'h']\n"
     ]
    }
   ],
   "source": [
    "# import Pauli error from\n",
    "# the IBM's Qiskit Aer Noise module\n",
    "from qiskit_aer.noise import pauli_error\n",
    "\n",
    "\n",
    "# create a noise model\n",
    "noise_model = NoiseModel()\n",
    "\n",
    "\n",
    "##### your code here #####\n",
    "\n",
    "# create the Pauli error probability\n",
    "pauli_error_prob = 0.1\n",
    "\n",
    "\n",
    "# create the Pauli error objects\n",
    "\n",
    "# create a phase flip error for a qubit\n",
    "phase_flip_error = pauli_error( [ ( \"Z\", pauli_error_prob ),\n",
    "                                  ( \"I\", ( 1 - pauli_error_prob ) ) ] )\n",
    "\n",
    "\n",
    "# add a phase flip error for a qubit,\n",
    "# after each Pauli-X, Pauli-Y, Pauli-Z, and Hadamard gate\n",
    "noise_model.add_all_qubit_quantum_error( phase_flip_error, [\"x\", \"y\", \"z\", \"h\"] )\n",
    "\n",
    "\n",
    "# print the noise model created before\n",
    "print(noise_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run the estimator with `resilience_level = 0` to ensure that no error mitigation is applied by the Runtime service."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated energy: 4.3016\n",
      "Energy error: 0.01066128897028662\n",
      "Variance: 4.44668384\n",
      "Standard error: 0.021087161591831178\n"
     ]
    }
   ],
   "source": [
    "# define the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime,\n",
    "# with a resilience level of 0 (zero)\n",
    "options = Options(\n",
    "    simulator=dict( noise_model=noise_model, **simulator ),\n",
    "    resilience_level=0,\n",
    ")\n",
    "\n",
    "\n",
    "# within the context of a session of the IBM's Qiskit Runtime \n",
    "with Session( service=service, backend=backend ):\n",
    "    \n",
    "    # create an estimator object with the options defined before\n",
    "    estimator = Estimator(options=options)\n",
    "    \n",
    "    # create a job for the quantum circuit implementing\n",
    "    # the Heisenberg's Hamiltonian, running the Estimator\n",
    "    job = estimator.run( circuit, hamiltonian, shots=shots )\n",
    "    \n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "\n",
    "# retrieve the values of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "experiment_value = result.values[0]\n",
    "\n",
    "# compute the error as the distance between\n",
    "# the experiment value and the exact value\n",
    "error = abs(experiment_value - exact_value)\n",
    "\n",
    "# retrieve the variance from the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "variance = result.metadata[0][\"variance\"]\n",
    "\n",
    "# compute the standard deviation of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "std = math.sqrt( variance / shots )\n",
    "\n",
    "\n",
    "# print the statistics for the estimated energy,\n",
    "# the energy error, the variance, and the standard error\n",
    "print(f\"Estimated energy: {experiment_value}\")\n",
    "print(f\"Energy error: {error}\")\n",
    "print(f\"Variance: {variance}\")\n",
    "print(f\"Standard error: {std}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run the estimator with `resilience_level = 1`, which turns on readout error mitigation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated energy: 4.293\n",
      "Energy error: 0.002061288970287123\n",
      "Variance: 4.476032119999999\n",
      "Standard error: 0.021156635176700474\n"
     ]
    }
   ],
   "source": [
    "# define the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime,\n",
    "# with a resilience level of 1 (one)\n",
    "options = Options(\n",
    "    simulator=dict( noise_model=noise_model, **simulator ),\n",
    "    resilience_level=1,\n",
    ")\n",
    "\n",
    "\n",
    "# within the context of a session of the IBM's Qiskit Runtime \n",
    "with Session( service=service, backend=backend ):\n",
    "    \n",
    "    # create an estimator object with the options defined before\n",
    "    estimator = Estimator(options=options)\n",
    "    \n",
    "    # create a job for the quantum circuit implementing\n",
    "    # the Heisenberg's Hamiltonian, running the Estimator\n",
    "    job = estimator.run( circuit, hamiltonian, shots=shots )\n",
    "    \n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "\n",
    "# retrieve the values of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "experiment_value = result.values[0]\n",
    "\n",
    "# compute the error as the distance between\n",
    "# the experiment value and the exact value\n",
    "error = abs(experiment_value - exact_value)\n",
    "\n",
    "# retrieve the variance from the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "variance = result.metadata[0][\"variance\"]\n",
    "\n",
    "# compute the standard deviation of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "std = math.sqrt( variance / shots )\n",
    "\n",
    "\n",
    "# print the statistics for the estimated energy,\n",
    "# the energy error, the variance, and the standard error\n",
    "print(f\"Estimated energy: {experiment_value}\")\n",
    "print(f\"Energy error: {error}\")\n",
    "print(f\"Variance: {variance}\")\n",
    "print(f\"Standard error: {std}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's turn on zero-noise extrapolation by setting `resilience_level = 2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated energy: 4.2693\n",
      "Energy error: 0.02163871102971271\n",
      "Variances: [4.46518532, 4.45294392, 4.443589960000001]\n"
     ]
    }
   ],
   "source": [
    "# define the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime,\n",
    "# with a resilience level of 2 (two)\n",
    "options = Options(\n",
    "    simulator=dict(noise_model=noise_model, **simulator),\n",
    "    resilience_level=2,\n",
    ")\n",
    "\n",
    "\n",
    "# within the context of a session of the IBM's Qiskit Runtime \n",
    "with Session( service=service, backend=backend ):\n",
    "    \n",
    "    # create an estimator object with the options defined before\n",
    "    estimator = Estimator(options=options)\n",
    "    \n",
    "    # create a job for the quantum circuit implementing\n",
    "    # the Heisenberg's Hamiltonian, running the Estimator\n",
    "    job = estimator.run( circuit, hamiltonian, shots=shots )\n",
    "\n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "\n",
    "# retrieve the values of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "experiment_value = result.values[0]\n",
    "\n",
    "# compute the error as the distance between\n",
    "# the experiment value and the exact value\n",
    "error = abs(experiment_value - exact_value)\n",
    "\n",
    "# retrieve the variances of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian,\n",
    "# applying Zero-Noise Extrapolation with Noise Amplification\n",
    "variances = result.metadata[0][\"zne\"][\"noise_amplification\"][\"variance\"]\n",
    "\n",
    "\n",
    "# print the statistics for the estimated energy,\n",
    "# the energy error, and the variances\n",
    "print(f\"Estimated energy: {experiment_value}\")\n",
    "print(f\"Energy error: {error}\")\n",
    "print(f\"Variances: {variances}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define the noise model for the reset error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NoiseModel:\n",
      "  Basis gates: ['cx', 'h', 'id', 'rz', 'sx', 'x', 'y', 'z']\n",
      "  Instructions with noise: ['y', 'h', 'x', 'z']\n",
      "  All-qubits errors: ['x', 'y', 'z', 'h']\n"
     ]
    }
   ],
   "source": [
    "# import Reset error from\n",
    "# the IBM's Qiskit Aer Noise module\n",
    "from qiskit_aer.noise import reset_error\n",
    "\n",
    "\n",
    "# create a noise model\n",
    "noise_model = NoiseModel()\n",
    "\n",
    "\n",
    "##### your code here #####\n",
    "\n",
    "# create the Reset error probabilities\n",
    "reset_0_prob = 0.2\n",
    "reset_1_prob = 0.33\n",
    "\n",
    "\n",
    "# create the Reset error objects\n",
    "\n",
    "# create a Reset error for a qubit\n",
    "reset_0_1_error = reset_error( reset_0_prob, reset_1_prob )\n",
    "\n",
    "\n",
    "# add a Reset error for a qubit,\n",
    "# after each Pauli-X, Pauli-Y, Pauli-Z, and Hadamard gate\n",
    "noise_model.add_all_qubit_quantum_error( reset_0_1_error, [\"x\", \"y\", \"z\", \"h\"] )\n",
    "\n",
    "\n",
    "# print the noise model created before\n",
    "print(noise_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run the estimator with `resilience_level = 0` to ensure that no error mitigation is applied by the Runtime service."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated energy: 4.321\n",
      "Energy error: 0.030061288970286704\n",
      "Variance: 4.4240206\n",
      "Standard error: 0.021033355890109406\n"
     ]
    }
   ],
   "source": [
    "# define the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime,\n",
    "# with a resilience level of 0 (zero)\n",
    "options = Options(\n",
    "    simulator=dict( noise_model=noise_model, **simulator ),\n",
    "    resilience_level=0,\n",
    ")\n",
    "\n",
    "\n",
    "# within the context of a session of the IBM's Qiskit Runtime \n",
    "with Session( service=service, backend=backend ):\n",
    "    \n",
    "    # create an estimator object with the options defined before\n",
    "    estimator = Estimator(options=options)\n",
    "    \n",
    "    # create a job for the quantum circuit implementing\n",
    "    # the Heisenberg's Hamiltonian, running the Estimator\n",
    "    job = estimator.run( circuit, hamiltonian, shots=shots )\n",
    "    \n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "\n",
    "# retrieve the values of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "experiment_value = result.values[0]\n",
    "\n",
    "# compute the error as the distance between\n",
    "# the experiment value and the exact value\n",
    "error = abs(experiment_value - exact_value)\n",
    "\n",
    "# retrieve the variance from the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "variance = result.metadata[0][\"variance\"]\n",
    "\n",
    "# compute the standard deviation of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "std = math.sqrt( variance / shots )\n",
    "\n",
    "\n",
    "# print the statistics for the estimated energy,\n",
    "# the energy error, the variance, and the standard error\n",
    "print(f\"Estimated energy: {experiment_value}\")\n",
    "print(f\"Energy error: {error}\")\n",
    "print(f\"Variance: {variance}\")\n",
    "print(f\"Standard error: {std}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run the estimator with `resilience_level = 1`, which turns on readout error mitigation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated energy: 4.190858233514689\n",
      "Energy error: 0.10008047751502414\n",
      "Variance: 15.77436433799761\n",
      "Standard error: 0.03971695398441025\n"
     ]
    }
   ],
   "source": [
    "# define the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime,\n",
    "# with a resilience level of 1 (one)\n",
    "options = Options(\n",
    "    simulator=dict( noise_model=noise_model, **simulator ),\n",
    "    resilience_level=1,\n",
    ")\n",
    "\n",
    "\n",
    "# within the context of a session of the IBM's Qiskit Runtime \n",
    "with Session( service=service, backend=backend ):\n",
    "    \n",
    "    # create an estimator object with the options defined before\n",
    "    estimator = Estimator(options=options)\n",
    "    \n",
    "    # create a job for the quantum circuit implementing\n",
    "    # the Heisenberg's Hamiltonian, running the Estimator\n",
    "    job = estimator.run( circuit, hamiltonian, shots=shots )\n",
    "    \n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "\n",
    "# retrieve the values of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "experiment_value = result.values[0]\n",
    "\n",
    "# compute the error as the distance between\n",
    "# the experiment value and the exact value\n",
    "error = abs(experiment_value - exact_value)\n",
    "\n",
    "# retrieve the variance from the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "variance = result.metadata[0][\"variance\"]\n",
    "\n",
    "# compute the standard deviation of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "std = math.sqrt( variance / shots )\n",
    "\n",
    "\n",
    "# print the statistics for the estimated energy,\n",
    "# the energy error, the variance, and the standard error\n",
    "print(f\"Estimated energy: {experiment_value}\")\n",
    "print(f\"Energy error: {error}\")\n",
    "print(f\"Variance: {variance}\")\n",
    "print(f\"Standard error: {std}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's turn on zero-noise extrapolation by setting `resilience_level = 2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated energy: 4.3398833333333355\n",
      "Energy error: 0.04894462230362251\n",
      "Variances: [4.433444, 4.4332847200000005, 4.4658270799999995]\n"
     ]
    }
   ],
   "source": [
    "# define the options for the quantum simulation\n",
    "# to run in the backend, using the IBM's Qiskit Runtime,\n",
    "# with a resilience level of 2 (two)\n",
    "options = Options(\n",
    "    simulator=dict(noise_model=noise_model, **simulator),\n",
    "    resilience_level=2,\n",
    ")\n",
    "\n",
    "\n",
    "# within the context of a session of the IBM's Qiskit Runtime \n",
    "with Session( service=service, backend=backend ):\n",
    "    \n",
    "    # create an estimator object with the options defined before\n",
    "    estimator = Estimator(options=options)\n",
    "    \n",
    "    # create a job for the quantum circuit implementing\n",
    "    # the Heisenberg's Hamiltonian, running the Estimator\n",
    "    job = estimator.run( circuit, hamiltonian, shots=shots )\n",
    "\n",
    "\n",
    "# retrieve the results of the job ran by\n",
    "# the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "result = job.result()\n",
    "\n",
    "\n",
    "# retrieve the values of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian\n",
    "experiment_value = result.values[0]\n",
    "\n",
    "# compute the error as the distance between\n",
    "# the experiment value and the exact value\n",
    "error = abs(experiment_value - exact_value)\n",
    "\n",
    "# retrieve the variances of the results of\n",
    "# the job ran by the Estimator created before,\n",
    "# that was ran on the quantum circuit\n",
    "# implementing the Heisenberg's Hamiltonian,\n",
    "# applying Zero-Noise Extrapolation with Noise Amplification\n",
    "variances = result.metadata[0][\"zne\"][\"noise_amplification\"][\"variance\"]\n",
    "\n",
    "\n",
    "# print the statistics for the estimated energy,\n",
    "# the energy error, and the variances\n",
    "print(f\"Estimated energy: {experiment_value}\")\n",
    "print(f\"Energy error: {error}\")\n",
    "print(f\"Variances: {variances}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The bit flip error noise model seems to benefit from error mitigation with zero-noise extrapolation."
   ]
  }
 ],
 "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"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "091466dd278345868b42eaf0a4bb3960": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "0f8d03ac861643108a253e1ea5f1a3b5": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_d4132f3f3004418a830c04f63579f7d8",
       "style": "IPY_MODEL_a5d36bf3432e4db7824697dfd5b18553",
       "value": "<p style='font-family: IBM Plex Sans, Arial, Helvetica, sans-serif; font-size: 20px; font-weight: medium;'>Circuit Properties</p>"
      }
     },
     "17a751b484d54ffca4ca6c816e8c83c4": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_area": "right",
       "padding": "0px 0px 0px 0px",
       "width": "70px"
      }
     },
     "22c6d0e747e34bf2a74059d01c22ed51": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "width": "190px"
      }
     },
     "2cd39d282cc14ee99c76b90b6660794b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_93d30752b6bc45779aaf0aa9370a0c2d",
       "style": "IPY_MODEL_9af6388b0ae441718aff92166f03c47b",
       "value": "<h5>Status</h5>"
      }
     },
     "36e1d4aeb2a7484eb2f6dcade5c17c81": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "ButtonModel",
      "state": {
       "button_style": "primary",
       "description": "Clear",
       "layout": "IPY_MODEL_17a751b484d54ffca4ca6c816e8c83c4",
       "style": "IPY_MODEL_7c92e8cb077d4e8ba548bb7fbb6fb9be",
       "tooltip": null
      }
     },
     "46dceba4b5ea4d6194206b2ed8f2ea46": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_5da96b077bbc4f64a395464db2efddc0",
       "style": "IPY_MODEL_def28c338d264378b0117ea30102e49d",
       "value": "<h5>Backend</h5>"
      }
     },
     "5d7d26b8f35f4ad8853e0f4698bd850b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "GridBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_36e1d4aeb2a7484eb2f6dcade5c17c81"
       ],
       "layout": "IPY_MODEL_7d1181e9509d4b92a33edea10a0fac42"
      }
     },
     "5da96b077bbc4f64a395464db2efddc0": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "width": "145px"
      }
     },
     "5f6a63d200e04ad88c2bfb224cc9bda0": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_a90695e6b6e245daa79843dd3aa24aae",
       "style": "IPY_MODEL_f5467842cb8e4a09bca83b20e2169b9e",
       "value": "<h5>Queue</h5>"
      }
     },
     "6d214d874a63453d99b9711103d8c694": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_22c6d0e747e34bf2a74059d01c22ed51",
       "style": "IPY_MODEL_fef8418404c0422a8d2b4ad04643f792",
       "value": "<h5>Job ID</h5>"
      }
     },
     "7c92e8cb077d4e8ba548bb7fbb6fb9be": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "ButtonStyleModel",
      "state": {
       "font_family": null,
       "font_size": null,
       "font_style": null,
       "font_variant": null,
       "font_weight": null,
       "text_color": null,
       "text_decoration": null
      }
     },
     "7d1181e9509d4b92a33edea10a0fac42": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "grid_template_areas": "\n                                       \". . . . right \"\n                                        ",
       "grid_template_columns": "20% 20% 20% 20% 20%",
       "width": "100%"
      }
     },
     "93d30752b6bc45779aaf0aa9370a0c2d": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "width": "95px"
      }
     },
     "9af6388b0ae441718aff92166f03c47b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "a5d36bf3432e4db7824697dfd5b18553": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "a90695e6b6e245daa79843dd3aa24aae": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "width": "70px"
      }
     },
     "bb54be70cfd649e5b29ce26dab7640b6": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_091466dd278345868b42eaf0a4bb3960",
       "style": "IPY_MODEL_fc3bb1d25af84e248ed891c1b0601442",
       "value": "<h5>Message</h5>"
      }
     },
     "d4132f3f3004418a830c04f63579f7d8": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "margin": "0px 0px 10px 0px"
      }
     },
     "def28c338d264378b0117ea30102e49d": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "eca48cd664d84495b590d960896afc08": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "2.0.0",
      "model_name": "LayoutModel",
      "state": {
       "margin": "0px 0px 0px 37px",
       "width": "600px"
      }
     },
     "ef7894df9ad14ace9087650dd2bff73c": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_6d214d874a63453d99b9711103d8c694",
        "IPY_MODEL_46dceba4b5ea4d6194206b2ed8f2ea46",
        "IPY_MODEL_2cd39d282cc14ee99c76b90b6660794b",
        "IPY_MODEL_5f6a63d200e04ad88c2bfb224cc9bda0",
        "IPY_MODEL_bb54be70cfd649e5b29ce26dab7640b6"
       ],
       "layout": "IPY_MODEL_eca48cd664d84495b590d960896afc08"
      }
     },
     "f5467842cb8e4a09bca83b20e2169b9e": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "fc3bb1d25af84e248ed891c1b0601442": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     },
     "fef8418404c0422a8d2b4ad04643f792": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "2.0.0",
      "model_name": "HTMLStyleModel",
      "state": {
       "description_width": "",
       "font_size": null,
       "text_color": null
      }
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}