examples/getting_started/2_Running_quantum_circuits_on_QPU_devices/2_Running_quantum_circuits_on_QPU_devices.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running quantum circuits on QPU devices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use Braket SDK Cost Tracking to estimate the cost to run this example\n",
    "from braket.tracking import Tracker\n",
    "t = Tracker().start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial we show how to run circuits on QPU devices. We can run our circuit on both the superconducting machine from Rigetti and the ion-trap machine provided by IonQ. As shown below, one can seamlessly swap between different devices without any modifications to the circuit definition, by just re-defining the device object. We also show how to recover results using the unique ARN associated with every quantum task. This tool is useful in order to deal with potential delays if your quantum task sits in the queue for some time waiting for execution. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# general imports\n",
    "import matplotlib.pyplot as plt\n",
    "# magic word for producing visualizations in notebook\n",
    "%matplotlib inline\n",
    "import string\n",
    "import time\n",
    "\n",
    "# AWS imports: Import Braket SDK modules\n",
    "from braket.aws import AwsDevice, AwsQuantumTask\n",
    "from braket.circuits import Circuit, Gate, observables\n",
    "from braket.device_schema import DeviceActionType\n",
    "from braket.devices import Devices, LocalSimulator\n",
    "from braket.parametric import FreeParameter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Supported gate sets by different devices\n",
    "\n",
    "First, let us check out the gate set currently supported by our SDK. As with on-demand simulators, you can instantiate a QPU by passing its ARN into `AwsDevice`. Note that the QPU devices only support a subset of these gates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gate set supported by SDK:\n",
      " ['CCNot', 'CNot', 'CPhaseShift', 'CPhaseShift00', 'CPhaseShift01', 'CPhaseShift10', 'CSwap', 'CV', 'CY', 'CZ', 'ECR', 'GPhase', 'GPi', 'GPi2', 'H', 'I', 'ISwap', 'MS', 'PRx', 'PSwap', 'PhaseShift', 'PulseGate', 'Rx', 'Ry', 'Rz', 'S', 'Si', 'Swap', 'T', 'Ti', 'U', 'Unitary', 'V', 'Vi', 'X', 'XX', 'XY', 'Y', 'YY', 'Z', 'ZZ']\n",
      "\n",
      "\n",
      "Gate set supported by the Rigetti device:\n",
      " ['cz', 'xy', 'ccnot', 'cnot', 'cphaseshift', 'cphaseshift00', 'cphaseshift01', 'cphaseshift10', 'cswap', 'h', 'i', 'iswap', 'phaseshift', 'pswap', 'rx', 'ry', 'rz', 's', 'si', 'swap', 't', 'ti', 'x', 'y', 'z']\n",
      "\n",
      "\n",
      "Gate set supported by the IonQ device:\n",
      " ['x', 'y', 'z', 'rx', 'ry', 'rz', 'h', 'cnot', 's', 'si', 't', 'ti', 'v', 'vi', 'xx', 'yy', 'zz', 'swap']\n",
      "\n",
      "\n",
      "Gate set supported by the OQC device:\n",
      " ['ccnot', 'cnot', 'cphaseshift', 'cswap', 'cy', 'cz', 'h', 'i', 'phaseshift', 'rx', 'ry', 'rz', 's', 'si', 'swap', 't', 'ti', 'v', 'vi', 'x', 'y', 'z', 'ecr']\n",
      "\n",
      "\n",
      "Gate set supported by the IQM Garnet device:\n",
      " ['ccnot', 'cnot', 'cphaseshift', 'cphaseshift00', 'cphaseshift01', 'cphaseshift10', 'cswap', 'swap', 'iswap', 'pswap', 'ecr', 'cy', 'cz', 'xy', 'xx', 'yy', 'zz', 'h', 'i', 'phaseshift', 'rx', 'ry', 'rz', 's', 'si', 't', 'ti', 'v', 'vi', 'x', 'y', 'z', 'start_verbatim_box', 'end_verbatim_box']\n"
     ]
    }
   ],
   "source": [
    "# print all (the usual suspects) available gates currently available within SDK\n",
    "gate_set = [attr for attr in dir(Gate) if attr[0] in string.ascii_uppercase]\n",
    "print('Gate set supported by SDK:\\n', gate_set)\n",
    "print('\\n') \n",
    "\n",
    "# the Rigetti device\n",
    "rigetti = AwsDevice(Devices.Rigetti.AspenM3)\n",
    "supported_gates = rigetti.properties.action[DeviceActionType.OPENQASM].supportedOperations\n",
    "# print the supported gate set\n",
    "print('Gate set supported by the Rigetti device:\\n', supported_gates)\n",
    "print('\\n') \n",
    "\n",
    "# the IonQ device\n",
    "ionq = AwsDevice(Devices.IonQ.Harmony)\n",
    "supported_gates = ionq.properties.action[DeviceActionType.OPENQASM].supportedOperations\n",
    "# print the supported gate set\n",
    "print('Gate set supported by the IonQ device:\\n', supported_gates)\n",
    "print('\\n')\n",
    "\n",
    "# the Oxford Quantum Circuits (OQC) device\n",
    "oqc = AwsDevice(Devices.OQC.Lucy)\n",
    "supported_gates = oqc.properties.action[DeviceActionType.OPENQASM].supportedOperations\n",
    "# print the supported gate set\n",
    "print('Gate set supported by the OQC device:\\n', supported_gates)\n",
    "print('\\n')\n",
    "\n",
    "# the IQM Garnet device\n",
    "iqm = AwsDevice(Devices.IQM.Garnet)\n",
    "supported_gates = iqm.properties.action[DeviceActionType.OPENQASM].supportedOperations\n",
    "# print the supported gate set\n",
    "print('Gate set supported by the IQM Garnet device:\\n', supported_gates)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Problem: Prepare Bell State"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Goal: Prepare maximally entangled Bell state: \n",
    "$$\\left|0,0\\right> \\rightarrow \\left|\\mathrm{Bell}\\right> = \\frac{1}{\\sqrt{2}}\\left(\\left|0,0\\right> + \\left|1,1\\right>\\right).$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To this end, we build and run the following circuit using a single-qubit Hadamard gate (denoted as ```H```) acting on the first qubit followed by a two-qubit ```CNOT``` gate: \n",
    "<div align=\"center\">\n",
    "<img src=\"bell_circuit.png\" width=\"500\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setup Circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# define circuit\n",
    "bell = Circuit().h(0).cnot(0, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │  0  │  1  │\n",
      "      ┌───┐       \n",
      "q0 : ─┤ H ├───●───\n",
      "      └───┘   │   \n",
      "            ┌─┴─┐ \n",
      "q1 : ───────┤ X ├─\n",
      "            └───┘ \n",
      "T  : │  0  │  1  │\n"
     ]
    }
   ],
   "source": [
    "# print circuit\n",
    "print(bell)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Local Simulator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we run our circuit locally, using an exact state-vector simulator. This local simulator is the preferred choice for fast experiments with low to intermediate qubit numbers ($N<20-25$) and essentially unlimited circuit depth. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# set up device: Local Simulator\n",
    "device = LocalSimulator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({'00': 504, '11': 496})\n"
     ]
    }
   ],
   "source": [
    "# run circuit (execute single TASK)\n",
    "result = device.run(bell, shots=1000).result()\n",
    "# get measurement shots\n",
    "counts = result.measurement_counts\n",
    "# print counts\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'counts')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot using Counter\n",
    "plt.bar(counts.keys(), counts.values())\n",
    "plt.xlabel('bitstrings')\n",
    "plt.ylabel('counts')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Quantum Hardware: Rigetti"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we submit our circuit to the superconducting quantum chip provided by Rigetti. Depending on our position in the queue, we may have to wait for some time till our circuit is actually run. However, thanks to asynchronous execution, we can always come back and recover the results by providing the unique ID associated with every quantum task. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To exectue your quantum task on a device, your task needs to wait for the device to complete running or already queued quantum tasks. Before submitting a quantum task on a device, you can check the queue depth for the quantum tasks. To check the number of hybrid jobs queued on the device call `device.queue_depth().quantum_tasks`. Here, Priority quantum tasks refer to the tasks submitted as part of a Hybrid Job. These quantum tasks has priority over the Normal quantum tasks. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{<QueueType.NORMAL: 'Normal'>: '7', <QueueType.PRIORITY: 'Priority'>: '0'}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check for the queue_depth for quantum tasks on the selected device\n",
    "rigetti.queue_depth().quantum_tasks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of task: QUEUED\n"
     ]
    }
   ],
   "source": [
    "# create a clean circuit with no result type attached.(This is because some result types are only supported when shots=0)\n",
    "bell = Circuit().h(0).cnot(0, 1)  \n",
    "\n",
    "# add the Z \\otimes Z expectation value\n",
    "bell.expectation(observables.Z() @ observables.Z(), target=[0,1])\n",
    "\n",
    "# run circuit \n",
    "rigetti_task = rigetti.run(bell, shots=1000)\n",
    "\n",
    "# get id and status of submitted task\n",
    "rigetti_task_id = rigetti_task.id\n",
    "rigetti_status = rigetti_task.state()\n",
    "# print('ID of task:', rigetti_task_id)\n",
    "print('Status of quantum task:', rigetti_status)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check the position of your quantum task in the queue by calling `task.queue_position().queue_position`. The queue position is only returned when the task is in \"QUEUED\" state, else None is returned. You can also check why the queue position value is not returned by calling calling `task.queue_position().message`. Here, `task` is the variable to which you assign your quantum_task creation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'8'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's check the queue position for task created with the rigetti device\n",
    "rigetti_task.queue_position().queue_position"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "The quantum task is submitted and we can regularly (or irregularly) check the status of this quantum task by executing the following cell. You may easily build logic around this query to wait for this quantum task to complete before your code proceeds. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of (reconstructed) task: COMPLETED\n"
     ]
    }
   ],
   "source": [
    "# print status\n",
    "status = rigetti_task.state()\n",
    "print('Status of (reconstructed) quantum task:', status)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Quantum Hardware: IonQ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we submit our example Bell state circuit to IonQ. We set the device as AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/ionq/Harmony\"). This quantum task may not readily be executed but enter a queue for this specific machine. While we can interrupt our kernel (and work on something else), we can always recover our results using the unique ID of this quantum task."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before submitting our quantum task, let's check the queue depth on the device for quantum tasks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{<QueueType.NORMAL: 'Normal'>: '3', <QueueType.PRIORITY: 'Priority'>: '0'}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ionq.queue_depth().quantum_tasks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of task: QUEUED\n"
     ]
    }
   ],
   "source": [
    "# run circuit\n",
    "ionq_task = ionq.run(bell, shots=1000)\n",
    "\n",
    "# get id and status of submitted quantum task\n",
    "ionq_task_id = ionq_task.id\n",
    "ionq_status = ionq_task.state()\n",
    "# print('ID of quantum task:', ionq_task_id)\n",
    "print('Status of quantum task:', ionq_status)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check the queue position for the submitted quantum task on the device."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check the queue position\n",
    "ionq_task.queue_position().queue_position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of (reconstructed) task: COMPLETED\n"
     ]
    }
   ],
   "source": [
    "# print status\n",
    "status = ionq_task.state()\n",
    "print('Status of (reconstructed) quantum task:', status)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quantum Hardware: Oxford Quantum Circuits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We submit our circuit to the superconducting quantum computer provided by Oxford Quantum Circuits (OQC). The quantum task runs asynchronously. We can retrieve the result when the quantum task is completed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of task: COMPLETED\n"
     ]
    }
   ],
   "source": [
    "# run circuit\n",
    "oqc_task = oqc.run(bell, shots=1000)\n",
    "\n",
    "# get id and status of submitted quantum task\n",
    "oqc_task_id = oqc_task.id\n",
    "oqc_status = oqc_task.state()\n",
    "# print('ID of quantum task:', oqc_task_id)\n",
    "print('Status of quantum task:', oqc_status)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum Hardware: IQM\n",
    "Finally, the Bell circuit is submitted to the IQM Garnet device."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of quantum task: QUEUED\n"
     ]
    }
   ],
   "source": [
    "# run circuit\n",
    "iqm_task = iqm.run(bell, shots=1000)\n",
    "\n",
    "# get id and status of submitted quantum task\n",
    "iqm_task_id = iqm_task.id\n",
    "iqm_status = iqm_task.state()\n",
    "# print('ID of quantum task:', iqm_task_id)\n",
    "print('Status of quantum task:', iqm_status)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to the state of the task, you can monitor the progress by the queue position of the task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check the queue position\n",
    "iqm_task.queue_position().queue_position"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parametric compilation\n",
    "When submitting a parametric circuit to a supported QPU, Braket will compile the circuit once and cached the compiled circuit. For the subsequent parameter updates to the same circuit, there is no recompilation which results in faster runtimes. The cached compiled circuits persist until the end of the availability window of the QPU. To learn more about submitting a parametrized task, see the [Amazon Braket developer guide](https://docs.aws.amazon.com/braket/latest/developerguide/braket-submit-tasks-to-braket.html#braket-submit-parametrized-task)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of task: CREATED\n"
     ]
    }
   ],
   "source": [
    "theta = FreeParameter(\"theta\")\n",
    "parametrized_circuit = Circuit().rx(0, theta)\n",
    "\n",
    "angle_value = 0.789\n",
    "pc_task = rigetti.run(parametrized_circuit, shots=100, inputs={\"theta\": angle_value})\n",
    "\n",
    "# get status of submitted quantum task\n",
    "print('Status of quantum task:', pc_task.state())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Quantum Task Recovery"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By simply grabbing the unique quantum task ID associated with the quantum tasks we have submitted above, we can recover this quantum task at any point in time and (once the status is completed) visualize and analyze the corresponding results. Note that apart from other metadata, you can retrieve the compiled circuit that was actually run on the Rigetti device. More information about the compiling process can be found [here](https://pyquil-docs.rigetti.com/en/v2.22.0/compiler.html#partial). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of (reconstructed) task: COMPLETED\n",
      "\n",
      "\n",
      "1000 shots taken on machine arn:aws:braket:us-west-1::device/qpu/rigetti/Aspen-M-3.\n",
      "\n",
      "The compiled circuit is:\n",
      " DECLARE ro BIT[2]\n",
      "PRAGMA INITIAL_REWIRING \"PARTIAL\"\n",
      "RESET\n",
      "RZ(pi) 12\n",
      "RZ(-pi/2) 13\n",
      "RX(-pi/2) 13\n",
      "XY(pi) 13 12\n",
      "RZ(pi/2) 13\n",
      "RX(pi/2) 13\n",
      "RZ(-pi/2) 13\n",
      "XY(pi) 13 12\n",
      "RX(-pi/2) 12\n",
      "MEASURE 12 ro[1]\n",
      "MEASURE 13 ro[0]\n",
      "\n",
      "Measurement counts: Counter({'11': 458, '00': 421, '10': 81, '01': 40})\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# recover quantum task\n",
    "task_load = AwsQuantumTask(arn=rigetti_task_id)\n",
    "\n",
    "# print status\n",
    "status = task_load.state()\n",
    "print('Status of (reconstructed) quantum task:', status)\n",
    "print('\\n')\n",
    "# wait for job to complete\n",
    "# terminal_states = ['COMPLETED', 'FAILED', 'CANCELLED']\n",
    "if status == 'COMPLETED':\n",
    "    # get results\n",
    "    rigetti_results = task_load.result()\n",
    "    # print(rigetti_results)\n",
    "    \n",
    "    # get all metadata of submitted quantum task\n",
    "    metadata = task_load.metadata()\n",
    "    # example for metadata\n",
    "    shots = metadata['shots']\n",
    "    machine = metadata['deviceArn']\n",
    "    # print example metadata\n",
    "    print(\"{} shots taken on machine {}.\\n\".format(shots, machine))\n",
    "    \n",
    "    # get the compiled circuit\n",
    "    print(\"The compiled circuit is:\\n\", rigetti_results.additional_metadata.rigettiMetadata.compiledProgram)\n",
    "    \n",
    "    # get measurement counts\n",
    "    rigetti_counts = rigetti_results.measurement_counts\n",
    "    print('Measurement counts:', rigetti_counts)\n",
    "\n",
    "    # plot results: see effects of noise\n",
    "    plt.bar(rigetti_counts.keys(), rigetti_counts.values())\n",
    "    plt.xlabel('bitstrings')\n",
    "    plt.ylabel('counts')\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('rigetti.png', dpi=700)\n",
    "    \n",
    "elif status in ['FAILED', 'CANCELLED']:\n",
    "    # print terminal message \n",
    "    print('Your quantum task is in terminal status, but has not completed.')\n",
    "\n",
    "else:\n",
    "    # print current status\n",
    "    print('Sorry, your quantum task is still being processed and has not been finalized yet.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of (reconstructed) task: COMPLETED\n",
      "1000 shots taken on machine arn:aws:braket:us-east-1::device/qpu/ionq/Harmony.\n",
      "Measurement counts: Counter({'11': 501, '00': 456, '01': 25, '10': 18})\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# recover quantum task\n",
    "task_load = AwsQuantumTask(arn=ionq_task_id)\n",
    "\n",
    "# print status\n",
    "status = task_load.state()\n",
    "print('Status of (reconstructed) quantum task:', status)\n",
    "\n",
    "# wait for job to complete\n",
    "# terminal_states = ['COMPLETED', 'FAILED', 'CANCELLED']\n",
    "if status == 'COMPLETED':\n",
    "    # get results\n",
    "    results = task_load.result()\n",
    "    # print(rigetti_results)\n",
    "    \n",
    "    # get all metadata of submitted quantum task\n",
    "    metadata = task_load.metadata()\n",
    "    # example for metadata\n",
    "    shots = metadata['shots']\n",
    "    machine = metadata['deviceArn']\n",
    "    # print example metadata\n",
    "    print(\"{} shots taken on machine {}.\".format(shots, machine))\n",
    "    \n",
    "    # get measurement counts\n",
    "    counts = results.measurement_counts\n",
    "    print('Measurement counts:', counts)\n",
    "\n",
    "    # plot results: see effects of noise\n",
    "    plt.bar(counts.keys(), counts.values())\n",
    "    plt.xlabel('bitstrings')\n",
    "    plt.ylabel('counts')\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('bell_ionq.png', dpi=700)\n",
    "    \n",
    "elif status in ['FAILED', 'CANCELLED']:\n",
    "    # print terminal message \n",
    "    print('Your quantum task is in terminal status, but has not completed.')\n",
    "\n",
    "else:\n",
    "    # print current status\n",
    "    print('Sorry, your quantum task is still being processed and has not been finalized yet.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "We have successfully recovered the results associated with the quantum tasks that were queued up for the quantum hardware providers. Because of noise (decoherence) and other imperfections we cannot fully recover the exact results we have seen when using the classical simulator. To deal with that, in the fullness of time we will be able to use error correction techniques. As long as error correction is not available, it is important to benchmark our quantum results using classical simulators, whenever possible. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# APPENDIX"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# set up device\n",
    "rigetti = AwsDevice(Devices.Rigetti.AspenM3)\n",
    "\n",
    "# run circuit\n",
    "task = rigetti.run(bell, shots=1000)\n",
    "print('Information on quantum task:\\n', task)\n",
    "print('==================================' * 2)\n",
    "\n",
    "# get status of submitted quantum task\n",
    "status = task.state()\n",
    "\n",
    "# wait for job to complete\n",
    "terminal_states = ['COMPLETED', 'FAILED', 'CANCELLED']\n",
    "while status not in terminal_states:\n",
    "    status = task.state()\n",
    "    print('Status:', status)\n",
    "    # time.sleep(60)\n",
    "\n",
    "print('Status:', status)\n",
    "\n",
    "# get results\n",
    "rigetti_results = task.result()\n",
    "print(rigetti_results)\n",
    "\n",
    "# get measurement counts\n",
    "rigetti_counts = rigetti_results.measurement_counts\n",
    "print(rigetti_counts)\n",
    "\n",
    "# plot results: see effects of noise\n",
    "plt.bar(rigetti_counts.keys(), rigetti_counts.values())\n",
    "plt.xlabel('bitstrings')\n",
    "plt.ylabel('counts')\n",
    "plt.tight_layout()\n",
    "plt.savefig('rigetti2.png', dpi=700)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Task Summary\n",
      "{'arn:aws:braket:us-west-1::device/qpu/rigetti/Aspen-M-3': {'shots': 2000, 'tasks': {'COMPLETED': 2}}, 'arn:aws:braket:us-east-1::device/qpu/ionq/Harmony': {'shots': 1000, 'tasks': {'QUEUED': 1}}, 'arn:aws:braket:eu-west-2::device/qpu/oqc/Lucy': {'shots': 1000, 'tasks': {'CREATED': 1}}}\n",
      "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n",
      "Estimated cost to run this example: 12.25 USD\n"
     ]
    }
   ],
   "source": [
    "print(\"Quantum Task Summary\")\n",
    "print(t.quantum_tasks_statistics())\n",
    "print('Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).')\n",
    "print(f\"Estimated cost to run this example: {t.qpu_tasks_cost() + t.simulator_tasks_cost():.2f} USD\")"
   ]
  }
 ],
 "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.9"
  },
  "vscode": {
   "interpreter": {
    "hash": "590fab68195cf107911461461f81d5c472d3d6127f579badfcfad30f03e5cab2"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}