examples/getting_started/3_Deep_dive_into_the_anatomy_of_quantum_circuits/3_Deep_dive_into_the_anatomy_of_quantum_circuits.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Anatomy of Quantum Circuits and Quantum Tasks in Amazon Braket"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:11.143425Z",
     "start_time": "2023-08-29T21:29:09.890217Z"
    }
   },
   "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 discuss in detail the anatomy of quantum circuits in Amazon Braket's SDK. Specifically, we learn how to build (parametrized) circuits and display them graphically, how to append circuits to each other, and discuss the associated circuit depth and circuit size. Finally we show how to execute our circuit on a device of our choice (defining a quantum task). We then learn how to efficiently track, log, recover or cancel such a _quantum task_. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IMPORT STATEMENTS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we import some modules we will need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.395144Z",
     "start_time": "2023-08-29T21:29:09.942484Z"
    }
   },
   "outputs": [],
   "source": [
    "# general imports\n",
    "import asyncio\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "# magic word for producing visualizations in notebook\n",
    "%matplotlib inline\n",
    "import string\n",
    "from datetime import datetime\n",
    "import logging\n",
    "\n",
    "# AWS imports: Import Braket SDK modules\n",
    "from braket.aws import AwsDevice, AwsQuantumTask\n",
    "from braket.circuits import Circuit, Gate, circuit, observables\n",
    "from braket.devices import Devices, LocalSimulator\n",
    "from braket.parametric import FreeParameter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CIRCUIT DEFINITION"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us get started a sample circuit for four qubits (labelled q0, q1, q2 and q3) consisting of standard single-qubit ```Hadamard``` gates and two-qubit ```CNOT``` gates; for a full list of available gates see below. We can then visualize our circuit by simply calling the ```print``` function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.403030Z",
     "start_time": "2023-08-29T21:29:12.399074Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │  0  │     1     │\n",
      "      ┌───┐             \n",
      "q0 : ─┤ H ├───●─────────\n",
      "      └───┘   │         \n",
      "      ┌───┐   │         \n",
      "q1 : ─┤ H ├───┼─────●───\n",
      "      └───┘   │     │   \n",
      "      ┌───┐ ┌─┴─┐   │   \n",
      "q2 : ─┤ H ├─┤ X ├───┼───\n",
      "      └───┘ └───┘   │   \n",
      "      ┌───┐       ┌─┴─┐ \n",
      "q3 : ─┤ H ├───────┤ X ├─\n",
      "      └───┘       └───┘ \n",
      "T  : │  0  │     1     │\n"
     ]
    }
   ],
   "source": [
    "# define circuit with 4 qubits\n",
    "my_circuit = Circuit().h(range(4)).cnot(control=0, target=2).cnot(control=1, target=3)\n",
    "print(my_circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, time is sliced up into moments. The circuit above consists of just two moments. First, we apply a ```Hadamard``` gate to every qubit in moment 0 and then we apply two ```CNOT``` gates. Since the latter can be run in parallel as they involve different sets of qubits, they only use up one moment of time. For better readability they are displayed next to each other with some small offset. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.407922Z",
     "start_time": "2023-08-29T21:29:12.404189Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MomentsKey(time=0, qubits=QubitSet([Qubit(0)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0, subindex=0)\n",
      "MomentsKey(time=0, qubits=QubitSet([Qubit(1)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0, subindex=0)\n",
      "MomentsKey(time=0, qubits=QubitSet([Qubit(2)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0, subindex=0)\n",
      "MomentsKey(time=0, qubits=QubitSet([Qubit(3)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0, subindex=0)\n",
      "MomentsKey(time=1, qubits=QubitSet([Qubit(0), Qubit(2)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0, subindex=0)\n",
      "MomentsKey(time=1, qubits=QubitSet([Qubit(1), Qubit(3)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0, subindex=0)\n"
     ]
    }
   ],
   "source": [
    "# show moments of our quantum circuit\n",
    "my_moments = my_circuit.moments\n",
    "for moment in my_moments:\n",
    "    print(moment)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.432975Z",
     "start_time": "2023-08-29T21:29:12.410615Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Instruction('operator': H('qubit_count': 1), 'target': QubitSet([Qubit(0)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)\n",
      "Instruction('operator': H('qubit_count': 1), 'target': QubitSet([Qubit(1)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)\n",
      "Instruction('operator': H('qubit_count': 1), 'target': QubitSet([Qubit(2)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)\n",
      "Instruction('operator': H('qubit_count': 1), 'target': QubitSet([Qubit(3)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)\n",
      "Instruction('operator': CNot('qubit_count': 2), 'target': QubitSet([Qubit(0), Qubit(2)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)\n",
      "Instruction('operator': CNot('qubit_count': 2), 'target': QubitSet([Qubit(1), Qubit(3)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)\n"
     ]
    }
   ],
   "source": [
    "# list all instructions/gates making up our circuit\n",
    "my_instructions = my_circuit.instructions\n",
    "for instruction in my_instructions:\n",
    "    print(instruction)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let us build a parametrized circuit where we have to supply numerical parameter values to fully define the circuit, as is the case for example for single-qubit rotations (as described [here](https://github.com/amazon-braket/amazon-braket-sdk-python/blob/main/src/braket/circuits/gates.py#L578)) and the two-qubit ```cnot``` as described in the source code [here](https://github.com/amazon-braket/amazon-braket-sdk-python/blob/main/src/braket/circuits/gates.py#L701). The specific parameter values are shown in circuit diagram. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.453818Z",
     "start_time": "2023-08-29T21:29:12.419431Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │     0      │     1     │  2  │\n",
      "      ┌──────────┐                   \n",
      "q0 : ─┤ Rx(0.15) ├───●───────────────\n",
      "      └──────────┘   │               \n",
      "      ┌──────────┐   │         ┌───┐ \n",
      "q1 : ─┤ Ry(0.20) ├───┼─────●───┤ X ├─\n",
      "      └──────────┘   │     │   └───┘ \n",
      "      ┌──────────┐ ┌─┴─┐   │         \n",
      "q2 : ─┤ Rz(0.25) ├─┤ X ├───┼─────────\n",
      "      └──────────┘ └───┘   │         \n",
      "         ┌───┐           ┌─┴─┐ ┌───┐ \n",
      "q3 : ────┤ H ├───────────┤ X ├─┤ X ├─\n",
      "         └───┘           └───┘ └───┘ \n",
      "T  : │     0      │     1     │  2  │\n"
     ]
    }
   ],
   "source": [
    "# define circuit with some parametrized gates \n",
    "my_circuit = Circuit().rx(0, 0.15).ry(1, 0.2).rz(2, 0.25).h(3).cnot(control=0, target=2).cnot(1, 3).x([1,3])\n",
    "print(my_circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also create a `Circuit` with gates which depend on a `FreeParameter`, the value of which can be set later, either by fixing it in the circuit itself, or when the circuit is run on a device."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.454305Z",
     "start_time": "2023-08-29T21:29:12.425947Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │      0      │     1     │  2  │\n",
      "      ┌───────────┐                   \n",
      "q0 : ─┤ Rx(alpha) ├───●───────────────\n",
      "      └───────────┘   │               \n",
      "      ┌──────────┐    │         ┌───┐ \n",
      "q1 : ─┤ Ry(beta) ├────┼─────●───┤ X ├─\n",
      "      └──────────┘    │     │   └───┘ \n",
      "      ┌───────────┐ ┌─┴─┐   │         \n",
      "q2 : ─┤ Rz(gamma) ├─┤ X ├───┼─────────\n",
      "      └───────────┘ └───┘   │         \n",
      "          ┌───┐           ┌─┴─┐ ┌───┐ \n",
      "q3 : ─────┤ H ├───────────┤ X ├─┤ X ├─\n",
      "          └───┘           └───┘ └───┘ \n",
      "T  : │      0      │     1     │  2  │\n",
      "\n",
      "Unassigned parameters: [alpha, beta, gamma].\n"
     ]
    }
   ],
   "source": [
    "# define circuit with some parametrized gates and free parameters\n",
    "alpha = FreeParameter('alpha')\n",
    "beta  = FreeParameter('beta')\n",
    "gamma = FreeParameter('gamma')\n",
    "my_circuit = Circuit().rx(0, alpha).ry(1, beta).rz(2, gamma).h(3).cnot(control=0, target=2).cnot(1, 3).x([1,3])\n",
    "print(my_circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__GATE SET__: Below we list all gates currently available in our SDK. Moreover, we can build custom gates as shown below for a general single-qubit rotation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.457289Z",
     "start_time": "2023-08-29T21:29:12.431752Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['CCNot', 'CNot', 'CPhaseShift', 'CPhaseShift00', 'CPhaseShift01', 'CPhaseShift10', 'CSwap', 'CV', 'CY', 'CZ', 'ECR', 'GPhase', 'GPi', 'GPi2', 'H', 'I', 'ISwap', 'MS', 'PSwap', 'PhaseShift', 'PulseGate', 'Rx', 'Ry', 'Rz', 'S', 'Si', 'Swap', 'T', 'Ti', 'U', 'Unitary', 'V', 'Vi', 'X', 'XX', 'XY', 'Y', 'YY', 'Z', 'ZZ']\n"
     ]
    }
   ],
   "source": [
    "# print all 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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.457608Z",
     "start_time": "2023-08-29T21:29:12.436051Z"
    }
   },
   "outputs": [],
   "source": [
    "# helper function to build custom gate \n",
    "def u3(alpha, theta, phi):\n",
    "    \"\"\"\n",
    "    function to return matrix for general single qubit rotation\n",
    "    rotation is given by exp(-i sigma*n/2*alpha) where alpha is rotation angle\n",
    "    and n defines rotation axis as n=(sin(theta)cos(phi), sin(theta)sin(phi), cos(theta))\n",
    "    sigma is vector of Pauli matrices\n",
    "    \"\"\"\n",
    "    u11 = np.cos(alpha/2)-1j*np.sin(alpha/2)*np.cos(theta)\n",
    "    u12 = -1j*(np.exp(-1j*phi))*np.sin(theta)*np.sin(alpha/2)\n",
    "    u21 = -1j*(np.exp(1j*phi))*np.sin(theta)*np.sin(alpha/2)\n",
    "    u22 = np.cos(alpha/2)+1j*np.sin(alpha/2)*np.cos(theta)\n",
    "    \n",
    "    return np.array([[u11, u12], [u21, u22]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.457916Z",
     "start_time": "2023-08-29T21:29:12.444295Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │  0  │  1  │\n",
      "      ┌───┐       \n",
      "q0 : ─┤ U ├───●───\n",
      "      └───┘   │   \n",
      "      ┌───┐ ┌─┴─┐ \n",
      "q1 : ─┤ H ├─┤ X ├─\n",
      "      └───┘ └───┘ \n",
      "T  : │  0  │  1  │\n"
     ]
    }
   ],
   "source": [
    "# define and print custom unitary\n",
    "my_u3 = u3(np.pi/2, 0, 0)\n",
    "# print(my_u3)\n",
    "# define example circuit applying custom U to the first qubit\n",
    "circ = Circuit().unitary(matrix=my_u3, targets=[0]).h(1).cnot(control=0, target=1)\n",
    "print(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, in the circuit diagram our custom unitary is depicted with the general symbol ```U```. \n",
    "In addition, we can use Braket's `circuit.subroutine` functionality, which allows us to use custom-built gates as any other built-in gates.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.469998Z",
     "start_time": "2023-08-29T21:29:12.454210Z"
    }
   },
   "outputs": [],
   "source": [
    "# helper function to build custom gate\n",
    "@circuit.subroutine(register=True)\n",
    "def u3(target, angles):\n",
    "    \"\"\"\n",
    "    Function to return the matrix for a general single qubit rotation,\n",
    "    given by exp(-i sigma*n/2*alpha), where alpha is the rotation angle,\n",
    "    n defines the rotation axis via n=(sin(theta)cos(phi), sin(theta)sin(phi), cos(theta)),\n",
    "    and sigma is the vector of Pauli matrices\n",
    "    \"\"\"\n",
    "    \n",
    "    # get angles\n",
    "    alpha = angles[0]\n",
    "    theta = angles[1]\n",
    "    phi = angles[2]\n",
    "    \n",
    "    # set 2x2 matrix entries\n",
    "    u11 = np.cos(alpha/2)-1j*np.sin(alpha/2)*np.cos(theta)\n",
    "    u12 = -1j*(np.exp(-1j*phi))*np.sin(theta)*np.sin(alpha/2)\n",
    "    u21 = -1j*(np.exp(1j*phi))*np.sin(theta)*np.sin(alpha/2)\n",
    "    u22 = np.cos(alpha/2)+1j*np.sin(alpha/2)*np.cos(theta)\n",
    "    \n",
    "    # define unitary as numpy matrix\n",
    "    u = np.array([[u11, u12], [u21, u22]])\n",
    "    # print('Unitary:', u)\n",
    "    \n",
    "    # define custom Braket gate\n",
    "    circ = Circuit()\n",
    "    circ.unitary(matrix=u, targets=target)\n",
    "    \n",
    "    return circ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.476356Z",
     "start_time": "2023-08-29T21:29:12.460167Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │  0  │  1  │\n",
      "      ┌───┐       \n",
      "q0 : ─┤ U ├───●───\n",
      "      └───┘   │   \n",
      "            ┌─┴─┐ \n",
      "q1 : ───────┤ X ├─\n",
      "            └───┘ \n",
      "T  : │  0  │  1  │\n"
     ]
    }
   ],
   "source": [
    "# define example circuit applying custom single-qubit gate U to the first qubit\n",
    "angles = [np.pi/2, np.pi/2, np.pi/2]\n",
    "angles = [np.pi/4, 0, 0]\n",
    "\n",
    "# build circuit using custom u3 gate\n",
    "circ2 = Circuit().u3([0], angles).cnot(control=0, target=1)\n",
    "print(circ2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CIRCUIT DEPTH AND CIRCUIT SIZE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get the circuit depth (the number of moments defining our circuit) with ```circuit.depth``` as shown below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.476595Z",
     "start_time": "2023-08-29T21:29:12.467478Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │     0      │     1     │  2  │\n",
      "      ┌──────────┐             ┌───┐ \n",
      "q0 : ─┤ Rx(0.15) ├───●─────────┤ X ├─\n",
      "      └──────────┘   │         └───┘ \n",
      "      ┌──────────┐   │               \n",
      "q1 : ─┤ Ry(0.20) ├───┼─────●─────────\n",
      "      └──────────┘   │     │         \n",
      "      ┌──────────┐ ┌─┴─┐   │         \n",
      "q2 : ─┤ Rz(0.25) ├─┤ X ├───┼─────────\n",
      "      └──────────┘ └───┘   │         \n",
      "         ┌───┐           ┌─┴─┐       \n",
      "q3 : ────┤ H ├───────────┤ X ├───────\n",
      "         └───┘           └───┘       \n",
      "T  : │     0      │     1     │  2  │\n",
      "\n",
      "Total circuit depth: 3\n"
     ]
    }
   ],
   "source": [
    "# define circuit with parametrized gates \n",
    "my_circuit = Circuit().rx(0, 0.15).ry(1, 0.2).rz(2, 0.25).h(3).cnot(control=0, target=2).cnot(1, 3).x(0)\n",
    "circuit_depth = my_circuit.depth\n",
    "print(my_circuit)\n",
    "print()\n",
    "print('Total circuit depth:', circuit_depth)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The total circuit depth of the circuit above is three (moments 0, 1, 2). It is three because we have added a single qubit ```X``` gate applied to qubit 0 in the final layer. However, note that gates are applied as early as possible in time, provided that this is not in conflict with any other gate that has to be applied before. See below an example where we add one qubit to which we only apply one single qubit ```X``` gate. This circuit is shallower as its circuit depth is only two. The ```X``` gate is applied to qubit 4 as early as possible even though we have applied the corresponding command at the end of our circuit definition. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.534505Z",
     "start_time": "2023-08-29T21:29:12.480749Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │     0      │     1     │\n",
      "      ┌──────────┐             \n",
      "q0 : ─┤ Rx(0.15) ├───●─────────\n",
      "      └──────────┘   │         \n",
      "      ┌──────────┐   │         \n",
      "q1 : ─┤ Ry(0.20) ├───┼─────●───\n",
      "      └──────────┘   │     │   \n",
      "      ┌──────────┐ ┌─┴─┐   │   \n",
      "q2 : ─┤ Rz(0.25) ├─┤ X ├───┼───\n",
      "      └──────────┘ └───┘   │   \n",
      "         ┌───┐           ┌─┴─┐ \n",
      "q3 : ────┤ H ├───────────┤ X ├─\n",
      "         └───┘           └───┘ \n",
      "         ┌───┐                 \n",
      "q4 : ────┤ X ├─────────────────\n",
      "         └───┘                 \n",
      "T  : │     0      │     1     │\n",
      "\n",
      "Total circuit depth: 2\n",
      "Number of qubits: 5\n",
      "Circuit size: 10\n"
     ]
    }
   ],
   "source": [
    "# define circuit with parameterized gates \n",
    "my_circuit = Circuit().rx(0, 0.15).ry(1, 0.2).rz(2, 0.25).h(3).cnot(control=0, target=2).cnot(1, 3).x(4)\n",
    "# get circuit depth\n",
    "circuit_depth = my_circuit.depth\n",
    "# get qubit number\n",
    "qubit_count = my_circuit.qubit_count\n",
    "# get approx. estimate of circuit size\n",
    "circuit_size = circuit_depth*qubit_count\n",
    "# print circuit\n",
    "print(my_circuit)\n",
    "print()\n",
    "# print characteristics of our circuit\n",
    "print('Total circuit depth:', circuit_depth)\n",
    "print('Number of qubits:', qubit_count)\n",
    "print('Circuit size:', circuit_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above we have also introduced the concept of __circuit size__. Intuitively, the circuit size is a metric that reflects the complexity of our circuit. The circuit size accounts for both quantity (the number of qubits) and quality (as captured by the depth of the circuit); here we have used a very simple definition multiplying the qubit number with the circuit depth (that is the area of our diagram). In practice, in the absence of quantum error correction, on real quantum machines the depth is limited by noise so we can only faithfully run circuits whose depth is within the quality bounds of our machine. Simply speaking, this means: The larger the circuit size, the harder it is to simulate on a classical device and the more powerful the quantum machine is that is able to faithfully execute this circuit. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## APPENDING CIRCUITS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can extend existing circuits by adding instructions or just appending circuits to each other, as shown below. In the most simple and straightforward fashion we can just append gates to existing circuits (for example, ```my_circuit.y(4)```). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.534984Z",
     "start_time": "2023-08-29T21:29:12.489006Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │     0      │     1     │\n",
      "      ┌──────────┐             \n",
      "q0 : ─┤ Rx(0.15) ├───●─────────\n",
      "      └──────────┘   │         \n",
      "      ┌──────────┐   │         \n",
      "q1 : ─┤ Ry(0.20) ├───┼─────●───\n",
      "      └──────────┘   │     │   \n",
      "      ┌──────────┐ ┌─┴─┐   │   \n",
      "q2 : ─┤ Rz(0.25) ├─┤ X ├───┼───\n",
      "      └──────────┘ └───┘   │   \n",
      "         ┌───┐           ┌─┴─┐ \n",
      "q3 : ────┤ H ├───────────┤ X ├─\n",
      "         └───┘           └───┘ \n",
      "         ┌───┐     ┌───┐       \n",
      "q4 : ────┤ X ├─────┤ Y ├───────\n",
      "         └───┘     └───┘       \n",
      "T  : │     0      │     1     │\n",
      "\n",
      "Total circuit depth: 2\n",
      "Number of qubits: 5\n",
      "Circuit size: 10\n"
     ]
    }
   ],
   "source": [
    "# simple circuit extension by appending gates (here Y on qubit 4)\n",
    "my_circuit = my_circuit.y(4)\n",
    "# get circuit depth\n",
    "circuit_depth = my_circuit.depth\n",
    "# get qubit number\n",
    "qubit_count = my_circuit.qubit_count\n",
    "# get circuit size\n",
    "circuit_size = circuit_depth*qubit_count\n",
    "# print circuit\n",
    "print(my_circuit)\n",
    "print()\n",
    "print('Total circuit depth:', circuit_depth)\n",
    "print('Number of qubits:', qubit_count)\n",
    "print('Circuit size:', circuit_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, we can define a gate as an ```Instruction``` and use the ```add_instruction(...)``` method to add this gate to an existing circuit object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.538575Z",
     "start_time": "2023-08-29T21:29:12.493364Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │     0      │     1     │  2  │\n",
      "      ┌──────────┐                   \n",
      "q0 : ─┤ Rx(0.15) ├───●───────────●───\n",
      "      └──────────┘   │           │   \n",
      "      ┌──────────┐   │         ┌─┴─┐ \n",
      "q1 : ─┤ Ry(0.20) ├───┼─────●───┤ X ├─\n",
      "      └──────────┘   │     │   └───┘ \n",
      "      ┌──────────┐ ┌─┴─┐   │         \n",
      "q2 : ─┤ Rz(0.25) ├─┤ X ├───┼─────────\n",
      "      └──────────┘ └───┘   │         \n",
      "         ┌───┐           ┌─┴─┐       \n",
      "q3 : ────┤ H ├───────────┤ X ├───────\n",
      "         └───┘           └───┘       \n",
      "         ┌───┐     ┌───┐             \n",
      "q4 : ────┤ X ├─────┤ Y ├─────────────\n",
      "         └───┘     └───┘             \n",
      "T  : │     0      │     1     │  2  │\n",
      "\n",
      "Total circuit depth: 3\n",
      "Number of qubits: 5\n",
      "Circuit size: 15\n"
     ]
    }
   ],
   "source": [
    "# add instruction to circuit\n",
    "my_circuit.cnot(0, 1)\n",
    "# get circuit depth\n",
    "circuit_depth = my_circuit.depth\n",
    "# get qubit number\n",
    "qubit_count = my_circuit.qubit_count\n",
    "# get circuit size\n",
    "circuit_size = circuit_depth*qubit_count\n",
    "# print circuit\n",
    "print(my_circuit)\n",
    "print()\n",
    "print('Total circuit depth:', circuit_depth)\n",
    "print('Number of qubits:', qubit_count)\n",
    "print('Circuit size:', circuit_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can append entire circuits to each other with ```add_circuit()```. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.539103Z",
     "start_time": "2023-08-29T21:29:12.505217Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │     0      │     1     │     2      │     3      │\n",
      "      ┌──────────┐                          ┌──────────┐ \n",
      "q0 : ─┤ Rx(0.15) ├───●──────────────●───────┤ Rz(0.10) ├─\n",
      "      └──────────┘   │              │       └──────────┘ \n",
      "      ┌──────────┐   │            ┌─┴─┐     ┌──────────┐ \n",
      "q1 : ─┤ Ry(0.20) ├───┼─────●──────┤ X ├─────┤ Rz(0.20) ├─\n",
      "      └──────────┘   │     │      └───┘     └──────────┘ \n",
      "      ┌──────────┐ ┌─┴─┐   │                             \n",
      "q2 : ─┤ Rz(0.25) ├─┤ X ├───┼─────────────────────────────\n",
      "      └──────────┘ └───┘   │                             \n",
      "         ┌───┐           ┌─┴─┐ ┌──────────┐              \n",
      "q3 : ────┤ H ├───────────┤ X ├─┤ Rz(0.30) ├──────────────\n",
      "         └───┘           └───┘ └──────────┘              \n",
      "         ┌───┐     ┌───┐       ┌──────────┐              \n",
      "q4 : ────┤ X ├─────┤ Y ├───────┤ Rz(0.40) ├──────────────\n",
      "         └───┘     └───┘       └──────────┘              \n",
      "T  : │     0      │     1     │     2      │     3      │\n",
      "\n",
      "Total circuit depth: 4\n",
      "Number of qubits: 5\n",
      "Circuit size: 20\n"
     ]
    }
   ],
   "source": [
    "# append two circuits with add_circuit() functionality\n",
    "my_circuit2 = Circuit().rz(0, 0.1).rz(1, 0.2).rz(3, 0.3).rz(4, 0.4)\n",
    "my_circuit.add_circuit(my_circuit2)\n",
    "\n",
    "# get circuit depth\n",
    "circuit_depth = my_circuit.depth\n",
    "# get qubit number\n",
    "qubit_count = my_circuit.qubit_count\n",
    "# get circuit size\n",
    "circuit_size = circuit_depth*qubit_count\n",
    "# print circuit\n",
    "print(my_circuit)\n",
    "print()\n",
    "# print characteristics of our circuit\n",
    "print('Total circuit depth:', circuit_depth)\n",
    "print('Number of qubits:', qubit_count)\n",
    "print('Circuit size:', circuit_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, note that the single qubit rotations we have appended to our circuit are applied as early as possible. This helps keeping the circuit as short as possible, as required in the presence of decoherence.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CIRCUIT EXECUTION AND QUANTUM TASK TRACKING"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let us run our circuit on a device of our choice. We do so by defining a classical ```device``` object below and calling the method ```device.run(my_circuit)```. Additional _task creation_ arguments can be provided to the ```run()``` method of the device object; in particular the optional “shots” argument refers to the number of desired measurement shots (default = 1000).\n",
    "\n",
    "The command ```device.run(...)``` defines a quantum task (with a unique quantum task ID), the status of which can be queried and tracked with ```task.state()``` as shown below. Once the quantum task completes (which may take some time, specifically for the QPU devices, depending on the length of the queue), one can retrieve the results from the S3 bucket as specified below; you can check for \"Quantum Task Status” under Quantum Tasks within your Braket console. Note that ```task = device.run()``` is an _asynchronous_ operation. This means you can keep working while the system in the background polls for the results. You can always check the quantum task status with ```task.state()```. When you call ```task.result()```, this becomes a blocking call that will throw an error if within the timeout period you will not get a result. We show below how to set this timeout period. \n",
    "\n",
    "By calling ```result()``` on a quantum task, you get the quantum task result by polling Amazon Braket to see if the quantum task is completed. Once the quantum task is completed, the result is retrieved from S3 and returned as a ```QuantumTaskResult```. As opposed to ```async_result()```, this method is a blocking thread call and synchronously returns a result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.790091Z",
     "start_time": "2023-08-29T21:29:12.518729Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create the device. The experiment value must be unique among any devices in use at the time\n",
    "device = AwsDevice(Devices.Amazon.SV1)\n",
    "\n",
    "# set up the device to be the Rigetti quantum computer\n",
    "# device = AwsDevice(Devices.Rigetti.AspenM3)\n",
    "\n",
    "# set up the device to be the IonQ quantum computer\n",
    "# device = AwsDevice(Devices.IonQ.Harmony)\n",
    "\n",
    "# set up the device to be the Oxford Quantum Circuits (OQC) quantum computer\n",
    "# device = AwsDevice(Devices.OQC.Lucy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check out the set of gates this device supports as follows: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:12.796519Z",
     "start_time": "2023-08-29T21:29:12.790417Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantum Gates supported by this device:\n",
      " ['ccnot', 'cnot', 'cphaseshift', 'cphaseshift00', 'cphaseshift01', 'cphaseshift10', 'cswap', 'cy', 'cz', 'ecr', 'h', 'i', 'iswap', 'pswap', 'phaseshift', 'rx', 'ry', 'rz', 's', 'si', 'swap', 't', 'ti', 'unitary', 'v', 'vi', 'x', 'xx', 'xy', 'y', 'yy', 'z', 'zz']\n"
     ]
    }
   ],
   "source": [
    "# show the properties of the device\n",
    "device_properties = device.properties\n",
    "# show supportedQuantumOperations (supported gates for a device)\n",
    "device_operations = device_properties.dict()['action']['braket.ir.jaqcd.program']['supportedOperations']\n",
    "# Note: This field also exists for other devices like the QPUs\n",
    "print('Quantum Gates supported by this device:\\n',device_operations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__POLLING PARAMETERS__: With the ```run(...)``` method we can set two important parameters: \n",
    "* ```poll_timeout_seconds``` is the number of seconds you want to wait and poll the task before it times out; the default value is 5 days (that is $\\sim 5*60*60*24$ seconds). \n",
    "* ```poll_interval_seconds``` is the frequency how often the task is polled, e.g., how often you call the Braket API to get the status; the default value is 1 second. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:16.554625Z",
     "start_time": "2023-08-29T21:29:12.800572Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of quantum task: CREATED\n",
      "Status: CREATED\n",
      "Status: CREATED\n",
      "Status: CREATED\n",
      "Status: CREATED\n",
      "Status: CREATED\n",
      "Status: CREATED\n",
      "Status: CREATED\n",
      "Status: QUEUED\n",
      "Status: QUEUED\n",
      "Status: QUEUED\n",
      "Status: QUEUED\n",
      "Status: RUNNING\n",
      "Status: RUNNING\n",
      "Status: RUNNING\n",
      "Status: RUNNING\n",
      "Status: RUNNING\n",
      "Status: RUNNING\n",
      "Status: RUNNING\n",
      "Status: RUNNING\n",
      "Status: RUNNING\n",
      "Status: COMPLETED\n",
      "Counter({'00000': 529, '00010': 455, '01000': 5, '01010': 5, '11110': 3, '11100': 3})\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define quantum task (asynchronous)\n",
    "task = device.run(my_circuit, \n",
    "                  poll_timeout_seconds = 100, \n",
    "                  shots=1000)\n",
    "\n",
    "# get id and status of submitted quantum task\n",
    "task_id = task.id\n",
    "status = task.state()\n",
    "# print('ID of quantum task:', task_id)\n",
    "print('Status of quantum task:', status)\n",
    "\n",
    "# wait for job to complete\n",
    "while status != 'COMPLETED':\n",
    "    status = task.state()\n",
    "    print('Status:', status)\n",
    "\n",
    "# get results of quantum task\n",
    "result = task.result()\n",
    "\n",
    "# get measurement shots\n",
    "counts = result.measurement_counts\n",
    "\n",
    "# print counts\n",
    "print(counts)\n",
    "\n",
    "# plot using Counter\n",
    "plt.bar(counts.keys(), counts.values());\n",
    "plt.xlabel('bitstrings');\n",
    "plt.ylabel('counts');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The on-demand simulators SV1 and DM1 also support running parametrized tasks. The value of any free parameters can be fixed when the circuit is run using the optional `inputs` argument to `run`. `inputs` should be a `dict` of `string`-`float` pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:19.219749Z",
     "start_time": "2023-08-29T21:29:16.536335Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │      0      │     1     │  2  │\n",
      "      ┌───────────┐                   \n",
      "q0 : ─┤ Rx(alpha) ├───●───────────────\n",
      "      └───────────┘   │               \n",
      "      ┌──────────┐    │         ┌───┐ \n",
      "q1 : ─┤ Ry(beta) ├────┼─────●───┤ X ├─\n",
      "      └──────────┘    │     │   └───┘ \n",
      "      ┌───────────┐ ┌─┴─┐   │         \n",
      "q2 : ─┤ Rz(gamma) ├─┤ X ├───┼─────────\n",
      "      └───────────┘ └───┘   │         \n",
      "          ┌───┐           ┌─┴─┐ ┌───┐ \n",
      "q3 : ─────┤ H ├───────────┤ X ├─┤ X ├─\n",
      "          └───┘           └───┘ └───┘ \n",
      "T  : │      0      │     1     │  2  │\n",
      "\n",
      "Unassigned parameters: [alpha, beta, gamma].\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of quantum task: CREATED\n",
      "Status: CREATED\n",
      "Status: CREATED\n",
      "Status: CREATED\n",
      "Status: QUEUED\n",
      "Status: QUEUED\n",
      "Status: QUEUED\n",
      "Status: RUNNING\n",
      "Status: RUNNING\n",
      "Status: RUNNING\n",
      "Status: RUNNING\n",
      "Status: RUNNING\n",
      "Status: RUNNING\n",
      "Status: COMPLETED\n",
      "Counter({'0101': 504, '0100': 482, '0001': 8, '0000': 2, '1110': 2, '1111': 2})\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define circuit with some parametrized gates and free parameters\n",
    "alpha = FreeParameter('alpha')\n",
    "beta  = FreeParameter('beta')\n",
    "gamma = FreeParameter('gamma')\n",
    "my_circuit = Circuit().rx(0, alpha).ry(1, beta).rz(2, gamma).h(3).cnot(control=0, target=2).cnot(1, 3).x([1,3])\n",
    "print(my_circuit)\n",
    "# define quantum task (asynchronous)\n",
    "task = device.run(my_circuit, \n",
    "                  poll_timeout_seconds = 100, \n",
    "                  shots=1000, inputs={'alpha': 0.1, 'beta': 0.2, 'gamma': 0.3})\n",
    "\n",
    "# get id and status of submitted quantum task\n",
    "task_id = task.id\n",
    "status = task.state()\n",
    "# print('ID of quantum task:', task_id)\n",
    "print('Status of quantum task:', status)\n",
    "\n",
    "# wait for job to complete\n",
    "while status != 'COMPLETED':\n",
    "    status = task.state()\n",
    "    print('Status:', status)\n",
    "\n",
    "# get results of task\n",
    "result = task.result()\n",
    "\n",
    "# get measurement shots\n",
    "counts = result.measurement_counts\n",
    "\n",
    "# print counts\n",
    "print(counts)\n",
    "\n",
    "# plot using Counter\n",
    "plt.bar(counts.keys(), counts.values());\n",
    "plt.xlabel('bitstrings');\n",
    "plt.ylabel('counts');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__TASK METADATA__: You can access a range of metadata associated with your ```task``` object, as shown below.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:19.317336Z",
     "start_time": "2023-08-29T21:29:19.222457Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000 shots taken on Tue, 02 Apr 2024 19:55:26 GMT.\n"
     ]
    }
   ],
   "source": [
    "# get all metadata of submitted quantum task\n",
    "metadata = task.metadata()\n",
    "# example for metadata\n",
    "shots = metadata['shots']\n",
    "date = metadata['ResponseMetadata']['HTTPHeaders']['date']\n",
    "# print example metadata\n",
    "print(\"{} shots taken on {}.\".format(shots, date))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__TASK RECONSTRUCTION__: Imagine your kernel dies after you have submitted the task, or you simply close your notebook. As recovery method, here is how you can reconstruct the ```task``` object (given the corresponding unique arn). You can reconstruct the ```task``` object using `task = AwsQuantumTask(arn=...)`; then you can simply call `task.result()` to get the result from S3. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:19.665129Z",
     "start_time": "2023-08-29T21:29:19.310153Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of (reconstructed) quantum task: COMPLETED\n"
     ]
    }
   ],
   "source": [
    "# restore quantum task from unique arn\n",
    "task_load = AwsQuantumTask(arn=task_id)\n",
    "# print status\n",
    "status = task_load.state()\n",
    "print('Status of (reconstructed) quantum task:', status)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:20.122317Z",
     "start_time": "2023-08-29T21:29:19.658423Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({'0101': 504, '0100': 482, '0001': 8, '0000': 2, '1110': 2, '1111': 2})\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get results of quantum task\n",
    "result = task_load.result()\n",
    "\n",
    "# get measurement shots\n",
    "counts = result.measurement_counts\n",
    "\n",
    "# print counts\n",
    "print(counts)\n",
    "\n",
    "# plot using Counter\n",
    "plt.bar(counts.keys(), counts.values(), color='g');\n",
    "plt.xlabel('bitstrings');\n",
    "plt.ylabel('counts');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__TASK CANCELLATION__: Finally, we can also cancel existing tasks by calling the ```cancel()``` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:20.811635Z",
     "start_time": "2023-08-29T21:29:20.124967Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of quantum task: CREATED\n",
      "Status of quantum task: CANCELLING\n"
     ]
    }
   ],
   "source": [
    "# define quantum task\n",
    "task = device.run(my_circuit, shots=1000, inputs={'alpha': 0.1, 'beta': 0.2, 'gamma': 0.3})\n",
    "\n",
    "# get id and status of submitted quantum task\n",
    "task_id = task.id\n",
    "status = task.state()\n",
    "# print('ID of quantum task:', task_id)\n",
    "print('Status of quantum task:', status)\n",
    "\n",
    "# cancel task \n",
    "task.cancel()\n",
    "status = task.state()\n",
    "print('Status of quantum task:', status)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PARTIAL MEASUREMENT\n",
    "\n",
    "So far, we have measured on all qubits in the quantum circuit. However, it is possible to measure individual qubits or a subset of qubits by adding a `measure` instruction with the target qubits to the end of our circuit. In the following example, we will create a Bell state circuit and measure only qubit 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │  0  │  1  │  2  │\n",
      "      ┌───┐       ┌───┐ \n",
      "q0 : ─┤ H ├───●───┤ M ├─\n",
      "      └───┘   │   └───┘ \n",
      "            ┌─┴─┐       \n",
      "q1 : ───────┤ X ├───────\n",
      "            └───┘       \n",
      "T  : │  0  │  1  │  2  │\n",
      "\n",
      "Measured qubits:  [0]\n"
     ]
    }
   ],
   "source": [
    "# Use the local state vector simulator\n",
    "device = LocalSimulator()\n",
    "\n",
    "# define an example bell circuit and measure qubit 0\n",
    "circuit = Circuit().h(0).cnot(0, 1).measure(0)\n",
    "\n",
    "# Run the circuit\n",
    "task = device.run(circuit, shots=10)\n",
    "\n",
    "# Get the results\n",
    "result = task.result()\n",
    "\n",
    "# Print the circuit and measured qubits\n",
    "print(circuit)\n",
    "print()\n",
    "print(\"Measured qubits: \", result.measured_qubits)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the `measure` instruction, represented by `M`, was added to our circuit, and only on qubit 0.\n",
    "\n",
    "Now, we can see the measurement counts from qubit 0 on this bell circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({'0': 6, '1': 4})\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAGwCAYAAACHJU4LAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAccklEQVR4nO3df5BV9X3/8dcVZEFlV1F+xlXywx9RBFMRinYatFpjldY4YxxLB0ISbS3+ysZUt6kijRad1ohVB380iumoMW0Hk7ajQalgVAiIGjWpBo0/SFxEqe4Cyqrsfv/ouN9s8QcuC+ejPB4zd4Zz7ufe85aZleecc+7dWmdnZ2cAAAq0Q9UDAAC8F6ECABRLqAAAxRIqAECxhAoAUCyhAgAUS6gAAMXqW/UAW6KjoyMvvvhiBg4cmFqtVvU4AMBm6OzszNq1azNixIjssMP7nzP5SIfKiy++mMbGxqrHAAB6YOXKldlzzz3fd81HOlQGDhyY5H//Q+vr6yueBgDYHG1tbWlsbOz6d/z9fKRD5Z3LPfX19UIFAD5iNue2DTfTAgDFEioAQLGECgBQLKECABRLqAAAxRIqAECxhAoAUCyhAgAUS6gAAMUSKgBAsYQKAFCsykPlN7/5Tf7sz/4su+++ewYMGJCDDjooDz30UNVjAQAFqPSXEr766qs5/PDDc8QRR+TOO+/M4MGDs2LFiuy2225VjgUAFKLSULnsssvS2NiYm266qWvfJz/5yQonAgBKUumlnx/96EcZO3ZsTjrppAwZMiSf+9zncsMNN7zn+vb29rS1tXV7AAAfX5WeUfnVr36VOXPmpKmpKX/913+dZcuW5ayzzkq/fv0yderUTdbPmjUrM2fOrGBS4OOqNrNW9QhQtM4ZnZUev9bZ2VnZBP369cvYsWPz4IMPdu0766yzsmzZsixevHiT9e3t7Wlvb+/abmtrS2NjY1pbW1NfX79NZgY+XoQKvL+tESptbW1paGjYrH+/K730M3z48BxwwAHd9n32s5/NCy+88K7r6+rqUl9f3+0BAHx8VRoqhx9+eJ566qlu+375y19m7733rmgiAKAklYbK17/+9SxZsiR/93d/l6effjq33nprrr/++kyfPr3KsQCAQlQaKoceemjmzZuX2267LaNGjcq3v/3tzJ49O5MnT65yLACgEJV+6idJjj/++Bx//PFVjwEAFKjyr9AHAHgvQgUAKJZQAQCKJVQAgGIJFQCgWEIFACiWUAEAiiVUAIBiCRUAoFhCBQAollABAIolVACAYgkVAKBYQgUAKJZQAQCKJVQAgGIJFQCgWEIFACiWUAEAiiVUAIBiCRUAoFhCBQAollABAIolVACAYgkVAKBYQgUAKJZQAQCKJVQAgGIJFQCgWEIFACiWUAEAiiVUAIBiCRUAoFhCBQAollABAIolVACAYgkVAKBYQgUAKJZQAQCKJVQAgGIJFQCgWEIFACiWUAEAiiVUAIBiCRUAoFhCBQAollABAIolVACAYlUaKhdddFFqtVq3x/7771/lSABAQfpWPcCBBx6Ye+65p2u7b9/KRwIAClF5FfTt2zfDhg3brLXt7e1pb2/v2m5ra9taYwEABaj8HpUVK1ZkxIgR+dSnPpXJkyfnhRdeeM+1s2bNSkNDQ9ejsbFxG04KAGxrtc7Ozs6qDn7nnXdm3bp12W+//dLS0pKZM2fmN7/5TZ544okMHDhwk/XvdkalsbExra2tqa+v35ajAx8TtZm1qkeAonXO6P1MaGtrS0NDw2b9+13ppZ9jjz2268+jR4/O+PHjs/fee+cHP/hBvvrVr26yvq6uLnV1ddtyRACgQpVf+vltu+66a/bdd988/fTTVY8CABSgqFBZt25dnnnmmQwfPrzqUQCAAlQaKueee24WLVqU5557Lg8++GC++MUvpk+fPjnllFOqHAsAKESl96j8+te/zimnnJI1a9Zk8ODB+b3f+70sWbIkgwcPrnIsAKAQlYbK97///SoPDwAUrqh7VAAAfptQAQCKJVQAgGIJFQCgWEIFACiWUAEAiiVUAIBiCRUAoFhCBQAollABAIolVACAYgkVAKBYQgUAKJZQAQCKJVQAgGIJFQCgWEIFACiWUAEAiiVUAIBiCRUAoFhCBQAollABAIolVACAYgkVAKBYQgUAKJZQAQCKJVQAgGIJFQCgWEIFACiWUAEAiiVUAIBiCRUAoFhCBQAollABAIolVACAYgkVAKBYQgUAKJZQAQCKJVQAgGIJFQCgWEIFACiWUAEAiiVUAIBiCRUAoFhCBQAollABAIolVACAYhUTKpdeemlqtVrOOeecqkcBAApRRKgsW7Ys1113XUaPHl31KABAQSoPlXXr1mXy5Mm54YYbsttuu1U9DgBQkMpDZfr06TnuuONy1FFHfeDa9vb2tLW1dXsAAB9ffas8+Pe///08/PDDWbZs2WatnzVrVmbOnLmVp/r/ajNr2+xY8FHTOaOz6hGA7UBlZ1RWrlyZs88+O7fcckv69++/Wa9pbm5Oa2tr12PlypVbeUoAoEqVnVFZvnx5Vq9end/5nd/p2rdx48bcd999ufrqq9Pe3p4+ffp0e01dXV3q6uq29agAQEUqC5U/+IM/yOOPP95t37Rp07L//vvnvPPO2yRSAIDtT2WhMnDgwIwaNarbvp133jm77777JvsBgO1T5Z/6AQB4L5V+6uf/WrhwYdUjAAAFcUYFACiWUAEAiiVUAIBiCRUAoFhCBQAollABAIolVACAYgkVAKBYQgUAKJZQAQCKJVQAgGIJFQCgWEIFACiWUAEAiiVUAIBiCRUAoFhCBQAollABAIolVACAYgkVAKBYQgUAKJZQAQCKJVQAgGL1KFRWrlyZX//6113bS5cuzTnnnJPrr7++1wYDAOhRqPzpn/5p7r333iTJqlWrcvTRR2fp0qX51re+lb/927/t1QEBgO1Xj0LliSeeyLhx45IkP/jBDzJq1Kg8+OCDueWWWzJ37tzenA8A2I71KFTeeuut1NXVJUnuueee/PEf/3GSZP/9909LS0vvTQcAbNd6FCoHHnhgrr322vzkJz/J3XffnS984QtJkhdffDG77757rw4IAGy/ehQql112Wa677rpMnDgxp5xySsaMGZMk+dGPftR1SQgAYEv17cmLJk6cmFdeeSVtbW3Zbbfduvafdtpp2XnnnXttOABg+9ajMypHHnlk1q5d2y1SkmTQoEE5+eSTe2UwAIAehcrChQvz5ptvbrJ/w4YN+clPfrLFQwEAJB/y0s9jjz3W9edf/OIXWbVqVdf2xo0bc9ddd+UTn/hE700HAGzXPlSoHHzwwanVaqnVajnyyCM3eX7AgAG56qqrem04AGD79qFC5dlnn01nZ2c+9alPZenSpRk8eHDXc/369cuQIUPSp0+fXh8SANg+fahQ2XvvvZMkHR0dW2UYAIDf1qOPJyfJihUrcu+992b16tWbhMuFF164xYMBAPQoVG644Yacfvrp2WOPPTJs2LDUarWu52q1mlABAHpFj0Ll4osvziWXXJLzzjuvt+cBAOjSo+9RefXVV3PSSSf19iwAAN30KFROOumkzJ8/v7dnAQDopkeXfj7zmc/kggsuyJIlS3LQQQdlxx137Pb8WWed1SvDAQDbtx6FyvXXX59ddtklixYtyqJFi7o9V6vVhAoA0Ct6FCrPPvtsb88BALCJHt2jAgCwLfTojMpXvvKV933+xhtv7NEwAAC/rUeh8uqrr3bbfuutt/LEE0/ktddee9dfVggA0BM9CpV58+Ztsq+joyOnn356Pv3pT2/xUAAASS/eo7LDDjukqakpV1xxxWa/Zs6cORk9enTq6+tTX1+fCRMm5M477+ytkQCAj7hevZn2mWeeydtvv73Z6/fcc89ceumlWb58eR566KEceeSR+ZM/+ZP8/Oc/782xAICPqB5d+mlqauq23dnZmZaWlvznf/5npk6dutnvM2nSpG7bl1xySebMmZMlS5bkwAMP7MloAMDHSI9C5ZFHHum2vcMOO2Tw4MG5/PLLP/ATQe9l48aN+Zd/+ZesX78+EyZMeNc17e3taW9v79pua2vr0bEAgI+GHoXKvffe22sDPP7445kwYUI2bNiQXXbZJfPmzcsBBxzwrmtnzZqVmTNn9tqxAYCybdE9Ki+//HLuv//+3H///Xn55Zd79B777bdfHn300fz0pz/N6aefnqlTp+YXv/jFu65tbm5Oa2tr12PlypVbMj4AULgenVFZv359zjzzzHzve99LR0dHkqRPnz6ZMmVKrrrqquy0006b/V79+vXLZz7zmSTJIYcckmXLluXKK6/Mddddt8naurq61NXV9WRkAOAjqEdnVJqamrJo0aL8+7//e1577bW89tpr+eEPf5hFixblG9/4xhYN1NHR0e0+FABg+9WjMyr/9m//ln/913/NxIkTu/b90R/9UQYMGJAvfelLmTNnzma9T3Nzc4499tjstddeWbt2bW699dYsXLgwP/7xj3syFgDwMdOjUHn99dczdOjQTfYPGTIkr7/++ma/z+rVqzNlypS0tLSkoaEho0ePzo9//OMcffTRPRkLAPiY6VGoTJgwITNmzMj3vve99O/fP0nyxhtvZObMme/50eJ3893vfrcnhwcAthM9CpXZs2fnC1/4Qvbcc8+MGTMmSfKzn/0sdXV1mT9/fq8OCABsv3oUKgcddFBWrFiRW265JU8++WSS5JRTTsnkyZMzYMCAXh0QANh+9ShUZs2alaFDh+bUU0/ttv/GG2/Myy+/nPPOO69XhgMAtm89+njyddddl/3333+T/QceeGCuvfbaLR4KACDpYaisWrUqw4cP32T/4MGD09LSssVDAQAkPQyVxsbGPPDAA5vsf+CBBzJixIgtHgoAIOnhPSqnnnpqzjnnnLz11ls58sgjkyQLFizIX/3VX23xN9MCALyjR6HyzW9+M2vWrMlf/uVf5s0330yS9O/fP+edd16am5t7dUAAYPvVo1Cp1Wq57LLLcsEFF+S///u/M2DAgOyzzz5+YSAA0Kt6FCrv2GWXXXLooYf21iwAAN306GZaAIBtQagAAMUSKgBAsYQKAFAsoQIAFEuoAADFEioAQLGECgBQLKECABRLqAAAxRIqAECxhAoAUCyhAgAUS6gAAMUSKgBAsYQKAFAsoQIAFEuoAADFEioAQLGECgBQLKECABRLqAAAxRIqAECxhAoAUCyhAgAUS6gAAMUSKgBAsYQKAFAsoQIAFEuoAADFEioAQLGECgBQLKECABRLqAAAxRIqAECxhAoAUCyhAgAUS6gAAMWqNFRmzZqVQw89NAMHDsyQIUNywgkn5KmnnqpyJACgIJWGyqJFizJ9+vQsWbIkd999d95666384R/+YdavX1/lWABAIfpWefC77rqr2/bcuXMzZMiQLF++PL//+7+/yfr29va0t7d3bbe1tW31GQGA6hR1j0pra2uSZNCgQe/6/KxZs9LQ0ND1aGxs3JbjAQDbWDGh0tHRkXPOOSeHH354Ro0a9a5rmpub09ra2vVYuXLlNp4SANiWKr3089umT5+eJ554Ivfff/97rqmrq0tdXd02nAoAqFIRoXLGGWfkP/7jP3Lfffdlzz33rHocAKAQlYZKZ2dnzjzzzMybNy8LFy7MJz/5ySrHAQAKU2moTJ8+Pbfeemt++MMfZuDAgVm1alWSpKGhIQMGDKhyNACgAJXeTDtnzpy0trZm4sSJGT58eNfj9ttvr3IsAKAQlV/6AQB4L8V8PBkA4P8SKgBAsYQKAFAsoQIAFEuoAADFEioAQLGECgBQLKECABRLqAAAxRIqAECxhAoAUCyhAgAUS6gAAMUSKgBAsYQKAFAsoQIAFEuoAADFEioAQLGECgBQLKECABRLqAAAxRIqAECxhAoAUCyhAgAUS6gAAMUSKgBAsYQKAFAsoQIAFEuoAADFEioAQLGECgBQLKECABRLqAAAxRIqAECxhAoAUCyhAgAUS6gAAMUSKgBAsYQKAFAsoQIAFEuoAADFEioAQLGECgBQLKECABRLqAAAxRIqAECxhAoAUKxKQ+W+++7LpEmTMmLEiNRqtdxxxx1VjgMAFKbSUFm/fn3GjBmTa665psoxAIBC9a3y4Mcee2yOPfbYKkcAAApWaah8WO3t7Wlvb+/abmtrq3AaAGBr+0jdTDtr1qw0NDR0PRobG6seCQDYij5SodLc3JzW1taux8qVK6seCQDYij5Sl37q6upSV1dX9RgAwDbykTqjAgBsXyo9o7Ju3bo8/fTTXdvPPvtsHn300QwaNCh77bVXhZMBACWoNFQeeuihHHHEEV3bTU1NSZKpU6dm7ty5FU0FAJSi0lCZOHFiOjs7qxwBACiYe1QAgGIJFQCgWEIFACiWUAEAiiVUAIBiCRUAoFhCBQAollABAIolVACAYgkVAKBYQgUAKJZQAQCKJVQAgGIJFQCgWEIFACiWUAEAiiVUAIBiCRUAoFhCBQAollABAIolVACAYgkVAKBYQgUAKJZQAQCKJVQAgGIJFQCgWEIFACiWUAEAiiVUAIBiCRUAoFhCBQAollABAIolVACAYgkVAKBYQgUAKJZQAQCKJVQAgGIJFQCgWEIFACiWUAEAiiVUAIBiCRUAoFhCBQAollABAIolVACAYgkVAKBYQgUAKJZQAQCKVUSoXHPNNRk5cmT69++f8ePHZ+nSpVWPBAAUoPJQuf3229PU1JQZM2bk4YcfzpgxY3LMMcdk9erVVY8GAFSs8lD5zne+k1NPPTXTpk3LAQcckGuvvTY77bRTbrzxxqpHAwAq1rfKg7/55ptZvnx5mpubu/btsMMOOeqoo7J48eJN1re3t6e9vb1ru7W1NUnS1ta2dQbcsHXeFj4OttrP3bbm5xze19b4WX/nPTs7Oz9wbaWh8sorr2Tjxo0ZOnRot/1Dhw7Nk08+ucn6WbNmZebMmZvsb2xs3GozAu+u4dKGqkcAtoGt+bO+du3aNDS8//tXGiofVnNzc5qamrq2Ozo68j//8z/ZfffdU6vVKpyMra2trS2NjY1ZuXJl6uvrqx4H2Ar8nG8/Ojs7s3bt2owYMeID11YaKnvssUf69OmTl156qdv+l156KcOGDdtkfV1dXerq6rrt23XXXbfmiBSmvr7e/8DgY87P+fbhg86kvKPSm2n79euXQw45JAsWLOja19HRkQULFmTChAkVTgYAlKDySz9NTU2ZOnVqxo4dm3HjxmX27NlZv359pk2bVvVoAEDFKg+Vk08+OS+//HIuvPDCrFq1KgcffHDuuuuuTW6wZftWV1eXGTNmbHLpD/j48HPOu6l1bs5ngwAAKlD5F74BALwXoQIAFEuoAADFEioAQLGECkW77777MmnSpIwYMSK1Wi133HFH1SMBW8k111yTkSNHpn///hk/fnyWLl1a9UgUQKhQtPXr12fMmDG55pprqh4F2Ipuv/32NDU1ZcaMGXn44YczZsyYHHPMMVm9enXVo1ExH0/mI6NWq2XevHk54YQTqh4F6GXjx4/PoYcemquvvjrJ/35LeWNjY84888ycf/75FU9HlZxRAaBSb775ZpYvX56jjjqqa98OO+yQo446KosXL65wMkogVACo1CuvvJKNGzdu8o3kQ4cOzapVqyqailIIFQCgWEIFgErtscce6dOnT1566aVu+1966aUMGzasoqkohVABoFL9+vXLIYcckgULFnTt6+joyIIFCzJhwoQKJ6MElf/2ZHg/69aty9NPP921/eyzz+bRRx/NoEGDstdee1U4GdCbmpqaMnXq1IwdOzbjxo3L7Nmzs379+kybNq3q0aiYjydTtIULF+aII47YZP/UqVMzd+7cbT8QsNVcffXV+fu///usWrUqBx98cP7xH/8x48ePr3osKiZUAIBiuUcFACiWUAEAiiVUAIBiCRUAoFhCBQAollABAIolVACAYgkVAKBYQgV4XxMnTsw555zzns+PHDkys2fP3iazPPfcc6nVann00Ue3yfGA6gkVYIssW7Ysp512Wtd2rVbLHXfcsdmvnzt3bnbdddfNWtvY2JiWlpaMGjXqQ04JfFT5pYTAFhk8ePA2Oc6bb76Zfv36ZdiwYdvkeEAZnFEBPtDbb7+dM844Iw0NDdljjz1ywQUX5J1fE/bbl35GjhyZJPniF7+YWq3Wtf2zn/0sRxxxRAYOHJj6+voccsgheeihh7Jw4cJMmzYtra2tqdVqqdVqueiii7re69vf/namTJmS+vr6nHbaaZtc+lm4cGFqtVoWLFiQsWPHZqeddsphhx2Wp556qtv8F198cYYMGZKBAwfma1/7Ws4///wcfPDBXc8vXLgw48aNy84775xdd901hx9+eJ5//vmt9dcJfAhCBfhAN998c/r27ZulS5fmyiuvzHe+85380z/90ybrli1bliS56aab0tLS0rU9efLk7Lnnnlm2bFmWL1+e888/PzvuuGMOO+ywzJ49O/X19WlpaUlLS0vOPffcrvf7h3/4h4wZMyaPPPJILrjggvec71vf+lYuv/zyPPTQQ+nbt2++8pWvdD13yy235JJLLslll12W5cuXZ6+99sqcOXO6nn/77bdzwgkn5POf/3wee+yxLF68OKeddlpqtdoW/70BW86lH+ADNTY25oorrkitVst+++2Xxx9/PFdccUVOPfXUbuveuQy06667drtE88ILL+Sb3/xm9t9//yTJPvvs0/VcQ0NDarXau17SOfLII/ONb3yja/u555571/kuueSSfP7zn0+SnH/++TnuuOOyYcOG9O/fP1dddVW++tWvZtq0aUmSCy+8MPPnz8+6deuSJG1tbWltbc3xxx+fT3/600mSz372sx/q7wfYepxRAT7Q7/7u73Y7wzBhwoSsWLEiGzdu3KzXNzU15Wtf+1qOOuqoXHrppXnmmWc263Vjx47drHWjR4/u+vPw4cOTJKtXr06SPPXUUxk3bly39b+9PWjQoHz5y1/OMccck0mTJuXKK69MS0vLZh0X2PqECrDVXXTRRfn5z3+e4447Lv/1X/+VAw44IPPmzfvA1+28886b9f477rhj15/fCaqOjo7Nnu+mm27K4sWLc9hhh+X222/PvvvumyVLlmz264GtR6gAH+inP/1pt+0lS5Zkn332SZ8+fTZZu+OOO77rmZZ99903X//61zN//vyceOKJuemmm5Ik/fr12+wzMz2x3377dd0r847/u50kn/vc59Lc3JwHH3wwo0aNyq233rrVZgI2n1ABPtALL7yQpqamPPXUU7ntttty1VVX5eyzz37XtSNHjsyCBQuyatWqvPrqq3njjTdyxhlnZOHChXn++efzwAMPZNmyZV33gYwcOTLr1q3LggUL8sorr+T111/v1dnPPPPMfPe7383NN9+cFStW5OKLL85jjz3Wdebl2WefTXNzcxYvXpznn38+8+fPz4oVK9ynAoVwMy3wgaZMmZI33ngj48aNS58+fXL22Wd3+5K333b55ZenqakpN9xwQz7xiU/kl7/8ZdasWZMpU6bkpZdeyh577JETTzwxM2fOTJIcdthh+Yu/+IucfPLJWbNmTWbMmNH1EeXeMHny5PzqV7/Kueeemw0bNuRLX/pSvvzlL2fp0qVJkp122ilPPvlkbr755qxZsybDhw/P9OnT8+d//ue9NgPQc7XOd74MAWA7cfTRR2fYsGH553/+56pHAT6AMyrAx9rrr7+ea6+9Nsccc0z69OmT2267Lffcc0/uvvvuqkcDNoMzKsDH2htvvJFJkyblkUceyYYNG7Lffvvlb/7mb3LiiSdWPRqwGYQKAFAsn/oBAIolVACAYgkVAKBYQgUAKJZQAQCKJVQAgGIJFQCgWEIFACjW/wNoaoeoMduUNQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# get measurement shots\n",
    "counts = result.measurement_counts\n",
    "\n",
    "# print counts\n",
    "print(counts)\n",
    "\n",
    "# plot using Counter\n",
    "plt.bar(counts.keys(), counts.values(), color='g');\n",
    "plt.xlabel('bitstrings');\n",
    "plt.ylabel('counts');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DEMONSTRATION OF RESULT TYPES: Expectation Values and Observables "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, we have only taken measurements in the computational basis. However, it is also possible to measure in other bases, as well as estimate important statistics like expectation value and variance. We do this by adding `ResultType`s to our circuit; in the following example, we will make measurements in the basis of the observable $X_{0}Y_{1}$ (this is the tensor product $X(0) \\otimes Y(1)$):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:20.822521Z",
     "start_time": "2023-08-29T21:29:20.810638Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │     0      │     1     │                     Result Types                     │\n",
      "      ┌──────────┐             ┌──────────────────┐ ┌───────────────┐ ┌─────────────┐ \n",
      "q0 : ─┤ Rx(0.15) ├───●─────────┤ Expectation(X@Y) ├─┤ Variance(X@Y) ├─┤ Sample(X@Y) ├─\n",
      "      └──────────┘   │         └────────┬─────────┘ └───────┬───────┘ └──────┬──────┘ \n",
      "      ┌──────────┐   │         ┌────────┴─────────┐ ┌───────┴───────┐ ┌──────┴──────┐ \n",
      "q1 : ─┤ Ry(0.20) ├───┼─────●───┤ Expectation(X@Y) ├─┤ Variance(X@Y) ├─┤ Sample(X@Y) ├─\n",
      "      └──────────┘   │     │   └──────────────────┘ └───────────────┘ └─────────────┘ \n",
      "      ┌──────────┐ ┌─┴─┐   │                                                          \n",
      "q2 : ─┤ Rz(0.25) ├─┤ X ├───┼──────────────────────────────────────────────────────────\n",
      "      └──────────┘ └───┘   │                                                          \n",
      "         ┌───┐           ┌─┴─┐                                                        \n",
      "q3 : ────┤ H ├───────────┤ X ├────────────────────────────────────────────────────────\n",
      "         └───┘           └───┘                                                        \n",
      "         ┌───┐                                                                        \n",
      "q4 : ────┤ X ├────────────────────────────────────────────────────────────────────────\n",
      "         └───┘                                                                        \n",
      "T  : │     0      │     1     │                     Result Types                     │\n"
     ]
    }
   ],
   "source": [
    "# define example circuit\n",
    "circ = Circuit().rx(0, 0.15).ry(1, 0.2).rz(2, 0.25).h(3).cnot(control=0, target=2).cnot(1, 3).x(4)\n",
    "# add expectation value\n",
    "obs = observables.X() @ observables.Y()\n",
    "target_qubits = [0, 1]\n",
    "circ.expectation(obs, target=target_qubits)\n",
    "# add variance\n",
    "circ.variance(obs, target=target_qubits) \n",
    "# add samples\n",
    "\n",
    "circ.sample(obs, target=target_qubits)\n",
    "print(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Note_: `sample` is only valid when `shots>0`.\n",
    "\n",
    "As shown above, results types are part of the `print` information. We now run this circuit on the local simulator above and output these results. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:20.980998Z",
     "start_time": "2023-08-29T21:29:20.819550Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expectation value for <X0*Y1>: -0.08\n",
      "Variance for <X0*Y1>: 0.9935999999999998\n",
      "Measurement samples for X0*Y1: [-1. -1. -1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1. -1. -1. -1.  1. -1.\n",
      "  1. -1.  1.  1.  1. -1.  1.  1.  1.  1. -1.  1. -1.  1.  1. -1. -1. -1.\n",
      "  1.  1. -1.  1.  1.  1. -1.  1. -1.  1.  1.  1. -1. -1. -1. -1. -1. -1.\n",
      " -1. -1.  1. -1. -1.  1. -1. -1.  1. -1. -1.  1. -1. -1.  1. -1. -1. -1.\n",
      "  1.  1. -1.  1. -1. -1.  1. -1. -1. -1.  1. -1. -1. -1. -1.  1.  1. -1.\n",
      "  1. -1.  1. -1. -1. -1. -1. -1. -1.  1.]\n"
     ]
    }
   ],
   "source": [
    "# set up device\n",
    "device = LocalSimulator()\n",
    "# run the circuit and output the results specified above\n",
    "task = device.run(circ, shots=100)\n",
    "result = task.result()\n",
    "print(\"Expectation value for <X0*Y1>:\", result.values[0])\n",
    "print(\"Variance for <X0*Y1>:\", result.values[1])\n",
    "print(\"Measurement samples for X0*Y1:\", result.values[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can verify that we get the same estimate for the expectation value if we compute it by hand from the samples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:20.987487Z",
     "start_time": "2023-08-29T21:29:20.981208Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expectation value from samples: -0.08\n"
     ]
    }
   ],
   "source": [
    "samples = result.values[2]\n",
    "sum_of_samples = samples.sum()\n",
    "total_counts = len(samples)\n",
    "expect_from_samples = sum_of_samples/total_counts\n",
    "print('Expectation value from samples:', expect_from_samples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, we have measured only one observable, namely $X_{0}Y_{1}$. However, it is possible to measure multiple observables at once, provided that any observables with overlapping qubits have the same factor acting on each qubit:\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note</b> The following code requires amazon-braket-sdk>=1.5.0 and amazon-braket-default-simulator>=1.1.0\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:21.062363Z",
     "start_time": "2023-08-29T21:29:21.013599Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expectation value for <X0*Y1>: 0.056\n",
      "Expectation value for <Z2*H4>: -0.668\n",
      "Expectation value for <Y1*X3*H4>:: -0.02\n"
     ]
    }
   ],
   "source": [
    "circ = Circuit().rx(0, 0.15).ry(1, 0.2).rz(2, 0.25).h(3).cnot(control=0, target=2).cnot(1, 3).x(4)\n",
    "circ.expectation(observables.X() @ observables.Y(), target=[0, 1])\n",
    "circ.expectation(observables.Z() @ observables.H(), target=[2, 4])\n",
    "# Overlaps on qubits 1 and 4, but Y and H are the same factors that have been applied to each, respectively\n",
    "circ.expectation(observables.Y() @ observables.X() @ observables.H(), target=[1, 3, 4])\n",
    "\n",
    "# run circuit\n",
    "task = device.run(circ, shots=1000)\n",
    "result = task.result()\n",
    "print(\"Expectation value for <X0*Y1>:\", result.values[0])\n",
    "print(\"Expectation value for <Z2*H4>:\", result.values[1])\n",
    "print(\"Expectation value for <Y1*X3*H4>::\", result.values[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is possible because we only need to measure in at most one basis for each qubit. For instance in the example above, on qubit 1 we only measure in the Y basis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### RESULT TYPES FOR ```shots=0```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note</b> This section requires amazon-braket-sdk>=1.8.0 and amazon-braket-default-simulator>=1.3.0\n",
    "</div>\n",
    "\n",
    "In all examples discussed so far we have set the parameter `shots>0`, thereby mimicking the behavior of actual quantum hardware. However, on a classical simulator we do have access to the full state vector when `shots=0`. We will illustrate this functionality in more detail in this section. \n",
    "\n",
    "Note that the full state vector and amplitudes can only be requested when `shots=0` for a classical simulator. \n",
    "When `shots=0` for a simulator, probability and expectation values are the exact values, as derived from the full wavefunction. \n",
    "When `shots>0` we cannot access the full state vector, but we can still get approximate expectation values as taken from measurement samples. Note that probability, sample, expectation, and variance are also supported for QPU devices.\n",
    "\n",
    "In the following example we output the state vector, the exact expectation values of $Y_{1}X_{2}$ and $Z_{0}Z_{1}$, the amplitude of the state $|00000\\rangle$, and the marginal probability of qubit $3$. Notice in particular that the two observables share qubit $1$ but don't have the same factor acting on it; this is allowed because simulators can directly compute expectation values using the state vector, and don't have to measure in a common basis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:21.062675Z",
     "start_time": "2023-08-29T21:29:21.027773Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │      0      │     1     │  2  │              Result Types               │\n",
      "      ┌───────────┐                                        ┌──────────────────┐ \n",
      "q0 : ─┤ Rx(alpha) ├───●────────────────────────────────────┤ Expectation(Z@Z) ├─\n",
      "      └───────────┘   │                                    └────────┬─────────┘ \n",
      "      ┌──────────┐    │         ┌───┐ ┌──────────────────┐ ┌────────┴─────────┐ \n",
      "q1 : ─┤ Ry(beta) ├────┼─────●───┤ X ├─┤ Expectation(Y@X) ├─┤ Expectation(Z@Z) ├─\n",
      "      └──────────┘    │     │   └───┘ └────────┬─────────┘ └──────────────────┘ \n",
      "      ┌───────────┐ ┌─┴─┐   │         ┌────────┴─────────┐                      \n",
      "q2 : ─┤ Rz(gamma) ├─┤ X ├───┼─────────┤ Expectation(Y@X) ├──────────────────────\n",
      "      └───────────┘ └───┘   │         └──────────────────┘                      \n",
      "          ┌───┐           ┌─┴─┐ ┌───┐   ┌─────────────┐                         \n",
      "q3 : ─────┤ H ├───────────┤ X ├─┤ X ├───┤ Probability ├─────────────────────────\n",
      "          └───┘           └───┘ └───┘   └─────────────┘                         \n",
      "T  : │      0      │     1     │  2  │              Result Types               │\n",
      "\n",
      "Additional result types: StateVector, Amplitude(0000)\n",
      "\n",
      "Unassigned parameters: [alpha, beta, gamma].\n"
     ]
    }
   ],
   "source": [
    "# add result types\n",
    "circ = my_circuit\n",
    "# add the state_vector ResultType available for shots=0\n",
    "circ.state_vector() \n",
    "# add single qubit expectation value\n",
    "obs1 = observables.Y() @ observables.X()\n",
    "circ.expectation(obs1, target=[1, 2])\n",
    "# add the two-qubit Z0*Z1 expectation value\n",
    "obs2 = observables.Z() @ observables.Z()\n",
    "circ.expectation(obs2, target=[0,1]) \n",
    "# add the amplitude for |0...0>\n",
    "bitstring = '0'*circ.qubit_count\n",
    "circ.amplitude(state=[bitstring]) \n",
    "# add marginal probability \n",
    "circ.probability(target=[3])\n",
    "print(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown above, results types are part of the `print` information. We now run this circuit on the local simulator above and output these results. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:21.125087Z",
     "start_time": "2023-08-29T21:29:21.047836Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final state vector:\n",
      " [ 6.97129718e-02-0.01053609j  6.97129718e-02-0.01053609j\n",
      "  0.00000000e+00+0.j          0.00000000e+00+0.j\n",
      "  6.94804402e-01-0.10500941j  6.94804402e-01-0.10500941j\n",
      "  0.00000000e+00+0.j          0.00000000e+00+0.j\n",
      "  0.00000000e+00+0.j          0.00000000e+00+0.j\n",
      " -5.27243703e-04-0.00348856j -5.27243703e-04-0.00348856j\n",
      "  0.00000000e+00+0.j          0.00000000e+00+0.j\n",
      " -5.25485051e-03-0.0347692j  -5.25485051e-03-0.0347692j ]\n",
      "Expectation value <Y1X2> 0.0\n",
      "Expectation value <Z0Z1>: -0.9751703272018156\n",
      "Amplitude <00000|Final state>: {'0000': (0.06971297180671754-0.010536085195500033j)}\n",
      "Marginal probability for target qubit 3 in computational basis: [0.5 0.5]\n"
     ]
    }
   ],
   "source": [
    "# set up device\n",
    "device = LocalSimulator()\n",
    "# run the circuit and output the results specified above\n",
    "task = device.run(circ, shots=0, inputs={'alpha': 0.1, 'beta': 0.2, 'gamma': 0.3})\n",
    "result = task.result()\n",
    "print(\"Final state vector:\\n\", result.values[0])\n",
    "print(\"Expectation value <Y1X2>\", result.values[1])\n",
    "print(\"Expectation value <Z0Z1>:\", result.values[2])\n",
    "print(\"Amplitude <00000|Final state>:\", result.values[3])\n",
    "print(\"Marginal probability for target qubit 3 in computational basis:\", result.values[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ADVANCED LOGGING"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we provide an example for advanced logging. Here, we change the ```poll_timeout_seconds``` and ```poll_interval_seconds``` parameters, such that a task can be long-running and the task status will be continuously logged to a file. You can also transfer this code to a python script instead of a Jupyter notebook, and the script can run as a process in the background so that your laptop can go to sleep and the script will still run. These advanced logging techniques allow you to see the background polling and create a record for later debugging. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:21.125398Z",
     "start_time": "2023-08-29T21:29:21.088115Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantum task info will be logged in: device_logs-20240402140441.txt\n"
     ]
    }
   ],
   "source": [
    "# set filename for logs\n",
    "log_file = 'device_logs-'+datetime.strftime(datetime.now(), '%Y%m%d%H%M%S')+'.txt'\n",
    "print('Quantum task info will be logged in:', log_file)\n",
    "\n",
    "# create new logger object\n",
    "logger = logging.getLogger(\"newLogger\")  \n",
    "# configure to log to file device_logs.txt in the appending mode\n",
    "logger.addHandler(logging.FileHandler(filename=log_file, mode='a'))\n",
    "# add to file all log messages with level DEBUG or above\n",
    "logger.setLevel(logging.DEBUG) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:24.330768Z",
     "start_time": "2023-08-29T21:29:21.094955Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │     0      │     1     │\n",
      "      ┌──────────┐             \n",
      "q0 : ─┤ Rx(0.15) ├───●─────────\n",
      "      └──────────┘   │         \n",
      "      ┌──────────┐   │         \n",
      "q1 : ─┤ Ry(0.20) ├───┼─────●───\n",
      "      └──────────┘   │     │   \n",
      "      ┌──────────┐ ┌─┴─┐   │   \n",
      "q2 : ─┤ Rz(0.25) ├─┤ X ├───┼───\n",
      "      └──────────┘ └───┘   │   \n",
      "         ┌───┐           ┌─┴─┐ \n",
      "q3 : ────┤ H ├───────────┤ X ├─\n",
      "         └───┘           └───┘ \n",
      "         ┌───┐                 \n",
      "q4 : ────┤ X ├─────────────────\n",
      "         └───┘                 \n",
      "T  : │     0      │     1     │\n"
     ]
    }
   ],
   "source": [
    "# define circuit\n",
    "circ_log = Circuit().rx(0, 0.15).ry(1, 0.2).rz(2, 0.25).h(3).cnot(control=0, target=2).cnot(1, 3).x(4)\n",
    "print(circ_log)\n",
    "# define device\n",
    "device = AwsDevice(Devices.Amazon.SV1)\n",
    "# define what info to log\n",
    "logger.info(\n",
    "    device.run(circ_log, \n",
    "               poll_timeout_seconds=1200, poll_interval_seconds=0.25, logger=logger, shots=1000)\n",
    "    .result().measurement_counts\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:24.487047Z",
     "start_time": "2023-08-29T21:29:24.333763Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Task arn:aws:braket:us-west-2:260818742045:quantum-task/d84bd470-c85c-4815-9918-02670b39f0fa: start polling for completion\n",
      "Task arn:aws:braket:us-west-2:260818742045:quantum-task/d84bd470-c85c-4815-9918-02670b39f0fa: task status CREATED\n",
      "Task is in Normal queue position: 1\n",
      "Task arn:aws:braket:us-west-2:260818742045:quantum-task/d84bd470-c85c-4815-9918-02670b39f0fa: task status QUEUED\n",
      "Task arn:aws:braket:us-west-2:260818742045:quantum-task/d84bd470-c85c-4815-9918-02670b39f0fa: task status RUNNING\n",
      "Task arn:aws:braket:us-west-2:260818742045:quantum-task/d84bd470-c85c-4815-9918-02670b39f0fa: task status RUNNING\n",
      "Task arn:aws:braket:us-west-2:260818742045:quantum-task/d84bd470-c85c-4815-9918-02670b39f0fa: task status COMPLETED\n",
      "Counter({'00011': 506, '00001': 477, '01011': 5, '01001': 5, '10111': 4, '10101': 3})\n"
     ]
    }
   ],
   "source": [
    "# print logs\n",
    "! cat {log_file}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:25.417196Z",
     "start_time": "2023-08-29T21:29:24.493187Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAArtUlEQVR4nO3de3QUdZ7//1fn1oRLd7gkaZAAOioYRZgJA7TjCGIkMpHVAR0GWYmKMjJBhShidrh5WxBHQTkI6iqwuyIuu6uuuCIxQpiV5mImKAbNMoqGHdIB0aS55UJSvz/8pb70cItJJ9358HycU+fQ9flU1bs+Vne/rKquOCzLsgQAAGCoqHAXAAAA0JIIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARosJdwGRoL6+Xvv371enTp3kcDjCXQ4AAGgEy7J0+PBh9ejRQ1FRZz5/Q9iRtH//fqWkpIS7DAAA0AT79u1Tz549z9hO2JHUqVMnST8MlsvlCnM1AACgMQKBgFJSUuzv8TMh7Ej2pSuXy0XYAQCgjTnXLSjcoAwAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwWkw4Nz5v3jw9+uijQfP69u2rL774QpJUVVWlBx98UGvWrFF1dbUyMjL0wgsvKDk52e5fWlqqKVOmaOPGjerYsaOysrI0f/58xcSEddfQXPPc4a4gPOZVhrsCADBO2BPB5Zdfrg8++MB+fXJImT59ut59912tXbtWbrdbU6dO1ZgxY/TRRx9Jkurq6pSZmSmPx6MtW7aorKxMEydOVGxsrP7xH/+x1fcFAABEnrCHnZiYGHk8nlPmV1ZW6pVXXtHq1as1YsQISdKKFSt02WWXaevWrRo6dKg2bNig3bt364MPPlBycrIGDhyoxx9/XDNnztS8efMUFxfX2rsDAAAiTNjv2dmzZ4969Oihiy66SBMmTFBpaakkqbCwULW1tUpPT7f79uvXT7169ZLP55Mk+Xw+9e/fP+iyVkZGhgKBgIqLi8+4zerqagUCgaAJAACYKaxhZ8iQIVq5cqXWr1+vZcuWae/evfrlL3+pw4cPy+/3Ky4uTgkJCUHLJCcny+/3S5L8fn9Q0Glob2g7k/nz58vtdttTSkpKaHcMAABEjLBexho1apT97yuvvFJDhgxR79699W//9m+Kj49vse3m5uYqJyfHfh0IBAg8AAAYKuyXsU6WkJCgSy+9VH/5y1/k8XhUU1OjioqKoD7l5eX2PT4ej0fl5eWntDe0nYnT6ZTL5QqaAACAmSIq7Bw5ckRffvmlunfvrrS0NMXGxio/P99uLykpUWlpqbxeryTJ6/Vq165dOnDggN0nLy9PLpdLqamprV4/AACIPGG9jPXQQw9p9OjR6t27t/bv36+5c+cqOjpa48ePl9vt1qRJk5STk6MuXbrI5XLpvvvuk9fr1dChQyVJI0eOVGpqqm6//XYtXLhQfr9fs2bNUnZ2tpxOZzh3DQAARIiwhp3/+7//0/jx43Xo0CElJibq6quv1tatW5WYmChJWrRokaKiojR27Nighwo2iI6O1rp16zRlyhR5vV516NBBWVlZeuyxx8K1SwAAIMI4LMuywl1EuAUCAbndblVWVnL/TqTgCcoAgHNo7Pd3RN2zAwAAEGqEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaGH9cxHnBZ4EDABAWHFmBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGC1iws6CBQvkcDg0bdo0e15VVZWys7PVtWtXdezYUWPHjlV5eXnQcqWlpcrMzFT79u2VlJSkGTNm6MSJE61cPQAAiFQREXZ27NihF198UVdeeWXQ/OnTp+udd97R2rVrVVBQoP3792vMmDF2e11dnTIzM1VTU6MtW7Zo1apVWrlypebMmdPauwAAACJU2MPOkSNHNGHCBL388svq3LmzPb+yslKvvPKKnn32WY0YMUJpaWlasWKFtmzZoq1bt0qSNmzYoN27d+tf//VfNXDgQI0aNUqPP/64li5dqpqamjNus7q6WoFAIGgCAABmCnvYyc7OVmZmptLT04PmFxYWqra2Nmh+v3791KtXL/l8PkmSz+dT//79lZycbPfJyMhQIBBQcXHxGbc5f/58ud1ue0pJSQnxXgEAgEgR1rCzZs0a/fnPf9b8+fNPafP7/YqLi1NCQkLQ/OTkZPn9frvPyUGnob2h7Uxyc3NVWVlpT/v27WvmngAAgEgVE64N79u3Tw888IDy8vLUrl27Vt220+mU0+ls1W0CAIDwCNuZncLCQh04cEA/+9nPFBMTo5iYGBUUFOj5559XTEyMkpOTVVNTo4qKiqDlysvL5fF4JEkej+eUX2c1vG7oAwAAzm9hCzvXXXeddu3apZ07d9rToEGDNGHCBPvfsbGxys/Pt5cpKSlRaWmpvF6vJMnr9WrXrl06cOCA3ScvL08ul0upqamtvk8AACDyhO0yVqdOnXTFFVcEzevQoYO6du1qz580aZJycnLUpUsXuVwu3XffffJ6vRo6dKgkaeTIkUpNTdXtt9+uhQsXyu/3a9asWcrOzuYyFQAAkBTGsNMYixYtUlRUlMaOHavq6mplZGTohRdesNujo6O1bt06TZkyRV6vVx06dFBWVpYee+yxMFYNAAAiicOyLCvcRYRbIBCQ2+1WZWWlXC5XaFc+zx3a9bUV8yqbuTzjBgA4u8Z+f4f9OTsAAAAtibADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIwW1rCzbNkyXXnllXK5XHK5XPJ6vXrvvffs9qqqKmVnZ6tr167q2LGjxo4dq/Ly8qB1lJaWKjMzU+3bt1dSUpJmzJihEydOtPauAACACBXWsNOzZ08tWLBAhYWF+vjjjzVixAjddNNNKi4uliRNnz5d77zzjtauXauCggLt379fY8aMsZevq6tTZmamampqtGXLFq1atUorV67UnDlzwrVLAAAgwjgsy7LCXcTJunTpoqefflq33HKLEhMTtXr1at1yyy2SpC+++EKXXXaZfD6fhg4dqvfee0833nij9u/fr+TkZEnS8uXLNXPmTB08eFBxcXGN2mYgEJDb7VZlZaVcLldod2ieO7TrayvmVTZzecYNAHB2jf3+jph7durq6rRmzRodPXpUXq9XhYWFqq2tVXp6ut2nX79+6tWrl3w+nyTJ5/Opf//+dtCRpIyMDAUCAfvs0OlUV1crEAgETQAAwExhDzu7du1Sx44d5XQ6de+99+rNN99Uamqq/H6/4uLilJCQENQ/OTlZfr9fkuT3+4OCTkN7Q9uZzJ8/X263255SUlJCu1MAACBihD3s9O3bVzt37tS2bds0ZcoUZWVlaffu3S26zdzcXFVWVtrTvn37WnR7AAAgfGLCXUBcXJwuvvhiSVJaWpp27Nih5557TuPGjVNNTY0qKiqCzu6Ul5fL4/FIkjwej7Zv3x60voZfazX0OR2n0ymn0xniPQEAAJEo7Gd2/lZ9fb2qq6uVlpam2NhY5efn220lJSUqLS2V1+uVJHm9Xu3atUsHDhyw++Tl5cnlcik1NbXVawcAAJGnSWd29u3bJ4fDoZ49e0qStm/frtWrVys1NVWTJ09u9Hpyc3M1atQo9erVS4cPH9bq1au1adMmvf/++3K73Zo0aZJycnLUpUsXuVwu3XffffJ6vRo6dKgkaeTIkUpNTdXtt9+uhQsXyu/3a9asWcrOzubMDQAAkNTEMzu33XabNm7cKOmHG4Gvv/56bd++XX/4wx/02GOPNXo9Bw4c0MSJE9W3b19dd9112rFjh95//31df/31kqRFixbpxhtv1NixY3XNNdfI4/HoP//zP+3lo6OjtW7dOkVHR8vr9erv//7vNXHixB9VAwAAMFuTnrPTuXNnbd26VX379tXzzz+vN954Qx999JE2bNige++9V1999VVL1NpieM5OC+A5O03Dc3YAoNFa9Dk7tbW19mWiDz74QH/3d38n6Yfn4JSVlTVllQAAAC2iSWHn8ssv1/Lly/WnP/1JeXl5uuGGGyRJ+/fvV9euXUNaIAAAQHM0Kew89dRTevHFFzV8+HCNHz9eAwYMkCT913/9lwYPHhzSAgEAAJqjSb/GGj58uL799lsFAgF17tzZnj958mR16NAhZMUBAAA0V5PO7IwYMUKHDx8OCjrSD3/Ec9y4cSEpDAAAIBSaFHY2bdqkmpqaU+ZXVVXpT3/6U7OLAgAACJUfdRnr008/tf+9e/fuoD+2WVdXp/Xr1+uCCy4IXXUAAADN9KPCzsCBA+VwOORwODRixIhT2uPj47VkyZKQFQcAANBcPyrs7N27V5Zl6aKLLtL27duVmJhot8XFxSkpKUnR0dEhLxIAAKCpflTY6d27t6Qf/lgnAABAW9Ckn55L0p49e7Rx40YdOHDglPAzZ86cZhcGAAAQCk0KOy+//LKmTJmibt26yePxyOFw2G0Oh4OwAwAAIkaTws4TTzyhJ598UjNnzgx1PQAAACHVpOfsfP/997r11ltDXQsAAEDINSns3HrrrdqwYUOoawEAAAi5Jl3GuvjiizV79mxt3bpV/fv3V2xsbFD7/fffH5LiAAAAmqtJYeell15Sx44dVVBQoIKCgqA2h8NB2AEAABGjSWFn7969oa4DAACgRTTpnh0AAIC2oklndu66666ztr/66qtNKgYAACDUmhR2vv/++6DXtbW1+uyzz1RRUXHaPxAKAAAQLk0KO2+++eYp8+rr6zVlyhT95Cc/aXZRAAAAoRKye3aioqKUk5OjRYsWhWqVAAAAzRbSG5S//PJLnThxIpSrBAAAaJYmXcbKyckJem1ZlsrKyvTuu+8qKysrJIUBAACEQpPCTlFRUdDrqKgoJSYm6plnnjnnL7UAAABaU5PCzsaNG0NdBwAAQItoUthpcPDgQZWUlEiS+vbtq8TExJAUBQAAECpNukH56NGjuuuuu9S9e3ddc801uuaaa9SjRw9NmjRJx44dC3WNAAAATdaksJOTk6OCggK98847qqioUEVFhd5++20VFBTowQcfDHWNAAAATdaky1j/8R//oX//93/X8OHD7Xm/+tWvFB8fr9/85jdatmxZqOoDAABoliad2Tl27JiSk5NPmZ+UlMRlLAAAEFGaFHa8Xq/mzp2rqqoqe97x48f16KOPyuv1hqw4AACA5mrSZazFixfrhhtuUM+ePTVgwABJ0ieffCKn06kNGzaEtEAAAIDmaFLY6d+/v/bs2aPXXntNX3zxhSRp/PjxmjBhguLj40NaIAAAQHM0KezMnz9fycnJuueee4Lmv/rqqzp48KBmzpwZkuIAAACaq0n37Lz44ovq16/fKfMvv/xyLV++vNlFAQAAhEqTwo7f71f37t1PmZ+YmKiysrJmFwUAABAqTQo7KSkp+uijj06Z/9FHH6lHjx7NLgoAACBUmnTPzj333KNp06aptrZWI0aMkCTl5+fr4Ycf5gnKAAAgojQp7MyYMUOHDh3S73//e9XU1EiS2rVrp5kzZyo3NzekBQIAADRHk8KOw+HQU089pdmzZ+vzzz9XfHy8LrnkEjmdzlDXBwAA0CxNCjsNOnbsqJ///OehqgUAACDkmnSDMgAAQFtB2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYLaxhZ/78+fr5z3+uTp06KSkpSTfffLNKSkqC+lRVVSk7O1tdu3ZVx44dNXbsWJWXlwf1KS0tVWZmptq3b6+kpCTNmDFDJ06caM1dAQAAESqsYaegoEDZ2dnaunWr8vLyVFtbq5EjR+ro0aN2n+nTp+udd97R2rVrVVBQoP3792vMmDF2e11dnTIzM1VTU6MtW7Zo1apVWrlypebMmROOXQIAABHGYVmWFe4iGhw8eFBJSUkqKCjQNddco8rKSiUmJmr16tW65ZZbJElffPGFLrvsMvl8Pg0dOlTvvfeebrzxRu3fv1/JycmSpOXLl2vmzJk6ePCg4uLizrndQCAgt9utyspKuVyu0O7UPHdo19dWzKts5vKMGwDg7Br7/R1R9+xUVv7wQd+lSxdJUmFhoWpra5Wenm736devn3r16iWfzydJ8vl86t+/vx10JCkjI0OBQEDFxcWn3U51dbUCgUDQBAAAzBQxYae+vl7Tpk3TL37xC11xxRWSJL/fr7i4OCUkJAT1TU5Olt/vt/ucHHQa2hvaTmf+/Plyu932lJKSEuK9AQAAkSJiwk52drY+++wzrVmzpsW3lZubq8rKSnvat29fi28TAACER0y4C5CkqVOnat26ddq8ebN69uxpz/d4PKqpqVFFRUXQ2Z3y8nJ5PB67z/bt24PW1/BrrYY+f8vpdMrpdIZ4LwAAQCQK65kdy7I0depUvfnmm/rwww914YUXBrWnpaUpNjZW+fn59rySkhKVlpbK6/VKkrxer3bt2qUDBw7YffLy8uRyuZSamto6OwIAACJWWM/sZGdna/Xq1Xr77bfVqVMn+x4bt9ut+Ph4ud1uTZo0STk5OerSpYtcLpfuu+8+eb1eDR06VJI0cuRIpaam6vbbb9fChQvl9/s1a9YsZWdnc/YGAACEN+wsW7ZMkjR8+PCg+StWrNAdd9whSVq0aJGioqI0duxYVVdXKyMjQy+88ILdNzo6WuvWrdOUKVPk9XrVoUMHZWVl6bHHHmut3QAAABEsop6zEy48Z6cF8JydpuE5OwDQaG3yOTsAAAChRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKOFNexs3rxZo0ePVo8ePeRwOPTWW28FtVuWpTlz5qh79+6Kj49Xenq69uzZE9Tnu+++04QJE+RyuZSQkKBJkybpyJEjrbgXAAAgkoU17Bw9elQDBgzQ0qVLT9u+cOFCPf/881q+fLm2bdumDh06KCMjQ1VVVXafCRMmqLi4WHl5eVq3bp02b96syZMnt9YuAACACBcTzo2PGjVKo0aNOm2bZVlavHixZs2apZtuukmS9M///M9KTk7WW2+9pd/+9rf6/PPPtX79eu3YsUODBg2SJC1ZskS/+tWv9Mc//lE9evQ47bqrq6tVXV1tvw4EAiHeMwAAECki9p6dvXv3yu/3Kz093Z7ndrs1ZMgQ+Xw+SZLP51NCQoIddCQpPT1dUVFR2rZt2xnXPX/+fLndbntKSUlpuR0BAABhFbFhx+/3S5KSk5OD5icnJ9ttfr9fSUlJQe0xMTHq0qWL3ed0cnNzVVlZaU/79u0LcfUAACBShPUyVrg4nU45nc5wlwEAAFpBxJ7Z8Xg8kqTy8vKg+eXl5Xabx+PRgQMHgtpPnDih7777zu4DAADObxEbdi688EJ5PB7l5+fb8wKBgLZt2yav1ytJ8nq9qqioUGFhod3nww8/VH19vYYMGdLqNQMAgMgT1stYR44c0V/+8hf79d69e7Vz50516dJFvXr10rRp0/TEE0/okksu0YUXXqjZs2erR48euvnmmyVJl112mW644Qbdc889Wr58uWprazV16lT99re/PeMvsQAAwPklrGHn448/1rXXXmu/zsnJkSRlZWVp5cqVevjhh3X06FFNnjxZFRUVuvrqq7V+/Xq1a9fOXua1117T1KlTdd111ykqKkpjx47V888/3+r7AgAAIpPDsiwr3EWEWyAQkNvtVmVlpVwuV2hXPs8d2vW1FfMqm7k84wYAOLvGfn9H7D07AAAAoUDYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGiwl3AaGydOlSPf300/L7/RowYICWLFmiwYMHh7ssoHXNc4e7gvCYVxnuCs4/HGtoQ4wIO2+88YZycnK0fPlyDRkyRIsXL1ZGRoZKSkqUlJQU7vIARLLz9Utb4osb5w0jws6zzz6re+65R3feeackafny5Xr33Xf16quv6pFHHglzdQAA/P/O13Ad5mDd5sNOTU2NCgsLlZuba8+LiopSenq6fD7faZeprq5WdXW1/bqy8of/CIFAIPQFVluhX2db0NyxZNyahnH78c7XMZMYt6bgPdo0LfH9qv/3vW1Z5xhXq43761//akmytmzZEjR/xowZ1uDBg0+7zNy5cy1JTExMTExMTAZM+/btO2tWaPNndpoiNzdXOTk59uv6+np999136tq1qxwORxgrC51AIKCUlBTt27dPLpcr3OW0GYxb0zBuTcO4/XiMWdOYOm6WZenw4cPq0aPHWfu1+bDTrVs3RUdHq7y8PGh+eXm5PB7PaZdxOp1yOp1B8xISElqqxLByuVxGHdithXFrGsataRi3H48xaxoTx83tdp+zT5t/zk5cXJzS0tKUn59vz6uvr1d+fr68Xm8YKwMAAJGgzZ/ZkaScnBxlZWVp0KBBGjx4sBYvXqyjR4/av84CAADnLyPCzrhx43Tw4EHNmTNHfr9fAwcO1Pr165WcnBzu0sLG6XRq7ty5p1yuw9kxbk3DuDUN4/bjMWZNc76Pm8OyzvV7LQAAgLarzd+zAwAAcDaEHQAAYDTCDgAAMBphBwAAGI2wE2GWLl2qPn36qF27dhoyZIi2b99ut1VVVSk7O1tdu3ZVx44dNXbs2FMeplhaWqrMzEy1b99eSUlJmjFjhk6cOBHUZ9OmTfrZz34mp9Opiy++WCtXrgxq37x5s0aPHq0ePXrI4XDorbfeaqndDZmWHreysjLddtttuvTSSxUVFaVp06adUkNxcbHGjh2rPn36yOFwaPHixS21uyFztnF76aWXNHz4cLlcLjkcDlVUVJyy/HfffacJEybI5XIpISFBkyZN0pEjR+z2qqoq3XHHHerfv79iYmJ08803n7KOxoxtpDjXe8OyLM2ZM0fdu3dXfHy80tPTtWfPnqA+Tz75pK666iq1b9/+jA8zvf/++5WWlian06mBAwee0t6YcY00LX2sSdKnn36qX/7yl2rXrp1SUlK0cOHCoPa29h5treMtFJ9/kY6wE0HeeOMN5eTkaO7cufrzn/+sAQMGKCMjQwcOHJAkTZ8+Xe+8847Wrl2rgoIC7d+/X2PGjLGXr6urU2ZmpmpqarRlyxatWrVKK1eu1Jw5c+w+e/fuVWZmpq699lrt3LlT06ZN0913363333/f7nP06FENGDBAS5cubb2db4bWGLfq6molJiZq1qxZGjBgwGnrOHbsmC666CItWLDgjE/vjiTnGrdjx47phhtu0D/8wz+ccR0TJkxQcXGx8vLytG7dOm3evFmTJ0+22+vq6hQfH6/7779f6enpp11HY8Y2UpzrvbFw4UI9//zzWr58ubZt26YOHTooIyNDVVVVdp+amhrdeuutmjJlylm3ddddd2ncuHGnbWvMuEaS1jjWAoGARo4cqd69e6uwsFBPP/205s2bp5deesnu09beo61xvIXq8y/iheKPcSI0Bg8ebGVnZ9uv6+rqrB49eljz58+3KioqrNjYWGvt2rV2++eff25Jsnw+n2VZlvXf//3fVlRUlOX3++0+y5Yts1wul1VdXW1ZlmU9/PDD1uWXXx603XHjxlkZGRmnrUmS9eabb4ZqF1tEa4zbyYYNG2Y98MADZ62pd+/e1qJFi5q3Yy3sbON2so0bN1qSrO+//z5o/u7duy1J1o4dO+x57733nuVwOKy//vWvp2wvKyvLuummm85aU2PGNlL87Xujvr7e8ng81tNPP23Pq6iosJxOp/X666+fsvyKFSsst9t91m3MnTvXGjBgwFn7NGZcw601jrUXXnjB6ty5c9B7dubMmVbfvn1PW1NbeI+erKWOt5b4/ItEnNmJEDU1NSosLAz6v7SoqCilp6fL5/OpsLBQtbW1Qe39+vVTr1695PP5JEk+n0/9+/cPephiRkaGAoGAiouL7T5/+3+CGRkZ9jramtYaN9Oca9waw+fzKSEhQYMGDbLnpaenKyoqStu2bQt5zZFu79698vv9QWPqdrs1ZMiQNvv+CoXWOtZ8Pp+uueYaxcXF2X0yMjJUUlKi77//PkR7EzlCdbydL59/hJ0I8e2336quru6Upz4nJyfL7/fL7/crLi7ulGuuDe2S5Pf7T7t8Q9vZ+gQCAR0/fjyUu9QqWmvcTHOucWsMv9+vpKSkoHkxMTHq0qWLseN2Ng373JwxNVFrHWvn2/s4VMfb+TJuhB0AAGA0wk6E6Natm6Kjo0/5lVB5ebk8Ho88Ho9qampO+ZVCQ7skeTye0y7f0Ha2Pi6XS/Hx8aHcpVbRWuNmmnONW2N4PB77BtMGJ06c0HfffWfsuJ1Nwz43Z0xN1FrH2vn2Pg7V8Xa+jBthJ0LExcUpLS1N+fn59rz6+nrl5+fL6/UqLS1NsbGxQe0lJSUqLS2V1+uVJHm9Xu3atSvoQyEvL08ul0upqal2n5PX0dCnYR1tTWuNm2nONW6N4fV6VVFRocLCQnvehx9+qPr6eg0ZMiTkNUe6Cy+8UB6PJ2hMA4GAtm3b1mbfX6HQWsea1+vV5s2bVVtba/fJy8tT37591blz5xDtTeQI1fF23nz+hfsOafw/a9assZxOp7Vy5Upr9+7d1uTJk62EhAT7Lvl7773X6tWrl/Xhhx9aH3/8seX1ei2v12svf+LECeuKK66wRo4cae3cudNav369lZiYaOXm5tp9vvrqK6t9+/bWjBkzrM8//9xaunSpFR0dba1fv97uc/jwYauoqMgqKiqyJFnPPvusVVRUZH3zzTetNxg/QmuMm2VZ9pikpaVZt912m1VUVGQVFxfb7dXV1Xaf7t27Ww899JBVVFRk7dmzp3UG4kc617iVlZVZRUVF1ssvv2xJsjZv3mwVFRVZhw4dstdxww03WD/96U+tbdu2Wf/zP/9jXXLJJdb48eODtlNcXGwVFRVZo0ePtoYPH26P0cnONbaR4lzvjQULFlgJCQnW22+/bX366afWTTfdZF144YXW8ePH7XV88803VlFRkfXoo49aHTt2tNd3+PBhu8+ePXusoqIi63e/+5116aWX2n1O/nVMY8Y1UrTGsVZRUWElJydbt99+u/XZZ59Za9assdq3b2+9+OKLdp+29h5tjeMtVJ9/kY6wE2GWLFli9erVy4qLi7MGDx5sbd261W47fvy49fvf/97q3Lmz1b59e+vXv/61VVZWFrT8119/bY0aNcqKj4+3unXrZj344INWbW1tUJ+NGzdaAwcOtOLi4qyLLrrIWrFixSntkk6ZsrKyWmq3m601xu10Y9K7d2+7fe/evaftM2zYsJbc9WY527jNnTv3tPtz8vFy6NAha/z48VbHjh0tl8tl3XnnnUFf2pb1w098T7eek51rbCPFud4b9fX11uzZs63k5GTL6XRa1113nVVSUhK0jqysrNOuY+PGjXafYcOGnbbP3r177T6NGddI0hrH2ieffGJdffXVltPptC644AJrwYIFQe1t7T3aWsdbKD7/Ip3Dsizrx58PAgAAaBu4ZwcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphB0CLGz58uKZNm3bG9j59+mjx4sWtUsvXX38th8OhnTt3tsr2AIQfYQdA2O3YsUOTJ0+2XzscDr311luNXn7lypVKSEhoVN+UlBSVlZXpiiuu+JFVAmirYsJdAAAkJia2ynZqamoUFxcnj8fTKtsDEBk4swOgVZw4cUJTp06V2+1Wt27dNHv2bDX8ab6TL2P16dNHkvTrX/9aDofDfv3JJ5/o2muvVadOneRyuZSWlqaPP/5YmzZt0p133qnKyko5HA45HA7NmzfPXtfjjz+uiRMnyuVyafLkyadcxtq0aZMcDofy8/M1aNAgtW/fXldddZVKSkqC6n/iiSeUlJSkTp066e6779YjjzyigQMH2u2bNm3S4MGD1aFDByUkJOgXv/iFvvnmm5YaTgA/AmEHQKtYtWqVYmJitH37dj333HN69tln9U//9E+n9NuxY4ckacWKFSorK7NfT5gwQT179tSOHTtUWFioRx55RLGxsbrqqqu0ePFiuVwulZWVqaysTA899JC9vj/+8Y8aMGCAioqKNHv27DPW94c//EHPPPOMPv74Y8XExOiuu+6y21577TU9+eSTeuqpp1RYWKhevXpp2bJldvuJEyd08803a9iwYfr000/l8/k0efJkORyOZo8bgObjMhaAVpGSkqJFixbJ4XCob9++2rVrlxYtWqR77rknqF/DJa2EhISgy02lpaWaMWOG+vXrJ0m65JJL7Da32y2Hw3Hay1MjRozQgw8+aL/++uuvT1vfk08+qWHDhkmSHnnkEWVmZqqqqkrt2rXTkiVLNGnSJN15552SpDlz5mjDhg06cuSIJCkQCKiyslI33nijfvKTn0iSLrvssh81PgBaDmd2ALSKoUOHBp3p8Hq92rNnj+rq6hq1fE5Oju6++26lp6drwYIF+vLLLxu13KBBgxrV78orr7T/3b17d0nSgQMHJEklJSUaPHhwUP+TX3fp0kV33HGHMjIyNHr0aD333HMqKytr1HYBtDzCDoA2Yd68eSouLlZmZqY+/PBDpaam6s033zznch06dGjU+mNjY+1/N4Sy+vr6Rte3YsUK+Xw+XXXVVXrjjTd06aWXauvWrY1eHkDLIewAaBXbtm0Ler1161Zdcsklio6OPqVvbGzsac/4XHrppZo+fbo2bNigMWPGaMWKFZKkuLi4Rp8haoq+ffva9w41+NvXkvTTn/5Uubm52rJli6644gqtXr26xWoC0HiEHQCtorS0VDk5OSopKdHrr7+uJUuW6IEHHjht3z59+ig/P19+v1/ff/+9jh8/rqlTp2rTpk365ptv9NFHH2nHjh32fTF9+vTRkSNHlJ+fr2+//VbHjh0Lae333XefXnnlFa1atUp79uzRE088oU8//dQ+A7R3717l5ubK5/Ppm2++0YYNG7Rnzx7u2wEiBDcoA2gVEydO1PHjxzV48GBFR0frgQceCHqQ4MmeeeYZ5eTk6OWXX9YFF1yg//3f/9WhQ4c0ceJElZeXq1u3bhozZoweffRRSdJVV12le++9V+PGjdOhQ4c0d+5c++fnoTBhwgR99dVXeuihh1RVVaXf/OY3uuOOO7R9+3ZJUvv27fXFF19o1apVOnTokLp3767s7Gz97ne/C1kNAJrOYTU86AIA0GjXX3+9PB6P/uVf/iXcpQA4B87sAMA5HDt2TMuXL1dGRoaio6P1+uuv64MPPlBeXl64SwPQCJzZAYBzOH78uEaPHq2ioiJVVVWpb9++mjVrlsaMGRPu0gA0AmEHAAAYjV9jAQAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABG+/8Ahlkxi8YT07QAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# parse log file for arn\n",
    "with open(log_file) as openfile:\n",
    "    for line in openfile:\n",
    "        for part in line.split():\n",
    "            if \"arn:\" in part:\n",
    "                arn = part\n",
    "                break\n",
    "# remove final semicolon in logs\n",
    "arn = arn[:-1]\n",
    "# print(arn)\n",
    "\n",
    "# with this arn we can restore again task from unique arn\n",
    "task_load = AwsQuantumTask(arn=arn)\n",
    "\n",
    "# get results of quantum task\n",
    "result = task_load.result()\n",
    "\n",
    "# get measurement shots\n",
    "counts = result.measurement_counts\n",
    "\n",
    "# plot using Counter\n",
    "plt.bar(counts.keys(), counts.values(), color='tab:orange');\n",
    "plt.xlabel('bitstrings');\n",
    "plt.ylabel('counts');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--- \n",
    "## APPENDIX"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### APPENDIX: ADVANCED FUNCTIONALITY WITH ASYNCHRONOUS EXECUTION"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__ASYNCHRONOUS EXECUTION__: When replacing the ```result()``` call on the task object above with ```async_result()```, we can get the quantum task result asynchronously. Consecutive calls to this method return the result cached from the most recent request. See [here](https://github.com/amazon-braket/braket-python-sdk/blob/master/src/braket/aws/aws_quantum_task.py#L206) for source code implementation. \n",
    "\n",
    "While ```result()``` is a blocking call that waits for the result, ```async_result()``` is a non-blocking call. For example, in Jupyter as shown here, if you run ```result()```, the notebook will stop and wait at this cell for a certain polling time (set as ```poll_timeout_seconds``` with default of 5 days) till the polling returns the result object or times out. If you run ```async_result()```, the notebook immediately goes to the next cell, _not_ waiting for polling to complete. Calling `result()` on the `async_result` object before it has completed, an `asyncio.exceptions.InvalidStateError` will be raised. This is expected behavior. Later, you can call ```result()``` and get the actual result from the task. \n",
    "\n",
    "Alternatively, we have provided a basic `asyncio` waiter function `wait_on_result()`, which will create a blocking call, wait for the result, and then return that result for downstream use. We have defaulted the notebook to leverage this call in favor of avoiding the `InvalidStateError`, but we have left the non-blocking `async_result.result()` call example as an option."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:27.408945Z",
     "start_time": "2023-08-29T21:29:27.402497Z"
    }
   },
   "outputs": [],
   "source": [
    "# asyncio waiter function to leverage Task.async_result() object\n",
    "async def wait_on_result(async_result):\n",
    "    print('Waiting on task.')\n",
    "    await async_result\n",
    "\n",
    "    print(f'Final task state: {async_result._state}')\n",
    "    res = async_result.result()\n",
    "    \n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:27.588403Z",
     "start_time": "2023-08-29T21:29:27.409630Z"
    }
   },
   "outputs": [],
   "source": [
    "# example with async_result - immediately returns asyncio Future object\n",
    "async_result = device.run(circ2, shots=100).async_result()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:30.099876Z",
     "start_time": "2023-08-29T21:29:27.594182Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Waiting on task.\n",
      "Final task state: FINISHED\n",
      "Counter({'00': 100})\n"
     ]
    }
   ],
   "source": [
    "# async_result.result() then returns the actual result (once completed)\n",
    "# Non-blocking call. Will raise an InvalidStateError if this is run before async task is complete:\n",
    "# async_res = async_result.result()\n",
    "# Blocking call, leveraging asyncio.run and await\n",
    "async_res = asyncio.run(wait_on_result(async_result))\n",
    "# get measurement shots\n",
    "counts = async_res.measurement_counts\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can also define custom callbacks to be invoked when the Future is completed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:30.852226Z",
     "start_time": "2023-08-29T21:29:30.100034Z"
    }
   },
   "outputs": [],
   "source": [
    "# async_result returns back a Future. \n",
    "# Details on Future: https://docs.python.org/3.8/library/asyncio-future.html#asyncio.Future\n",
    "future = device.run(circ2, shots=100).async_result()\n",
    "\n",
    "# this is invoked when the Future is done. i.e. task is in a terminal state.\n",
    "# This will print out to STDOUT when its done.\n",
    "def call_back_function(future):\n",
    "    print(f\"Custom task Result: {future.result().measurement_probabilities}\")\n",
    "\n",
    "# attached the callback function to the future.\n",
    "future.add_done_callback(call_back_function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:29:31.001598Z",
     "start_time": "2023-08-29T21:29:30.856842Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantum Task Summary\n",
      "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 4200, 'tasks': {'COMPLETED': 4, 'QUEUED': 1, 'CREATED': 1}, 'execution_duration': datetime.timedelta(microseconds=22000), 'billed_execution_duration': datetime.timedelta(seconds=12)}}\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: 0.02 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",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}