Quantum Circuits.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "fad11076-f053-41db-9a77-575fd7b45cf7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#Diving deep into quantum circuits\n",
    "#importing libraries \n",
    "import asyncio # a library to write concurrent code using the async/await syntax.\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 #to store information about your script and track events that occur\n",
    "\n",
    "\n",
    "#AWS imports : Importing braket SDK modules\n",
    "from braket.circuits import Circuit,Gate,Instruction, circuit, Observable,FreeParameter\n",
    "from braket.circuits.serialization import IRType #The IR format is used to represent the circuit in a way that can be easily translated to other formats, such as OpenQASM, which is a widely used quantum assembly language.\n",
    "from braket.aws import AwsDevice,AwsQuantumTask\n",
    "from braket.devices import LocalSimulator "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "783aeeb1-29af-466e-a04c-4ef484feb149",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |0| 1 |\n",
      "            \n",
      "q0 : -H-C---\n",
      "        |   \n",
      "q1 : -H-|-C-\n",
      "        | | \n",
      "q2 : -H-X-|-\n",
      "          | \n",
      "q3 : -H---X-\n",
      "\n",
      "T  : |0| 1 |\n"
     ]
    }
   ],
   "source": [
    "#DEFINING A CIRCUIT WITH 4 QUBITS\n",
    "my_circuit = Circuit().h(range(4)).cnot(control=0,target = 2).cnot(1,3)\n",
    "print(my_circuit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "f208b0b6-45c9-4c59-9268-88ca78192fa8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MomentsKey(time=0, qubits=QubitSet([Qubit(0)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0)\n",
      "MomentsKey(time=0, qubits=QubitSet([Qubit(1)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0)\n",
      "MomentsKey(time=0, qubits=QubitSet([Qubit(2)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0)\n",
      "MomentsKey(time=0, qubits=QubitSet([Qubit(3)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0)\n",
      "MomentsKey(time=1, qubits=QubitSet([Qubit(0), Qubit(2)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=0)\n",
      "MomentsKey(time=1, qubits=QubitSet([Qubit(1), Qubit(3)]), moment_type=<MomentType.GATE: 'gate'>, noise_index=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": 90,
   "id": "e13b9ed0-34ba-4719-ab48-aa01ab7341e3",
   "metadata": {
    "tags": []
   },
   "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": "code",
   "execution_count": 91,
   "id": "e8d58352-2d11-4540-81c7-6890446c65f6",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |   0    | 1 |2|\n",
      "                     \n",
      "q0 : -Rx(0.15)-C-----\n",
      "               |     \n",
      "q1 : -Ry(0.20)-|-C-X-\n",
      "               | |   \n",
      "q2 : -Rz(0.25)-X-|---\n",
      "                 |   \n",
      "q3 : -H----------X-X-\n",
      "\n",
      "T  : |   0    | 1 |2|\n"
     ]
    }
   ],
   "source": [
    "#Defining the 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([1,3])\n",
    "print(my_circuit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "1785c33b-c0c5-431d-bf54-4c4848b32b11",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |    0    | 1 |2|\n",
      "                      \n",
      "q0 : -Rx(alpha)-C-----\n",
      "                |     \n",
      "q1 : -Ry(beta)--|-C-X-\n",
      "                | |   \n",
      "q2 : -Rz(gamma)-X-|---\n",
      "                  |   \n",
      "q3 : -H-----------X-X-\n",
      "\n",
      "T  : |    0    | 1 |2|\n",
      "\n",
      "Unassigned parameters: [alpha, beta, gamma].\n"
     ]
    }
   ],
   "source": [
    "#designing gates with free parameters and 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(0,2).cnot(1,3).x([1,3])\n",
    "print(my_circuit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "34fc1463-ddd0-41e5-9d4a-df803d606f6b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['CCNot', 'CNot', 'CPhaseShift', 'CPhaseShift00', 'CPhaseShift01', 'CPhaseShift10', 'CSwap', 'CV', 'CY', 'CZ', 'ECR', 'GPi', 'GPi2', 'H', 'I', 'ISwap', 'MS', 'PSwap', 'PhaseShift', 'PulseGate', 'Rx', 'Ry', 'Rz', 'S', 'Si', 'Swap', 'T', 'Ti', 'Unitary', 'V', 'Vi', 'X', 'XX', 'XY', 'Y', 'YY', 'Z', 'ZZ']\n"
     ]
    }
   ],
   "source": [
    "#Printing 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": 94,
   "id": "ff4e816b-95a5-46db-9979-2b58b0036e49",
   "metadata": {},
   "outputs": [],
   "source": [
    "#HELPER function to build a 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]])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "31ac8020-64e8-4456-aecd-b2ce05632f19",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.70710678-0.70710678j 0.        +0.j        ]\n",
      " [0.        +0.j         0.70710678+0.70710678j]]\n",
      "\n",
      "T  : |0|1|\n",
      "          \n",
      "q0 : -U-C-\n",
      "        | \n",
      "q1 : -H-X-\n",
      "\n",
      "T  : |0|1|\n"
     ]
    }
   ],
   "source": [
    "# define the print custom unitary \n",
    "import numpy as np\n",
    "my_u3 = u3(np.pi/2, 0, 0)\n",
    "print(my_u3)\n",
    "\n",
    "#example circuit applying custom U to the first qubit\n",
    "circ = Circuit().unitary(matrix = my_u3, targets=[0]).h(1).cnot(0,1)\n",
    "print()\n",
    "print(circ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "ef472ecf-d46c-4b97-983f-0232709ea307",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#helper function to build custom gate \n",
    "@circuit.subroutine(register=True) # it's a subroutine and @ is called decorator for modifying the subroutine\n",
    "\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",
    "    #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",
    "    print()\n",
    "    print()\n",
    "    \n",
    "    #define custom Braket gate \n",
    "    circ = Circuit()\n",
    "    circ.unitary(matrix=u, targets=target)\n",
    "    \n",
    "    return circ\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "667a3525-a047-4a7e-be68-f95929933041",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e61a95b7-bb7c-4f5f-9be2-f73456704d11",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "a6385db9-b119-4de5-849e-b93e6edaa5bc",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unitary:  [[0.92387953-0.38268343j 0.        +0.j        ]\n",
      " [0.        +0.j         0.92387953+0.38268343j]]\n",
      "\n",
      "\n",
      "T  : |0|1|\n",
      "          \n",
      "q0 : -U-C-\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(0,1)\n",
    "print(circ2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "c96870e9-fd24-4a3e-83e4-38d7a54e01c6",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |   0    | 1 |2|\n",
      "                     \n",
      "q0 : -Rx(0.15)-C---X-\n",
      "               |     \n",
      "q1 : -Ry(0.20)-|-C---\n",
      "               | |   \n",
      "q2 : -Rz(0.25)-X-|---\n",
      "                 |   \n",
      "q3 : -H----------X---\n",
      "\n",
      "T  : |   0    | 1 |2|\n",
      "\n",
      "Total circuit depth: 3\n"
     ]
    }
   ],
   "source": [
    "#CIRCUIT DEPTH AND CIRCUIT SIZE\n",
    "#We can get the circuit depth (the number of moments defining our circuit) with ```circuit.depth``` \n",
    "\n",
    "#DEFINING CIRCUIT WITH PARAMETRIZED GATES\n",
    "my_circuit = Circuit().rx(0,0.15).ry(1,0.2).rz(2, 0.25).h(3).cnot(0,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)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "a4de5ffe-28ea-4a29-8a9b-e0e2099553b3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |   0    | 1 |\n",
      "                   \n",
      "q0 : -Rx(0.15)-C---\n",
      "               |   \n",
      "q1 : -Ry(0.20)-|-C-\n",
      "               | | \n",
      "q2 : -Rz(0.25)-X-|-\n",
      "                 | \n",
      "q3 : -H----------X-\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": [
    "# defining 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",
    "# getting circuit depth\n",
    "circuit_depth = my_circuit.depth\n",
    "# get qubit number\n",
    "qubit_count = my_circuit.qubit_count\n",
    "# getting approx. estimate of circuit size\n",
    "circuit_size = circuit_depth*qubit_count\n",
    "# printing circuit\n",
    "print(my_circuit)\n",
    "print()\n",
    "# printing 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",
   "id": "ad73adb9-61a7-461b-87b7-6dabd5c77b96",
   "metadata": {},
   "source": [
    "                                      APPENDING CIRCUITS\n",
    "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": 100,
   "id": "fd48d367-0fc5-4f07-851f-65df25ec6f77",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |   0    | 1 |\n",
      "                   \n",
      "q0 : -Rx(0.15)-C---\n",
      "               |   \n",
      "q1 : -Ry(0.20)-|-C-\n",
      "               | | \n",
      "q2 : -Rz(0.25)-X-|-\n",
      "                 | \n",
      "q3 : -H----------X-\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 EXPTENSION BY APPENDING GATES ( Y ON QUBIT 4)\n",
    "my_circuit = my_circuit.y(4)\n",
    "# updating circuit depth , circuit count , circuit size\n",
    "circuit_depth = my_circuit.depth\n",
    "qubit_count = my_circuit.qubit_count\n",
    "\n",
    "circuit_size = circuit_depth*qubit_count\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": "code",
   "execution_count": 101,
   "id": "5f354611-85f9-4ef2-8b48-d328b8d5d441",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#Alternatively, we can define a gate as an Instruction and use the add_instruction(...) \n",
    "#method to add this gate to an existing circuit object.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "bf20ffce-49b5-4bdf-834c-868cdfc6ff58",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |   0    | 1 |2|\n",
      "                     \n",
      "q0 : -Rx(0.15)-C---C-\n",
      "               |   | \n",
      "q1 : -Ry(0.20)-|-C-X-\n",
      "               | |   \n",
      "q2 : -Rz(0.25)-X-|---\n",
      "                 |   \n",
      "q3 : -H----------X---\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": [
    "    # INSTRUCTION TO CIRCUIT\n",
    "    gate_instr = Instruction(Gate.CNot(),[0,1])\n",
    "    my_circuit = my_circuit.add_instruction(gate_instr)\n",
    "    # updating circuit depth , circuit count , circuit size\n",
    "    circuit_depth = my_circuit.depth\n",
    "    qubit_count = my_circuit.qubit_count\n",
    "\n",
    "    circuit_size = circuit_depth*qubit_count\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": "code",
   "execution_count": 103,
   "id": "21d4cca2-8330-46f2-95e6-19e210e7534e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |   0    | 1 |2|3|\n",
      "                       \n",
      "q0 : -Rx(0.15)-C---C-C-\n",
      "               |   | | \n",
      "q1 : -Ry(0.20)-|-C-X-X-\n",
      "               | |     \n",
      "q2 : -Rz(0.25)-X-|-----\n",
      "                 |     \n",
      "q3 : -H----------X-----\n",
      "                       \n",
      "q4 : -X--------Y-------\n",
      "\n",
      "T  : |   0    | 1 |2|3|\n",
      "\n",
      "Total circuit depth: 4\n",
      "Number of qubits: 5\n",
      "Circuit size: 20\n"
     ]
    }
   ],
   "source": [
    "# add instruction to circuit\n",
    "gate_instr = Instruction(Gate.CNot(), [0, 1])\n",
    "my_circuit = my_circuit.add_instruction(gate_instr)\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": "code",
   "execution_count": 104,
   "id": "3b3f3f89-3d41-4b51-91c7-643ec2460a2a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |   0    | 1 |2|3|4|\n",
      "                         \n",
      "q0 : -Rx(0.15)-C---C-C-C-\n",
      "               |   | | | \n",
      "q1 : -Ry(0.20)-|-C-X-X-X-\n",
      "               | |       \n",
      "q2 : -Rz(0.25)-X-|-------\n",
      "                 |       \n",
      "q3 : -H----------X-------\n",
      "                         \n",
      "q4 : -X--------Y---------\n",
      "\n",
      "T  : |   0    | 1 |2|3|4|\n",
      "\n",
      "Total circuit depth: 5\n",
      "Number of qubits: 5\n",
      "Circuit size: 25\n"
     ]
    }
   ],
   "source": [
    "# add instruction to circuit\n",
    "gate_instr = Instruction(Gate.CNot(), [0, 1])\n",
    "my_circuit = my_circuit.add_instruction(gate_instr)\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": "code",
   "execution_count": 105,
   "id": "783a34e6-f7f6-478b-8af8-ee7309626a7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#WE CAN APPEND TWO CIRCUITS WITH add_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "15cedae2-9751-441e-9ab1-1531acc30331",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |   0    | 1 |   2    |3|4|   5    |\n",
      "                                         \n",
      "q0 : -Rx(0.15)-C---C--------C-C-Rz(0.10)-\n",
      "               |   |        | |          \n",
      "q1 : -Ry(0.20)-|-C-X--------X-X-Rz(0.20)-\n",
      "               | |                       \n",
      "q2 : -Rz(0.25)-X-|-----------------------\n",
      "                 |                       \n",
      "q3 : -H----------X-Rz(0.30)--------------\n",
      "                                         \n",
      "q4 : -X--------Y---Rx(0.40)--------------\n",
      "\n",
      "T  : |   0    | 1 |   2    |3|4|   5    |\n",
      "\n",
      "Total circuit depth: 6\n",
      "Number of qubits: 5\n",
      "Circuit size: 30\n"
     ]
    }
   ],
   "source": [
    "#appending two circuits with add_circuit() functionality \n",
    "my_circuit2= Circuit().rz(0,0.1).rz(1,0.2).rz(3,0.3).rx(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": "code",
   "execution_count": 107,
   "id": "bc3ba376-4ba7-493a-b709-00d0340a5167",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "## CIRCUIT EXECUTION AND QUANTUM TASK TRACKING\n",
    "\n",
    "# Create the device. The experiment value must be unique among any devices in use at the tim\n",
    "device = AwsDevice(\"arn:aws:braket:::device/quantum-simulator/amazon/sv1\")\n",
    "\n",
    "# set up the device to be the Rigetti quantum computer\n",
    "# device = AwsDevice(\"arn:aws:braket:us-west-1::device/qpu/rigetti/Aspen-M-3\")\n",
    "\n",
    "# set up the device to be the IonQ quantum computer\n",
    "# device = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/ionq/Harmony\")\n",
    "\n",
    "# set up the device to be the Oxford Quantum Circuits (OQC) quantum computer\n",
    "# device = AwsDevice(\"arn:aws:braket:eu-west-2::device/qpu/oqc/Lucy\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "5c26587f-e21b-4b71-84af-487667f1c3ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "#CHECKING THE SET OF GATES THE DEVICE SUPPORTS\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "e971b4da-3a90-4f21-b644-610208ce76bb",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Quantum Gates supported by this device are:\t \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": [
    "#showing the properties of device\n",
    "device_properties = device.properties\n",
    "\n",
    "#to show supportedQuantumOperations ( supported gates for a device)\n",
    "device_operations = device_properties.dict()['action']['braket.ir.jaqcd.program']['supportedOperations']\n",
    "\n",
    "#This field also exists for other devices like QPUs\n",
    "print('The Quantum Gates supported by this device are:\\t \\n',device_operations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "75404ba6-3d31-4fca-8855-e7642827a2c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'POLLING PARAMETERS: With the run(...) method we can set two important parameters:\\n•\\tpoll_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 ∼5∗60∗60∗24∼5∗60∗60∗24 seconds).\\n•\\tpoll_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.'"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''POLLING PARAMETERS: With the run(...) method we can set two important parameters:\n",
    "•\tpoll_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 ∼5∗60∗60∗24∼5∗60∗60∗24 seconds).\n",
    "•\tpoll_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.'''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "0238c18c-3d4a-4cd3-8ed2-4b35c1a6531e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ID of quantum task: arn:aws:braket:us-east-1:666089549503:quantum-task/7a19c6b0-cbbc-477f-8e9b-fcb720eed033\n",
      "Status of quantum task: CREATED\n",
      "Status: 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: RUNNING\n",
      "Status: RUNNING\n",
      "Status: RUNNING\n",
      "Status: COMPLETED\n",
      "Counter({'00010': 500, '00000': 448, '00001': 18, '00011': 18, '01000': 5, '11110': 4, '11100': 4, '01010': 3})\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#defining the quantum task(asynchronous)\n",
    "task = device.run(my_circuit,poll_timeout_seconds = 100, 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",
    "#waiting for the job to complete\n",
    "while status != 'COMPLETED':\n",
    "    status = task.state()\n",
    "    print('Status:',status)\n",
    "\n",
    "#getting results of quantum task\n",
    "result = task.result()\n",
    "\n",
    "#get measurement shots\n",
    "counts = result.measurement_counts\n",
    "\n",
    "#printing 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": "code",
   "execution_count": 112,
   "id": "2af047ea-2545-4a50-803c-26a44a30cdcd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The on-demand simulators SV1 and DM1 also support \\nrunning parametrized tasks. The value of any free parameters can be fixed when \\nthe circuit is run using the optional `inputs` argument to `run`. `inputs` should be \\na `dict` of `string`-`float` pairs.'"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''The on-demand simulators SV1 and DM1 also support \n",
    "running parametrized tasks. The value of any free parameters can be fixed when \n",
    "the circuit is run using the optional `inputs` argument to `run`. `inputs` should be \n",
    "a `dict` of `string`-`float` pairs.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "2d623fc3-85b0-49f8-8478-f550d35191ec",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |    0    | 1 |2|\n",
      "                      \n",
      "q0 : -Rx(alpha)-C-----\n",
      "                |     \n",
      "q1 : -Ry(beta)--|-C-X-\n",
      "                | |   \n",
      "q2 : -Rz(gamma)-X-|---\n",
      "                  |   \n",
      "q3 : -H-----------X-X-\n",
      "\n",
      "T  : |    0    | 1 |2|\n",
      "\n",
      "Unassigned parameters: [alpha, beta, gamma].\n",
      "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: QUEUED\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: COMPLETED\n",
      "Counter({'0101': 500, '0100': 487, '0001': 8, '0000': 3, '1111': 1, '1110': 1})\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Defining 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": "code",
   "execution_count": 135,
   "id": "6b17ddff-7f56-4be9-864f-a5b377686d8a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'TASK METADATA: You can access a range of metadata associated with your task object, as shown below.'"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''TASK METADATA: You can access a range of metadata associated with your task object, as shown below.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "03b5324d-8b7f-4df4-be12-e91533abce3e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shots 1000\n",
      "date Thu, 05 Oct 2023 05:12:13 GMT\n",
      "1000 shots taken on Thu, 05 Oct 2023 05:12:13 GMT \n"
     ]
    }
   ],
   "source": [
    "#Getting metadata of all submitted quantum-task\n",
    "metadata = task.metadata()\n",
    "# metadata example\n",
    "shots = metadata['shots']\n",
    "date = metadata['ResponseMetadata']['HTTPHeaders']['date']\n",
    "print(\"shots\" , shots)\n",
    "print(\"date\", date)\n",
    "# print example metadata\n",
    "print(\"{} shots taken on {} \".format(shots,date))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "ae50c4b8-2066-4c30-b5cd-57766622fc46",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'  TASK RECONSTRUCTION \\n When kernel dies after you have submitted the task, \\n or you simply close your notebook. As recovery method, here \\n is how you can reconstruct the ```task``` object (given the corresponding unique arn). \\n You can reconstruct the ```task``` object using `\\n task = AwsQuantumTask(arn=...)`; then you can simply call `task.result()` to get \\n the result from S3. '"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "                                  '''  TASK RECONSTRUCTION \n",
    " When kernel dies after you have submitted the task, \n",
    " or you simply close your notebook. As recovery method, here \n",
    " is how you can reconstruct the ```task``` object (given the corresponding unique arn). \n",
    " You can reconstruct the ```task``` object using `\n",
    " task = AwsQuantumTask(arn=...)`; then you can simply call `task.result()` to get \n",
    " the result from S3. '''\n",
    "  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "0398e40a-26e0-43d5-998c-d9b2f8cc506a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status of (reconstructed) quantum task: COMPLETED\n"
     ]
    }
   ],
   "source": [
    "# Restoring 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": 118,
   "id": "61c8c0e3-98a9-4156-9842-8f25c3e7eb05",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({'0101': 500, '0100': 487, '0001': 8, '0000': 3, '1111': 1, '1110': 1})\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAquElEQVR4nO3de3QUZYL//0/nCgG6QyBJEwmgowKR2wwINON4YSLRjew4oOMgR6OirExghChidhC8Lsqs4mVBHNchnF0Rhz2Ls+CKxMhlVppbDIqgWUaRMEs6QSRpQHKv3x/zTf3sASR2Ot2dx/frnDonVc9TVc/znK7059StHZZlWQIAADBUTKQbAAAA0JEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARouLdAOiQUtLi44cOaIePXrI4XBEujkAAKANLMvSiRMnlJGRoZiYc5+/IexIOnLkiDIzMyPdDAAAEITDhw+rb9++5ywn7Ejq0aOHpL8OltPpjHBrAABAW/j9fmVmZtrf4+dC2JHsS1dOp5OwAwBAJ3O+W1C4QRkAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARoto2HnkkUfkcDgCpkGDBtnldXV1ys/PV69evdS9e3dNnjxZVVVVAduoqKhQbm6ukpKSlJaWprlz56qpqSncXQEAAFEq4j8Eetlll+ndd9+15+Pi/v8mzZkzR2+99ZbWrFkjl8ulmTNnatKkSXr//fclSc3NzcrNzZXb7da2bdtUWVmp22+/XfHx8fqnf/qnsPcFAABEn4iHnbi4OLnd7jOW19bW6tVXX9WqVas0fvx4SdKKFSs0ePBgbd++XWPHjtXGjRu1f/9+vfvuu0pPT9eIESP0+OOPa968eXrkkUeUkJAQ7u4AAIAoE/F7dg4cOKCMjAxddNFFmjp1qioqKiRJpaWlamxsVHZ2tl130KBB6tevn7xeryTJ6/Vq6NChSk9Pt+vk5OTI7/dr375959xnfX29/H5/wAQAAMwU0bAzZswYFRUVacOGDXrppZd08OBB/eQnP9GJEyfk8/mUkJCg5OTkgHXS09Pl8/kkST6fLyDotJa3lp3LokWL5HK57CkzMzO0HUP7ORzfzwkAEHIRvYx1/fXX238PGzZMY8aMUf/+/fWHP/xBXbt27bD9FhYWqqCgwJ73+/0EHgAADBXxy1jflJycrEsvvVR//vOf5Xa71dDQoJqamoA6VVVV9j0+brf7jKezWufPdh9Qq8TERDmdzoAJAACYKarCzsmTJ/XZZ5+pT58+GjlypOLj41VSUmKXl5eXq6KiQh6PR5Lk8Xi0d+9eVVdX23WKi4vldDqVlZUV9vYDAIDoE9HLWA888IAmTpyo/v3768iRI1q4cKFiY2M1ZcoUuVwuTZs2TQUFBUpJSZHT6dSsWbPk8Xg0duxYSdKECROUlZWl2267TYsXL5bP59P8+fOVn5+vxMTESHYNAABEiYiGnb/85S+aMmWKjh07ptTUVF1xxRXavn27UlNTJUlLlixRTEyMJk+erPr6euXk5GjZsmX2+rGxsVq/fr1mzJghj8ejbt26KS8vT4899likugQAAKKMw7IsK9KNiDS/3y+Xy6Xa2lru34kW39cnkzgcAaDN2vr9HVX37AAAAIQaYQcAABgt4j8XYTwuxwAAEFGc2QEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARouasPPUU0/J4XBo9uzZ9rK6ujrl5+erV69e6t69uyZPnqyqqqqA9SoqKpSbm6ukpCSlpaVp7ty5ampqCnPrAQBAtIqKsLNr1y69/PLLGjZsWMDyOXPmaN26dVqzZo22bNmiI0eOaNKkSXZ5c3OzcnNz1dDQoG3btmnlypUqKirSggULwt0FAAAQpSIedk6ePKmpU6fqlVdeUc+ePe3ltbW1evXVV/Xss89q/PjxGjlypFasWKFt27Zp+/btkqSNGzdq//79+vd//3eNGDFC119/vR5//HEtXbpUDQ0N59xnfX29/H5/wAQAAMwU8bCTn5+v3NxcZWdnBywvLS1VY2NjwPJBgwapX79+8nq9kiSv16uhQ4cqPT3drpOTkyO/3699+/adc5+LFi2Sy+Wyp8zMzBD3CgAARIuIhp3Vq1frgw8+0KJFi84o8/l8SkhIUHJycsDy9PR0+Xw+u843g05reWvZuRQWFqq2ttaeDh8+3M6eAACAaBUXqR0fPnxY9913n4qLi9WlS5ew7jsxMVGJiYlh3ScAAIiMiJ3ZKS0tVXV1tX70ox8pLi5OcXFx2rJli1544QXFxcUpPT1dDQ0NqqmpCVivqqpKbrdbkuR2u894Oqt1vrUOAAD4fotY2PnpT3+qvXv3as+ePfY0atQoTZ061f47Pj5eJSUl9jrl5eWqqKiQx+ORJHk8Hu3du1fV1dV2neLiYjmdTmVlZYW9TwAAIPpE7DJWjx49NGTIkIBl3bp1U69evezl06ZNU0FBgVJSUuR0OjVr1ix5PB6NHTtWkjRhwgRlZWXptttu0+LFi+Xz+TR//nzl5+dzmQoAAEiKYNhpiyVLligmJkaTJ09WfX29cnJytGzZMrs8NjZW69ev14wZM+TxeNStWzfl5eXpsccei2CrAQBANHFYlmVFuhGR5vf75XK5VFtbK6fTGdqNOxyh3V5n0d6PFeMGADiPtn5/R/w9OwAAAB2JsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARoto2HnppZc0bNgwOZ1OOZ1OeTwevf3223Z5XV2d8vPz1atXL3Xv3l2TJ09WVVVVwDYqKiqUm5urpKQkpaWlae7cuWpqagp3VwAAQJSKaNjp27evnnrqKZWWlmr37t0aP368fvazn2nfvn2SpDlz5mjdunVas2aNtmzZoiNHjmjSpEn2+s3NzcrNzVVDQ4O2bdumlStXqqioSAsWLIhUlwAAQJRxWJZlRboR35SSkqLf/va3uummm5SamqpVq1bppptukiR9+umnGjx4sLxer8aOHau3335bN9xwg44cOaL09HRJ0vLlyzVv3jwdPXpUCQkJbdqn3++Xy+VSbW2tnE5naDvkcIR2e51Fez9WjBsA4Dza+v0dNffsNDc3a/Xq1Tp16pQ8Ho9KS0vV2Nio7Oxsu86gQYPUr18/eb1eSZLX69XQoUPtoCNJOTk58vv99tmhs6mvr5ff7w+YAACAmSIedvbu3avu3bsrMTFR9957r9auXausrCz5fD4lJCQoOTk5oH56erp8Pp8kyefzBQSd1vLWsnNZtGiRXC6XPWVmZoa2UwAAIGpEPOwMHDhQe/bs0Y4dOzRjxgzl5eVp//79HbrPwsJC1dbW2tPhw4c7dH8AACBy4iLdgISEBF188cWSpJEjR2rXrl16/vnndcstt6ihoUE1NTUBZ3eqqqrkdrslSW63Wzt37gzYXuvTWq11ziYxMVGJiYkh7gkAAIhGET+z87daWlpUX1+vkSNHKj4+XiUlJXZZeXm5Kioq5PF4JEkej0d79+5VdXW1Xae4uFhOp1NZWVlhbzsAAIg+ET2zU1hYqOuvv179+vXTiRMntGrVKm3evFnvvPOOXC6Xpk2bpoKCAqWkpMjpdGrWrFnyeDwaO3asJGnChAnKysrSbbfdpsWLF8vn82n+/PnKz8/nzA0AAJAU4bBTXV2t22+/XZWVlXK5XBo2bJjeeecdXXvttZKkJUuWKCYmRpMnT1Z9fb1ycnK0bNkye/3Y2FitX79eM2bMkMfjUbdu3ZSXl6fHHnssUl0CAABRJqj37Bw+fFgOh0N9+/aVJO3cuVOrVq1SVlaWpk+fHvJGdjTes9MBeM9OcHjPDgC0WYe+Z+fWW2/Vpk2bJP31Ee9rr71WO3fu1G9+8xvOqgAAgKgSVNj5+OOPNXr0aEnSH/7wBw0ZMkTbtm3Ta6+9pqKiolC2DwAAoF2CCjuNjY32DcDvvvuu/v7v/17SX99wXFlZGbrWAQAAtFNQYeeyyy7T8uXL9ac//UnFxcW67rrrJElHjhxRr169QtpAAACA9ggq7Dz99NN6+eWXdfXVV2vKlCkaPny4JOm//uu/7MtbAAAA0SDoXz1vbm6W3+9Xz5497WVffPGFunXrptTU1JA1MBx4GqsD8DRWcHgaCwDarEOfxho/frxOnDgREHQkKSUlRbfcckswmwQAAOgQQYWdzZs3q6Gh4YzldXV1+tOf/tTuRgEAAITKd3qD8kcffWT/vX//fvl8Pnu+ublZGzZs0AUXXBC61gEAALTTdwo7I0aMkMPhkMPh0Pjx488o79q1q1588cWQNQ4AAKC9vlPYOXjwoCzL0kUXXaSdO3cG3IickJCgtLQ0xcbGhryRAAAAwfpOYad///6SpJaWlg5pDAAAQKgF/avnBw4c0KZNm1RdXX1G+FmwYEG7GwYAABAKQYWdV155RTNmzFDv3r3ldrvl+MY7URwOB2EHAABEjaDCzhNPPKEnn3xS8+bNC3V7AAAAQiqo9+wcP35cN998c6jbAgAAEHJBhZ2bb75ZGzduDHVbAAAAQi6oy1gXX3yxHn74YW3fvl1Dhw5VfHx8QPmvf/3rkDQOAACgvYL6IdALL7zw3Bt0OPT555+3q1Hhxg+BdgB+CDQ4/BAoALRZW7+/gzqzc/DgwaAbBgAAEE5B3bMDAADQWQR1Zueuu+761vLf//73QTUGAAAg1IIKO8ePHw+Yb2xs1Mcff6yampqz/kAoAABApAQVdtauXXvGspaWFs2YMUM/+MEP2t0oAACAUAnZPTsxMTEqKCjQkiVLQrVJAACAdgvpDcqfffaZmpqaQrlJAACAdgnqMlZBQUHAvGVZqqys1FtvvaW8vLyQNAwAACAUggo7ZWVlAfMxMTFKTU3VM888c94ntQAAAMIpqLCzadOmULcDAACgQwQVdlodPXpU5eXlkqSBAwcqNTU1JI0CAAAIlaBuUD516pTuuusu9enTR1deeaWuvPJKZWRkaNq0afr6669D3UYAAICgBRV2CgoKtGXLFq1bt041NTWqqanRH//4R23ZskX3339/qNsIAAAQtKB+9bx37976j//4D1199dUByzdt2qRf/OIXOnr0aKjaFxb86nkH4FfPg8OvngNAm7X1+zuoMztff/210tPTz1ielpbGZSwAABBVggo7Ho9HCxcuVF1dnb3s9OnTevTRR+XxeELWOAAAgPYK6mms5557Ttddd5369u2r4cOHS5I+/PBDJSYmauPGjSFtIAAAQHsEdc+O9NdLWa+99po+/fRTSdLgwYM1depUde3aNaQNDAfu2ekA3LMTHO7ZAYA2a+v3d1BndhYtWqT09HTdc889Act///vf6+jRo5o3b14wmwUAAAi5oO7ZefnllzVo0KAzll922WVavnx5uxsFAAAQKkGFHZ/Ppz59+pyxPDU1VZWVle1uFAAAQKgEFXYyMzP1/vvvn7H8/fffV0ZGRrsbBQAAECpB3bNzzz33aPbs2WpsbNT48eMlSSUlJXrwwQd5gzIAAIgqQYWduXPn6tixY/rVr36lhoYGSVKXLl00b948FRYWhrSBAAAA7RH0o+eSdPLkSX3yySfq2rWrLrnkEiUmJoaybWHDo+cdgEfPg8Oj5wDQZh366Hmr7t276/LLL2/PJgAAADpUUDcoAwAAdBaEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGi2jYWbRokS6//HL16NFDaWlpuvHGG1VeXh5Qp66uTvn5+erVq5e6d++uyZMnq6qqKqBORUWFcnNzlZSUpLS0NM2dO1dNTU3h7AoAAIhSEQ07W7ZsUX5+vrZv367i4mI1NjZqwoQJOnXqlF1nzpw5WrdundasWaMtW7boyJEjmjRpkl3e3Nys3NxcNTQ0aNu2bVq5cqWKioq0YMGCSHQJAABEGYdlWVakG9Hq6NGjSktL05YtW3TllVeqtrZWqampWrVqlW666SZJ0qeffqrBgwfL6/Vq7Nixevvtt3XDDTfoyJEjSk9PlyQtX75c8+bN09GjR5WQkHDe/fr9frlcLtXW1srpdIa2Uw5HaLfXWbT3Y8W4AQDOo63f31F1z05tba0kKSUlRZJUWlqqxsZGZWdn23UGDRqkfv36yev1SpK8Xq+GDh1qBx1JysnJkd/v1759+866n/r6evn9/oAJAACYKWrCTktLi2bPnq0f//jHGjJkiCTJ5/MpISFBycnJAXXT09Pl8/nsOt8MOq3lrWVns2jRIrlcLnvKzMwMcW8AAEC0iJqwk5+fr48//lirV6/u8H0VFhaqtrbWng4fPtzh+wQAAJERF+kGSNLMmTO1fv16bd26VX379rWXu91uNTQ0qKamJuDsTlVVldxut11n586dAdtrfVqrtc7fSkxMVGJiYoh7AQAAolFEz+xYlqWZM2dq7dq1eu+993ThhRcGlI8cOVLx8fEqKSmxl5WXl6uiokIej0eS5PF4tHfvXlVXV9t1iouL5XQ6lZWVFZ6OAACAqBXRMzv5+flatWqV/vjHP6pHjx72PTYul0tdu3aVy+XStGnTVFBQoJSUFDmdTs2aNUsej0djx46VJE2YMEFZWVm67bbbtHjxYvl8Ps2fP1/5+fmcvQEAAJF99NxxjseLV6xYoTvuuEPSX18qeP/99+v1119XfX29cnJytGzZsoBLVIcOHdKMGTO0efNmdevWTXl5eXrqqacUF9e2LMej5x2AR8+Dw6PnANBmbf3+jqr37EQKYacDEHaCw+EIAG3WKd+zAwAAEGqEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYLaJhZ+vWrZo4caIyMjLkcDj05ptvBpRblqUFCxaoT58+6tq1q7Kzs3XgwIGAOl999ZWmTp0qp9Op5ORkTZs2TSdPngxjLwAAQDSLaNg5deqUhg8frqVLl561fPHixXrhhRe0fPly7dixQ926dVNOTo7q6ursOlOnTtW+fftUXFys9evXa+vWrZo+fXq4ugAAAKKcw7IsK9KNkCSHw6G1a9fqxhtvlPTXszoZGRm6//779cADD0iSamtrlZ6erqKiIv3yl7/UJ598oqysLO3atUujRo2SJG3YsEF/93d/p7/85S/KyMg4677q6+tVX19vz/v9fmVmZqq2tlZOpzPUHQvt9jqL9n6sGDcAwHn4/X65XK7zfn9H7T07Bw8elM/nU3Z2tr3M5XJpzJgx8nq9kiSv16vk5GQ76EhSdna2YmJitGPHjnNue9GiRXK5XPaUmZnZcR0BAAARFbVhx+fzSZLS09MDlqenp9tlPp9PaWlpAeVxcXFKSUmx65xNYWGhamtr7enw4cMhbj0AAIgWcZFuQCQkJiYqMTEx0s0AAABhELVndtxutySpqqoqYHlVVZVd5na7VV1dHVDe1NSkr776yq4DAAC+36I27Fx44YVyu90qKSmxl/n9fu3YsUMej0eS5PF4VFNTo9LSUrvOe++9p5aWFo0ZMybsbQYAANEnopexTp48qT//+c/2/MGDB7Vnzx6lpKSoX79+mj17tp544gldcskluvDCC/Xwww8rIyPDfmJr8ODBuu6663TPPfdo+fLlamxs1MyZM/XLX/7ynE9iAQCA75eIhp3du3frmmuusecLCgokSXl5eSoqKtKDDz6oU6dOafr06aqpqdEVV1yhDRs2qEuXLvY6r732mmbOnKmf/vSniomJ0eTJk/XCCy+EvS8AACA6Rc17diKprc/pB4X3xQSHcQMAnEenf88OAABAKBB2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjxUW6AQBCyOGIdAsiw7Ii3QIAUYwzOwAAwGjGhJ2lS5dqwIAB6tKli8aMGaOdO3dGukkAACAKGBF23njjDRUUFGjhwoX64IMPNHz4cOXk5Ki6ujrSTQMAABHmsKzOf7F7zJgxuvzyy/Uv//IvkqSWlhZlZmZq1qxZeuihh867vt/vl8vlUm1trZxOZ2gbxz0UwWHcgsO4AdGNYzSk2vr93elvUG5oaFBpaakKCwvtZTExMcrOzpbX6z3rOvX19aqvr7fna2trJf110BAijGVwGLfgtGfcXK7QtaOz+X//+4LyfR239ozZ91kH/W9r/d4+33mbTh92vvzySzU3Nys9PT1geXp6uj799NOzrrNo0SI9+uijZyzPzMzskDZ+L31f/xG2F+MWHMYtOIzbd8eYBaeDx+3EiRNyfcs+On3YCUZhYaEKCgrs+ZaWFn311Vfq1auXHIacYvT7/crMzNThw4dDf2nOYIxbcBi34DBu3x1jFhxTx82yLJ04cUIZGRnfWq/Th53evXsrNjZWVVVVAcurqqrkdrvPuk5iYqISExMDliUnJ3dUEyPK6XQa9cEOF8YtOIxbcBi3744xC46J4/ZtZ3RadfqnsRISEjRy5EiVlJTYy1paWlRSUiKPxxPBlgEAgGjQ6c/sSFJBQYHy8vI0atQojR49Ws8995xOnTqlO++8M9JNAwAAEWZE2Lnlllt09OhRLViwQD6fTyNGjNCGDRvOuGn5+yQxMVELFy4843Idvh3jFhzGLTiM23fHmAXn+z5uRrxnBwAA4Fw6/T07AAAA34awAwAAjEbYAQAARiPsAAAAoxF2OoGlS5dqwIAB6tKli8aMGaOdO3faZb/73e909dVXy+l0yuFwqKam5oz1v/rqK02dOlVOp1PJycmaNm2aTp48GVDno48+0k9+8hN16dJFmZmZWrx4cUd3q0N19JjV1dXpjjvu0NChQxUXF6cbb7wxDL3qeN82bnV1dcrPz1evXr3UvXt3TZ48+YyXeVZUVCg3N1dJSUlKS0vT3Llz1dTUZJdXVlbq1ltv1aWXXqqYmBjNnj07XF3rEFu3btXEiROVkZEhh8OhN998M6D8P//zPzVhwgT77ex79uw5Yxtt+Tw++eSTGjdunJKSkox4AWq4xq0t//s6m44+RiVp8+bN+tGPfqTExERdfPHFKioqCkfXOhRhJ8q98cYbKigo0MKFC/XBBx9o+PDhysnJUXV1tSTp66+/1nXXXad//Md/POc2pk6dqn379qm4uFjr16/X1q1bNX36dLvc7/drwoQJ6t+/v0pLS/Xb3/5WjzzyiH73u991eP86QjjGrLm5WV27dtWvf/1rZWdnd3ifwuF84zZnzhytW7dOa9as0ZYtW3TkyBFNmjTJXr+5uVm5ublqaGjQtm3btHLlShUVFWnBggV2nfr6eqWmpmr+/PkaPnx42PsYaqdOndLw4cO1dOnSc5ZfccUVevrpp8+5jbZ8HhsaGnTzzTdrxowZ7W5zNAjXuJ3vOO5swnGMHjx4ULm5ubrmmmu0Z88ezZ49W3fffbfeeeedsPc3pCxEtdGjR1v5+fn2fHNzs5WRkWEtWrQooN6mTZssSdbx48cDlu/fv9+SZO3atcte9vbbb1sOh8P6v//7P8uyLGvZsmVWz549rfr6ervOvHnzrIEDB3ZAjzpeOMbsm/Ly8qyf/exnIe1DJHzbuNXU1Fjx8fHWmjVr7PJPPvnEkmR5vV7Lsizrv//7v62YmBjL5/PZdV566SXL6XQGfLZaXXXVVdZ9993XcR0KM0nW2rVrz1p28OBBS5JVVlZ2zvXP9Xn8phUrVlgul6td7Yw2HTVu3/U47gzCcYw++OCD1mWXXRaw31tuucXKycnpyK51OM7sRLGGhgaVlpYGnDmIiYlRdna2vF5vm7bh9XqVnJysUaNG2cuys7MVExOjHTt22HWuvPJKJSQk2HVycnJUXl6u48ePh6g34RGuMTPN+cattLRUjY2NAeWDBg1Sv3797HH1er0aOnRowMs8c3Jy5Pf7tW/fvvB1BpB5x3G4jlGv13vG2eqcnJw2//+MVoSdKPbll1+qubn5jDdBp6eny+fztWkbPp9PaWlpAcvi4uKUkpJib8Pn8511H61lnUm4xsw05xs3n8+nhISEM+4X+ea4mvQ5Qudn2nEcrmP0XHX8fr9Onz4dyi6FFWEHAAAYjbATxXr37q3Y2Ngz7qavqqqS2+1u0zbcbrd981qrpqYmffXVV/Y23G73WffRWtaZhGvMTHO+cXO73WpoaDjjiZdvjqtJnyN0fqYdx+E6Rs9Vx+l0qmvXrqHsUlgRdqJYQkKCRo4cqZKSEntZS0uLSkpK5PF42rQNj8ejmpoalZaW2svee+89tbS0aMyYMXadrVu3qrGx0a5TXFysgQMHqmfPniHqTXiEa8xMc75xGzlypOLj4wPKy8vLVVFRYY+rx+PR3r17A75giouL5XQ6lZWVFb7OADLvOA7XMerxeAK20Vqnrf8/o1ak75DGt1u9erWVmJhoFRUVWfv377emT59uJScn23fTV1ZWWmVlZdYrr7xiSbK2bt1qlZWVWceOHbO3cd1111k//OEPrR07dlj/8z//Y11yySXWlClT7PKamhorPT3duu2226yPP/7YWr16tZWUlGS9/PLLYe9vKIRjzCzLsvbt22eVlZVZEydOtK6++mqrrKzsW58aiXbnG7d7773X6tevn/Xee+9Zu3fvtjwej+XxeOz1m5qarCFDhlgTJkyw9uzZY23YsMFKTU21CgsLA/bTOk4jR460br31VqusrMzat29fWPsaKidOnLD7I8l69tlnrbKyMuvQoUOWZVnWsWPHrLKyMuutt96yJFmrV6+2ysrKrMrKSnsbbfk8Hjp0yCorK7MeffRRq3v37vY+T5w4EfY+h0K4xq0tx3FnEo5j9PPPP7eSkpKsuXPnWp988om1dOlSKzY21tqwYUPY+xtKhJ1O4MUXX7T69etnJSQkWKNHj7a2b99uly1cuNCSdMa0YsUKu86xY8esKVOmWN27d7ecTqd15513nvFP8sMPP7SuuOIKKzEx0brgggusp556Klzd6xDhGLP+/fufdTud2beN2+nTp61f/epXVs+ePa2kpCTr5z//ecCXj2VZ1hdffGFdf/31VteuXa3evXtb999/v9XY2BhQ52xj1r9//3B0L+RaH3v+2ykvL8+yrL8+Kn628oULF9rbaMvnMS8v76x1Nm3aFNb+hkq4xq0tx3FnE45jdNOmTdaIESOshIQE66KLLgoY087KYVmWFYITRAAAAFGJe3YAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgB0uKuvvlqzZ88+Z/mAAQP03HPPhaUtX3zxhRwOh/bs2ROW/QGIPMIOgIjbtWuXpk+fbs87HA69+eabbV6/qKhIycnJbaqbmZmpyspKDRky5Du2EkBnFRfpBgBAampqWPbT0NCghIQEud3usOwPQHTgzA6AsGhqatLMmTPlcrnUu3dvPfzww2r9ab5vXsYaMGCAJOnnP/+5HA6HPf/hhx/qmmuuUY8ePeR0OjVy5Ejt3r1bmzdv1p133qna2lo5HA45HA498sgj9rYef/xx3X777XI6nZo+ffoZl7E2b94sh8OhkpISjRo1SklJSRo3bpzKy8sD2v/EE08oLS1NPXr00N13362HHnpII0aMsMs3b96s0aNHq1u3bkpOTtaPf/xjHTp0qKOGE8B3QNgBEBYrV65UXFycdu7cqeeff17PPvus/vVf//WMert27ZIkrVixQpWVlfb81KlT1bdvX+3atUulpaV66KGHFB8fr3Hjxum5556T0+lUZWWlKisr9cADD9jb++d//mcNHz5cZWVlevjhh8/Zvt/85jd65plntHv3bsXFxemuu+6yy1577TU9+eSTevrpp1VaWqp+/frppZdessubmpp044036qqrrtJHH30kr9er6dOny+FwtHvcALQfl7EAhEVmZqaWLFkih8OhgQMHau/evVqyZInuueeegHqtl7SSk5MDLjdVVFRo7ty5GjRokCTpkksusctcLpccDsdZL0+NHz9e999/vz3/xRdfnLV9Tz75pK666ipJ0kMPPaTc3FzV1dWpS5cuevHFFzVt2jTdeeedkqQFCxZo48aNOnnypCTJ7/ertrZWN9xwg37wgx9IkgYPHvydxgdAx+HMDoCwGDt2bMCZDo/HowMHDqi5ublN6xcUFOjuu+9Wdna2nnrqKX322WdtWm/UqFFtqjds2DD77z59+kiSqqurJUnl5eUaPXp0QP1vzqekpOiOO+5QTk6OJk6cqOeff16VlZVt2i+AjkfYAdApPPLII9q3b59yc3P13nvvKSsrS2vXrj3vet26dWvT9uPj4+2/W0NZS0tLm9u3YsUKeb1ejRs3Tm+88YYuvfRSbd++vc3rA+g4hB0AYbFjx46A+e3bt+uSSy5RbGzsGXXj4+PPesbn0ksv1Zw5c7Rx40ZNmjRJK1askCQlJCS0+QxRMAYOHGjfO9Tqb+cl6Yc//KEKCwu1bds2DRkyRKtWreqwNgFoO8IOgLCoqKhQQUGBysvL9frrr+vFF1/Ufffdd9a6AwYMUElJiXw+n44fP67Tp09r5syZ2rx5sw4dOqT3339fu3btsu+LGTBggE6ePKmSkhJ9+eWX+vrrr0Pa9lmzZunVV1/VypUrdeDAAT3xxBP66KOP7DNABw8eVGFhobxerw4dOqSNGzfqwIED3LcDRAluUAYQFrfffrtOnz6t0aNHKzY2Vvfdd1/AiwS/6ZlnnlFBQYFeeeUVXXDBBfrf//1fHTt2TLfffruqqqrUu3dvTZo0SY8++qgkady4cbr33nt1yy236NixY1q4cKH9+HkoTJ06VZ9//rkeeOAB1dXV6Re/+IXuuOMO7dy5U5KUlJSkTz/9VCtXrtSxY8fUp08f5efn6x/+4R9C1gYAwXNYrS+6AAC02bXXXiu3261/+7d/i3RTAJwHZ3YA4Dy+/vprLV++XDk5OYqNjdXrr7+ud999V8XFxZFuGoA24MwOAJzH6dOnNXHiRJWVlamurk4DBw7U/PnzNWnSpEg3DUAbEHYAAIDReBoLAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADDa/wc2QONjqj9bhAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#getting result of quantum task\n",
    "result = task_load.result()\n",
    "\n",
    "\n",
    "#to get measurement shors\n",
    "shots = result.measurement_counts\n",
    "\n",
    "#to print counts\n",
    "print(counts)\n",
    "\n",
    "#plot using counter\n",
    "plt.bar(counts.keys(),counts.values(),color='r');\n",
    "plt.xlabel('bitstrings');\n",
    "plt.ylabel('counts');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "6b48e29a-e4ed-4a96-a35d-6618b3c7a8b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' Using cancel()  method to cancel the existing task '"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "''' Using cancel()  method to cancel the existing task '''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "b2991427-8997-4b61-a8d8-3511700f04bc",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ID of quantum task :  arn:aws:braket:us-east-1:666089549503:quantum-task/c2545ca2-19d1-4f65-bca3-5192848d9502\n",
      "status of quantum task :  CREATED\n",
      "status of quantum task : CANCELLING\n"
     ]
    }
   ],
   "source": [
    "# defining quantum task \n",
    "task = device.run(my_circuit, shots=1000,inputs = {'alpha':0.1, 'beta':0.2,'gamma': 0.3})\n",
    "\n",
    "#to get id and status of quantum task \n",
    "task_id = task.id\n",
    "status = task.state()\n",
    "\n",
    "print (\"ID of quantum task : \" , task_id )\n",
    "print(\"status of quantum task : \",status) \n",
    "#cancelling the task \n",
    "task.cancel()\n",
    "status = task.state()\n",
    "print('status of quantum task :',status)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "2363ea61-d3f9-4662-a775-f25856fcf755",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'DEMONSTRATION OF RESULT TYPES: Expectation Values and Observables'"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''DEMONSTRATION OF RESULT TYPES: Expectation Values and Observables'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "610674d3-674b-4396-9037-b5716f6d3ec5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'So far, we have only taken measurements in the computational basis. However, \\nit is also possible to measure in other bases, as well as estimate important statistics \\nlike expectation value and variance. We do this by adding ResultTypes to our circuit; in the \\nfollowing example, we will make measurements in the basis of the observable  𝑋0𝑌1\\n  (this is the tensor product  𝑋(0)⊗𝑌(1)):'"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''So far, we have only taken measurements in the computational basis. However, \n",
    "it is also possible to measure in other bases, as well as estimate important statistics \n",
    "like expectation value and variance. We do this by adding ResultTypes to our circuit; in the \n",
    "following example, we will make measurements in the basis of the observable  𝑋0𝑌1\n",
    "  (this is the tensor product  𝑋(0)⊗𝑌(1)):'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "76b870de-3dd5-4ae6-9b19-e311e07fe33c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |   0    | 1 |               Result Types               |\n",
      "                                                              \n",
      "q0 : -Rx(0.15)-C---Expectation(X@Y)-Variance(X@Y)-Sample(X@Y)-\n",
      "               |   |                |             |           \n",
      "q1 : -Ry(0.20)-|-C-Expectation(X@Y)-Variance(X@Y)-Sample(X@Y)-\n",
      "               | |                                            \n",
      "q2 : -Rz(0.25)-X-|--------------------------------------------\n",
      "                 |                                            \n",
      "q3 : -H----------X--------------------------------------------\n",
      "                                                              \n",
      "q4 : -X-------------------------------------------------------\n",
      "\n",
      "T  : |   0    | 1 |               Result Types               |\n"
     ]
    }
   ],
   "source": [
    "#defining example circuit\n",
    "circ = Circuit().rx(0,0.15).ry(1,0.2).rz(2,0.25).h(3).cnot(0,2).cnot(1,3).x(4)\n",
    "#adding expectation value\n",
    "obs = Observable.X() @ Observable.Y()\n",
    "target_qubits = [0,1]\n",
    "circ.expectation(obs , target = target_qubits)\n",
    "# adding variance\n",
    "circ.variance(obs , target= target_qubits)\n",
    "#adding sample\n",
    "\n",
    "circ.sample(obs, target = target_qubits)\n",
    "print(circ)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "ab214fa8-52dd-44e2-b84b-f0f329ab44e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sample is only valid when shots>0\\n\\nAs shown above, results types are part of the print information. \\nWe now run this circuit on the local simulator above and output these results.'"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''Sample is only valid when shots>0\n",
    "\n",
    "As shown above, results types are part of the print information. \n",
    "We now run this circuit on the local simulator above and output these results.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "6f7ab78a-2b9c-487c-a549-bb0acda7a654",
   "metadata": {},
   "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": [
    "#setting 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": "code",
   "execution_count": 138,
   "id": "ef7ee84d-0561-476e-98dc-90304de78791",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' TO VERIFY THAT WE GET THE SAME \\nESTIMATE FOR THE EXPECTATION VALUE IF WE COMPUTE IT BY HAND FROM THE SAMPLES'"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "''' TO VERIFY THAT WE GET THE SAME \n",
    "ESTIMATE FOR THE EXPECTATION VALUE IF WE COMPUTE IT BY HAND FROM THE SAMPLES'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "e2c6d534-87c1-4a99-8cfa-7b9e1e15fc78",
   "metadata": {
    "tags": []
   },
   "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": "code",
   "execution_count": 129,
   "id": "fafff175-dd10-487a-a1d5-57e6a4138123",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'So far, we have measured only one observable, namely  𝑋0𝑌1\\n . 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:'"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''So far, we have measured only one observable, namely  𝑋0𝑌1\n",
    " . 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:'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "95c58387-4e2b-4949-91e8-f38810f2c237",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |   0    | 1 |           Result Types            |\n",
      "                                                       \n",
      "q0 : -Rx(0.15)-C---Expectation(X@Y)--------------------\n",
      "               |   |                                   \n",
      "q1 : -Ry(0.20)-|-C-Expectation(X@Y)-Expectation(Y@X@H)-\n",
      "               | |                  |                  \n",
      "q2 : -Rz(0.25)-X-|-Expectation(Z@H)-|------------------\n",
      "                 | |                |                  \n",
      "q3 : -H----------X-|----------------Expectation(Y@X@H)-\n",
      "                   |                |                  \n",
      "q4 : -X------------Expectation(Z@H)-Expectation(Y@X@H)-\n",
      "\n",
      "T  : |   0    | 1 |           Result Types            |\n",
      "EXPECTATION VALUE FOR <X0*Y1>:  -0.04\n",
      "EXPECTATION VALUE FOR <Z2*H4>:  -0.71\n",
      "Expectation value for <Y1*X3*H4>::  0.062\n"
     ]
    }
   ],
   "source": [
    "circ = Circuit().rx(0,0.15).ry(1,0.2).rz(2,0.25).h(3).cnot(0,2).cnot(1,3).x(4)\n",
    "circ.expectation(Observable.X() @ Observable.Y(), target=[0,1])\n",
    "circ.expectation(Observable.Z() @ Observable.H(), target =[2,4])\n",
    "# Overlaps on qubits 1 and 4, but Y and H are the same factors \n",
    "#that have been applied to each, respectively\n",
    "circ.expectation(Observable.Y() @ Observable.X() @ Observable.H(), target=[1,3,4])\n",
    "\n",
    "print(circ)\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": "code",
   "execution_count": 133,
   "id": "2e5d20c6-a5c5-42f5-b4ab-dea5dd4b59f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' This is possible because we only need to measure in at most one basis \\nfor each qubit. For instance in the example above, on qubit 1 we only measure in the Y basis. '"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "''' This is possible because we only need to measure in at most one basis \n",
    "for each qubit. For instance in the example above, on qubit 1 we only measure in the Y basis. '''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "7bafe405-1025-4210-9b42-4c6cb67cc39e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'In all examples discussed so far we have set the parameter shots>0, thereby \\nmimicking the behavior of actual quantum hardware. However, on a classical \\nsimulator we do have access to the full state vector when shots=0. \\nWe will illustrate this functionality in more detail in this section. '"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''In all examples discussed so far we have set the parameter shots>0, thereby \n",
    "mimicking the behavior of actual quantum hardware. However, on a classical \n",
    "simulator we do have access to the full state vector when shots=0. \n",
    "We will illustrate this functionality in more detail in this section. '''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "213c618c-5d60-495b-a9dc-ec499ff10fe2",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "conda_braket",
   "language": "python",
   "name": "conda_braket"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}