examples/braket_features/Using_the_tensor_network_simulator_TN1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using the Amazon Braket tensor network simulator TN1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:54:12.333525Z",
     "start_time": "2023-08-29T21:54:12.225874Z"
    }
   },
   "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": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Caution:</b> Running the code in this notebook will result in <a href=\"https://aws.amazon.com/braket/pricing/\">usage fees</a> charged to your AWS account. The expected cost is less than $1.00 USD. Only run the notebook if you are comfortable with the costs. We recommend monitoring the Billing & Cost Management Dashboard on the AWS console and being aware that tasks involving a large number of qubits can be costly.\n",
    "</div>\n",
    "\n",
    "This tutorial serves as an in-depth introduction to TN1, the Amazon Braket tensor network simulator. TN1 was previously introduced in [Running quantum circuits on simulators notebook](../getting_started/1_Running_quantum_circuits_on_simulators/1_Running_quantum_circuits_on_simulators.ipynb). This tutorial explains what makes TN1 different from SV1, Braket's state vector simulator, and it discusses which use cases are well suited for tensor network simulations. We examine what circuit properties affect TN1's performance and how TN1 can be used to simulate some types circuits for many more qubits than SV1 can handle."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How TN1 Works\n",
    "\n",
    "A tensor network simulator models the execution of circuits on a quantum computer by representing each gate in the circuit as a *tensor*. Tensors generalize the concept of vectors and matrices to higher dimensions. The gates in the network form a graph. The simulator works by finding an efficient way to multiply all the different tensors on the graph during the _rehearsal_ stage and then, after a suitable multiplication sequence or _path_ is found, it performs these multiplications in the _contraction_ stage. For more information about TN1 and how it works, see the [TN1 docs](https://docs.aws.amazon.com/braket/latest/developerguide/braket-devices.html#braket-simulator-tn1).\n",
    "\n",
    "## How is this different from SV1, the state vector simulator?\n",
    "\n",
    "SV1 works differently -- SV1 simulates all the evolution of all amplitudes as gates are applied. This means that SV1 cannot simulate large numbers of qubits for any circuit, because the memory required becomes infeasible. However, this restriction does not necessarily apply to TN1. Because TN1 works by contracting gates, it is able to work only with worldlines through the circuit which are relevant to the final outcome. However, TN1 can be slower than SV1 for circuits with complex geometry. In circuits which include multi-qubit gates, gates with long range, or circuits with few qubits (fewer than 28), SV1 is often the better choice. To use TN1 effectively it is important to understand that circuit geometry can pose more of a barrier than simple qubit number, as we will see below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Can my circuit be simulated on TN1?\n",
    "\n",
    "While SV1 will simulate every circuit within the service limits (i.e., smaller or equal than 34 qubits), TN1 can only decide if a circuit can be contracted after it has the full information from the rehearsal stage. In the best case, this enables you to simulate circuits of much larger size than SV1 (up to 50 qubits) but, on the flip side, that means that in some cases you might find that TN1 will terminate the simulation after the rehearsal if it finds that the projected contraction time exceeds its runtime limit. In this case the `failureReason` for the quantum task will be `Predicted runtime based on best contraction path found exceeds TN1 limit.` The rehearsal stage of TN1 is limited to 10 minutes, but in most cases you will find that TN1 will arrive at a decision much faster. \n",
    "    \n",
    "As we will see below, if this situation occurs for a quantum task for which you have requested a large number of shots, the quantum task may be successful if you lower the shot count. It can also occur, albeit rarely, that the time to find a single contraction path candidate exceeds TN1's internal rehearsal runtime limit -- circuits for which this occurs are extremely unlikely to be contractable in reasonable time. In this case, the `failureReason` for the quantum task will be `No viable contraction path found.`\n",
    "    \n",
    "To learn more about why these two stages are present and what the simulator does in each, you can read the TN1 documentation [here](https://docs.aws.amazon.com/braket/latest/developerguide/braket-devices.html#braket-simulator-tn1)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> In the worst case, the TN1 runtime can scale linearly with the number of shots requested. It is strongly recommended to test your circuit or circuit class with a small number of shots first.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:54:15.038574Z",
     "start_time": "2023-08-29T21:54:12.272012Z"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# general imports\n",
    "import numpy as np\n",
    "import math\n",
    "\n",
    "import boto3\n",
    "# AWS imports: Import Braket SDK modules\n",
    "from braket.circuits import Circuit, circuit, Gate, Instruction\n",
    "from braket.aws import AwsDevice\n",
    "from braket.devices import Devices\n",
    "\n",
    "tn_device = AwsDevice(Devices.Amazon.TN1)\n",
    "sv_device = AwsDevice(Devices.Amazon.SV1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two simple examples: The GHZ state and Quantum Fourier Transform\n",
    "\n",
    "We already presented the GHZ example circuit in the [Running quantum circuits on simulators notebook](../getting_started/1_Running_quantum_circuits_on_simulators/1_Running_quantum_circuits_on_simulators.ipynb). Here, we'll compare the performance of SV1 and TN1 for this relatively simple circuit. The GHZ state is simple to prepare:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:54:15.044799Z",
     "start_time": "2023-08-29T21:54:15.040249Z"
    }
   },
   "outputs": [],
   "source": [
    "def ghz_circuit(n_qubits: int) -> Circuit:\n",
    "    \"\"\"\n",
    "    Function to return simple GHZ circuit ansatz. Assumes all qubits in range(0, n_qubits-1)\n",
    "    are entangled.\n",
    "\n",
    "    :param int n_qubits: number of qubits\n",
    "    :return: Constructed GHZ circuit\n",
    "    :rtype: Circuit\n",
    "    \"\"\"\n",
    "\n",
    "    circuit = Circuit()                          # instantiate circuit object\n",
    "    circuit.h(0)                                 # add Hadamard gate on first qubit\n",
    "\n",
    "    for ii in range(0, n_qubits-1):\n",
    "        circuit.cnot(control=ii, target=ii+1)    # apply series of CNOT gates\n",
    "    return circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will simulate the measurement counts for this circuit on SV1 and TN1. SV1 can only simulate up to 34 qubits, but TN1 can work with substantially more in this case because of the circuit's geometry. In this case we will not run up to 34 qubits on SV1, because the runtime on that simulator can become quite long. 30 qubits is enough to see that TN1 can equal or outperform SV1 for circuits like GHZ, which has a simple, compact nearest-neighbor circuit geometry. Because the GHZ state is a \"cat state\", with only two possible measurement outcomes (all up or all down), it is easy for TN1 to explore all possible output bitstrings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:57:31.935938Z",
     "start_time": "2023-08-29T21:54:15.062606Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GHZ circuit:\n",
      "T   : |0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|\n",
      "                                                         \n",
      "q0  : -H-C-----------------------------------------------\n",
      "         |                                               \n",
      "q1  : ---X-C---------------------------------------------\n",
      "           |                                             \n",
      "q2  : -----X-C-------------------------------------------\n",
      "             |                                           \n",
      "q3  : -------X-C-----------------------------------------\n",
      "               |                                         \n",
      "q4  : ---------X-C---------------------------------------\n",
      "                 |                                       \n",
      "q5  : -----------X-C-------------------------------------\n",
      "                   |                                     \n",
      "q6  : -------------X-C-----------------------------------\n",
      "                     |                                   \n",
      "q7  : ---------------X-C---------------------------------\n",
      "                       |                                 \n",
      "q8  : -----------------X-C-------------------------------\n",
      "                         |                               \n",
      "q9  : -------------------X-C-----------------------------\n",
      "                           |                             \n",
      "q10 : ---------------------X--C--------------------------\n",
      "                              |                          \n",
      "q11 : ------------------------X--C-----------------------\n",
      "                                 |                       \n",
      "q12 : ---------------------------X--C--------------------\n",
      "                                    |                    \n",
      "q13 : ------------------------------X--C-----------------\n",
      "                                       |                 \n",
      "q14 : ---------------------------------X--C--------------\n",
      "                                          |              \n",
      "q15 : ------------------------------------X--C-----------\n",
      "                                             |           \n",
      "q16 : ---------------------------------------X--C--------\n",
      "                                                |        \n",
      "q17 : ------------------------------------------X--C-----\n",
      "                                                   |     \n",
      "q18 : ---------------------------------------------X--C--\n",
      "                                                      |  \n",
      "q19 : ------------------------------------------------X--\n",
      "\n",
      "T   : |0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|\n",
      "20-qubit TN1 task COMPLETED.\n",
      "Tensor network simulator:\n",
      "This quantum task ran 50 shots and the total runtime was 12548 ms\n",
      "Measurement results: Counter({'00000000000000000000': 27, '11111111111111111111': 23})\n",
      "\n",
      "20-qubit SV1 task COMPLETED.\n",
      "State vector simulator:\n",
      "This quantum task ran 50 shots and the total runtime was 18 ms\n",
      "Measurement results: Counter({'11111111111111111111': 26, '00000000000000000000': 24})\n",
      "\n",
      "GHZ circuit:\n",
      "T   : |0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|\n",
      "                                                                        \n",
      "q0  : -H-C--------------------------------------------------------------\n",
      "         |                                                              \n",
      "q1  : ---X-C------------------------------------------------------------\n",
      "           |                                                            \n",
      "q2  : -----X-C----------------------------------------------------------\n",
      "             |                                                          \n",
      "q3  : -------X-C--------------------------------------------------------\n",
      "               |                                                        \n",
      "q4  : ---------X-C------------------------------------------------------\n",
      "                 |                                                      \n",
      "q5  : -----------X-C----------------------------------------------------\n",
      "                   |                                                    \n",
      "q6  : -------------X-C--------------------------------------------------\n",
      "                     |                                                  \n",
      "q7  : ---------------X-C------------------------------------------------\n",
      "                       |                                                \n",
      "q8  : -----------------X-C----------------------------------------------\n",
      "                         |                                              \n",
      "q9  : -------------------X-C--------------------------------------------\n",
      "                           |                                            \n",
      "q10 : ---------------------X--C-----------------------------------------\n",
      "                              |                                         \n",
      "q11 : ------------------------X--C--------------------------------------\n",
      "                                 |                                      \n",
      "q12 : ---------------------------X--C-----------------------------------\n",
      "                                    |                                   \n",
      "q13 : ------------------------------X--C--------------------------------\n",
      "                                       |                                \n",
      "q14 : ---------------------------------X--C-----------------------------\n",
      "                                          |                             \n",
      "q15 : ------------------------------------X--C--------------------------\n",
      "                                             |                          \n",
      "q16 : ---------------------------------------X--C-----------------------\n",
      "                                                |                       \n",
      "q17 : ------------------------------------------X--C--------------------\n",
      "                                                   |                    \n",
      "q18 : ---------------------------------------------X--C-----------------\n",
      "                                                      |                 \n",
      "q19 : ------------------------------------------------X--C--------------\n",
      "                                                         |              \n",
      "q20 : ---------------------------------------------------X--C-----------\n",
      "                                                            |           \n",
      "q21 : ------------------------------------------------------X--C--------\n",
      "                                                               |        \n",
      "q22 : ---------------------------------------------------------X--C-----\n",
      "                                                                  |     \n",
      "q23 : ------------------------------------------------------------X--C--\n",
      "                                                                     |  \n",
      "q24 : ---------------------------------------------------------------X--\n",
      "\n",
      "T   : |0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|\n",
      "25-qubit TN1 task COMPLETED.\n",
      "Tensor network simulator:\n",
      "This quantum task ran 50 shots and the total runtime was 12624 ms\n",
      "Measurement results: Counter({'0000000000000000000000000': 29, '1111111111111111111111111': 21})\n",
      "\n",
      "25-qubit SV1 task COMPLETED.\n",
      "State vector simulator:\n",
      "This quantum task ran 50 shots and the total runtime was 478 ms\n",
      "Measurement results: Counter({'1111111111111111111111111': 30, '0000000000000000000000000': 20})\n",
      "\n",
      "GHZ circuit:\n",
      "T   : |0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|\n",
      "                                                                                       \n",
      "q0  : -H-C-----------------------------------------------------------------------------\n",
      "         |                                                                             \n",
      "q1  : ---X-C---------------------------------------------------------------------------\n",
      "           |                                                                           \n",
      "q2  : -----X-C-------------------------------------------------------------------------\n",
      "             |                                                                         \n",
      "q3  : -------X-C-----------------------------------------------------------------------\n",
      "               |                                                                       \n",
      "q4  : ---------X-C---------------------------------------------------------------------\n",
      "                 |                                                                     \n",
      "q5  : -----------X-C-------------------------------------------------------------------\n",
      "                   |                                                                   \n",
      "q6  : -------------X-C-----------------------------------------------------------------\n",
      "                     |                                                                 \n",
      "q7  : ---------------X-C---------------------------------------------------------------\n",
      "                       |                                                               \n",
      "q8  : -----------------X-C-------------------------------------------------------------\n",
      "                         |                                                             \n",
      "q9  : -------------------X-C-----------------------------------------------------------\n",
      "                           |                                                           \n",
      "q10 : ---------------------X--C--------------------------------------------------------\n",
      "                              |                                                        \n",
      "q11 : ------------------------X--C-----------------------------------------------------\n",
      "                                 |                                                     \n",
      "q12 : ---------------------------X--C--------------------------------------------------\n",
      "                                    |                                                  \n",
      "q13 : ------------------------------X--C-----------------------------------------------\n",
      "                                       |                                               \n",
      "q14 : ---------------------------------X--C--------------------------------------------\n",
      "                                          |                                            \n",
      "q15 : ------------------------------------X--C-----------------------------------------\n",
      "                                             |                                         \n",
      "q16 : ---------------------------------------X--C--------------------------------------\n",
      "                                                |                                      \n",
      "q17 : ------------------------------------------X--C-----------------------------------\n",
      "                                                   |                                   \n",
      "q18 : ---------------------------------------------X--C--------------------------------\n",
      "                                                      |                                \n",
      "q19 : ------------------------------------------------X--C-----------------------------\n",
      "                                                         |                             \n",
      "q20 : ---------------------------------------------------X--C--------------------------\n",
      "                                                            |                          \n",
      "q21 : ------------------------------------------------------X--C-----------------------\n",
      "                                                               |                       \n",
      "q22 : ---------------------------------------------------------X--C--------------------\n",
      "                                                                  |                    \n",
      "q23 : ------------------------------------------------------------X--C-----------------\n",
      "                                                                     |                 \n",
      "q24 : ---------------------------------------------------------------X--C--------------\n",
      "                                                                        |              \n",
      "q25 : ------------------------------------------------------------------X--C-----------\n",
      "                                                                           |           \n",
      "q26 : ---------------------------------------------------------------------X--C--------\n",
      "                                                                              |        \n",
      "q27 : ------------------------------------------------------------------------X--C-----\n",
      "                                                                                 |     \n",
      "q28 : ---------------------------------------------------------------------------X--C--\n",
      "                                                                                    |  \n",
      "q29 : ------------------------------------------------------------------------------X--\n",
      "\n",
      "T   : |0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|\n",
      "30-qubit TN1 task COMPLETED.\n",
      "Tensor network simulator:\n",
      "This quantum task ran 50 shots and the total runtime was 2324 ms\n",
      "Measurement results: Counter({'000000000000000000000000000000': 30, '111111111111111111111111111111': 20})\n",
      "\n",
      "30-qubit SV1 task COMPLETED.\n",
      "State vector simulator:\n",
      "This quantum task ran 50 shots and the total runtime was 15494 ms\n",
      "Measurement results: Counter({'111111111111111111111111111111': 33, '000000000000000000000000000000': 17})\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35-qubit TN1 task COMPLETED.\n",
      "Tensor network simulator:\n",
      "This quantum task ran 50 shots and the total runtime was 2284 ms\n",
      "Measurement results: Counter({'11111111111111111111111111111111111': 29, '00000000000000000000000000000000000': 21})\n",
      "\n",
      "40-qubit TN1 task COMPLETED.\n",
      "Tensor network simulator:\n",
      "This quantum task ran 50 shots and the total runtime was 2412 ms\n",
      "Measurement results: Counter({'1111111111111111111111111111111111111111': 29, '0000000000000000000000000000000000000000': 21})\n",
      "\n",
      "45-qubit TN1 task COMPLETED.\n",
      "Tensor network simulator:\n",
      "This quantum task ran 50 shots and the total runtime was 2377 ms\n",
      "Measurement results: Counter({'000000000000000000000000000000000000000000000': 26, '111111111111111111111111111111111111111111111': 24})\n",
      "\n",
      "50-qubit TN1 task COMPLETED.\n",
      "Tensor network simulator:\n",
      "This quantum task ran 50 shots and the total runtime was 2434 ms\n",
      "Measurement results: Counter({'00000000000000000000000000000000000000000000000000': 25, '11111111111111111111111111111111111111111111111111': 25})\n"
     ]
    }
   ],
   "source": [
    "qubit_range = range(20, 31, 5)\n",
    "tn_qubit_range = range(35, 51, 5)\n",
    "n_shots     = 50\n",
    "ghz_circs   = {}\n",
    "sv_tasks    = {}\n",
    "tn_tasks    = {}\n",
    "sv_results  = {}\n",
    "tn_results  = {}\n",
    "for num_qubits in qubit_range:\n",
    "    ghz = ghz_circuit(num_qubits)\n",
    "    sv_tasks[num_qubits] = sv_device.run(ghz, shots=n_shots)\n",
    "    tn_tasks[num_qubits] = tn_device.run(ghz, shots=n_shots)\n",
    "    ghz_circs[num_qubits] = ghz\n",
    "\n",
    "# Run qubit numbers which only TN1 supports\n",
    "for num_qubits in tn_qubit_range:\n",
    "    ghz = ghz_circuit(num_qubits)\n",
    "    tn_tasks[num_qubits] = tn_device.run(ghz, shots=n_shots)\n",
    "    ghz_circs[num_qubits] = ghz\n",
    "\n",
    "for num_qubits in qubit_range:\n",
    "    tn_status = tn_tasks[num_qubits].state()\n",
    "    sv_status = sv_tasks[num_qubits].state()\n",
    "    while tn_status != 'COMPLETED':\n",
    "        tn_status = tn_tasks[num_qubits].state()\n",
    "    while sv_status != 'COMPLETED':\n",
    "        sv_status = sv_tasks[num_qubits].state()\n",
    "\n",
    "    tn_results[num_qubits] = tn_tasks[num_qubits].result()\n",
    "    sv_results[num_qubits] = sv_tasks[num_qubits].result()\n",
    "\n",
    "    # get the running time of the quantum tasks\n",
    "    sv_runtime = sv_results[num_qubits].additional_metadata.simulatorMetadata.executionDuration\n",
    "    tn_runtime = tn_results[num_qubits].additional_metadata.simulatorMetadata.executionDuration\n",
    "\n",
    "    # get the 'shots' parameter from metadata\n",
    "    tn_num_shots = tn_results[num_qubits].task_metadata.shots\n",
    "    sv_num_shots = sv_results[num_qubits].task_metadata.shots\n",
    "\n",
    "    # get the measurement counts\n",
    "    tn_counts = tn_results[num_qubits].measurement_counts\n",
    "    sv_counts = sv_results[num_qubits].measurement_counts\n",
    "    \n",
    "    print(\"GHZ circuit:\")\n",
    "    print(ghz_circs[num_qubits])\n",
    "    print('{}-qubit TN1 task {}.'.format(num_qubits,tn_status))\n",
    "    print('Tensor network simulator:')\n",
    "    print('This quantum task ran {} shots and the total runtime was {} ms'.format(tn_num_shots,tn_runtime))\n",
    "    print(\"Measurement results: {}\\n\".format(tn_counts))\n",
    "    print('{}-qubit SV1 task {}.'.format(num_qubits,sv_status))\n",
    "    print('State vector simulator:')\n",
    "    print('This quantum task ran {} shots and the total runtime was {} ms'.format(sv_num_shots,sv_runtime))\n",
    "    print(\"Measurement results: {}\\n\".format(sv_counts))\n",
    "\n",
    "for num_qubits in tn_qubit_range:\n",
    "    tn_status = tn_tasks[num_qubits].state()\n",
    "    while tn_status != 'COMPLETED':\n",
    "        tn_status = tn_tasks[num_qubits].state()\n",
    "\n",
    "    tn_results[num_qubits] = tn_tasks[num_qubits].result()\n",
    "\n",
    "    # get the running time of the quantum tasks\n",
    "    tn_runtime = tn_results[num_qubits].additional_metadata.simulatorMetadata.executionDuration\n",
    "\n",
    "    # get the 'shots' parameter from metadata\n",
    "    tn_num_shots = tn_results[num_qubits].task_metadata.shots\n",
    "\n",
    "    # get the measurement counts\n",
    "    tn_counts = tn_results[num_qubits].measurement_counts\n",
    "    \n",
    "    # we will not print the circuits here as they are quite large\n",
    "    print('{}-qubit TN1 task {}.'.format(num_qubits,tn_status))\n",
    "    print('Tensor network simulator:')\n",
    "    print('This quantum task ran {} shots and the total runtime was {} ms'.format(tn_num_shots,tn_runtime))\n",
    "    print(\"Measurement results: {}\\n\".format(tn_counts))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many circuits which can be efficiently simulated by TN1 even up to very large qubit counts. Another example is the quantum Fourier transform (QFT) and its inverse, shown in [the QFT notebook](../advanced_circuits_algorithms/Quantum_Fourier_Transform/Quantum_Fourier_Transform.ipynb). TN1 is able to efficiently simulate the QFT on an input state of |00..00> because in this case it amounts to a simple rotation, even up to many qubits:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:57:31.936079Z",
     "start_time": "2023-08-29T21:57:31.917126Z"
    }
   },
   "outputs": [],
   "source": [
    "@circuit.subroutine(register=True)\n",
    "def qft(qubits):    \n",
    "    \"\"\"\n",
    "    Construct a circuit object corresponding to the Quantum Fourier Transform (QFT)\n",
    "    algorithm, applied to the argument qubits.  Does not use recursion to generate the QFT.\n",
    "    \n",
    "    Args:\n",
    "        qubits (int): The list of qubits on which to apply the QFT\n",
    "    \"\"\"\n",
    "    qftcirc = Circuit()\n",
    "\n",
    "    # get number of qubits\n",
    "    num_qubits = len(qubits)\n",
    "    \n",
    "    for k in range(num_qubits):\n",
    "        # First add a Hadamard gate\n",
    "        qftcirc.h(qubits[k])\n",
    "    \n",
    "        # Then apply the controlled rotations, with weights (angles) defined by the distance to the control qubit.\n",
    "        # Start on the qubit after qubit k, and iterate until the end.  When num_qubits==1, this loop does not run.\n",
    "        for j in range(1,num_qubits - k):\n",
    "            angle = 2*math.pi/(2**(j+1))\n",
    "            qftcirc.cphaseshift(qubits[k+j],qubits[k], angle)\n",
    "            \n",
    "    # Then add SWAP gates to reverse the order of the qubits:\n",
    "    for i in range(math.floor(num_qubits/2)):\n",
    "        qftcirc.swap(qubits[i], qubits[-i-1])\n",
    "        \n",
    "    return qftcirc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:58:24.654423Z",
     "start_time": "2023-08-29T21:57:31.957381Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20-qubit task COMPLETED.\n",
      "QFT:\n",
      "This quantum task ran 50 shots and the total runtime was 2210 ms\n",
      "Measurement results: Counter({'10111011100101010111': 1, '00111001010110001110': 1, '01011010001110100100': 1, '01000110101110001101': 1, '00111111100101100100': 1, '10100011010111101001': 1, '00100000010010100001': 1, '10110011111011100101': 1, '01110011001001110001': 1, '01010011110010110110': 1, '10010000110100010100': 1, '10000101000110011000': 1, '01101011110100010111': 1, '10111111100011010011': 1, '10110000101110011110': 1, '10000111111001001000': 1, '10011010001001001011': 1, '01000010110110101111': 1, '00110011110110011000': 1, '11001101000001101000': 1, '11110110111001101011': 1, '00110010101111011011': 1, '11000100000001110101': 1, '01011011110001111010': 1, '00010101000010111010': 1, '11000001111110111100': 1, '10000110010111101100': 1, '11010110101110110010': 1, '01010111000011010110': 1, '01010100001110100101': 1, '00111100000101101111': 1, '00010101101100001010': 1, '10001110100100011010': 1, '00011000000101100011': 1, '11100011000010010111': 1, '00111011001000001101': 1, '10011101101111111110': 1, '10000100100000000010': 1, '00001001110001000011': 1, '10001001110010001110': 1, '01001111101010010101': 1, '01111110101101010011': 1, '01001000000101000101': 1, '00000001101111111111': 1, '00010001110001111101': 1, '10010000111101101010': 1, '11010101101010110010': 1, '01111010100011000011': 1, '01101111101001001010': 1, '01011110111010011011': 1})\n",
      "\n",
      "30-qubit task COMPLETED.\n",
      "QFT:\n",
      "This quantum task ran 50 shots and the total runtime was 13817 ms\n",
      "Measurement results: Counter({'110000110010001001010100001011': 1, '001011111011010011001100101010': 1, '101001000011011010111010111101': 1, '010001011100111110110110000010': 1, '111000011111100111000001100010': 1, '000001111101111101010001011100': 1, '100000010001101111011010010010': 1, '011111100001010100011001010011': 1, '111100101110111101101111111001': 1, '100110101001000100000111111001': 1, '111110101010100110000101111111': 1, '110001101001000101000100101100': 1, '001011011001011111010000111101': 1, '010000101000001010100001001111': 1, '110001000001011000000000010110': 1, '111100010000101101111010100011': 1, '011101010111111001000011100100': 1, '001100100010001101110100001001': 1, '100001010011010100110000101111': 1, '100001110000110000011010110010': 1, '101101101001101100111010101111': 1, '101100010000000100010110100100': 1, '110001010000001011111010011011': 1, '111011101100000111001000001000': 1, '111100000011011010010101011001': 1, '101010010001011011011100011111': 1, '011010101000100110100000011001': 1, '100011100011110110011010011011': 1, '010011010101101100101001000010': 1, '010101000001100011011100111101': 1, '000000011101001000100011001101': 1, '101101101001101111110000011001': 1, '011011001010011100100011001001': 1, '000100101010110010010011110101': 1, '101011100001101111110110100001': 1, '011001111010111001011011010111': 1, '111010011001010001010011110001': 1, '111001101110100110111111000100': 1, '010111110011111001100110000011': 1, '100001000101001101110011100100': 1, '000111010000111110111101111011': 1, '011001000000110000000101101001': 1, '100000100100111010100001111010': 1, '000001101001100101111100011011': 1, '001101110010000101101100011000': 1, '101011100001001000001000100000': 1, '111000111011001101110101110011': 1, '110000010011100010011010110000': 1, '110100110000111011010111110100': 1, '011000010110101101000100011101': 1})\n",
      "\n",
      "40-qubit task COMPLETED.\n",
      "QFT:\n",
      "This quantum task ran 50 shots and the total runtime was 20795 ms\n",
      "Measurement results: Counter({'1101001000110111001111100110100001001000': 1, '0000111010001100100100100011000111001101': 1, '0111101111110001010110001010110011110011': 1, '0010001110011000111000010011011010111010': 1, '0000010111101100100010100100010111000111': 1, '1011100100101011100000101110110100010110': 1, '1110110100011100101101100000110111000010': 1, '1101001111100001110011001101110101111101': 1, '0110000100111100110111001000110001001000': 1, '1100111110010011100000101110101100000000': 1, '0011010111011101011111011110100010101110': 1, '1110111101110001101001011101110110001100': 1, '1100010100000011100111111111100100110110': 1, '0000010010101111100100110101110101010011': 1, '1111111101100000011010110100000001100101': 1, '1111100001000110001001111110101111111001': 1, '0110110011100011000011001001011110000111': 1, '1110001011100010001001110000101101110010': 1, '0101100001111110010000010101111000111111': 1, '1010000101100011110011101111001100011010': 1, '1011110001011011000011100100011000001001': 1, '1011100101000100010010110000010000000100': 1, '0110110101110011111000110100100011001101': 1, '0111100101000011101011001101001011100011': 1, '0110011000010001110101001001100110011100': 1, '0110101100010000010000010001001111011010': 1, '1011001001111110101100100010010101010111': 1, '0011101110000111010011010100100101100001': 1, '1100010001011001000011111111101101110001': 1, '0001111111001101101110101001010010100100': 1, '0011100010111111001000001000110001111001': 1, '0010110000011100000110101101101110000001': 1, '0011100101001111101010000001110111101111': 1, '1100010011011000100101100111100100001111': 1, '0110110011010011100110010010101110110000': 1, '0100000100000000011101101110101111111100': 1, '1110011000010110111100101001001000011111': 1, '0110110000101000010100100010110000111110': 1, '1100001101000011111010011010101111110110': 1, '0001111011011001011100100100010110000000': 1, '0010100000000011001100111000101001000001': 1, '1010101100101111011011101000010001011100': 1, '0101110110000101101111111000101110101111': 1, '0000001001011010000000000101001100111010': 1, '0001011110000111000111110001100111110010': 1, '1000101111111001000011000000000100000111': 1, '0111001010010011110110010000101000010000': 1, '0111100100111001101111111101110100110100': 1, '0000111111100000111111010110111101000110': 1, '1100000101111101100101101001011001000010': 1})\n"
     ]
    }
   ],
   "source": [
    "qubit_range = range(20, 41, 10)\n",
    "tn_tasks    = {}\n",
    "tn_results  = {}\n",
    "for num_qubits in qubit_range:\n",
    "    # generate QFT circuit\n",
    "    qft_circ = qft(range(num_qubits))\n",
    "    tn_tasks[num_qubits] = tn_device.run(qft_circ, shots=n_shots)\n",
    "\n",
    "for num_qubits in qubit_range:\n",
    "    tn_status = tn_tasks[num_qubits].state()\n",
    "    while tn_status != 'COMPLETED':\n",
    "        tn_status = tn_tasks[num_qubits].state()\n",
    "\n",
    "    tn_results[num_qubits] = tn_tasks[num_qubits].result()\n",
    "    # get the running time of the quantum task\n",
    "    tn_runtime = tn_results[num_qubits].additional_metadata.simulatorMetadata.executionDuration\n",
    "\n",
    "    # get the measurement counts\n",
    "    tn_counts = tn_results[num_qubits].measurement_counts\n",
    "    \n",
    "    print('{}-qubit task {}.'.format(num_qubits,tn_status))\n",
    "    print('QFT:')\n",
    "    print('This quantum task ran {} shots and the total runtime was {} ms'.format(tn_num_shots,tn_runtime))\n",
    "    print(\"Measurement results: {}\\n\".format(tn_counts))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Circuit geometry is extremely important for TN1\n",
    "\n",
    "We'll now examine a type of circuit that is harder for the tensor network simulator: local Hayden-Preskill circuits. \"Local\" here means that multi-qubit gates only act on qubits which are nearest-neighbors. In this case, we will simulate a one-dimensional chain, and so any 2-qubit gates will act on qubits `q` and `q+1`. These circuits are generated in the following way:\n",
    "\n",
    "For each of `N` gates:\n",
    "- Choose a single qubit gate with 50% chance\n",
    "    - Choose between x-, y-, or z-rotations and Hadamard with equal likelihood.\n",
    "    - If a rotation is chosen, the angle is chosen from a uniform random distribution between `0` and `2*pi`.\n",
    "    - The qubit `q` to which to apply the gate is chosen randomly with equal likelihood from among all the available `N` qubits\n",
    "- Choose a CZ gate with 50% chance\n",
    "    - The qubit `q` to which to apply the control is chosen randomly with equal likelihood from among `N-1` qubits. The `Z` gate is applied to `q+1`.\n",
    "\n",
    "Circuits of this type are effective at generating entanglement among qubits. We can see this by scaling the number of gates applied quadratically with the number of qubits. This is enough gates to spread entanglement throughout all the qubits. We see that the circuit becomes more time consuming to simulate as we apply more gates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:58:24.671727Z",
     "start_time": "2023-08-29T21:58:24.660736Z"
    }
   },
   "outputs": [],
   "source": [
    "@circuit.subroutine(register=True)\n",
    "def local_Hayden_Preskill(num_qubits, num_gates):\n",
    "    hp_circ = Circuit()\n",
    "    \"\"\"Yields the circuit elements for a scrambling unitary.\n",
    "    Generates a circuit with numgates gates by laying down a\n",
    "    random gate at each time step.  Gates are chosen from single\n",
    "    qubit unitary rotations by a random angle, Hadamard, or a \n",
    "    controlled-Z between a qubit and its nearest neighbor (i.e.,\n",
    "    incremented by 1).\"\"\"\n",
    "    qubits = range(num_qubits)\n",
    "    for i in range(num_gates):\n",
    "        if np.random.random_sample() > 0.5:\n",
    "            \"\"\"CZ between a random qubit and the next qubit to its left.\"\"\"\n",
    "            a = np.random.choice(range(len(qubits)-1), 1, replace=True)[0]\n",
    "            hp_circ.cz(qubits[a],qubits[a+1])\n",
    "        else:\n",
    "            \"\"\"Random single qubit rotation.\"\"\"\n",
    "            angle = np.random.uniform(0, 2 * math.pi)\n",
    "            qubit = np.random.choice(qubits,1,replace=True)[0]\n",
    "            gate  = np.random.choice([Gate.Rx(angle), Gate.Ry(angle), Gate.Rz(angle), Gate.H()], 1, replace=True)[0]\n",
    "            hp_circ.add_instruction(Instruction(gate, qubit))\n",
    "    return hp_circ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualizing the Hayden-Preskill circuit\n",
    "\n",
    "Let's examine the geometry of some HP circuits of varying depths. We can see that the deeper the circuit, the more likely it is for (mediated) connections to exist among all qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:58:24.702643Z",
     "start_time": "2023-08-29T21:58:24.696509Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "HAYDEN PRESKILL CIRCUIT WITH 5 GATES:\n",
      "T  : |   0    |   1    |2|\n",
      "                          \n",
      "q0 : -C-------------------\n",
      "      |                   \n",
      "q1 : -Z-------------------\n",
      "                          \n",
      "q2 : -Ry(6.24)------------\n",
      "                          \n",
      "q3 : -C--------Rx(2.63)-C-\n",
      "      |                 | \n",
      "q4 : -Z-----------------Z-\n",
      "\n",
      "T  : |   0    |   1    |2|\n",
      "\n",
      "HAYDEN PRESKILL CIRCUIT WITH 10 GATES:\n",
      "T  : |0|   1    |2|3|   4    |   5    |\n",
      "                                       \n",
      "q1 : --------------C-Rx(4.33)-Rx(0.81)-\n",
      "                   |                   \n",
      "q2 : -H----------C-Z-C-----------------\n",
      "                 |   |                 \n",
      "q3 : -C-H--------Z-C-Z-----------------\n",
      "      |            |                   \n",
      "q4 : -Z-Rx(1.79)---Z-------------------\n",
      "\n",
      "T  : |0|   1    |2|3|   4    |   5    |\n",
      "\n",
      "HAYDEN PRESKILL CIRCUIT WITH 15 GATES:\n",
      "T  : |   0    |1|   2    |3|   4    |5|6|\n",
      "                                         \n",
      "q0 : ---------------------C-Rx(2.12)-----\n",
      "                          |              \n",
      "q1 : -Ry(4.60)-H-H--------Z-C--------C---\n",
      "                            |        |   \n",
      "q2 : -C--------C------------Z--------Z-H-\n",
      "      |        |                         \n",
      "q3 : -Z--------Z-Ry(3.82)-C-C------------\n",
      "                          | |            \n",
      "q4 : -Rz(5.56)-H----------Z-Z------------\n",
      "\n",
      "T  : |   0    |1|   2    |3|   4    |5|6|\n",
      "\n",
      "HAYDEN PRESKILL CIRCUIT WITH 20 GATES:\n",
      "T  : |   0    |1|   2    |   3    |   4    |5|   6    |7|8|9|\n",
      "                                                             \n",
      "q0 : -Ry(5.21)-C-Rx(4.17)---------------------C--------------\n",
      "               |                              |              \n",
      "q1 : -Rx(2.00)-Z----------C-----------------C-Z----------C---\n",
      "                          |                 |            |   \n",
      "q2 : -Ry(3.59)-C-Rz(0.74)-Z--------Rz(4.65)-Z-Ry(1.62)-C-Z-C-\n",
      "               |                                       |   | \n",
      "q3 : ----------Z-H--------Ry(1.07)-C-------------------Z-C-Z-\n",
      "                                   |                     |   \n",
      "q4 : -Rx(5.20)---------------------Z---------------------Z---\n",
      "\n",
      "T  : |   0    |1|   2    |   3    |   4    |5|   6    |7|8|9|\n",
      "\n",
      "HAYDEN PRESKILL CIRCUIT WITH 25 GATES:\n",
      "T  : |0|1|2|   3    |   4    |   5    |6|7|8|9|10|11|   12   |   13   |14|\n",
      "                                                                          \n",
      "q0 : -H-C------------C----------------------------------------------------\n",
      "        |            |                                                    \n",
      "q1 : ---Z-C-Rx(1.07)-Z--------C--------C-H--------------------------------\n",
      "          |                   |        |                                  \n",
      "q2 : ---C-Z-------------------Z--------Z-C-C---C--C--Rz(1.98)-Rx(6.11)----\n",
      "        |                                | |   |  |                       \n",
      "q3 : -H-Z-C-C----------------------------Z-Z-H-Z--Z--C--------H--------C--\n",
      "          | |                                        |                 |  \n",
      "q4 : -H---Z-Z--------Rx(4.46)-Rx(3.80)---------------Z-----------------Z--\n",
      "\n",
      "T  : |0|1|2|   3    |   4    |   5    |6|7|8|9|10|11|   12   |   13   |14|\n"
     ]
    }
   ],
   "source": [
    "num_qubits = 5\n",
    "for num_gates in range(5, 26, 5):\n",
    "    print('')\n",
    "    print(f\"HAYDEN PRESKILL CIRCUIT WITH {num_gates} GATES:\")\n",
    "    my_hp_circ = local_Hayden_Preskill(num_qubits, num_gates)\n",
    "    print(my_hp_circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experimenting with Hayden-Preskill circuits\n",
    "\n",
    "We will examine runtimes for various depths of circuits at relatively low (for TN1) qubit counts. This is to ensure that our job finishes in a reasonable amount of time. We'll examine the measurement counts at the end of each simulation. Because these are random circuits, we should not expect to see the measurement counts highly concentrated in a few outcomes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:58:24.709311Z",
     "start_time": "2023-08-29T21:58:24.702265Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20-qubit 48-depth task COMPLETED.\n",
      "Hayden-Preskill circuit:\n",
      "This task ran 5 shots and the total runtime was 6795 ms\n",
      "Measurement results: Counter({'11010111111101110111': 1, '11000011111000101101': 1, '11100110100100010110': 1, '11000010001100101111': 1, '10000001011010111100': 1})\n",
      "\n",
      "20-qubit 69-depth task COMPLETED.\n",
      "Hayden-Preskill circuit:\n",
      "This task ran 5 shots and the total runtime was 22773 ms\n",
      "Measurement results: Counter({'00110010000101010000': 1, '00010001010101000001': 1, '11011100010101000111': 1, '11101100011011001100': 1, '10001110000001110111': 1})\n"
     ]
    }
   ],
   "source": [
    "num_qubits  = 20\n",
    "n_shots     = 5\n",
    "gate_range  = [250, 500]\n",
    "tn_tasks    = {}\n",
    "tn_results  = {}\n",
    "for gates in gate_range:\n",
    "    # construct HP circuit\n",
    "    circ = Circuit()\n",
    "    # ensure the HP circuit is runnable -- circuits must have depth <= 100\n",
    "    while True:\n",
    "        circ = local_Hayden_Preskill(num_qubits, gates)\n",
    "        if circ.depth <= 100:\n",
    "            break\n",
    "    tn_tasks[circ.depth] = tn_device.run(circ, shots=n_shots)\n",
    "\n",
    "for depth in tn_tasks.keys():\n",
    "    tn_status = tn_tasks[depth].state()\n",
    "    while tn_status != 'COMPLETED':\n",
    "        tn_status = tn_tasks[depth].state()\n",
    "\n",
    "    tn_results[depth] = tn_tasks[depth].result()\n",
    "    # get the running time of the task\n",
    "    tn_runtime = tn_results[depth].additional_metadata.simulatorMetadata.executionDuration\n",
    "\n",
    "    # get the measurement counts\n",
    "    tn_counts = tn_results[depth].measurement_counts\n",
    "    \n",
    "    print('{}-qubit {}-depth task {}.'.format(num_qubits,depth,tn_status))\n",
    "    print('Hayden-Preskill circuit:')\n",
    "    print('This task ran {} shots and the total runtime was {} ms'.format(n_shots,tn_runtime))\n",
    "    print(\"Measurement results: {}\\n\".format(tn_counts))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The effect of shot counts on runtimes in TN1\n",
    "\n",
    "In order to generate samples from a quantum circuit, TN1 first partitions the qubits into groups, and then contracts each group in turn, generating a prediction for the current group's configuration based on the results of previously encountered groups. Because of this, in the worst case, the time to generate `n` shots may scale linearly with `n`. However, if the number of possible outcomes is small (as it is in the GHZ or QFT case), the runtime is effectively constant no matter the number of shots. We will examine this behavior below. It's therefore important to understand that your job may be rejected if the time to contract all the shots you have requested is too large. In this case your task will finish with a `FAILED` message, and the `failureReason` will be `Predicted runtime based on best contraction path found exceeds TN1 limit.` -- in this case you can attempt to retry the computation with fewer shots."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> Because the runtime of the quantum task can scale linearly with the number of shots in the worst case, it is <b>strongly advised</b> that users run their circuits with a small number of shots (20 or fewer) to explore typical runtimes for their circuit <b>before</b> running the circuit for many shots.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:58:24.724780Z",
     "start_time": "2023-08-29T21:58:24.709746Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GHZ task ran 5 shots and the total runtime was 1696 ms\n",
      "QFT task ran 5 shots and the total runtime was 2940 ms\n",
      "HP task ran 5 shots and the total runtime was 40343 ms\n",
      "GHZ task ran 20 shots and the total runtime was 1315 ms\n",
      "QFT task ran 20 shots and the total runtime was 2916 ms\n",
      "HP task ran 20 shots and the total runtime was 38092 ms\n"
     ]
    }
   ],
   "source": [
    "num_qubits = 25\n",
    "ghz_circ = ghz_circuit(num_qubits)\n",
    "qft_circ = qft(range(num_qubits))\n",
    "hp_circ  = Circuit()\n",
    "for _i in range(10):\n",
    "    circ = local_Hayden_Preskill(num_qubits, 500)\n",
    "    if circ.depth <= 100:\n",
    "        hp_circ = circ\n",
    "        break\n",
    "ghz_tasks    = {}\n",
    "ghz_results  = {}\n",
    "qft_tasks    = {}\n",
    "qft_results  = {}\n",
    "hp_tasks     = {}\n",
    "hp_results   = {}\n",
    "for n_shots in [5, 20]:\n",
    "    ghz_tasks[n_shots] = tn_device.run(ghz_circ, shots=n_shots)\n",
    "    qft_tasks[n_shots] = tn_device.run(qft_circ, shots=n_shots)\n",
    "    hp_tasks[n_shots]  = tn_device.run(hp_circ, shots=n_shots)\n",
    "\n",
    "for n_shots in [5, 20]:\n",
    "    ghz_status = ghz_tasks[n_shots].state()\n",
    "    while ghz_status != 'COMPLETED':\n",
    "        ghz_status = ghz_tasks[n_shots].state()\n",
    "\n",
    "    qft_status = qft_tasks[n_shots].state()\n",
    "    while qft_status != 'COMPLETED':\n",
    "        qft_status = qft_tasks[n_shots].state()\n",
    "\n",
    "    hp_status  = hp_tasks[n_shots].state()\n",
    "    while hp_status != 'COMPLETED':\n",
    "        hp_status = hp_tasks[n_shots].state()\n",
    "\n",
    "    ghz_results[n_shots] = ghz_tasks[n_shots].result()\n",
    "    qft_results[n_shots] = qft_tasks[n_shots].result()\n",
    "    hp_results[n_shots]  = hp_tasks[n_shots].result()\n",
    "    # get the running time of the task\n",
    "    ghz_runtime = ghz_results[n_shots].additional_metadata.simulatorMetadata.executionDuration\n",
    "    qft_runtime = qft_results[n_shots].additional_metadata.simulatorMetadata.executionDuration\n",
    "    hp_runtime  = hp_results[n_shots].additional_metadata.simulatorMetadata.executionDuration\n",
    "\n",
    "    print('GHZ task ran {} shots and the total runtime was {} ms'.format(n_shots,ghz_runtime))\n",
    "    print('QFT task ran {} shots and the total runtime was {} ms'.format(n_shots,qft_runtime))\n",
    "    print('HP task ran {} shots and the total runtime was {} ms'.format(n_shots,hp_runtime))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:58:24.928915Z",
     "start_time": "2023-08-29T21:58:24.716623Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantum Task Summary\n",
      "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 150, 'tasks': {'COMPLETED': 3}, 'execution_duration': datetime.timedelta(seconds=15, microseconds=990000), 'billed_execution_duration': datetime.timedelta(seconds=21, microseconds=494000)}, 'arn:aws:braket:::device/quantum-simulator/amazon/tn1': {'shots': 585, 'tasks': {'COMPLETED': 18}, 'execution_duration': datetime.timedelta(seconds=190, microseconds=695000), 'billed_execution_duration': datetime.timedelta(seconds=197, microseconds=787000)}}\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.933 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():.3f} USD\")"
   ]
  }
 ],
 "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.11.4"
  },
  "vscode": {
   "interpreter": {
    "hash": "590fab68195cf107911461461f81d5c472d3d6127f579badfcfad30f03e5cab2"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}