research/glued_trees/glued_trees.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Glued Trees Algorithm\n",
    "### Introduction\n",
    "Consider a network of two mirrored binary trees connected to each other, where the outermost nodes of each tree are connected to two random nodes in the other tree. This structure will have $2n$ columns and $2^{n+1}-2$ nodes in total, as shown in the diagram below. Each node in the structure has a secret key in the form of a random bit string of size $2n$, and you are given oracular access to the network such that you can query a node using its key to get the keys of its neighbors. Your goal is, given the key of the entrance node, to find the key of the exit node as efficiently as possible.\n",
    "\n",
    "![png](figures/glued_trees_diagram.png)\n",
    "\n",
    "If you try to play this game yourself, or program an algorithm to do so, you'll quickly run into a major problem: since you don't know what specific nodes on the tree the interior keys correspond to, you will get lost within the structure once you reach the area between the two trees. There is no way to guarantee a solution to this problem—using a classical computer—that doesn't require you to check every node in the worst case.\n",
    "\n",
    "There is a way to solve this problem efficiently however, on the order of the total number of *columns* of the structure instead of the nodes. You just need to use a quantum computer! This paper [[1](#GluedTrees)] published in December 2023 describes a quantum approach to solving this algorithm by considering the structure as a system of coupled harmonic oscillators attached by springs. A quantum computer can use Hamiltonian simulation to simulate this classical system efficiently. If you apply a push to the oscillator representing the entrance node, and treat the interactions between nodes as queries, you can \"reach\" the exit node (trigger a spike in its oscillatory movement) in time $2n$, offering linear efficiency as opposed to exponential efficiency!\n",
    "\n",
    "While this notebook will be following the algorithm described by the 2023 paper above, it should be noted that this problem was first set by this paper from October 2002 [[2](#QuantumWalk)].\n",
    "\n",
    "The following code segment imports all the necessary libraries for this notebook. NetworkX is required for the `generate_pauli_list` function, but the Pauli lists for 10 and 20 qubits (the examples in this notebook) have already been generated and cached in the `glued_trees_cache.json` file. You may uncomment the line at the bottom of the code segment, however, if you would like to try recalculating the Pauli lists or calculating them for other qubit sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: jsonpickle in /usr/local/lib/python3.10/site-packages (3.2.2)\n",
      "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/site-packages (4.66.5)\n"
     ]
    }
   ],
   "source": [
    "# install required modules\n",
    "!pip install jsonpickle\n",
    "!pip install tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-31T12:02:18.972978Z",
     "iopub.status.busy": "2024-07-31T12:02:18.971748Z",
     "iopub.status.idle": "2024-07-31T12:02:21.946168Z",
     "shell.execute_reply": "2024-07-31T12:02:21.945520Z"
    }
   },
   "outputs": [],
   "source": [
    "import json\n",
    "import pathlib\n",
    "import random\n",
    "\n",
    "import jsonpickle\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import tqdm\n",
    "\n",
    "from classiq import *\n",
    "from classiq.execution import ExecutionPreferences\n",
    "\n",
    "# import networkx as nx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-31T12:02:21.949489Z",
     "iopub.status.busy": "2024-07-31T12:02:21.948846Z",
     "iopub.status.idle": "2024-07-31T12:02:21.952717Z",
     "shell.execute_reply": "2024-07-31T12:02:21.952285Z"
    }
   },
   "outputs": [],
   "source": [
    "# notebooks path issue\n",
    "\n",
    "\n",
    "def get_path(file_name):\n",
    "    path = (\n",
    "        pathlib.Path(__file__).parent.resolve()\n",
    "        if \"__file__\" in globals()\n",
    "        else pathlib.Path(\".\")\n",
    "    )\n",
    "    return path / file_name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quantum Algorithm\n",
    "To model the columns of the glued trees structure as a system of coupled harmonic oscillators, we consider a matrix $\\mathbf{A}$ of size $N \\times N$ corresponding to the nodes of the glued trees structure, such that $N=2^{n+1}-2$ and $n$ is the number of columns of one of the two glued trees. This matrix is defined as $\\mathbf{A}:=3(\\mathbf{1}_N)-A$, where $A$ is the adjacency matrix of the glued trees system using any ordering. \n",
    "\n",
    "For demonstration purposes, we will be using a simple linear ordering of this adjacency matrix such that the entrance node is first and the exit node is last. This matrix will be symmetrical and take the following shape:\n",
    "\n",
    "![png](figures/A_matrix.png)\n",
    "\n",
    "As shown in further detail in the paper, we can define a block Hamiltonian $\\mathbf{H}$ such that\n",
    "\n",
    "$$\n",
    "\\mathbf{H} := -\\begin{pmatrix}\n",
    "\\mathbf{0} & \\mathbf{B} \\\\\n",
    "\\mathbf{B}^† & \\mathbf{0}\n",
    "\\end{pmatrix}\n",
    "$$\n",
    "\n",
    "where $\\mathbf{B}$ is any $N \\times M$ matrix such that $\\mathbf{B}\\mathbf{B}^†=\\mathbf{A}$. However, to use this matrix $\\mathbf{H}$ for Hamiltonian simulation, it must have a size corresponding to a power of two, while $\\mathbf{A}$ is size $N \\times N$. We can deal with this by ensuring that $\\mathbf{B}$ is size $N \\times (N+4)$, so the resulting Hamiltonian $\\mathbf{H}$ is a square matrix with side length $2N+4 = 2(2^{n+1}-2)+4 = 2^{n+2}$. This means that a glued trees system with $n$ columns for one tree can be simulated using $n+2$ qubits.\n",
    "\n",
    "In this notebook, we generate the matrix $\\mathbf{A}$ by building the glued trees structure using the NetworkX library such that the nodes are labeled in order from the entrance to exit node and using the `nx.adjacency_matrix` function to generate an adjacency matrix using that ordering. We will decompose $\\mathbf{A}$ using [Cholesky decomposition](https://en.wikipedia.org/wiki/Cholesky_decomposition) to get a square matrix where its product with its conjugate transpose is equal to $\\mathbf{A}$. This matrix is the same size as $\\mathbf{A}$, however, so we must pad it with 4 columns of zeroes to get our matrix $\\mathbf{B}$ of size $N \\times (N+4)$ so $\\mathbf{H}$ has a size corresponding to a power of two. We can then create the block Hamiltonian with the proper size using $\\mathbf{B}$ and $\\mathbf{B}^†$, and generate its full Pauli list using Classiq's built-in `matrix_to_hamiltonian` function.\n",
    "\n",
    "All Pauli list outputs are cropped so they have no more than 200 terms. This is to ensure that the circuit depth is at a reasonable range (low thousands) given the limits of current quantum hardware. As a result of this approach, as the number of qubits increases, the accuracy of the Pauli list in comparison to the matrix it represents diminishes so the circuit depth remains roughly constant.\n",
    "\n",
    "The Pauli list representation of $\\mathbf{H}$ for qubit sizes small enough to calculate (12 qubits and lower) are generated and cropped using the `generate_pauli_list` function, which uses an ad hoc approach that tries to represent the Pauli list as a whole as accurately as possible using only the 200 ostensibly most relevant terms to simulating the system.\n",
    "\n",
    "The cropping algorithm, defined in the `crop_pauli_list` function, first selects 120 terms (60%) by going through each character position from the end to the start and picking the Pauli terms with the largest coefficients that contain each of the four possibilities ($I$, $X$, $Y$, $Z$) at that character position. If all positions are exhausted before reaching 120 terms, the algorithm takes another pass through the character positions until 120 are selected. The other 80 terms (40%) are selected by picking the 80 remaining terms with the largest coefficients. The algorithm balances important high-coefficient terms with diversity in the 200 selected terms.\n",
    "\n",
    "The Pauli lists for qubit sizes too large to fully calculate (greater than 12 qubits) are approximated by padding with the second character of the Pauli strings of the largest cropped Pauli list that can be generated in reasonable time, as this follows a pattern present in the vast majority of strings in the cropped Pauli list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-31T12:02:21.961607Z",
     "iopub.status.busy": "2024-07-31T12:02:21.961126Z",
     "iopub.status.idle": "2024-07-31T12:02:21.972114Z",
     "shell.execute_reply": "2024-07-31T12:02:21.971515Z"
    }
   },
   "outputs": [],
   "source": [
    "def crop_pauli_list(pauli_list, size):\n",
    "    if len(pauli_list) <= size:\n",
    "        return pauli_list\n",
    "    result = []\n",
    "    idx = 0\n",
    "    while len(result) < round(size * 0.6):\n",
    "        for i in range(len(pauli_list[0].pauli) - 1, -1, -1):\n",
    "            for k in pauli_list:\n",
    "                if (\n",
    "                    k.pauli[i] == [Pauli.I, Pauli.X, Pauli.Y, Pauli.Z][idx % 4]\n",
    "                    and k not in result\n",
    "                ):\n",
    "                    result.append(k)\n",
    "                    break\n",
    "            idx += 1\n",
    "    for i in pauli_list:\n",
    "        if len(result) >= size:\n",
    "            break\n",
    "        if i not in result:\n",
    "            result.append(i)\n",
    "    return result\n",
    "\n",
    "\n",
    "def generate_pauli_list(qubits):\n",
    "    dim = qubits - 2\n",
    "    T1 = nx.balanced_tree(2, dim - 1)\n",
    "    T2 = nx.relabel_nodes(T1, lambda x: 2 ** (dim + 1) - 3 - x)\n",
    "    T = nx.union(T1, T2)\n",
    "    edges = {i: 0 for i in range(2**dim - 1, 2 ** (dim - 1) + 2**dim - 1)}\n",
    "    for i in range(2 ** (dim - 1) - 1, 2**dim - 1):\n",
    "        nums = [\n",
    "            j for j in range(2**dim - 1, 2 ** (dim - 1) + 2**dim - 1) if edges[j] < 1\n",
    "        ]\n",
    "        if len(nums) == 0:\n",
    "            nums = [\n",
    "                j\n",
    "                for j in range(2**dim - 1, 2 ** (dim - 1) + 2**dim - 1)\n",
    "                if edges[j] < 2\n",
    "            ]\n",
    "        vals = random.sample(nums, k=2)\n",
    "        for j in vals:\n",
    "            edges[j] += 1\n",
    "        T.add_edges_from([(i, vals[0]), (i, vals[1])])\n",
    "    A = 3 * np.identity(2 ** (dim + 1) - 2) - np.array(\n",
    "        nx.adjacency_matrix(T, nodelist=sorted(T.nodes())).todense()\n",
    "    )\n",
    "    B = np.hstack((np.linalg.cholesky(A), np.zeros((2 ** (dim + 1) - 2, 4))))\n",
    "    H = -np.block(\n",
    "        [\n",
    "            [np.zeros((B.shape[0], B.shape[0])), B],\n",
    "            [B.conj().T, np.zeros((B.shape[1], B.shape[1]))],\n",
    "        ]\n",
    "    )\n",
    "    result = matrix_to_hamiltonian(H)\n",
    "    return crop_pauli_list(\n",
    "        sorted(result, key=lambda x: abs(x.coefficient), reverse=True), 200\n",
    "    )\n",
    "\n",
    "\n",
    "def pauli_str(qubits, recalculate=False):\n",
    "    with open(get_path(\"glued_trees_cache.json\"), \"r\") as f:\n",
    "        cache = json.load(f)\n",
    "    if not recalculate and str(qubits) in cache:\n",
    "        return jsonpickle.decode(cache[str(qubits)])\n",
    "    if qubits > 12:\n",
    "        return [\n",
    "            PauliTerm(\n",
    "                [i.pauli[0]] + [i.pauli[1]] * (qubits - len(i.pauli)) + i.pauli[1:],\n",
    "                i.coefficient,\n",
    "            )\n",
    "            for i in generate_pauli_list(12)\n",
    "        ]\n",
    "    return generate_pauli_list(qubits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are now ready to run our main execution function, `run_point`. This function takes in the number of qubits `qubits` and the time `t` to perform Hamiltonian simulation $e^{-it\\mathbf{H}}$ using the `exponentiation_with_depth_constraint` function in the Classiq software development kit. \n",
    "\n",
    "The `max_depth` parameter is set to 1400, which is around the range of the current limit for comprehensible results in state of the art quantum computers. The `num_shots` parameter is set to 8192 to give enough of room for significant spikes in a state to be apparent given the high number of total possible states.\n",
    "\n",
    "The resulting quantum state can be written as follows:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "|\\psi(t)\\rangle &\\propto \\begin{pmatrix}\n",
    "\\dot{\\vec{x}}(t) \\\\\n",
    "i\\mathbf{B}^{†} \\vec{x}(t) \n",
    "\\end{pmatrix} \\\\\n",
    "\\begin{pmatrix}\n",
    "\\dot{\\vec{x}}(t) \\\\\n",
    "i\\mathbf{B}^{†} \\vec{x}(t) \n",
    "\\end{pmatrix} &= e^{-it\\mathbf{H}} \\begin{pmatrix}\n",
    "\\dot{\\vec{x}}(0) \\\\\n",
    "i\\mathbf{B}^{†} \\vec{x}(0) \n",
    "\\end{pmatrix}\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "where $\\vec{x}(0)=(0,0,\\dots,0)^T$ and $\\dot{\\vec{x}}(0)=(1,0,\\dots,0)^T$ using a linear ordering of nodes. \n",
    "\n",
    "Since the speed of the entrance node oscillator $|\\dot{x}_1(t)|$ is represented by the quantum state $|0\\rangle$ and should have probability 1 at $t=0$, there is no specific state preparation necessary for this system. It should also be noted that since our matrix $\\mathbf{B}^†$ is padded with 4 rows of zeroes, the highest 4 quantum states do not correspond to the displacement or speed of any oscillator. This means that the quantum state representing the speed of the exit node oscillator $|\\dot{x}_N(t)|$, which is what we are most interested in, will correspond to $|N-1\\rangle=|2^{n+1}-3\\rangle$. We will be tracking this particular quantum state at time $t \\approx 2n$ expecting a spike, which represents the system of oscillators \"reaching\" the exit node from the initial push to the entrance node.\n",
    "\n",
    "We will run the `run_point` function through a helper function `run_range`, which executes it 13 times in total for a given qubit size, spanning from $t=2n-12$ to $t=2n+12$ in 2 second intervals. This range gives time to observe oscillation occurring at the state value corresponding to $|\\dot{x}_N(t)|$ while also being close enough around $t=2n$, the time where we are expecting a spike."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-31T12:02:21.974670Z",
     "iopub.status.busy": "2024-07-31T12:02:21.974286Z",
     "iopub.status.idle": "2024-07-31T12:02:21.979670Z",
     "shell.execute_reply": "2024-07-31T12:02:21.979061Z"
    }
   },
   "outputs": [],
   "source": [
    "def run_point(qubits, t, pauli_list):\n",
    "    @qfunc\n",
    "    def main(state: Output[QArray[QBit]]) -> None:\n",
    "        allocate(len(pauli_list[0].pauli), state)\n",
    "        exponentiation_with_depth_constraint(\n",
    "            pauli_list,\n",
    "            evolution_coefficient=t,\n",
    "            max_depth=1400,\n",
    "            qbv=state,\n",
    "        )\n",
    "\n",
    "    execution_preferences = ExecutionPreferences(num_shots=8192)\n",
    "    model = set_execution_preferences(create_model(main), execution_preferences)\n",
    "    quantum_program = synthesize(model)\n",
    "    job = execute(quantum_program)\n",
    "    filename = (\n",
    "        str(qubits)\n",
    "        + \"-qubits/2n\"\n",
    "        + (\n",
    "            str(t - 2 * qubits + 4)\n",
    "            if t < 2 * qubits - 4\n",
    "            else \"+\" + str(t - 2 * qubits + 4)\n",
    "        )\n",
    "    )\n",
    "    with open(get_path(\"results/\" + filename + \".json\"), \"w\") as f:\n",
    "        json.dump(dict(job.result_value()), f)\n",
    "\n",
    "\n",
    "def run_range(qubits, recalculate=False):\n",
    "    pauli_list = pauli_str(qubits, recalculate)\n",
    "    for i in tqdm.tqdm(range(-12, 13, 2)):\n",
    "        run_point(qubits, 2 * qubits - 4 + i, pauli_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code segment displays the execution of `run_range` for 10 qubits ($n=8, N=510$), a higher qubit size that is still simulatable. In addition, it is low enough that its Pauli list can still be fully generated and cropped.\n",
    "\n",
    "This instance of the function should take a few minutes to run. As defined, it will use the cached Pauli list for 10 qubits in `glued_trees_cache.json`. If you would like to recalculate the Pauli list, ensure that you have uncommented and run the two lines at the top of this notebook and add `recalculate=True` as the second parameter to the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-31T12:02:21.981896Z",
     "iopub.status.busy": "2024-07-31T12:02:21.981720Z",
     "iopub.status.idle": "2024-07-31T12:04:02.331267Z",
     "shell.execute_reply": "2024-07-31T12:04:02.330497Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 13/13 [01:48<00:00,  8.36s/it]\n"
     ]
    }
   ],
   "source": [
    "run_range(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code segment, on the other hand, displays the execution of `run_range` for 20 qubits ($n=18, N=524286$), a qubit size that is still simulatable but where its Pauli list cannot be generated and is thus approximated using the Pauli list for 12 qubits.\n",
    "\n",
    "This instance of the function should take a few minutes to run if the cached Pauli list is used. Since this instance of the function requires generating the Pauli list for 12 qubits, which is very large, it will take much longer to run if you choose to recalculate the Pauli list.\n",
    "\n",
    "You can also view the `qmod` file for the execution of `run_point` for 20 qubits at $t=2n$, which has been saved in this directory as `glued_trees_example.qmod`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-31T12:04:02.335415Z",
     "iopub.status.busy": "2024-07-31T12:04:02.334720Z",
     "iopub.status.idle": "2024-07-31T12:06:57.530106Z",
     "shell.execute_reply": "2024-07-31T12:06:57.529501Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/13 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 13/13 [02:39<00:00, 12.30s/it]\n"
     ]
    }
   ],
   "source": [
    "run_range(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now graph the results we have generated using the simulator, which have been saved into directories in the `results` folder based on their qubit size. The `graph_results` function creates a plot of the proportion of shots for the qubit state $|N-1\\rangle$ corresponding to $|\\dot{x}_N(t)|$ for a given qubit size from $t=2n-12$ to $t=2n+12$ and saves it in the `figures` folder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-31T12:06:57.532666Z",
     "iopub.status.busy": "2024-07-31T12:06:57.532298Z",
     "iopub.status.idle": "2024-07-31T12:06:57.537863Z",
     "shell.execute_reply": "2024-07-31T12:06:57.537291Z"
    }
   },
   "outputs": [],
   "source": [
    "def graph_results(qubits):\n",
    "    states = [(str(i) if i < 0 else \"+\" + str(i)) for i in range(-12, 13, 2)]\n",
    "    times = [2 * qubits - 4 + int(i) for i in states]\n",
    "    data = []\n",
    "    for i in states:\n",
    "        with open(\n",
    "            get_path(\"results/\" + str(qubits) + \"-qubits\" + \"/2n\" + i + \".json\"), \"r\"\n",
    "        ) as f:\n",
    "            j = json.load(f)\n",
    "            key = str(\"0\" + bin(2 ** (qubits - 1) - 3)[2:])\n",
    "            data.append(j[\"counts\"][key] / j[\"num_shots\"] if key in j[\"counts\"] else 0)\n",
    "    plt.plot(times, data)\n",
    "    plt.xlabel(\"Time (s)\")\n",
    "    plt.ylabel(\"Proportion of |\" + str(2 ** (qubits - 1) - 3) + \"> shots\")\n",
    "    plt.title(\n",
    "        r\"Glued Trees System at $t \\approx 2n$ for \"\n",
    "        + str(qubits)\n",
    "        + r\" Qubits ($n=\"\n",
    "        + str(qubits - 2)\n",
    "        + r\"$)\"\n",
    "    )\n",
    "    plt.savefig(\n",
    "        get_path(\"figures/\" + str(qubits) + \"_qubits.png\"), bbox_inches=\"tight\", dpi=300\n",
    "    )\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code segment displays the graph for 10 qubits, a qubit size with a generated and cropped Pauli list. As expected, there is a large spike at $t \\approx 2n$ indicative of the initial push to the entrance node having \"reached\" the exit node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-31T12:06:57.539989Z",
     "iopub.status.busy": "2024-07-31T12:06:57.539822Z",
     "iopub.status.idle": "2024-07-31T12:06:58.190121Z",
     "shell.execute_reply": "2024-07-31T12:06:58.189419Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph_results(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code segment displays the graph for 20 qubits, a qubit size with an approximated Pauli list. There is a clear spike at $t \\approx 2n$ caused by the propagation from the entrance node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-07-31T12:06:58.209108Z",
     "iopub.status.busy": "2024-07-31T12:06:58.207891Z",
     "iopub.status.idle": "2024-07-31T12:06:59.067021Z",
     "shell.execute_reply": "2024-07-31T12:06:59.066274Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph_results(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because of our Pauli list cropping, the algorithm can also be run with reasonable accuracy on actual quantum hardware. Simply add one of Classiq's quantum hardware [cloud providers](https://docs.classiq.io/latest/user-guide/execution/cloud-providers/) as an execution preference in the `run_point` function.\n",
    "\n",
    "Perhaps the most interesting thing about the glued trees algorithm is that it is a relatively heavy case of using a quantum computer to gain an exponential advantage, usually requiring several executions at different time points to observe the intended result, but it can still be executed effectively on present-day quantum hardware due to the Pauli list cropping. I encourage you to try out the algorithm on both a simulator and quantum hardware for various qubit sizes! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### References\n",
    "<a id=\"GluedTrees\">[1]</a>: [Babbush, Ryan and Berry, Dominic W. and Kothari, Robin and Somma, Rolando D. and Wiebe, Nathan. \"Exponential Quantum Speedup in Simulating Coupled Classical Oscillators.\" Phys. Rev. X 13, 041041 (2023)](https://journals.aps.org/prx/pdf/10.1103/PhysRevX.13.041041)\n",
    "\n",
    "<a id=\"QuantumWalk\">[2]</a>: [Childs, Andrew M. and Cleve, Richard and Deotto, Enrico and Farhi, Edward and Gutmann, Sam and Spielman, Daniel A. \"Exponential algorithmic speedup by a quantum walk.\" Proc. 35th ACM Symposium on Theory of Computing (STOC 2003), pp. 59-68](https://arxiv.org/pdf/quant-ph/0209131)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}