{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "72751fb3",
   "metadata": {},
   "source": [
    "# Toffoli ladders",
    "\n",
    "**Download Notebook** - {nb-download}`toffoli_ladders.ipynb`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f8812ac5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pytket import Circuit\n",
    "from pytket.circuit.display import render_circuit_jupyter as draw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e7191c1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def toffoli_ladder_circuit(\n",
    "    n_qubits: int,\n",
    "    n_anc: int,\n",
    "    labeled_indices: list[\n",
    "        tuple[tuple[int, int], tuple[int, int], tuple[int, int]]\n",
    "    ],\n",
    ") -> Circuit:\n",
    "    \"\"\"Create pytket circuit for a Toffoli ladder.\n",
    "\n",
    "    Args:\n",
    "        n_qubits: Number of main/data qubits in register \"q\".\n",
    "        n_anc: Number of ancilla qubits in register \"a\".\n",
    "        labeled_indices: Triples of qubit references of the form\n",
    "            ((reg1, i1), (reg2, i2), (reg3, i3)),\n",
    "            where reg is 0 or 1.\n",
    "\n",
    "    Returns:\n",
    "        A pytket Circuit on n_qubits + n_anc qubits, with the first n_qubits\n",
    "        corresponding to q[0], ..., q[n_qubits-1], and the next n_anc\n",
    "        corresponding to a[0], ..., a[n_anc-1].\n",
    "    \"\"\"\n",
    "    circuit = Circuit(n_qubits + n_anc)\n",
    "\n",
    "    def resolve(ref: tuple[str, int]) -> int:\n",
    "        reg, idx = ref\n",
    "        if reg == 0:\n",
    "            if 0 <= idx < n_qubits:\n",
    "                return idx\n",
    "            raise IndexError(f\"q index out of range: q[{idx}] for n_qubits={n_qubits}\")\n",
    "        if reg == 1:\n",
    "            if 0 <= idx < n_anc:\n",
    "                return n_qubits + idx\n",
    "            raise IndexError(f\"a index out of range: a[{idx}] for n_anc={n_anc}\")\n",
    "        raise ValueError(f\"Unknown register {reg!r}; expected 'q' or 'a'\")\n",
    "\n",
    "    for c1, c2, t in labeled_indices:\n",
    "        circuit.CCX(resolve(c1), resolve(c2), resolve(t))\n",
    "\n",
    "    return circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29585152",
   "metadata": {},
   "source": [
    "## Linear Toffoli ladder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1c28f06a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "<!-- Bypass some Iframe origin concerns for VS Code and import the scripts needed\n",
       "directly so they will be cached for the subsequent IFrame. -->\n",
       "<!-- Download Vue 3-->\n",
       "<script type=\"application/javascript\" src=\"https://unpkg.com/vue@3\"></script>\n",
       "<!-- Download Circuit Renderer with styles -->\n",
       "<script type=\"application/javascript\" src=\"https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.js\"></script>\n",
       "<link rel=\"stylesheet\" href=\"https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.css\">\n",
       "\n",
       "<!-- Fallback to jsdelivr in case UNPKG is down -->\n",
       "<script type=\"application/javascript\">\n",
       "    if (typeof Vue === \"undefined\") {\n",
       "        const loadVue = new Promise(resolve => {\n",
       "            const vueFallback = document.createElement(\"script\")\n",
       "            vueFallback.type = \"application/javascript\"\n",
       "            vueFallback.src = \"https://cdn.jsdelivr.net/npm/vue@3\"\n",
       "            vueFallback.async = false\n",
       "            vueFallback.defer = false\n",
       "            vueFallback.addEventListener('load', () => {\n",
       "              console.log(\"vue loaded\");\n",
       "              resolve(true)\n",
       "            })\n",
       "            document.head.appendChild(vueFallback)\n",
       "        })\n",
       "        const loadRenderer = new Promise(resolve => {\n",
       "            const rendererFallback = document.createElement(\"script\")\n",
       "            rendererFallback.type = \"application/javascript\"\n",
       "            rendererFallback.src = \"https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.min.js\"\n",
       "            rendererFallback.async = false\n",
       "            rendererFallback.defer = false\n",
       "            rendererFallback.addEventListener('load', () => {\n",
       "              console.log(\"renderer loaded\");\n",
       "              resolve(true)\n",
       "            })\n",
       "            document.head.appendChild(rendererFallback)\n",
       "        })\n",
       "        const loadCSS = new Promise(resolve => {\n",
       "            const cssFallback = document.createElement(\"link\")\n",
       "            cssFallback.rel = \"stylesheet\"\n",
       "            cssFallback.href = \"https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.min.css\"\n",
       "            cssFallback.addEventListener('load', () => {\n",
       "              console.log(\"css loaded\");\n",
       "              resolve(true)\n",
       "            })\n",
       "            document.head.appendChild(cssFallback)\n",
       "        })\n",
       "        window['_circuitRendererLoading'] = Promise.all([loadVue, loadRenderer, loadCSS])\n",
       "    } else {\n",
       "        window['_circuitRendererLoading'] = new Promise(resolve => resolve(\"already loaded\"))\n",
       "    }\n",
       "</script>\n",
       "\n",
       "<div style=\"resize: vertical; overflow: auto; height: 400px; display: block\">\n",
       "    <iframe srcdoc=\"\n",
       "&lt;!DOCTYPE html&gt;\n",
       "&lt;html lang=&#34;en&#34;&gt;\n",
       "&lt;head&gt;\n",
       "    &lt;meta charset=&#34;UTF-8&#34;&gt;\n",
       "    &lt;!-- Download Vue 3--&gt;\n",
       "&lt;script type=&#34;application/javascript&#34; src=&#34;https://unpkg.com/vue@3&#34;&gt;&lt;/script&gt;\n",
       "&lt;!-- Download Circuit Renderer with styles --&gt;\n",
       "&lt;script type=&#34;application/javascript&#34; src=&#34;https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.js&#34;&gt;&lt;/script&gt;\n",
       "&lt;link rel=&#34;stylesheet&#34; href=&#34;https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.css&#34;&gt;\n",
       "\n",
       "&lt;!-- Fallback to jsdelivr in case UNPKG is down --&gt;\n",
       "&lt;script type=&#34;application/javascript&#34;&gt;\n",
       "    if (typeof Vue === &#34;undefined&#34;) {\n",
       "        const loadVue = new Promise(resolve =&gt; {\n",
       "            const vueFallback = document.createElement(&#34;script&#34;)\n",
       "            vueFallback.type = &#34;application/javascript&#34;\n",
       "            vueFallback.src = &#34;https://cdn.jsdelivr.net/npm/vue@3&#34;\n",
       "            vueFallback.async = false\n",
       "            vueFallback.defer = false\n",
       "            vueFallback.addEventListener(&#39;load&#39;, () =&gt; {\n",
       "              console.log(&#34;vue loaded&#34;);\n",
       "              resolve(true)\n",
       "            })\n",
       "            document.head.appendChild(vueFallback)\n",
       "        })\n",
       "        const loadRenderer = new Promise(resolve =&gt; {\n",
       "            const rendererFallback = document.createElement(&#34;script&#34;)\n",
       "            rendererFallback.type = &#34;application/javascript&#34;\n",
       "            rendererFallback.src = &#34;https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.min.js&#34;\n",
       "            rendererFallback.async = false\n",
       "            rendererFallback.defer = false\n",
       "            rendererFallback.addEventListener(&#39;load&#39;, () =&gt; {\n",
       "              console.log(&#34;renderer loaded&#34;);\n",
       "              resolve(true)\n",
       "            })\n",
       "            document.head.appendChild(rendererFallback)\n",
       "        })\n",
       "        const loadCSS = new Promise(resolve =&gt; {\n",
       "            const cssFallback = document.createElement(&#34;link&#34;)\n",
       "            cssFallback.rel = &#34;stylesheet&#34;\n",
       "            cssFallback.href = &#34;https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.min.css&#34;\n",
       "            cssFallback.addEventListener(&#39;load&#39;, () =&gt; {\n",
       "              console.log(&#34;css loaded&#34;);\n",
       "              resolve(true)\n",
       "            })\n",
       "            document.head.appendChild(cssFallback)\n",
       "        })\n",
       "        window[&#39;_circuitRendererLoading&#39;] = Promise.all([loadVue, loadRenderer, loadCSS])\n",
       "    } else {\n",
       "        window[&#39;_circuitRendererLoading&#39;] = new Promise(resolve =&gt; resolve(&#34;already loaded&#34;))\n",
       "    }\n",
       "&lt;/script&gt;\n",
       "&lt;/head&gt;\n",
       "&lt;body&gt;\n",
       "\n",
       "\n",
       "    &lt;div id=&#34;circuit-display-vue-container-1e883c1d-e297-4f56-9bbe-3c6cd748e73f&#34; class=&#34;pytket-circuit-display-container&#34;&gt;\n",
       "        &lt;div style=&#34;display: none&#34;&gt;\n",
       "            &lt;div id=&#34;circuit-json-to-display&#34;&gt;{&#34;bits&#34;: [], &#34;commands&#34;: [{&#34;args&#34;: [[&#34;q&#34;, [0]], [&#34;q&#34;, [1]], [&#34;q&#34;, [2]]], &#34;op&#34;: {&#34;type&#34;: &#34;CCX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [2]], [&#34;q&#34;, [3]], [&#34;q&#34;, [4]]], &#34;op&#34;: {&#34;type&#34;: &#34;CCX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [4]], [&#34;q&#34;, [5]], [&#34;q&#34;, [6]]], &#34;op&#34;: {&#34;type&#34;: &#34;CCX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [6]], [&#34;q&#34;, [7]], [&#34;q&#34;, [8]]], &#34;op&#34;: {&#34;type&#34;: &#34;CCX&#34;}}], &#34;created_qubits&#34;: [], &#34;discarded_qubits&#34;: [], &#34;implicit_permutation&#34;: [[[&#34;q&#34;, [0]], [&#34;q&#34;, [0]]], [[&#34;q&#34;, [1]], [&#34;q&#34;, [1]]], [[&#34;q&#34;, [2]], [&#34;q&#34;, [2]]], [[&#34;q&#34;, [3]], [&#34;q&#34;, [3]]], [[&#34;q&#34;, [4]], [&#34;q&#34;, [4]]], [[&#34;q&#34;, [5]], [&#34;q&#34;, [5]]], [[&#34;q&#34;, [6]], [&#34;q&#34;, [6]]], [[&#34;q&#34;, [7]], [&#34;q&#34;, [7]]], [[&#34;q&#34;, [8]], [&#34;q&#34;, [8]]]], &#34;phase&#34;: &#34;0.0&#34;, &#34;qubits&#34;: [[&#34;q&#34;, [0]], [&#34;q&#34;, [1]], [&#34;q&#34;, [2]], [&#34;q&#34;, [3]], [&#34;q&#34;, [4]], [&#34;q&#34;, [5]], [&#34;q&#34;, [6]], [&#34;q&#34;, [7]], [&#34;q&#34;, [8]]]}&lt;/div&gt;\n",
       "        &lt;/div&gt;\n",
       "        &lt;circuit-display-container\n",
       "                :circuit-element-str=&#34;&#39;#circuit-json-to-display&#39;&#34;\n",
       "                :init-render-options=&#34;initRenderOptions&#34;\n",
       "                view-format=&#34;None&#34;\n",
       "        &gt;&lt;/circuit-display-container&gt;\n",
       "    &lt;/div&gt;\n",
       "    &lt;script type=&#34;application/javascript&#34;&gt;\n",
       "      (async function () {\n",
       "        await window[&#39;_circuitRendererLoading&#39;]\n",
       "\n",
       "        const circuitRendererUid = &#34;1e883c1d-e297-4f56-9bbe-3c6cd748e73f&#34;;\n",
       "        const displayOptions = JSON.parse(&#39;{}&#39;);\n",
       "\n",
       "        // Script to initialize the circuit renderer app\n",
       "\n",
       "const { createApp } = Vue;\n",
       "const circuitDisplayContainer = window[&#34;pytket-circuit-renderer&#34;].default;\n",
       "// Init variables to be shared between circuit display instances\n",
       "if (typeof window.pytketCircuitDisplays === &#34;undefined&#34;) {\n",
       "    window.pytketCircuitDisplays = {};\n",
       "}\n",
       "// Create the root Vue component\n",
       "const app = createApp({\n",
       "    delimiters: [&#39;[[#&#39;, &#39;#]]&#39;],\n",
       "    components: { circuitDisplayContainer },\n",
       "    data () {\n",
       "      return {\n",
       "        initRenderOptions: displayOptions,\n",
       "      }\n",
       "    }\n",
       "})\n",
       "app.config.unwrapInjectedRef = true;\n",
       "app.mount(&#34;#circuit-display-vue-container-&#34;+circuitRendererUid);\n",
       "window.pytketCircuitDisplays[circuitRendererUid] = app;\n",
       "      })()\n",
       "    &lt;/script&gt;\n",
       "\n",
       "\n",
       "\n",
       "&lt;/body&gt;\n",
       "&lt;/html&gt;\n",
       "\"\n",
       "            width=\"100%\" height=\"100%\"\n",
       "            style=\"border: none; outline: none; overflow: auto\"></iframe>\n",
       "</div>\n",
       "\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from guppylang import guppy\n",
    "from guppyalgos.utils import qarray\n",
    "from guppyalgos.primitives.subroutines.ladders import ToffoliLadderLinear, ToffoliLadderLog\n",
    "from guppyalgos.primitives.subroutines.ladders.toffoli_ladder import _lin_toffoli_ladder_indices\n",
    "\n",
    "def get_linear_circuit(n_qubits: int) -> Circuit:\n",
    "    indices = _lin_toffoli_ladder_indices(n_qubits)\n",
    "    labeled_indices = [((0, i), (0, j), (0, k)) for i, j, k in indices]\n",
    "    circ = toffoli_ladder_circuit(n_qubits, 0, labeled_indices)\n",
    "    return circ\n",
    "\n",
    "n_qubits = 9\n",
    "\n",
    "circ = get_linear_circuit(n_qubits)\n",
    "draw(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8850ffba",
   "metadata": {},
   "source": [
    "## Log-depth Toffoli ladder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d714b47d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "<!-- Bypass some Iframe origin concerns for VS Code and import the scripts needed\n",
       "directly so they will be cached for the subsequent IFrame. -->\n",
       "<!-- Download Vue 3-->\n",
       "<script type=\"application/javascript\" src=\"https://unpkg.com/vue@3\"></script>\n",
       "<!-- Download Circuit Renderer with styles -->\n",
       "<script type=\"application/javascript\" src=\"https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.js\"></script>\n",
       "<link rel=\"stylesheet\" href=\"https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.css\">\n",
       "\n",
       "<!-- Fallback to jsdelivr in case UNPKG is down -->\n",
       "<script type=\"application/javascript\">\n",
       "    if (typeof Vue === \"undefined\") {\n",
       "        const loadVue = new Promise(resolve => {\n",
       "            const vueFallback = document.createElement(\"script\")\n",
       "            vueFallback.type = \"application/javascript\"\n",
       "            vueFallback.src = \"https://cdn.jsdelivr.net/npm/vue@3\"\n",
       "            vueFallback.async = false\n",
       "            vueFallback.defer = false\n",
       "            vueFallback.addEventListener('load', () => {\n",
       "              console.log(\"vue loaded\");\n",
       "              resolve(true)\n",
       "            })\n",
       "            document.head.appendChild(vueFallback)\n",
       "        })\n",
       "        const loadRenderer = new Promise(resolve => {\n",
       "            const rendererFallback = document.createElement(\"script\")\n",
       "            rendererFallback.type = \"application/javascript\"\n",
       "            rendererFallback.src = \"https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.min.js\"\n",
       "            rendererFallback.async = false\n",
       "            rendererFallback.defer = false\n",
       "            rendererFallback.addEventListener('load', () => {\n",
       "              console.log(\"renderer loaded\");\n",
       "              resolve(true)\n",
       "            })\n",
       "            document.head.appendChild(rendererFallback)\n",
       "        })\n",
       "        const loadCSS = new Promise(resolve => {\n",
       "            const cssFallback = document.createElement(\"link\")\n",
       "            cssFallback.rel = \"stylesheet\"\n",
       "            cssFallback.href = \"https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.min.css\"\n",
       "            cssFallback.addEventListener('load', () => {\n",
       "              console.log(\"css loaded\");\n",
       "              resolve(true)\n",
       "            })\n",
       "            document.head.appendChild(cssFallback)\n",
       "        })\n",
       "        window['_circuitRendererLoading'] = Promise.all([loadVue, loadRenderer, loadCSS])\n",
       "    } else {\n",
       "        window['_circuitRendererLoading'] = new Promise(resolve => resolve(\"already loaded\"))\n",
       "    }\n",
       "</script>\n",
       "\n",
       "<div style=\"resize: vertical; overflow: auto; height: 400px; display: block\">\n",
       "    <iframe srcdoc=\"\n",
       "&lt;!DOCTYPE html&gt;\n",
       "&lt;html lang=&#34;en&#34;&gt;\n",
       "&lt;head&gt;\n",
       "    &lt;meta charset=&#34;UTF-8&#34;&gt;\n",
       "    &lt;!-- Download Vue 3--&gt;\n",
       "&lt;script type=&#34;application/javascript&#34; src=&#34;https://unpkg.com/vue@3&#34;&gt;&lt;/script&gt;\n",
       "&lt;!-- Download Circuit Renderer with styles --&gt;\n",
       "&lt;script type=&#34;application/javascript&#34; src=&#34;https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.js&#34;&gt;&lt;/script&gt;\n",
       "&lt;link rel=&#34;stylesheet&#34; href=&#34;https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.css&#34;&gt;\n",
       "\n",
       "&lt;!-- Fallback to jsdelivr in case UNPKG is down --&gt;\n",
       "&lt;script type=&#34;application/javascript&#34;&gt;\n",
       "    if (typeof Vue === &#34;undefined&#34;) {\n",
       "        const loadVue = new Promise(resolve =&gt; {\n",
       "            const vueFallback = document.createElement(&#34;script&#34;)\n",
       "            vueFallback.type = &#34;application/javascript&#34;\n",
       "            vueFallback.src = &#34;https://cdn.jsdelivr.net/npm/vue@3&#34;\n",
       "            vueFallback.async = false\n",
       "            vueFallback.defer = false\n",
       "            vueFallback.addEventListener(&#39;load&#39;, () =&gt; {\n",
       "              console.log(&#34;vue loaded&#34;);\n",
       "              resolve(true)\n",
       "            })\n",
       "            document.head.appendChild(vueFallback)\n",
       "        })\n",
       "        const loadRenderer = new Promise(resolve =&gt; {\n",
       "            const rendererFallback = document.createElement(&#34;script&#34;)\n",
       "            rendererFallback.type = &#34;application/javascript&#34;\n",
       "            rendererFallback.src = &#34;https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.min.js&#34;\n",
       "            rendererFallback.async = false\n",
       "            rendererFallback.defer = false\n",
       "            rendererFallback.addEventListener(&#39;load&#39;, () =&gt; {\n",
       "              console.log(&#34;renderer loaded&#34;);\n",
       "              resolve(true)\n",
       "            })\n",
       "            document.head.appendChild(rendererFallback)\n",
       "        })\n",
       "        const loadCSS = new Promise(resolve =&gt; {\n",
       "            const cssFallback = document.createElement(&#34;link&#34;)\n",
       "            cssFallback.rel = &#34;stylesheet&#34;\n",
       "            cssFallback.href = &#34;https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.min.css&#34;\n",
       "            cssFallback.addEventListener(&#39;load&#39;, () =&gt; {\n",
       "              console.log(&#34;css loaded&#34;);\n",
       "              resolve(true)\n",
       "            })\n",
       "            document.head.appendChild(cssFallback)\n",
       "        })\n",
       "        window[&#39;_circuitRendererLoading&#39;] = Promise.all([loadVue, loadRenderer, loadCSS])\n",
       "    } else {\n",
       "        window[&#39;_circuitRendererLoading&#39;] = new Promise(resolve =&gt; resolve(&#34;already loaded&#34;))\n",
       "    }\n",
       "&lt;/script&gt;\n",
       "&lt;/head&gt;\n",
       "&lt;body&gt;\n",
       "\n",
       "\n",
       "    &lt;div id=&#34;circuit-display-vue-container-46e0a2b9-f7b0-47bf-ba4a-0a3e8487e7b5&#34; class=&#34;pytket-circuit-display-container&#34;&gt;\n",
       "        &lt;div style=&#34;display: none&#34;&gt;\n",
       "            &lt;div id=&#34;circuit-json-to-display&#34;&gt;{&#34;bits&#34;: [], &#34;commands&#34;: [{&#34;args&#34;: [[&#34;q&#34;, [0]], [&#34;q&#34;, [1]], [&#34;q&#34;, [2]]], &#34;op&#34;: {&#34;type&#34;: &#34;CCX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [3]], [&#34;q&#34;, [5]], [&#34;q&#34;, [11]]], &#34;op&#34;: {&#34;type&#34;: &#34;CCX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [7]], [&#34;q&#34;, [9]], [&#34;q&#34;, [12]]], &#34;op&#34;: {&#34;type&#34;: &#34;CCX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [4]], [&#34;q&#34;, [5]], [&#34;q&#34;, [6]]], &#34;op&#34;: {&#34;type&#34;: &#34;CCX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [8]], [&#34;q&#34;, [9]], [&#34;q&#34;, [10]]], &#34;op&#34;: {&#34;type&#34;: &#34;CCX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [2]], [&#34;q&#34;, [11]], [&#34;q&#34;, [6]]], &#34;op&#34;: {&#34;type&#34;: &#34;CCX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [2]], [&#34;q&#34;, [3]], [&#34;q&#34;, [4]]], &#34;op&#34;: {&#34;type&#34;: &#34;CCX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [6]], [&#34;q&#34;, [12]], [&#34;q&#34;, [10]]], &#34;op&#34;: {&#34;type&#34;: &#34;CCX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [3]], [&#34;q&#34;, [5]], [&#34;q&#34;, [11]]], &#34;op&#34;: {&#34;type&#34;: &#34;CCX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [6]], [&#34;q&#34;, [7]], [&#34;q&#34;, [8]]], &#34;op&#34;: {&#34;type&#34;: &#34;CCX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [7]], [&#34;q&#34;, [9]], [&#34;q&#34;, [12]]], &#34;op&#34;: {&#34;type&#34;: &#34;CCX&#34;}}], &#34;created_qubits&#34;: [], &#34;discarded_qubits&#34;: [], &#34;implicit_permutation&#34;: [[[&#34;q&#34;, [0]], [&#34;q&#34;, [0]]], [[&#34;q&#34;, [1]], [&#34;q&#34;, [1]]], [[&#34;q&#34;, [2]], [&#34;q&#34;, [2]]], [[&#34;q&#34;, [3]], [&#34;q&#34;, [3]]], [[&#34;q&#34;, [4]], [&#34;q&#34;, [4]]], [[&#34;q&#34;, [5]], [&#34;q&#34;, [5]]], [[&#34;q&#34;, [6]], [&#34;q&#34;, [6]]], [[&#34;q&#34;, [7]], [&#34;q&#34;, [7]]], [[&#34;q&#34;, [8]], [&#34;q&#34;, [8]]], [[&#34;q&#34;, [9]], [&#34;q&#34;, [9]]], [[&#34;q&#34;, [10]], [&#34;q&#34;, [10]]], [[&#34;q&#34;, [11]], [&#34;q&#34;, [11]]], [[&#34;q&#34;, [12]], [&#34;q&#34;, [12]]]], &#34;phase&#34;: &#34;0.0&#34;, &#34;qubits&#34;: [[&#34;q&#34;, [0]], [&#34;q&#34;, [1]], [&#34;q&#34;, [2]], [&#34;q&#34;, [3]], [&#34;q&#34;, [4]], [&#34;q&#34;, [5]], [&#34;q&#34;, [6]], [&#34;q&#34;, [7]], [&#34;q&#34;, [8]], [&#34;q&#34;, [9]], [&#34;q&#34;, [10]], [&#34;q&#34;, [11]], [&#34;q&#34;, [12]]]}&lt;/div&gt;\n",
       "        &lt;/div&gt;\n",
       "        &lt;circuit-display-container\n",
       "                :circuit-element-str=&#34;&#39;#circuit-json-to-display&#39;&#34;\n",
       "                :init-render-options=&#34;initRenderOptions&#34;\n",
       "                view-format=&#34;None&#34;\n",
       "        &gt;&lt;/circuit-display-container&gt;\n",
       "    &lt;/div&gt;\n",
       "    &lt;script type=&#34;application/javascript&#34;&gt;\n",
       "      (async function () {\n",
       "        await window[&#39;_circuitRendererLoading&#39;]\n",
       "\n",
       "        const circuitRendererUid = &#34;46e0a2b9-f7b0-47bf-ba4a-0a3e8487e7b5&#34;;\n",
       "        const displayOptions = JSON.parse(&#39;{}&#39;);\n",
       "\n",
       "        // Script to initialize the circuit renderer app\n",
       "\n",
       "const { createApp } = Vue;\n",
       "const circuitDisplayContainer = window[&#34;pytket-circuit-renderer&#34;].default;\n",
       "// Init variables to be shared between circuit display instances\n",
       "if (typeof window.pytketCircuitDisplays === &#34;undefined&#34;) {\n",
       "    window.pytketCircuitDisplays = {};\n",
       "}\n",
       "// Create the root Vue component\n",
       "const app = createApp({\n",
       "    delimiters: [&#39;[[#&#39;, &#39;#]]&#39;],\n",
       "    components: { circuitDisplayContainer },\n",
       "    data () {\n",
       "      return {\n",
       "        initRenderOptions: displayOptions,\n",
       "      }\n",
       "    }\n",
       "})\n",
       "app.config.unwrapInjectedRef = true;\n",
       "app.mount(&#34;#circuit-display-vue-container-&#34;+circuitRendererUid);\n",
       "window.pytketCircuitDisplays[circuitRendererUid] = app;\n",
       "      })()\n",
       "    &lt;/script&gt;\n",
       "\n",
       "\n",
       "\n",
       "&lt;/body&gt;\n",
       "&lt;/html&gt;\n",
       "\"\n",
       "            width=\"100%\" height=\"100%\"\n",
       "            style=\"border: none; outline: none; overflow: auto\"></iframe>\n",
       "</div>\n",
       "\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from guppyalgos.primitives.subroutines.ladders.toffoli_ladder import _log_toffoli_ladder_labeled_indices, log_toffoli_ladder_num_ancilla\n",
    "\n",
    "def get_log_circuit(n_qubits: int) -> Circuit:\n",
    "    labeled_indices = _log_toffoli_ladder_labeled_indices(n_qubits)\n",
    "    n_anc = log_toffoli_ladder_num_ancilla(n_qubits)\n",
    "    circ = toffoli_ladder_circuit(n_qubits, n_anc, labeled_indices)\n",
    "    return circ\n",
    "\n",
    "n_qubits = 11\n",
    "\n",
    "circ = get_log_circuit(n_qubits)\n",
    "draw(circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3275bf39",
   "metadata": {},
   "source": [
    "## Comparing resources"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3e8c7b45",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from pytket import Circuit, OpType\n",
    "\n",
    "def count_toffolis(circ: Circuit) -> int:\n",
    "    return circ.n_gates_of_type(OpType.CCX)\n",
    "\n",
    "def toffoli_depth(circ: Circuit) -> int:\n",
    "    return circ.depth_by_type(OpType.CCX)\n",
    "\n",
    "def sweep_metrics(\n",
    "    circ_func,\n",
    "    n_values: list[int],\n",
    ") -> tuple[np.ndarray, np.ndarray, np.ndarray]:\n",
    "    n_arr = np.array(list(n_values), dtype=float)\n",
    "    counts = []\n",
    "    depths = []\n",
    "\n",
    "    for n in n_arr.astype(int):\n",
    "        circ = circ_func(n)\n",
    "        counts.append(count_toffolis(circ))\n",
    "        depths.append(toffoli_depth(circ))\n",
    "\n",
    "    return n_arr, np.array(counts, dtype=float), np.array(depths, dtype=float)\n",
    "\n",
    "\n",
    "def linear_fit(x: np.ndarray, y: np.ndarray) -> tuple[np.ndarray, np.ndarray]:\n",
    "    \"\"\"Fit y = a x + b.\"\"\"\n",
    "    a, b = np.polyfit(x, y, 1)\n",
    "    that = a * x + b\n",
    "    return np.array([a, b]), that\n",
    "\n",
    "\n",
    "def log_fit(x: np.ndarray, y: np.ndarray) -> tuple[np.ndarray, np.ndarray]:\n",
    "    \"\"\"Fit y = a log2(x) + b.\"\"\"\n",
    "    lx = np.log2(x)\n",
    "    a, b = np.polyfit(lx, y, 1)\n",
    "    that = a * lx + b\n",
    "    return np.array([a, b]), that"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "66d67047",
   "metadata": {},
   "outputs": [],
   "source": [
    "impl_name = \"ASCENDING_TARGET_BOTTOM\"\n",
    "n_values = range(3, 32, 2)\n",
    "\n",
    "n_lin, count_lin, depth_lin = sweep_metrics(get_linear_circuit, n_values)\n",
    "n_log, count_log, depth_log = sweep_metrics(get_log_circuit, n_values)\n",
    "\n",
    "lin_count_params, lin_count_fit = linear_fit(n_lin, count_lin)\n",
    "lin_depth_params, lin_depth_fit = linear_fit(n_lin, depth_lin)\n",
    "\n",
    "log_count_params, log_count_fit = linear_fit(n_log, count_log)\n",
    "log_depth_params, log_depth_fit = log_fit(n_log, depth_log)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "cb1ccfcd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 5))\n",
    "\n",
    "plt.plot(n_lin, count_lin, color=\"g\", marker=\"o\", linestyle=\"None\", label=\"Linear Toffoli count\")\n",
    "plt.plot(n_lin, lin_count_fit, color=\"g\", linestyle=\"-\", label=f\"Linear fit: c = {lin_count_params[0]:.4f}n + {lin_count_params[1]:.4f}\")\n",
    "\n",
    "plt.plot(n_log, count_log, color=\"b\", marker=\"o\", linestyle=\"None\", label=\"Log Toffoli count\")\n",
    "plt.plot(n_log, log_count_fit, color=\"b\", linestyle=\"-\", label=f\"Log fit: c = {log_count_params[0]:.4f}n + {log_count_params[1]:.4f}\")\n",
    "\n",
    "plt.xlabel(\"n_qubits\")\n",
    "plt.ylabel(\"Toffoli count\")\n",
    "plt.title(f\"Toffoli count vs n_qubits ({impl_name})\")\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "\n",
    "ax = plt.gca()\n",
    "odd_ticks = [int(n) for n in n_lin if int(n) % 2 == 1]\n",
    "ax.set_xticks(odd_ticks)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "46dddd00",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 5))\n",
    "\n",
    "plt.plot(n_lin, depth_lin, color=\"g\", marker=\"o\", linestyle=\"None\", label=\"Linear Toffoli depth\")\n",
    "plt.plot(n_lin, lin_depth_fit, color=\"g\", linestyle=\"-\", label=f\"Linear fit: d = {lin_depth_params[0]:.4f}n + {lin_depth_params[1]:.4f}\")\n",
    "\n",
    "plt.plot(n_log, depth_log, color=\"b\", marker=\"o\", linestyle=\"None\", label=\"Log Toffoli depth\")\n",
    "plt.plot(n_log, log_depth_fit, color=\"b\", linestyle=\"-\", label=f\"Log fit: d = {log_depth_params[0]:.4f}log₂(n) + {log_depth_params[1]:.4f}\")\n",
    "\n",
    "plt.xlabel(\"n_qubits\")\n",
    "plt.ylabel(\"Toffoli depth\")\n",
    "plt.title(f\"Toffoli depth vs n_qubits ({impl_name})\")\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "\n",
    "ax = plt.gca()\n",
    "odd_ticks = [int(n) for n in n_lin if int(n) % 2 == 1]\n",
    "ax.set_xticks(odd_ticks)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2f710fe5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from guppyalgos.primitives.subroutines.ladders.toffoli_ladder import log_toffoli_ladder_num_ancilla\n",
    "\n",
    "# Sweep n_qubits\n",
    "n_values = np.arange(3, 41)\n",
    "\n",
    "anc_lin = np.array([0 for n in n_values])\n",
    "anc_log = np.array([log_toffoli_ladder_num_ancilla(int(n)) for n in n_values])\n",
    "\n",
    "plt.figure(figsize=(8, 5))\n",
    "\n",
    "plt.plot(n_values, anc_lin, marker=\"o\", linestyle=\"None\", label=\"Linear Toffoli ancilla (0)\")\n",
    "plt.plot(n_values, anc_log, marker=\"o\", linestyle=\"None\", label=\"Log Toffoli ancilla\")\n",
    "\n",
    "# Force odd integer ticks\n",
    "odd_ticks = [int(n) for n in n_values if int(n) % 2 == 1]\n",
    "plt.xticks(odd_ticks)\n",
    "\n",
    "plt.xlabel(\"n_qubits\")\n",
    "plt.ylabel(\"Number of ancilla qubits\")\n",
    "plt.title(\"Ancilla count vs n qubits\")\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c44e692d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv (3.13.12)",
   "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.13.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}