examples/braket_features/TN1_demo_local_vs_non-local_random_circuits.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Testing the tensor network simulator with 2-local Hayden-Preskill circuits\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:53:33.542091Z",
     "start_time": "2023-08-29T21:53:32.995986Z"
    }
   },
   "outputs": [],
   "source": [
    "# Use Braket SDK Cost Tracking to estimate the cost to run this example\n",
    "from braket.tracking import Tracker\n",
    "\n",
    "t = Tracker().start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Abstract:** We study a class of random quantum circuits known as Hayden-Preskill circuits using the tensor network simulator backend in Amazon Braket. The goal is to understand the degree to which the tensor network simulator is capable of detecting a hidden local structure in a quantum circuit, while simultaneously building experience with the Amazon Braket service and SDK. We find that the TN1 tensor network simulator can efficiently simulate local random quantum circuits, even when the local structure is obfuscated by permuting the qubit indices. Conversely, when running genuinely non-local versions of the quantum circuits, the simulator's performance is significantly degraded.\n",
    "\n",
    "This notebook is aimed at users who are familiar with Amazon Braket and have a working knowledge of quantum computing and quantum circuits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:53:35.773091Z",
     "start_time": "2023-08-29T21:53:33.058941Z"
    }
   },
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "from braket.aws import AwsDevice\n",
    "from braket.circuits import Circuit\n",
    "from braket.devices import Devices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup the tensor network simulator:\n",
    "In this notebook we will use the TN1 simulator on Amazon Braket [[1]](#References):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:53:36.203360Z",
     "start_time": "2023-08-29T21:53:35.753643Z"
    }
   },
   "outputs": [],
   "source": [
    "device = AwsDevice(Devices.Amazon.TN1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Local Hayden-Preskill Circuits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hayden-Preskill circuits are a class of unstructured, random quantum circuits.  To produce a Hayden-Preskill circuit, one chooses a gate at random from some universal gate set at each time step and applies this gate to random target qubits.  For example, one can choose to either apply a random single qubit rotation to a random qubit, or a CZ gate to a random pair of qubits at each time step.  As a concrete example, consider the following pseudocode:\n",
    "```\n",
    "Choose either {single qubit, two qubit} gate w/ prob. {1/2, 1/2}\n",
    " \n",
    "If single qubit:\n",
    "    Choose either {Rx, Ry, Rz, H} randomly w/ prob. {1/4, 1/4, 1/4, 1/4}    \n",
    "    Apply the chosen gate to a randomly chosen qubit\n",
    "    If the gate is Rx, Ry, or Rz, rotate by a randomly chosen angle\n",
    " \n",
    "If two qubit gate:\n",
    "    Choose (qubit 1, qubit 2) to be two randomly chosen qubits out of the set of N qubits\n",
    "    Apply CZ(qubit 1, qubit 2) # This means the couplings are long range, all-to-all\n",
    "```\n",
    "\n",
    "Using the strategy above, one can quickly generate random circuits with all-to-all, long-range couplings.  These circuits generate unitaries that rapidly converge to Haar random unitaries, and they are difficult to simulate.  \n",
    "\n",
    "A much simpler class of random circuits, which we call **local Hayden-Preskill circuits**, can be generated using the same strategy as above, but in which the two qubit CZ gates are applied to nearest neighbour qubits instead of random pairs:\n",
    "```\n",
    "Choose a random qubit j from [0, N-2]\n",
    "Apply CZ(qubit j, qubit j+1)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### In this notebook, we will focus on both local and non-local Hayden-Preskill circuits, defined using the helper functions below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:53:36.281375Z",
     "start_time": "2023-08-29T21:53:36.215832Z"
    }
   },
   "outputs": [],
   "source": [
    "def CZtuple_generator(qubits):\n",
    "    \"\"\"Yields a CZ between a random qubit and its next nearest neighbor.\n",
    "    For simplicity, we choose a random qubit from the first N-1 qubits for\n",
    "    the control and we set the target to be qubit i+1, where i is the control.\"\"\"\n",
    "    a = np.random.choice(range(len(qubits) - 1), 1, replace=True)[0]\n",
    "    yield Circuit().cz(qubits[a], qubits[a + 1])\n",
    "\n",
    "\n",
    "def local_Hayden_Preskill_generator(qubits, numgates):\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",
    "    for i in range(numgates):\n",
    "        yield np.random.choice(\n",
    "            [\n",
    "                Circuit().rx(np.random.choice(qubits, 1, replace=True), np.random.ranf()),\n",
    "                Circuit().ry(np.random.choice(qubits, 1, replace=True), np.random.ranf()),\n",
    "                Circuit().rz(np.random.choice(qubits, 1, replace=True), np.random.ranf()),\n",
    "                Circuit().h(np.random.choice(qubits, 1, replace=True)),\n",
    "                CZtuple_generator(\n",
    "                    qubits\n",
    "                ),  # For all-to-all: Circuit().cz(*np.random.choice(qubits,2,replace=False)),\n",
    "            ],\n",
    "            1,\n",
    "            replace=True,\n",
    "            p=[1 / 8, 1 / 8, 1 / 8, 1 / 8, 1 / 2],\n",
    "        )\n",
    "\n",
    "\n",
    "def non_local_Hayden_Preskill_generator(qubits, numgates):\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",
    "    for i in range(numgates):\n",
    "        yield np.random.choice(\n",
    "            [\n",
    "                Circuit().rx(np.random.choice(qubits, 1, replace=True), np.random.ranf()),\n",
    "                Circuit().ry(np.random.choice(qubits, 1, replace=True), np.random.ranf()),\n",
    "                Circuit().rz(np.random.choice(qubits, 1, replace=True), np.random.ranf()),\n",
    "                Circuit().h(np.random.choice(qubits, 1, replace=True)),\n",
    "                Circuit().cz(*np.random.choice(qubits, 2, replace=False)),\n",
    "            ],\n",
    "            1,\n",
    "            replace=True,\n",
    "            p=[1 / 8, 1 / 8, 1 / 8, 1 / 8, 1 / 2],\n",
    "        )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the helper functions above to generate local Hayden-Preskill (random) quantum circuits. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:53:36.302280Z",
     "start_time": "2023-08-29T21:53:36.224766Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |   0    |1|   2    |3|   4    |5|6|7|   8    |   9    |10|\n",
      "                                                                \n",
      "q0 : -Ry(0.23)-C---------------------C--------------------------\n",
      "               |                     |                          \n",
      "q1 : -Rx(0.72)-Z------------C--------Z-C-C-C--------Rz(0.87)----\n",
      "                            |          | | |                    \n",
      "q2 : ---------------------C-Z----------Z-Z-Z-----------------C--\n",
      "                          |                                  |  \n",
      "q3 : -C--------C-Ry(0.52)-Z-Rz(1.00)-C-C-C-Ry(0.12)-Rx(0.13)-Z--\n",
      "      |        |                     | | |                      \n",
      "q4 : -Z--------Z---------------------Z-Z-Z----------------------\n",
      "\n",
      "T  : |   0    |1|   2    |3|   4    |5|6|7|   8    |   9    |10|\n"
     ]
    }
   ],
   "source": [
    "# Generate an example of a local Hayden Preskill circuit\n",
    "test_circuit = Circuit()\n",
    "test_circuit.add(local_Hayden_Preskill_generator(range(5), 20))\n",
    "print(test_circuit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:53:36.303063Z",
     "start_time": "2023-08-29T21:53:36.275669Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : |   0    |1|   2    |    3     |    4     |   5    |   6    |7|8| 9 |\n",
      "                                                                          \n",
      "q0 : ----------C----------Z----------Z----------Ry(0.87)-Ry(0.21)---------\n",
      "               |          |          |                                    \n",
      "q1 : -Rz(0.77)-Z-Rx(0.11)-|--------H-|-Rx(0.78)-Ry(0.23)--------------Z---\n",
      "                          |          |                                |   \n",
      "q2 : ----------C-C--------C----------|-------------------Z--------Z---|-C-\n",
      "               | |                   |                   |        |   | | \n",
      "q3 : -C--------|-|-------------------C----------C--------C--------|-C-|-Z-\n",
      "      |        | |                              |                 | | |   \n",
      "q4 : -Z--------Z-Z--------Ry(0.02)--------------Z-----------------C-Z-C---\n",
      "\n",
      "T  : |   0    |1|   2    |    3     |    4     |   5    |   6    |7|8| 9 |\n"
     ]
    }
   ],
   "source": [
    "# Generate an example of a non-local Hayden Preskill circuit\n",
    "test_circuit = Circuit()\n",
    "test_circuit.add(non_local_Hayden_Preskill_generator(range(5), 20))\n",
    "print(test_circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulating _local_ random circuits using the TN1 tensor network simulator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing and timing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with a reasonably sized circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:53:36.519472Z",
     "start_time": "2023-08-29T21:53:36.345740Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 qubits, 10 layers = 200 total gates\n"
     ]
    }
   ],
   "source": [
    "num_qubits = 20  # Number of qubits\n",
    "num_layers = 10  # Number of layers.  A layer consists of num_qubits gates.\n",
    "numgates = num_qubits * num_layers  # Total number of gates.\n",
    "print(f\"{num_qubits} qubits, {num_layers} layers = {numgates} total gates\")\n",
    "circ = Circuit()\n",
    "circ.add(\n",
    "    local_Hayden_Preskill_generator(range(num_qubits), numgates)\n",
    ");  # Create the circuit with numgates gates."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Time this circuit using TN1.  It should take about a minute or so."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:54:07.387577Z",
     "start_time": "2023-08-29T21:53:36.458563Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running: 20 qubits, 10 layers = 200 total gates\n",
      "ID of quantum task: arn:aws:braket:us-west-2:260818742045:quantum-task/bdf7d17a-8e24-4676-8e61-d9334024db63\n",
      "Status of quantum task: CREATED\n",
      "Status: COMPLETED\n",
      "CPU times: user 1.1 s, sys: 78.7 ms, total: 1.18 s\n",
      "Wall time: 22.7 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "# define quantum task\n",
    "print(f\"Running: {num_qubits} qubits, {num_layers} layers = {numgates} total gates\")\n",
    "task = device.run(circ, shots=1000, poll_timeout_seconds=1000)\n",
    "\n",
    "# get id and status of submitted quantum\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",
    "terminal_states = [\"COMPLETED\", \"FAILED\", \"CANCELLED\"]\n",
    "while status not in terminal_states:\n",
    "    time.sleep(20)  # Update this for shorter circuits.\n",
    "    status = task.state()\n",
    "    print(\"Status:\", status)\n",
    "\n",
    "# get results of quantum task\n",
    "result = task.result()\n",
    "\n",
    "# get measurement shots\n",
    "counts = result.measurement_counts\n",
    "plt.bar(counts.keys(), counts.values());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The importance of locality in circuits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The goal of this section is to understand the importance of a local structure in quantum circuits being simulated in the tensor network simulator.  We will first generate and benchmark a local Hayden-Preskill circuit, and then we will re-run the exact same circuit with the qubits randomly permuted. By permuting the qubits, we produce a circuit that appears to be have non-local, long-range coupling, but for which we know that there exists an underlying local structure.\n",
    "\n",
    "An example of a circuit and its permuted version is shown below.  A local Hayden-Preskill circuit is generated, and then a version of the same circuit is created in which the qubits are randomly permuted, according to the permutation [0,1,2,3,4,5]$\\mapsto$[5,2,4,1,0,3]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:54:07.390697Z",
     "start_time": "2023-08-29T21:54:07.301771Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 9,
     "metadata": {
      "image/png": {
       "width": 400
      }
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "\n",
    "Image(filename=\"permuted_circuit.png\", width=400)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With these two circuits (that seem to have vastly different locality, but which are \"secretly\" the same), we can explore the tensor network simulator's ability to discern structure in a given circuit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First generate a modest sized local Hayden-Preskill circuit.  Then make a copy of that circuit by permuting the qubit indices randomly.  We'll compare the runtime to sample from the outputs of these two circuits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:54:07.926383Z",
     "start_time": "2023-08-29T21:54:07.343059Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50 qubits, 10 layers = 500 total gates\n"
     ]
    }
   ],
   "source": [
    "num_qubits = 50  # Number of qubits\n",
    "num_layers = 10  # Number of layers.  A layer consists of num_qubits gates.\n",
    "numgates = num_qubits * num_layers  # Total number of gates.\n",
    "qubits = range(num_qubits)  # Generate the (1D) qubits\n",
    "print(f\"{num_qubits} qubits, {num_layers} layers = {numgates} total gates\")\n",
    "\n",
    "# Generate the circuit with numgates gates acting on qubits.\n",
    "circ = Circuit()\n",
    "circ.add(local_Hayden_Preskill_generator(qubits, numgates))\n",
    "# Choose a random permutation of the qubits\n",
    "permuted_qubits = np.random.permutation(qubits)\n",
    "\n",
    "# Copy the circuit circ acting on the permuted qubits\n",
    "perm = Circuit().add_circuit(circ, target_mapping=dict(zip(qubits, permuted_qubits)))\n",
    "\n",
    "##Uncomment for testing:\n",
    "# print(permuted_qubits)\n",
    "# print(circ)\n",
    "# print(perm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Time both circuits using the tensor network simulator for a **single shot**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:57:23.688508Z",
     "start_time": "2023-08-29T21:54:07.921238Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running the local circuit with 50 qubits, 10 layers = 500 total gates\n",
      "The sample was: 00000111010010001110000001010011000011101101011011.\n",
      "CPU times: user 617 ms, sys: 42.8 ms, total: 660 ms\n",
      "Wall time: 3min 15s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# define quantum task\n",
    "task = device.run(circ, shots=1, poll_timeout_seconds=1000)\n",
    "\n",
    "# get results of quantum\n",
    "result = task.result()\n",
    "\n",
    "# get measurement shots\n",
    "print(\n",
    "    f\"Running the local circuit with {num_qubits} qubits, {num_layers} layers = {numgates} total gates\"\n",
    ")\n",
    "counts = result.measurement_counts\n",
    "print(f\"The sample was: {next(iter(counts))}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:57:55.971448Z",
     "start_time": "2023-08-29T21:57:23.679033Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running the non-local circuit with 50 qubits, 10 layers = 500 total gates\n",
      "The sample was: 10100001000011000011100110111110010000010101100100.\n",
      "CPU times: user 146 ms, sys: 12.8 ms, total: 159 ms\n",
      "Wall time: 32.3 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# define quantum task\n",
    "task = device.run(perm, shots=1, poll_timeout_seconds=1000)\n",
    "\n",
    "# get results of quantum task\n",
    "result = task.result()\n",
    "\n",
    "# get measurement shots\n",
    "print(\n",
    "    f\"Running the non-local circuit with {num_qubits} qubits, {num_layers} layers = {numgates} total gates\"\n",
    ")\n",
    "counts = result.measurement_counts\n",
    "print(f\"The sample was: {next(iter(counts))}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you repeat these experiments, you'll find that the two runtimes are (typically) very similar! Even though the permuted circuit seems to be highly non-local at first glance, the simulator discovers the underlying local structure, and the total runtime is comparable to the manifestly local circuit. This similarity is due to the rehearsal phase of the tensor network simulation [[1]](#References). A sophisticated algorithm works behind the scenes to find an efficient path for contracting the tensor network. Thus, when the tensor network has an underlying structure, the tensor network simulator can often tease it out."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulating _non-local_ random circuits using the TN1 tensor network simulator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us now compare the efficiency of simulating local and genuinely non-local random quantum circuits. When using the non-local Hayden Preskill circuits above, the circuits we generate have no underlying structure, making them especially difficult for the tensor network simulator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will generate one local random circuit and one non-local quantum circuit of the same size, and we will compare their runtimes. In this section, the we will not be comparing identical quantum circuits as we were above, so our results can be understood by repeating these experiments several times and noting that our claims are true on average."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:57:56.549838Z",
     "start_time": "2023-08-29T21:57:55.991726Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50 qubits, 8 layers = 400 total gates\n"
     ]
    }
   ],
   "source": [
    "num_qubits = 50  # Number of qubits\n",
    "num_layers = 8  # Number of layers.  A layer consists of num_qubits gates.\n",
    "numgates = num_qubits * num_layers  # Total number of gates.\n",
    "qubits = range(num_qubits)  # Generate the (1D) qubits\n",
    "print(f\"{num_qubits} qubits, {num_layers} layers = {numgates} total gates\")\n",
    "\n",
    "# Generate the local circuit with numgates gates acting on qubits.\n",
    "localcirc = Circuit()\n",
    "localcirc.add(local_Hayden_Preskill_generator(qubits, numgates))\n",
    "# Generate the non-local circuit with numgates gates acting on qubits.\n",
    "nonlocalcirc = Circuit()\n",
    "nonlocalcirc.add(non_local_Hayden_Preskill_generator(qubits, numgates));\n",
    "\n",
    "##Uncomment for testing:\n",
    "# print(permuted_qubits)\n",
    "# print(circ)\n",
    "# print(perm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the local circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:58:25.564674Z",
     "start_time": "2023-08-29T21:57:56.580145Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running the local circuit with 50 qubits, 8 layers = 400 total gates\n",
      "The sample was: 00000100001110001010000000000000000001111010001111.\n",
      "CPU times: user 141 ms, sys: 11.4 ms, total: 153 ms\n",
      "Wall time: 29 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# define quantum task\n",
    "task = device.run(localcirc, shots=1, poll_timeout_seconds=1000)\n",
    "\n",
    "# get results of quantum task\n",
    "result = task.result()\n",
    "\n",
    "# get measurement shots\n",
    "print(\n",
    "    f\"Running the local circuit with {num_qubits} qubits, {num_layers} layers = {numgates} total gates\"\n",
    ")\n",
    "counts = result.measurement_counts\n",
    "print(f\"The sample was: {next(iter(counts))}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the non-local circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:58:44.597893Z",
     "start_time": "2023-08-29T21:58:25.543306Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running the non-local circuit with 50 qubits, 8 layers = 400 total gates\n",
      "The sample was: 00101111001010000001101101010100010000001100001000.\n",
      "CPU times: user 105 ms, sys: 7.38 ms, total: 112 ms\n",
      "Wall time: 19.1 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# define quantum task\n",
    "task = device.run(nonlocalcirc, shots=1, poll_timeout_seconds=1000)\n",
    "\n",
    "# get results of quantum task\n",
    "result = task.result()\n",
    "\n",
    "# get measurement shots\n",
    "print(\n",
    "    f\"Running the non-local circuit with {num_qubits} qubits, {num_layers} layers = {numgates} total gates\"\n",
    ")\n",
    "counts = result.measurement_counts\n",
    "print(f\"The sample was: {next(iter(counts))}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When running this notebook several times, we find that the non-local circuit generally takes 2-3 times longer to run than the local circuit. However, on occasion the non-local circuit fails to run, for a reason we will explore below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Non-local circuits quickly become too difficult for tensor network methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, we will compare larger circuits with and without locality. We will see that the local circuits execute very efficiently on the tensor network simulator, whereas the non-local circuits actually fail in the rehearsal phase.\n",
    "\n",
    "We start by generating these larger circuits:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:58:46.294400Z",
     "start_time": "2023-08-29T21:58:44.612564Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50 qubits, 20 layers = 1000 total gates\n"
     ]
    }
   ],
   "source": [
    "num_qubits = 50  # Number of qubits\n",
    "num_layers = 20  # Number of layers.  A layer consists of num_qubits gates.\n",
    "numgates = num_qubits * num_layers  # Total number of gates.\n",
    "qubits = range(num_qubits)  # Generate the (1D) qubits\n",
    "print(f\"{num_qubits} qubits, {num_layers} layers = {numgates} total gates\")\n",
    "\n",
    "# Generate the circuit with numgates gates acting on qubits.\n",
    "localcirc = Circuit()\n",
    "localcirc.add(local_Hayden_Preskill_generator(qubits, numgates))\n",
    "# Generate the circuit with numgates gates acting on qubits.\n",
    "nonlocalcirc = Circuit()\n",
    "nonlocalcirc.add(non_local_Hayden_Preskill_generator(qubits, numgates));\n",
    "\n",
    "##Uncomment for testing:\n",
    "# print(permuted_qubits)\n",
    "# print(circ)\n",
    "# print(perm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The local Hayden Preskill circuit executes in a reasonable amount of time, generally about a minute or so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:59:18.922221Z",
     "start_time": "2023-08-29T21:58:46.351320Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running the local circuit with 50 qubits, 20 layers = 1000 total gates\n",
      "The sample was: 10010010000101000101001110000000100110100011000111.\n",
      "CPU times: user 185 ms, sys: 12.3 ms, total: 197 ms\n",
      "Wall time: 32.6 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# define quantum task\n",
    "task = device.run(localcirc, shots=1, poll_timeout_seconds=1000)\n",
    "\n",
    "# get results of quantum task\n",
    "result = task.result()\n",
    "\n",
    "# get measurement shots\n",
    "print(\n",
    "    f\"Running the local circuit with {num_qubits} qubits, {num_layers} layers = {numgates} total gates\"\n",
    ")\n",
    "counts = result.measurement_counts\n",
    "print(f\"The sample was: {next(iter(counts))}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conversely, the non-local Hayden Preskill circuit actually fails to execute:\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> The following cell can take several minutes to run on TN1. It is only present to illustrate a quantum task that will result in a FAILED state. To run this cell, uncomment it.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:59:18.924174Z",
     "start_time": "2023-08-29T21:59:18.894085Z"
    }
   },
   "outputs": [],
   "source": [
    "##%%time\n",
    "## define quantum task\n",
    "# task = device.run(nonlocalcirc, shots=1, poll_timeout_seconds = 1000)\n",
    "\n",
    "## get results of quantum task\n",
    "# result = task.result()\n",
    "\n",
    "## get measurement shots\n",
    "# print(f\"Running the non-local circuit with {num_qubits} qubits, {num_layers} layers = {numgates} total gates\")\n",
    "## counts = result.measurement_counts\n",
    "## print(f\"The sample was: {next(iter(counts))}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see why this circuit `FAILED` to run, we can check the `failureReason` in the quantum task's `_metadata`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:59:18.924288Z",
     "start_time": "2023-08-29T21:59:18.898900Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# print(task._metadata['failureReason'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evidently, without any structure to exploit, this tensor network would take too long to simulate, and the simulator returns with a `FAILED` state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We saw that structured quantum circuits can be simulated much more efficiently than unstructured random quantum circuits. That said, structure in a quantum circuit may not be immediately evident, as the tensor network simulator was able to discover the hidden structure in our permuted quantum circuits, leading to efficiency on-par with their unpermuted, local counterparts. Note, however, that discovering this underlying structure is analogous to the graph isomorphism problem, and finding an efficient contraction path for a tensor network is a hard problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appendix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "[1] [Amazon Braket Documentation: Tensor Network Simulator](https://docs.aws.amazon.com/braket/latest/developerguide/braket-devices.html#braket-simulator-tn1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:59:21.853214Z",
     "start_time": "2023-08-29T21:59:21.718915Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantum Task Summary\n",
      "{'arn:aws:braket:::device/quantum-simulator/amazon/tn1': {'shots': 1005, 'tasks': {'COMPLETED': 6}, 'execution_duration': datetime.timedelta(seconds=119, microseconds=226000), 'billed_execution_duration': datetime.timedelta(seconds=119, microseconds=226000)}}\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",
      "This estimate does not included the task which fails after rehearsal, for which charges may apply. See https://docs.aws.amazon.com/braket/latest/developerguide/braket-devices.html for more details.\n",
      "Estimated cost to run this example: 0.546 USD\n"
     ]
    }
   ],
   "source": [
    "print(\"Quantum Task Summary\")\n",
    "print(t.quantum_tasks_statistics())\n",
    "print(\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",
    ")\n",
    "print(\n",
    "    \"This estimate does not included the task which fails after rehearsal, for which charges may apply. See https://docs.aws.amazon.com/braket/latest/developerguide/braket-devices.html for more details.\"\n",
    ")\n",
    "print(\n",
    "    f\"Estimated cost to run this example: {t.qpu_tasks_cost() + t.simulator_tasks_cost():.3f} USD\"\n",
    ")"
   ]
  }
 ],
 "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.8.10"
  },
  "vscode": {
   "interpreter": {
    "hash": "590fab68195cf107911461461f81d5c472d3d6127f579badfcfad30f03e5cab2"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}