{ "cells": [ { "cell_type": "markdown", "id": "4b1ce9ef-6970-49bf-bae4-332d3eef0423", "metadata": {}, "source": [ "# Repeat Until Success\n", "\n", "**Download this notebook - {nb-download}`repeat-until-success.ipynb`**\n", "\n", "This notebook implements the single-qubit unitary $V_3 = R_z(-2\\arctan(2)) = (I + 2iZ)/\\sqrt{5}$ using a repeat-until-success (RUS) scheme from [arXiv:1311.1074](https://arxiv.org/abs/1311.1074). More specifically, we will implement in Guppy the scheme with a particularly low expected $T$ count, in this case the circuit from *Fig. 1c*:\n", "\n", "![](./img/rus_circuit.png){w=240px align=center}\n", "\n", "The aim is to showcase how such a scheme translates into Guppy using [control flow](https://docs.quantinuum.com/guppy/language_guide/control_flow.html), and how we can experimentally validate the success rate of $5/8$ provided in the paper." ] }, { "cell_type": "markdown", "id": "ea33f985558f7e9e", "metadata": {}, "source": [ "## Implementation\n", "\n", "The repeat-until-success scheme in use specifies that we must run the circuit from [arXiv:1311.1074](https://arxiv.org/abs/1311.1074) *Fig. 1c* until both $X$-basis measurements return the $0$ outcome. In Guppy, we can implement this with an endless loop that resumes iteration on failure, and otherwise assumes success and breaks.\n", "\n", "Note: Contrary to details in the paper, we must apply a correction to the data qubit in case the second measurement does not yield $0$. If you comment out the correction, the function does not implement the unitary anymore and you will receive a discrepancy in the validation section later on." ] }, { "cell_type": "code", "execution_count": 1, "id": "1be5c488-36df-4a8b-b0af-0a330a8293fd", "metadata": {}, "outputs": [], "source": [ "import math\n", "\n", "from guppylang import guppy\n", "from guppylang.std.builtins import result\n", "from guppylang.std.quantum import measure, qubit, discard, h, tdg, cx, t, z\n", "\n", "@guppy\n", "def repeat_until_success(q: qubit) -> None:\n", " attempts = 0\n", " while True:\n", " attempts += 1\n", "\n", " # Prepare ancilla qubits\n", " a, b = qubit(), qubit()\n", " h(a)\n", " h(b)\n", "\n", " tdg(a)\n", " cx(b, a)\n", " t(a)\n", " h(a)\n", " if measure(a):\n", " # First ancilla failed, consume all ancillas, try again\n", " discard(b)\n", " continue\n", "\n", " t(q)\n", " z(q)\n", " cx(q, b)\n", " t(b)\n", " h(b)\n", " if measure(b):\n", " # Second ancilla failed, apply correction and try again\n", " z(q)\n", " continue\n", "\n", " result(\"attempts\", attempts)\n", " break\n", "repeat_until_success.check()" ] }, { "cell_type": "markdown", "id": "6c342c1d", "metadata": {}, "source": [ "## Usage and Results\n", "\n", "We can now use the unitary that is implemented by the RUS scheme in another Guppy function. For now, we are not concerned with the actual outcome just yet (in fact we will do a more rigorous analysis later), so we discard the qubit immediately after the transformation." ] }, { "cell_type": "code", "execution_count": 2, "id": "fbd490b3-8cc4-43c2-87f8-e799d00fa2c2", "metadata": { "jupyter": { "is_executing": true } }, "outputs": [], "source": [ "@guppy\n", "def main() -> None:\n", " q = qubit()\n", " repeat_until_success(q)\n", " discard(q)" ] }, { "cell_type": "markdown", "id": "7efe3a81", "metadata": {}, "source": [ "\n", "To test the finished Guppy program, we create an emulator with the maximum number of qubits allocated and simulate a few shots. We bin the number of shots according to the number of attempts they required to implement the unitary, and see that the majority of shots realizes the unitary on the first try. To increase the probability of this happening one may employ strategies further described in [arXiv:1311.1074](https://arxiv.org/abs/1311.1074), but this is beyond the scope of this example." ] }, { "cell_type": "code", "execution_count": 3, "id": "413d4d4c", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import matplotlib.ticker as ticker\n", "import numpy as np\n", "\n", "shots = main.emulator(n_qubits=3).with_seed(0).with_shots(50000).run()\n", "attempts = [int(shot.as_dict()[\"attempts\"]) for shot in shots]\n", "avg_attempts = sum(attempts) / len(shots)\n", "\n", "fig, ax = plt.subplots(1, 1)\n", "ax.hist(attempts, bins=np.array(range(1, 10)) - 0.5)\n", "ax.set_title(f\"Attempts per shot [avg={avg_attempts}]\")\n", "ax.set_xlabel(\"Attempts\")\n", "ax.set_ylabel(\"Frequency\")\n", "ax.xaxis.set_major_locator(ticker.MultipleLocator(1.0))\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "dad2717c", "metadata": {}, "source": [ "Finally, inverting the average number of shots required yields the experimental success rate for the implemented scheme. Following the Law of Large Numbers, increasing the number of shots yields a better approximation to the true success rate, which we can compare to the analytic success rate of $5/8$ provided in [arXiv:1311.1074](https://arxiv.org/abs/1311.1074)." ] }, { "cell_type": "code", "execution_count": 4, "id": "b85a8619", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Analytic rate: 0.625\n", "------------------- Shots: 100 -------------------\n", "Average attempts: 1.49\n", "Predicted rate: 0.6711409395973155\n", "------------------ Shots: 1000 -------------------\n", "Average attempts: 1.545\n", "Predicted rate: 0.6472491909385113\n", "------------------ Shots: 10000 ------------------\n", "Average attempts: 1.5842\n", "Predicted rate: 0.6312334301224592\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "------------------- Shots: 100 -------------------\n", "Average attempts: 1.49\n", "Predicted rate: 0.6711409395973155\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "------------------ Shots: 1000 -------------------\n", "Average attempts: 1.545\n", "Predicted rate: 0.6472491909385113\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "------------------ Shots: 10000 ------------------\n", "Average attempts: 1.5842\n", "Predicted rate: 0.6312334301224592\n" ] } ], "source": [ "def exp_with_shots(n_shots: int) -> None:\n", " shots = main.emulator(n_qubits=3).with_seed(0).with_shots(n_shots).run()\n", " attempts = [int(shot.as_dict()[\"attempts\"]) for shot in shots]\n", " total_attempts = sum(attempts)\n", " print(f\" Shots: {n_shots} \".center(50, \"-\"))\n", " print(f\"Average attempts: {total_attempts / len(shots)}\")\n", " print(f\"Predicted rate: {len(shots) / total_attempts}\")\n", "\n", "print(f\"Analytic rate: {5/8}\")\n", "exp_with_shots(100)\n", "exp_with_shots(1000)\n", "exp_with_shots(10000)" ] }, { "cell_type": "markdown", "id": "615ce353db88b3c9", "metadata": {}, "source": [ "## Validation\n", "\n", "To ensure we have implemented the given Unitary correctly, we must compare it to a reference implementation. Guppy itself does not allow loading arbitrary unitary matrices, but we can utilize [`pytket`](https://docs.quantinuum.com/tket/api-docs/) to achieve this goal for the single-qubit case.\n", "\n", "First, we express the unitary as a single matrix:\n", "\n", "\\begin{equation*}\n", "V_3 = (I + 2iZ)/\\sqrt{5} = \\left(\\begin{pmatrix}1&0\\\\0&1\\end{pmatrix} + \\begin{pmatrix}2i&0\\\\0&-2i\\end{pmatrix}\\right)/\\sqrt{5} = \\begin{pmatrix}\\frac{1+2i}{\\sqrt{5}}&0\\\\0&\\frac{1-2i}{\\sqrt{5}}\\end{pmatrix}\n", "\\end{equation*}\n", "\n", "We then load the matrix into `pytket` as an opaque block, add it to a circuit and let the library synthesise full circuit by telling it to decompose the block. You can find out more about how circuit generation works in `pytket` [here](https://docs.quantinuum.com/tket/user-guide/examples/circuit_construction/circuit_generation_example.html), and about how Guppy and `pytket` interact [here](https://docs.quantinuum.com/guppy/migration_guide.html)." ] }, { "cell_type": "code", "execution_count": 5, "id": "c3d1904531a06faa", "metadata": {}, "outputs": [], "source": [ "from pytket.circuit import Unitary1qBox, OpType, Circuit\n", "from pytket.passes import DecomposeBoxes, AutoRebase\n", "\n", "unitary = np.array([[(1 + 2j) / math.sqrt(5), 0], [0, (1 - 2j) / math.sqrt(5)]])\n", "circ = Circuit(1).add_gate(Unitary1qBox(unitary), [0])\n", "DecomposeBoxes().apply(circ)\n", "\n", "# Make sure Guppy can understand the gate set\n", "rebase = AutoRebase({OpType.CX, OpType.Rz, OpType.H, OpType.CCX})\n", "rebase.apply(circ)\n", "\n", "unitary_func = guppy.load_pytket(\"unitary1q\", circ, use_arrays=False)" ] }, { "cell_type": "markdown", "id": "babc71bcacd7285c", "metadata": {}, "source": [ "Finally, we sample shots from both the reference unitary and the RUS implementation we created on different input states of the $X$ basis and compare. For this, we create a helper function that constructs the emulators for some configurations of initialization gates, and a second helper function that runs the experiment with a given configuration and displays a side-by-side plot comparison of the results." ] }, { "cell_type": "code", "execution_count": 6, "id": "800e0c25b961bc49", "metadata": { "jupyter": { "is_executing": true } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAHHCAYAAABeLEexAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAASOBJREFUeJzt3XlcVdX+//H3AWUQBZwASRRSU3Go1EKy7Jp8RcW+mXgd0pxIs4uZ2mB+bzk1WHbNtEm7mdhgqZVWeh3IIcvIqRwyJSsNjclSOA4BCuv3Rz/29YiVEnDQ/Xo+Hvvx8Ky1ztqfvc8B3u6z9z4OY4wRAACAjXm4uwAAAAB3IxABAADbIxABAADbIxABAADbIxABAADbIxABAADbIxABAADbIxABAADbIxABAADbIxAB+EOrVq3SNddcIx8fHzkcDuXk5Li7JFzChgwZIofDIYfDoZYtW7q7nAq3Y8cOa/sdDofeffddd5eE/49AhEppz549GjhwoK644gp5e3srNDRUAwYM0J49e/7SvE8++aSWLVtWNkXawC+//KI+ffrI19dXL774ot544w35+fmdd+zAgQPl4+Ojb7/9tkTfU089JYfDoeXLl5d3yahg6enpmjx5snbs2HHBz6lTp47eeOMNPfXUU1bb5MmTXYLC7y0X4+DBgxc0p8Ph0MGDBy9q7tJq2LCh3njjDf3f//1fhawPF87Bd5mhsnn//ffVv39/1apVSwkJCYqIiNDBgwc1b948/fLLL3rnnXd0++23l2ru6tWrq3fv3kpKSirboi9Tq1atUrdu3ZScnKyYmJg/HJudna1mzZrpmmuu0bp166z2AwcOqEWLFurevTv/G74Mbdu2Tdddd53mz5+vIUOG/On4IUOGaMOGDSUCyK5du7Rr167zPmfXrl165plnFBUVpS+++OKCazt58qSWLl3q0jZjxgwdPnxYM2fOdGm//fbbfzfsl4cNGzaoU6dOWrJkiXr37l1h68Xvq+LuAoCzff/997rzzjt15ZVXauPGjapbt67Vd9999+mmm27SnXfeqV27dunKK690Y6X2kJ2dLUkKDAz807FBQUF6+umnNWLECC1YsECDBw+WJP3jH/9Q1apVNWvWrPIs9ZJUVFSkgoIC+fj4uLsUt2vdurVat25dov3kyZN6/PHHFRAQoLfffvui5vTz89PAgQNd2t555x0dO3asRPvZjDHKy8uTr6/vRa0PlzgDVCJ33323kWQ2btx43v5PPvnESDJ333231TZ48GDTsGHDEmMnTZpkzn6LSyqxDB482Oo/fPiwGTZsmKlXr57x8vIy4eHhZuTIkSY/P98a8/3335vevXubmjVrGl9fXxMVFWWWL1/ust7169cbSWbRokVm8uTJJjQ01FSvXt3Ex8ebnJwck5eXZ+677z5Tt25d4+fnZ4YMGWLy8vJK1P/GG2+YNm3aGB8fH1OzZk3Tt29fk5aW5jLm22+/Nb169TLBwcHG29vbXHHFFaZv374mJyfnD/ezMcYsXrzYmr927dpmwIAB5vDhw1b/zTff/If763yKiopMhw4dTJ06dczPP/9s3n77bSPJzJ49+0/rMcaYhg0bmri4OLN+/XrTtm1b4+PjY1q2bGnWr19vjDHmvffeMy1btjTe3t6mTZs25ssvvywxx969e018fLypWbOm8fb2Nm3btjUffPCBy5hffvnF3H///aZly5bGz8/P1KhRw3Tt2tXs2LGjxHyzZ882kZGRxtfX1wQGBpq2bduat956y+q/0PefMb+9BxMTE82bb75pIiMjTZUqVczSpUuNMb+9/4YOHWqCgoKMl5eXiYyMNPPmzXN5fkW+t26++WbTokULs2fPHvO3v/3N+Pr6mtDQUPP000+XqOfcZf78+SXW+Wf76/cMGjTI2uazFRQUmL1795r09PQLnssYY+Li4kqsv/h9t2rVKtO2bVvj7e1tZs6caQ4cOPC72yPJTJo0yaXtQl7DYsX7bsmSJRdVP8oPR4hQqXz00UcKDw/XTTfddN7+jh07Kjw8XCtWrLjoud944w3ddddduv766zVixAhJUqNGjST9dh7E9ddfr5ycHI0YMULNmjXTTz/9pHfffVenTp2Sl5eXsrKydMMNN+jUqVMaPXq0ateurQULFuh///d/9e6775b4GG/atGny9fXVww8/rO+++07PP/+8qlatKg8PDx07dkyTJ0/WF198oaSkJEVERGjixInWc5944gk9+uij6tOnj+666y4dOXJEzz//vDp27KivvvpKgYGBKigoUGxsrPLz83XvvfcqJCREP/30k5YvX66cnBwFBAT87r5ISkrS0KFDdd1112natGnKysrSrFmztGnTJmv+f/7zn2ratKleeeUVTZ06VREREdb++j0Oh0Nz587Vtddeq3vuuUeffvqp2rVrp8TExAt+nb777jvdcccduvvuuzVw4ED961//0q233qo5c+bo//7v//SPf/zD2r99+vRRamqqPDx+Ox1yz5496tChg6644go9/PDD8vPz0+LFi9WzZ0+999571mv0ww8/aNmyZfr73/+uiIgIZWVlae7cubr55pv1zTffKDQ0VJL073//W6NHj1bv3r113333KS8vT7t27dLmzZt1xx13XPA2nW3dunVavHixRo0apTp16ig8PFxZWVlq3769HA6HRo0apbp162rlypVKSEiQ0+nUmDFjXOYo7/dWsWPHjqlr167q1auX+vTpo3fffVfjx49Xq1at1K1bNzVv3lxTp07VxIkTNWLECOvn9oYbbijVvjnXggUL9Prrr2v48OHq06ePS99PP/2k5s2ba/DgwWXyEXhqaqr69++vu+++W8OHD1fTpk0v6vkX+xqiEnJ3IgOK5eTkGEnmtttu+8Nx//u//2skGafTaYy5uP+h+/n5nfcox6BBg4yHh4fZunVrib6ioiJjjDFjxowxksynn35q9R0/ftxERESY8PBwU1hYaIz57//8WrZsaQoKCqyx/fv3Nw6Hw3Tr1s1l/ujoaJf6Dx48aDw9Pc0TTzzhMm737t2mSpUqVvtXX31Vqv9hFhQUmKCgINOyZUvz66+/Wu3Lly83kszEiROttvnz5xtJ590vf2TChAlGkvH09DTbt2+/4Oc1bNjQSDKff/651bZ69Wojyfj6+poff/zRap87d66RZB09MsaYzp07m1atWrkcFSkqKjI33HCDadKkidWWl5dnvV7FDhw4YLy9vc3UqVOttttuu820aNHiD2u+2CNEHh4eZs+ePS7tCQkJpl69eubnn392ae/Xr58JCAgwp06dMsZU3HvLmP8eIXz99dettvz8fBMSEmLi4+Ottq1bt/7pUaGzXegRor179xo/Pz/TokULa/vPVnz05s+OWp7r944QSTKrVq067zou5AjRhb6GxThCVPlwlRkqjePHj0uSatSo8YfjivudTmeZrLeoqEjLli3Trbfeqnbt2pXoL76y5T//+Y+uv/563XjjjVZf9erVNWLECB08eFDffPONy/MGDRqkqlWrWo+joqJkjNGwYcNcxkVFRenQoUM6c+aMpN9OKi8qKlKfPn30888/W0tISIiaNGmi9evXS5J1BGj16tU6derUBW/vtm3blJ2drX/84x8u567ExcWpWbNmpTr6dq46depIkkJDQy/60urIyEhFR0dbj6OioiRJt9xyixo0aFCi/YcffpAkHT16VOvWrVOfPn10/Phxa7/98ssvio2N1f79+/XTTz9Jkry9va2jSoWFhfrll19UvXp1NW3aVF9++aW1jsDAQB0+fFhbt2692F3wu26++WZFRkZaj40xeu+993TrrbfKGOPymsfGxio3N9elJqn831vFqlev7nKujZeXl66//nprn5eXvLw89e3bV0VFRVq0aNF5z+UJDw+XMabMLpCIiIhQbGxsqZ5bmtcQlQ+BCJVGcdApDka/50KD04U6cuSInE7nn/7h/vHHH897GL158+ZW/9nO/uMt/TfAhIWFlWgvKipSbm6uJGn//v0yxqhJkyaqW7euy7J3717rROeIiAiNGzdOr776qurUqaPY2Fi9+OKL1jx/tB2SzrstzZo1K7EdF+vQoUOaNGmSWrZsqUOHDmn69OkX9fyL2W/Sbx/rSL991GaM0aOPPlpiv02aNEnSf08SLyoq0syZM9WkSRN5e3urTp06qlu3rnbt2uWy/8aPH6/q1avr+uuvV5MmTZSYmKhNmzZd1PacKyIiwuXxkSNHlJOTo1deeaVE3UOHDnWpuzT7qDTvrWL169cvcal7zZo1rX1eXsaMGaNdu3bpueeeU4sWLcp1XcXOfV0uRmleQ1Q+nEOESiMgIED16tX73Utvi+3atUtXXHGF/P39Jel3701SWFhY5jVeDE9Pz4tqN///DhhFRUVyOBxauXLlecdWr17d+veMGTM0ZMgQffDBB1qzZo1Gjx6tadOm6YsvvlD9+vXLYCsu3qhRoyRJK1eu1Lhx4/TEE0/ojjvuuOCrAv/KfpOkBx544Hf/p9+4cWNJv92P6tFHH9WwYcP02GOPqVatWvLw8NCYMWOseaTfwm5qaqqWL1+uVatW6b333tNLL72kiRMnasqUKZIu/v137tGO4vUNHDjQujLvXOdefVUR760Lma88LFmyRHPnzlWfPn2sc/0qwvmOQl3oa1ua1xCVD4EIlUqPHj3073//W5999pnLR1PFPv30Ux08eFB333231VazZs3z3j35fEc6zvcLrm7duvL399fXX3/9h7U1bNhQqampJdr37dtn9ZeFRo0ayRijiIgIXXXVVX86vlWrVmrVqpUeeeQRff755+rQoYPmzJmjxx9//Lzji+tMTU3VLbfc4tKXmpr6l7Zj6dKl+vDDDzVz5kzVr19fzz33nFavXq3ExEStXLmy1PNeiOLAVbVq1T+9Z9K7776rTp06ad68eS7tOTk51sd9xfz8/NS3b1/17dtXBQUF6tWrl5544glNmDBBPj4+F/X+O5+6deuqRo0aKiws/NO6/6qLfW9diIu9WeIf+eGHHzR8+HBFRETolVdeKbN5S6tmzZqSVOL1Pfe1rcjXEOWHj8xQqTz44IPy9fXV3XffrV9++cWl7+jRoxo5cqSqVaumBx980Gpv1KiRcnNzXY4sZWRklLghm/TbH7dzf7l5eHioZ8+e+uijj7Rt27YSzyn+33D37t21ZcsWpaSkWH0nT57UK6+8ovDwcJfzQv6KXr16ydPTU1OmTCnxP3FjjLVfnE6ndW5IsVatWsnDw0P5+fm/O3+7du0UFBSkOXPmuIxbuXKl9u7dq7i4uFLVffz4cY0ePVrXXnut7r33Xkm/nUP02GOPadWqVVqyZEmp5r1QQUFB+tvf/qa5c+cqIyOjRP+RI0esf3t6epbYt0uWLLHOMSp27nvQy8tLkZGRMsbo9OnTki7u/Xc+np6eio+P13vvvXfeUH523X/Vhb63LkbxzQz/6le6nD59Wv369dOpU6f09ttv/+FVksXj9+3bd97Xuqz4+/urTp062rhxo0v7Sy+95PK4Il9DlB+OEKFSadKkiRYsWKABAwaoVatWJe5U/fPPP+vtt992ufy7X79+Gj9+vG6//XaNHj1ap06d0ssvv6yrrrqqxImMbdu21ccff6xnn31WoaGhioiIUFRUlJ588kmtWbNGN998s0aMGKHmzZsrIyNDS5Ys0WeffabAwEA9/PDDevvtt9WtWzeNHj1atWrV0oIFC3TgwAG999571km6f1WjRo30+OOPa8KECTp48KB69uypGjVq6MCBA1q6dKlGjBihBx54QOvWrdOoUaP097//XVdddZXOnDmjN954w/rl/HuqVq2qp59+WkOHDtXNN9+s/v37W5fdh4eHa+zYsaWq+5FHHlF6erref/99l49aEhMTtWDBAo0ZM0Zdu3Yts3O/zufFF1/UjTfeqFatWmn48OG68sorlZWVpZSUFB0+fFg7d+6U9NuRyKlTp2ro0KG64YYbtHv3br311lslPtbr0qWLQkJC1KFDBwUHB2vv3r164YUXFBcXZ23Hxbz/fs9TTz2l9evXKyoqSsOHD1dkZKSOHj2qL7/8Uh9//LGOHj1aJvvnQt9bFztnYGCg5syZoxo1asjPz09RUVEXfU7Oo48+qq1bt+qWW27R/v37tX///vOOK76jdFlfdv977rrrLj311FO666671K5dO23cuPF3v56mIl5DlKMKvKINuGC7du0y/fv3N/Xq1TNVq1Y1ISEhpn///mb37t3nHb9mzRrTsmVL4+XlZZo2bWrefPPN8172vG/fPtOxY0fj6+tb4pLdH3/80QwaNMjUrVvXeHt7myuvvNIkJiae98aMgYGBxsfHx1x//fW/e2PGcy+n/b1L2IvrPHLkiEv7e++9Z2688Ubj5+dn/Pz8TLNmzUxiYqJJTU01xhjzww8/mGHDhplGjRoZHx8fU6tWLdOpUyfz8ccfX9A+XrRokbn22muNt7e3qVWrVokbM/5Rzefatm2b8fT0NKNGjTpv/5YtW4yHh4cZPXr0H85TfIO8c+n/39DwbMWXRD/zzDMu7d9//70ZNGiQCQkJMVWrVjVXXHGF6dGjh3n33XetMXl5eeb+++839erVM76+vqZDhw4mJSXF3Hzzzebmm2+2xs2dO9d07NjR1K5d23h7e5tGjRqZBx980OTm5rqs80Lff+fbjmJZWVkmMTHRhIWFWe/5zp07m1deecUaU1HvLWP+e2PGc53vsvkPPvjAutGkSnljxvPdCPR8y4EDB4wxZX/Z/fned8YYc+rUKZOQkGACAgJMjRo1TJ8+fUx2dvZ5b8x4Ia9hMS67r3z4LjMAQIUZMmSI1q1bpy+//FJVqlS5oK+FuZwUFhbq2LFj2rRpk3r27Ml3mVUifGQGAKhQhw4dUt26ddWiRYs/vZjhcrN7925de+217i4D58ERIgBAhfnmm2+Unp4u6bfL/Nu3b+/miirWiRMn9MUXX1iPW7duraCgIDdWhGIEIgAAYHtcdg8AAGyPQAQAAGyPQAQAAGyPq8wuQFFRkdLT01WjRo0yvU09AAAoP8YYHT9+XKGhoX9681wC0QVIT08v8S3SAADg0nDo0KE//cJrAtEFKL5F/6FDh6xvWAcAAJWb0+lUWFjYBX1lEIHoAhR/TObv708gAgDgEnMhp7twUjUAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9twaiwsJCPfroo4qIiJCvr68aNWqkxx57TMYYa4wxRhMnTlS9evXk6+urmJgY7d+/32Weo0ePasCAAfL391dgYKASEhJ04sQJlzG7du3STTfdJB8fH4WFhWn69OkVso0AAKDyc2sgevrpp/Xyyy/rhRde0N69e/X0009r+vTpev75560x06dP1+zZszVnzhxt3rxZfn5+io2NVV5enjVmwIAB2rNnj5KTk7V8+XJt3LhRI0aMsPqdTqe6dOmihg0bavv27XrmmWc0efJkvfLKKxW6vQAAoHJymLMPx1SwHj16KDg4WPPmzbPa4uPj5evrqzfffFPGGIWGhur+++/XAw88IEnKzc1VcHCwkpKS1K9fP+3du1eRkZHaunWr2rVrJ0latWqVunfvrsOHDys0NFQvv/yy/vnPfyozM1NeXl6SpIcffljLli3Tvn37/rROp9OpgIAA5ebmyt/fvxz2hL05pjjcXYLbmUlu+zEEgMvWxfz9dusRohtuuEFr167Vt99+K0nauXOnPvvsM3Xr1k2SdODAAWVmZiomJsZ6TkBAgKKiopSSkiJJSklJUWBgoBWGJCkmJkYeHh7avHmzNaZjx45WGJKk2NhYpaam6tixY+W+nQAAoHKr4s6VP/zww3I6nWrWrJk8PT1VWFioJ554QgMGDJAkZWZmSpKCg4NdnhccHGz1ZWZmKigoyKW/SpUqqlWrlsuYiIiIEnMU99WsWdOlLz8/X/n5+dZjp9P5VzcVAABUYm49QrR48WK99dZbWrhwob788kstWLBA//rXv7RgwQJ3lqVp06YpICDAWsLCwsp1fQ6HvRcAANzNrYHowQcf1MMPP6x+/fqpVatWuvPOOzV27FhNmzZNkhQSEiJJysrKcnleVlaW1RcSEqLs7GyX/jNnzujo0aMuY843x9nrONuECROUm5trLYcOHSqDrQUAAJWVWwPRqVOn5OHhWoKnp6eKiookSREREQoJCdHatWutfqfTqc2bNys6OlqSFB0drZycHG3fvt0as27dOhUVFSkqKsoas3HjRp0+fdoak5ycrKZNm5b4uEySvL295e/v77IAAIDLl1sD0a233qonnnhCK1as0MGDB7V06VI9++yzuv322yVJDodDY8aM0eOPP64PP/xQu3fv1qBBgxQaGqqePXtKkpo3b66uXbtq+PDh2rJlizZt2qRRo0apX79+Cg0NlSTdcccd8vLyUkJCgvbs2aNFixZp1qxZGjdunLs2HQAAVCJuPan6+eef16OPPqp//OMfys7OVmhoqO6++25NnDjRGvPQQw/p5MmTGjFihHJycnTjjTdq1apV8vHxsca89dZbGjVqlDp37iwPDw/Fx8dr9uzZVn9AQIDWrFmjxMREtW3bVnXq1NHEiRNd7lUEAADsy633IbpUlPd9iGx/YvFku+8A7kMEAOXhkrkPEQAAQGVAIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALbn1kAUHh4uh8NRYklMTJQk5eXlKTExUbVr11b16tUVHx+vrKwslznS0tIUFxenatWqKSgoSA8++KDOnDnjMmbDhg1q06aNvL291bhxYyUlJVXUJgIAgEuAWwPR1q1blZGRYS3JycmSpL///e+SpLFjx+qjjz7SkiVL9Mknnyg9PV29evWynl9YWKi4uDgVFBTo888/14IFC5SUlKSJEydaYw4cOKC4uDh16tRJO3bs0JgxY3TXXXdp9erVFbuxAACg0nIYY4y7iyg2ZswYLV++XPv375fT6VTdunW1cOFC9e7dW5K0b98+NW/eXCkpKWrfvr1WrlypHj16KD09XcHBwZKkOXPmaPz48Tpy5Ii8vLw0fvx4rVixQl9//bW1nn79+iknJ0erVq26oLqcTqcCAgKUm5srf3//Mt9uh6PMp7y0TLb7DpDMpErzYwgAl42L+ftdac4hKigo0Jtvvqlhw4bJ4XBo+/btOn36tGJiYqwxzZo1U4MGDZSSkiJJSklJUatWrawwJEmxsbFyOp3as2ePNebsOYrHFM9xPvn5+XI6nS4LAAC4fFWaQLRs2TLl5ORoyJAhkqTMzEx5eXkpMDDQZVxwcLAyMzOtMWeHoeL+4r4/GuN0OvXrr7+et5Zp06YpICDAWsLCwv7q5gEAgEqs0gSiefPmqVu3bgoNDXV3KZowYYJyc3Ot5dChQ+4uCQAAlKMq7i5Akn788Ud9/PHHev/99622kJAQFRQUKCcnx+UoUVZWlkJCQqwxW7ZscZmr+Cq0s8ece2VaVlaW/P395evre956vL295e3t/Ze3CwAAXBoqxRGi+fPnKygoSHFxcVZb27ZtVbVqVa1du9ZqS01NVVpamqKjoyVJ0dHR2r17t7Kzs60xycnJ8vf3V2RkpDXm7DmKxxTPAQAA4PZAVFRUpPnz52vw4MGqUuW/B6wCAgKUkJCgcePGaf369dq+fbuGDh2q6OhotW/fXpLUpUsXRUZG6s4779TOnTu1evVqPfLII0pMTLSO8IwcOVI//PCDHnroIe3bt08vvfSSFi9erLFjx7plewEAQOXj9o/MPv74Y6WlpWnYsGEl+mbOnCkPDw/Fx8crPz9fsbGxeumll6x+T09PLV++XPfcc4+io6Pl5+enwYMHa+rUqdaYiIgIrVixQmPHjtWsWbNUv359vfrqq4qNja2Q7QMAAJVfpboPUWXFfYjKGfch4j5EAFAOLsn7EAEAALgLgQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANgegQgAANie2wPRTz/9pIEDB6p27dry9fVVq1attG3bNqvfGKOJEyeqXr168vX1VUxMjPbv3+8yx9GjRzVgwAD5+/srMDBQCQkJOnHihMuYXbt26aabbpKPj4/CwsI0ffr0Ctk+AABQ+bk1EB07dkwdOnRQ1apVtXLlSn3zzTeaMWOGatasaY2ZPn26Zs+erTlz5mjz5s3y8/NTbGys8vLyrDEDBgzQnj17lJycrOXLl2vjxo0aMWKE1e90OtWlSxc1bNhQ27dv1zPPPKPJkyfrlVdeqdDtBQAAlZPDGGPctfKHH35YmzZt0qeffnrefmOMQkNDdf/99+uBBx6QJOXm5io4OFhJSUnq16+f9u7dq8jISG3dulXt2rWTJK1atUrdu3fX4cOHFRoaqpdffln//Oc/lZmZKS8vL2vdy5Yt0759+/60TqfTqYCAAOXm5srf37+Mtv6/HI4yn/LSMtnuO0Ayk9z2YwgAl62L+fvt1iNEH374odq1a6e///3vCgoK0rXXXqt///vfVv+BAweUmZmpmJgYqy0gIEBRUVFKSUmRJKWkpCgwMNAKQ5IUExMjDw8Pbd682RrTsWNHKwxJUmxsrFJTU3Xs2LESdeXn58vpdLosAADg8uXWQPTDDz/o5ZdfVpMmTbR69Wrdc889Gj16tBYsWCBJyszMlCQFBwe7PC84ONjqy8zMVFBQkEt/lSpVVKtWLZcx55vj7HWcbdq0aQoICLCWsLCwMthaAABQWbk1EBUVFalNmzZ68sknde2112rEiBEaPny45syZ486yNGHCBOXm5lrLoUOH3FoPAAAoX24NRPXq1VNkZKRLW/PmzZWWliZJCgkJkSRlZWW5jMnKyrL6QkJClJ2d7dJ/5swZHT161GXM+eY4ex1n8/b2lr+/v8sCAAAuX24NRB06dFBqaqpL27fffquGDRtKkiIiIhQSEqK1a9da/U6nU5s3b1Z0dLQkKTo6Wjk5Odq+fbs1Zt26dSoqKlJUVJQ1ZuPGjTp9+rQ1Jjk5WU2bNnW5og0AANiTWwPR2LFj9cUXX+jJJ5/Ud999p4ULF+qVV15RYmKiJMnhcGjMmDF6/PHH9eGHH2r37t0aNGiQQkND1bNnT0m/HVHq2rWrhg8fri1btmjTpk0aNWqU+vXrp9DQUEnSHXfcIS8vLyUkJGjPnj1atGiRZs2apXHjxrlr0wEAQCVSxZ0rv+6667R06VJNmDBBU6dOVUREhJ577jkNGDDAGvPQQw/p5MmTGjFihHJycnTjjTdq1apV8vHxsca89dZbGjVqlDp37iwPDw/Fx8dr9uzZVn9AQIDWrFmjxMREtW3bVnXq1NHEiRNd7lUEAADsy633IbpUcB+icsZ9iLgPEQCUg0vmPkQAAACVAYEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYnlsD0eTJk+VwOFyWZs2aWf15eXlKTExU7dq1Vb16dcXHxysrK8tljrS0NMXFxalatWoKCgrSgw8+qDNnzriM2bBhg9q0aSNvb281btxYSUlJFbF5AADgEuH2I0QtWrRQRkaGtXz22WdW39ixY/XRRx9pyZIl+uSTT5Senq5evXpZ/YWFhYqLi1NBQYE+//xzLViwQElJSZo4caI15sCBA4qLi1OnTp20Y8cOjRkzRnfddZdWr15dodsJAAAqrypuL6BKFYWEhJRoz83N1bx587Rw4ULdcsstkqT58+erefPm+uKLL9S+fXutWbNG33zzjT7++GMFBwfrmmuu0WOPPabx48dr8uTJ8vLy0pw5cxQREaEZM2ZIkpo3b67PPvtMM2fOVGxsbIVuKwAAqJzcfoRo//79Cg0N1ZVXXqkBAwYoLS1NkrR9+3adPn1aMTEx1thmzZqpQYMGSklJkSSlpKSoVatWCg4OtsbExsbK6XRqz5491piz5ygeUzwHAACAW48QRUVFKSkpSU2bNlVGRoamTJmim266SV9//bUyMzPl5eWlwMBAl+cEBwcrMzNTkpSZmekShor7i/v+aIzT6dSvv/4qX1/fEnXl5+crPz/feux0Ov/ytgIAgMqrVIHohx9+0JVXXvmXV96tWzfr361bt1ZUVJQaNmyoxYsXnzeoVJRp06ZpypQpbls/AACoWKX6yKxx48bq1KmT3nzzTeXl5ZVZMYGBgbrqqqv03XffKSQkRAUFBcrJyXEZk5WVZZ1zFBISUuKqs+LHfzbG39//d0PXhAkTlJubay2HDh0qi80DAACVVKkC0ZdffqnWrVtr3LhxCgkJ0d13360tW7b85WJOnDih77//XvXq1VPbtm1VtWpVrV271upPTU1VWlqaoqOjJUnR0dHavXu3srOzrTHJycny9/dXZGSkNebsOYrHFM9xPt7e3vL393dZAADA5atUgeiaa67RrFmzlJ6ertdee00ZGRm68cYb1bJlSz377LM6cuTIBc3zwAMP6JNPPtHBgwf1+eef6/bbb5enp6f69++vgIAAJSQkaNy4cVq/fr22b9+uoUOHKjo6Wu3bt5ckdenSRZGRkbrzzju1c+dOrV69Wo888ogSExPl7e0tSRo5cqR++OEHPfTQQ9q3b59eeuklLV68WGPHji3NpgMAgMvQX7rKrEqVKurVq5eWLFmip59+Wt99950eeOABhYWFadCgQcrIyPjD5x8+fFj9+/dX06ZN1adPH9WuXVtffPGF6tatK0maOXOmevToofj4eHXs2FEhISF6//33red7enpq+fLl8vT0VHR0tAYOHKhBgwZp6tSp1piIiAitWLFCycnJuvrqqzVjxgy9+uqrXHIPAAAsDmOMKe2Tt23bptdee03vvPOO/Pz8NHjwYCUkJOjw4cOaMmWKnE5nmXyU5m5Op1MBAQHKzc0tl4/PHI4yn/LSMtnuO0Ayk0r9YwgA+B0X8/e7VFeZPfvss5o/f75SU1PVvXt3vf766+revbs8PH474BQREaGkpCSFh4eXZnoAAIAKVapA9PLLL2vYsGEaMmSI6tWrd94xQUFBmjdv3l8qDgAAoCKUKhDt37//T8d4eXlp8ODBpZkeAACgQpXqpOr58+dryZIlJdqXLFmiBQsW/OWiAAAAKlKpAtG0adNUp06dEu1BQUF68skn/3JRAAAAFalUgSgtLU0REREl2hs2bGh9OSsAAMClolSBKCgoSLt27SrRvnPnTtWuXfsvFwUAAFCRShWI+vfvr9GjR2v9+vUqLCxUYWGh1q1bp/vuu0/9+vUr6xoBAADKVamuMnvsscd08OBBde7cWVWq/DZFUVGRBg0axDlEAADgklOqQOTl5aVFixbpscce086dO+Xr66tWrVqpYcOGZV0fAABAuStVICp21VVX6aqrriqrWgAAANyiVIGosLBQSUlJWrt2rbKzs1VUVOTSv27dujIpDgAAoCKUKhDdd999SkpKUlxcnFq2bCmH7b+dFAAAXMpKFYjeeecdLV68WN27dy/regAAACpcqS679/LyUuPGjcu6FgAAALcoVSC6//77NWvWLBljyroeAACACleqj8w+++wzrV+/XitXrlSLFi1UtWpVl/7333+/TIoDAACoCKUKRIGBgbr99tvLuhYAAAC3KFUgmj9/flnXAQAA4DalOodIks6cOaOPP/5Yc+fO1fHjxyVJ6enpOnHiRJkVBwAAUBFKdYToxx9/VNeuXZWWlqb8/Hz9z//8j2rUqKGnn35a+fn5mjNnTlnXCQAAUG5KdYTovvvuU7t27XTs2DH5+vpa7bfffrvWrl1bZsUBAABUhFIdIfr000/1+eefy8vLy6U9PDxcP/30U5kUBgAAUFFKdYSoqKhIhYWFJdoPHz6sGjVq/OWiAAAAKlKpAlGXLl303HPPWY8dDodOnDihSZMm8XUeAADgklOqj8xmzJih2NhYRUZGKi8vT3fccYf279+vOnXq6O233y7rGgEAAMpVqQJR/fr1tXPnTr3zzjvatWuXTpw4oYSEBA0YMMDlJGsAAIBLQakCkSRVqVJFAwcOLMtaAAAA3KJUgej111//w/5BgwaVqhgAAAB3KFUguu+++1wenz59WqdOnZKXl5eqVatGIAIAAJeUUl1lduzYMZflxIkTSk1N1Y033shJ1QAA4JJT6u8yO1eTJk301FNPlTh6BAAAUNmVWSCSfjvROj09vSynBAAAKHelCkQffvihy/LBBx9ozpw5GjhwoDp06FCqQp566ik5HA6NGTPGasvLy1NiYqJq166t6tWrKz4+XllZWS7PS0tLU1xcnKpVq6agoCA9+OCDOnPmjMuYDRs2qE2bNvL29lbjxo2VlJRUqhoBAMDlqVQnVffs2dPlscPhUN26dXXLLbdoxowZFz3f1q1bNXfuXLVu3dqlfezYsVqxYoWWLFmigIAAjRo1Sr169dKmTZskSYWFhYqLi1NISIg+//xzZWRkaNCgQapataqefPJJSdKBAwcUFxenkSNH6q233tLatWt11113qV69eoqNjS3N5gMAgMuMwxhj3FnAiRMn1KZNG7300kt6/PHHdc011+i5555Tbm6u6tatq4ULF6p3796SpH379ql58+ZKSUlR+/bttXLlSvXo0UPp6ekKDg6WJM2ZM0fjx4/XkSNH5OXlpfHjx2vFihX6+uuvrXX269dPOTk5WrVq1QXV6HQ6FRAQoNzcXPn7+5f5PnA4ynzKS8tku+8AyUxy648hAFyWLubvd5meQ1QaiYmJiouLU0xMjEv79u3bdfr0aZf2Zs2aqUGDBkpJSZEkpaSkqFWrVlYYkqTY2Fg5nU7t2bPHGnPu3LGxsdYc55Ofny+n0+myAACAy1epPjIbN27cBY999tlnf7fvnXfe0ZdffqmtW7eW6MvMzJSXl5cCAwNd2oODg5WZmWmNOTsMFfcX9/3RGKfTqV9//fW8XzUybdo0TZky5c83DgAAXBZKFYi++uorffXVVzp9+rSaNm0qSfr222/l6empNm3aWOMcf/BZ0KFDh3TfffcpOTlZPj4+pSmj3EyYMMEl9DmdToWFhbmxIgAAUJ5KFYhuvfVW1ahRQwsWLFDNmjUl/XazxqFDh+qmm27S/fff/6dzbN++XdnZ2S4BqrCwUBs3btQLL7yg1atXq6CgQDk5OS5HibKyshQSEiJJCgkJ0ZYtW1zmLb4K7ewx516ZlpWVJX9//9/9Ilpvb295e3v/6TYAAIDLQ6nOIZoxY4amTZtmhSFJqlmzph5//PELvsqsc+fO2r17t3bs2GEt7dq104ABA6x/V61aVWvXrrWek5qaqrS0NEVHR0uSoqOjtXv3bmVnZ1tjkpOT5e/vr8jISGvM2XMUjymeAwAAoFRHiJxOp44cOVKi/ciRIzp+/PgFzVGjRg21bNnSpc3Pz0+1a9e22hMSEjRu3DjVqlVL/v7+uvfeexUdHa327dtLkrp06aLIyEjdeeedmj59ujIzM/XII48oMTHROsIzcuRIvfDCC3rooYc0bNgwrVu3TosXL9aKFStKs+kAAOAyVKojRLfffruGDh2q999/X4cPH9bhw4f13nvvKSEhQb169Sqz4mbOnKkePXooPj5eHTt2VEhIiN5//32r39PTU8uXL5enp6eio6M1cOBADRo0SFOnTrXGREREaMWKFUpOTtbVV1+tGTNm6NVXX+UeRAAAwFKq+xCdOnVKDzzwgF577TWdPn1a0m9f25GQkKBnnnlGfn5+ZV6oO3EfonLGfYi4DxEAlIOL+fv9l27MePLkSX3//feSpEaNGl12QagYgaicEYgIRABQDirsxowZGRnKyMhQkyZN5OfnJzff9BoAAKBUShWIfvnlF3Xu3FlXXXWVunfvroyMDEm/nQR9IZfcAwAAVCalCkRjx45V1apVlZaWpmrVqlntffv2veDvBwMAAKgsSnXZ/Zo1a7R69WrVr1/fpb1Jkyb68ccfy6QwAACAilKqI0QnT550OTJU7OjRo9zhGQAAXHJKFYhuuukmvf7669Zjh8OhoqIiTZ8+XZ06dSqz4gAAACpCqT4ymz59ujp37qxt27apoKBADz30kPbs2aOjR49q06ZNZV0jAABAuSrVEaKWLVvq22+/1Y033qjbbrtNJ0+eVK9evfTVV1+pUaNGZV0jAABAubroI0SnT59W165dNWfOHP3zn/8sj5oAAAAq1EUfIapatap27dpVHrUAAAC4Rak+Mhs4cKDmzZtX1rUAAAC4RalOqj5z5oxee+01ffzxx2rbtm2J7zB79tlny6Q4AACAinBRgeiHH35QeHi4vv76a7Vp00aS9O2337qMcdj+m0oBAMCl5qICUZMmTZSRkaH169dL+u2rOmbPnq3g4OByKQ4AAKAiXNQ5ROd+m/3KlSt18uTJMi0IAACgopXqpOpi5wYkAACAS9FFBSKHw1HiHCHOGQIAAJe6izqHyBijIUOGWF/gmpeXp5EjR5a4yuz9998vuwoBAADK2UUFosGDB7s8HjhwYJkWAwAA4A4XFYjmz59fXnUAAAC4zV86qRoAAOByQCACAAC2RyACAAC2RyACAAC2RyACAAC2RyACAAC2RyACAAC2RyACAAC2RyACAAC2RyACAAC2RyACAAC2RyACAAC259ZA9PLLL6t169by9/eXv7+/oqOjtXLlSqs/Ly9PiYmJql27tqpXr674+HhlZWW5zJGWlqa4uDhVq1ZNQUFBevDBB3XmzBmXMRs2bFCbNm3k7e2txo0bKykpqSI2DwAAXCLcGojq16+vp556Stu3b9e2bdt0yy236LbbbtOePXskSWPHjtVHH32kJUuW6JNPPlF6erp69eplPb+wsFBxcXEqKCjQ559/rgULFigpKUkTJ060xhw4cEBxcXHq1KmTduzYoTFjxuiuu+7S6tWrK3x7AQBA5eQwxhh3F3G2WrVq6ZlnnlHv3r1Vt25dLVy4UL1795Yk7du3T82bN1dKSorat2+vlStXqkePHkpPT1dwcLAkac6cORo/fryOHDkiLy8vjR8/XitWrNDXX39traNfv37KycnRqlWrLqgmp9OpgIAA5ebmyt/fv8y32eEo8ykvLZPtvgMkM6lS/RgCwGXhYv5+V5pziAoLC/XOO+/o5MmTio6O1vbt23X69GnFxMRYY5o1a6YGDRooJSVFkpSSkqJWrVpZYUiSYmNj5XQ6raNMKSkpLnMUjyme43zy8/PldDpdFgAAcPlyeyDavXu3qlevLm9vb40cOVJLly5VZGSkMjMz5eXlpcDAQJfxwcHByszMlCRlZma6hKHi/uK+PxrjdDr166+/nremadOmKSAgwFrCwsLKYlMBAEAl5fZA1LRpU+3YsUObN2/WPffco8GDB+ubb75xa00TJkxQbm6utRw6dMit9QAAgPJVxd0FeHl5qXHjxpKktm3bauvWrZo1a5b69u2rgoIC5eTkuBwlysrKUkhIiCQpJCREW7ZscZmv+Cq0s8ece2VaVlaW/P395evre96avL295e3tXSbbBwAAKj+3HyE6V1FRkfLz89W2bVtVrVpVa9eutfpSU1OVlpam6OhoSVJ0dLR2796t7Oxsa0xycrL8/f0VGRlpjTl7juIxxXMAAAC49QjRhAkT1K1bNzVo0EDHjx/XwoULtWHDBq1evVoBAQFKSEjQuHHjVKtWLfn7++vee+9VdHS02rdvL0nq0qWLIiMjdeedd2r69OnKzMzUI488osTEROsIz8iRI/XCCy/ooYce0rBhw7Ru3TotXrxYK1ascOemAwCASsStgSg7O1uDBg1SRkaGAgIC1Lp1a61evVr/8z//I0maOXOmPDw8FB8fr/z8fMXGxuqll16ynu/p6anly5frnnvuUXR0tPz8/DR48GBNnTrVGhMREaEVK1Zo7NixmjVrlurXr69XX31VsbGxFb69AACgcqp09yGqjLgPUTnjPkTchwgAysEleR8iAAAAdyEQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA2yMQAQAA23NrIJo2bZquu+461ahRQ0FBQerZs6dSU1NdxuTl5SkxMVG1a9dW9erVFR8fr6ysLJcxaWlpiouLU7Vq1RQUFKQHH3xQZ86ccRmzYcMGtWnTRt7e3mrcuLGSkpLKe/MAAMAlwq2B6JNPPlFiYqK++OILJScn6/Tp0+rSpYtOnjxpjRk7dqw++ugjLVmyRJ988onS09PVq1cvq7+wsFBxcXEqKCjQ559/rgULFigpKUkTJ060xhw4cEBxcXHq1KmTduzYoTFjxuiuu+7S6tWrK3R7AQBA5eQwxhh3F1HsyJEjCgoK0ieffKKOHTsqNzdXdevW1cKFC9W7d29J0r59+9S8eXOlpKSoffv2WrlypXr06KH09HQFBwdLkubMmaPx48fryJEj8vLy0vjx47VixQp9/fXX1rr69eunnJwcrVq16k/rcjqdCggIUG5urvz9/ct8ux2OMp/y0jLZ7jtAMpMqzY8hAFw2Lubvd6U6hyg3N1eSVKtWLUnS9u3bdfr0acXExFhjmjVrpgYNGiglJUWSlJKSolatWllhSJJiY2PldDq1Z88ea8zZcxSPKZ7jXPn5+XI6nS4LAAC4fFWaQFRUVKQxY8aoQ4cOatmypSQpMzNTXl5eCgwMdBkbHByszMxMa8zZYai4v7jvj8Y4nU79+uuvJWqZNm2aAgICrCUsLKxMthEAcH4Oh70XuF+lCUSJiYn6+uuv9c4777i7FE2YMEG5ubnWcujQIXeXBAAAylEVdxcgSaNGjdLy5cu1ceNG1a9f32oPCQlRQUGBcnJyXI4SZWVlKSQkxBqzZcsWl/mKr0I7e8y5V6ZlZWXJ399fvr6+Jerx9vaWt7d3mWwbAACo/NwaiIwxuvfee7V06VJt2LBBERERLv1t27ZV1apVtXbtWsXHx0uSUlNTlZaWpujoaElSdHS0nnjiCWVnZysoKEiSlJycLH9/f0VGRlpj/vOf/7jMnZycbM0BAIA7OabwuZm7Ly5xayBKTEzUwoUL9cEHH6hGjRrWOT8BAQHy9fVVQECAEhISNG7cONWqVUv+/v669957FR0drfbt20uSunTposjISN15552aPn26MjMz9cgjjygxMdE6yjNy5Ei98MILeuihhzRs2DCtW7dOixcv1ooVK9y27QAAoPJw6zlEL7/8snJzc/W3v/1N9erVs5ZFixZZY2bOnKkePXooPj5eHTt2VEhIiN5//32r39PTU8uXL5enp6eio6M1cOBADRo0SFOnTrXGREREaMWKFUpOTtbVV1+tGTNm6NVXX1VsbGyFbi8AAKicKtV9iCor7kNUzrgPkdsPFQPuxu9Bu++A8vk9eMnehwgAAMAdCEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD23BqINm7cqFtvvVWhoaFyOBxatmyZS78xRhMnTlS9evXk6+urmJgY7d+/32XM0aNHNWDAAPn7+yswMFAJCQk6ceKEy5hdu3bppptuko+Pj8LCwjR9+vTy3jQAAHAJcWsgOnnypK6++mq9+OKL5+2fPn26Zs+erTlz5mjz5s3y8/NTbGys8vLyrDEDBgzQnj17lJycrOXLl2vjxo0aMWKE1e90OtWlSxc1bNhQ27dv1zPPPKPJkyfrlVdeKfftAwAAl4Yq7lx5t27d1K1bt/P2GWP03HPP6ZFHHtFtt90mSXr99dcVHBysZcuWqV+/ftq7d69WrVqlrVu3ql27dpKk559/Xt27d9e//vUvhYaG6q233lJBQYFee+01eXl5qUWLFtqxY4eeffZZl+AEAADsq9KeQ3TgwAFlZmYqJibGagsICFBUVJRSUlIkSSkpKQoMDLTCkCTFxMTIw8NDmzdvtsZ07NhRXl5e1pjY2Filpqbq2LFj5113fn6+nE6nywIAAC5flTYQZWZmSpKCg4Nd2oODg62+zMxMBQUFufRXqVJFtWrVchlzvjnOXse5pk2bpoCAAGsJCwv76xsEAAAqrUobiNxpwoQJys3NtZZDhw65uyQAAFCOKm0gCgkJkSRlZWW5tGdlZVl9ISEhys7Oduk/c+aMjh496jLmfHOcvY5zeXt7y9/f32UBAACXr0obiCIiIhQSEqK1a9dabU6nU5s3b1Z0dLQkKTo6Wjk5Odq+fbs1Zt26dSoqKlJUVJQ1ZuPGjTp9+rQ1Jjk5WU2bNlXNmjUraGsAAEBl5tZAdOLECe3YsUM7duyQ9NuJ1Dt27FBaWpocDofGjBmjxx9/XB9++KF2796tQYMGKTQ0VD179pQkNW/eXF27dtXw4cO1ZcsWbdq0SaNGjVK/fv0UGhoqSbrjjjvk5eWlhIQE7dmzR4sWLdKsWbM0btw4N201AACobNx62f22bdvUqVMn63FxSBk8eLCSkpL00EMP6eTJkxoxYoRycnJ04403atWqVfLx8bGe89Zbb2nUqFHq3LmzPDw8FB8fr9mzZ1v9AQEBWrNmjRITE9W2bVvVqVNHEydO5JJ7AABgcRhjjLuLqOycTqcCAgKUm5tbLucTORxlPuWlZbLdd4BkJvFjCHvj96Ddd0D5/B68mL/flfYcIgAAgIpCIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZHIAIAALZnq0D04osvKjw8XD4+PoqKitKWLVvcXRIAAKgEbBOIFi1apHHjxmnSpEn68ssvdfXVVys2NlbZ2dnuLg0AALiZbQLRs88+q+HDh2vo0KGKjIzUnDlzVK1aNb322mvuLg0AALiZLQJRQUGBtm/frpiYGKvNw8NDMTExSklJcWNlAACgMqji7gIqws8//6zCwkIFBwe7tAcHB2vfvn0lxufn5ys/P996nJubK0lyOp3lW6hd5bm7APfjvQXYHL8Hy+X3YPGcxpg/HWuLQHSxpk2bpilTppRoDwsLc0M1NvCUuwtwv4CnAtxdAgB34vdguf4ePH78uAIC/nh+WwSiOnXqyNPTU1lZWS7tWVlZCgkJKTF+woQJGjdunPW4qKhIR48eVe3ateVwOMq9XjtxOp0KCwvToUOH5O/v7+5yAKDC8Xuw/BhjdPz4cYWGhv7pWFsEIi8vL7Vt21Zr165Vz549Jf0WctauXatRo0aVGO/t7S1vb2+XtsDAwAqo1L78/f35RQDA1vg9WD7+7MhQMVsEIkkaN26cBg8erHbt2un666/Xc889p5MnT2ro0KHuLg0AALiZbQJR3759deTIEU2cOFGZmZm65pprtGrVqhInWgMAAPuxTSCSpFGjRp33IzK4j7e3tyZNmlTiI0oAsAt+D1YODnMh16IBAABcxmxxY0YAAIA/QiACAAC2RyACAAC2RyACAAC2RyCCW7344osKDw+Xj4+PoqKitGXLFneXBAAVZuPGjbr11lsVGhoqh8OhZcuWubsk2yIQwW0WLVqkcePGadKkSfryyy919dVXKzY2VtnZ2e4uDQAqxMmTJ3X11VfrxRdfdHcptsdl93CbqKgoXXfddXrhhRck/fZ1KmFhYbr33nv18MMPu7k6AKhYDodDS5cutb5iChWLI0Rwi4KCAm3fvl0xMTFWm4eHh2JiYpSSkuLGygAAdkQgglv8/PPPKiwsLPHVKcHBwcrMzHRTVQAAuyIQAQAA2yMQwS3q1KkjT09PZWVlubRnZWUpJCTETVUBAOyKQAS38PLyUtu2bbV27VqrraioSGvXrlV0dLQbKwMA2JGtvu0elcu4ceM0ePBgtWvXTtdff72ee+45nTx5UkOHDnV3aQBQIU6cOKHvvvvOenzgwAHt2LFDtWrVUoMGDdxYmf1w2T3c6oUXXtAzzzyjzMxMXXPNNZo9e7aioqLcXRYAVIgNGzaoU6dOJdoHDx6spKSkii/IxghEAADA9jiHCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCEClk5KSIk9PT8XFxbm0T548Wddcc02J8Q6HQ8uWLauY4i7AkCFD1LNnT3eXAeAiEIgAVDrz5s3Tvffeq40bNyo9Pd3d5QCwAQIRgErlxIkTWrRoke655x7FxcVZ3+eUlJSkKVOmaOfOnXI4HHI4HEpKSlJ4eLgk6fbbb5fD4bAeS9IHH3ygNm3ayMfHR1deeaWmTJmiM2fOWP0Oh0Nz585Vjx49VK1aNTVv3lwpKSn67rvv9Le//U1+fn664YYb9P3331vPKT5KNXfuXIWFhalatWrq06ePcnNzrf4FCxbogw8+sOrcsGGDCgoKNGrUKNWrV08+Pj5q2LChpk2bVu77E8AFMgBQicybN8+0a9fOGGPMRx99ZBo1amSKiorMqVOnzP33329atGhhMjIyTEZGhjl16pTJzs42ksz8+fNNRkaGyc7ONsYYs3HjRuPv72+SkpLM999/b9asWWPCw8PN5MmTrXVJMldccYVZtGiRSU1NNT179jTh4eHmlltuMatWrTLffPONad++venatav1nEmTJhk/Pz9zyy23mK+++sp88sknpnHjxuaOO+4wxhhz/Phx06dPH9O1a1erzvz8fPPMM8+YsLAws3HjRnPw4EHz6aefmoULF1bgngXwRwhEACqVG264wTz33HPGGGNOnz5t6tSpY9avX2+M+S2MXH311SWeI8ksXbrUpa1z587mySefdGl74403TL169Vye98gjj1iPU1JSjCQzb948q+3tt982Pj4+1uNJkyYZT09Pc/jwYatt5cqVxsPDw2RkZBhjjBk8eLC57bbbXNZ97733mltuucUUFRX9+U4AUOH4yAxApZGamqotW7aof//+kqQqVaqob9++mjdv3kXPtXPnTk2dOlXVq1e3luHDhysjI0OnTp2yxrVu3dr6d3BwsCSpVatWLm15eXlyOp1WW4MGDXTFFVdYj6Ojo1VUVKTU1NTfrWfIkCHasWOHmjZtqtGjR2vNmjUXvU0Ayk8VdxcAAMXmzZunM2fOKDQ01Gozxsjb21svvPDCRc114sQJTZkyRb169SrR5+PjY/27atWq1r8dDsfvthUVFV3U+s/Vpk0bHThwQCtXrtTHH3+sPn36KCYmRu++++5fmhdA2SAQAagUzpw5o9dff10zZsxQly5dXPp69uypt99+W15eXiosLCzx3KpVq5Zob9OmjVJTU9W4ceMyrzUtLU3p6elWcPviiy/k4eGhpk2bStLv1unv76++ffuqb9++6t27t7p27aqjR4+qVq1aZV4jgItDIAJQKSxfvlzHjh1TQkKCAgICXPri4+M1b948jR07VgcOHNCOHTtUv3591ahRQ97e3goPD9fatWvVoUMHeXt7q2bNmpo4caJ69OihBg0aqHfv3vLw8NDOnTv19ddf6/HHH/9Ltfr4+Gjw4MH617/+JafTqdGjR6tPnz4KCQmRJIWHh2v16tVKTU1V7dq1FRAQoOeff1716tXTtddeKw8PDy1ZskQhISEKDAz8S7UAKBucQwSgUpg3b55iYmJKhCHpt0C0bds2tWjRQl27dlWnTp1Ut25dvf3225KkGTNmKDk5WWFhYbr22mslSbGxsVq+fLnWrFmj6667Tu3bt9fMmTPVsGHDv1xr48aN1atXL3Xv3l1dunRR69at9dJLL1n9w4cPV9OmTdWuXTvVrVtXmzZtUo0aNTR9+nS1a9dO1113nQ4ePKj//Oc/8vDg1zBQGTiMMcbdRQDApWLy5MlatmyZduzY4e5SAJQh/msCAABsj0AEAABsj4/MAACA7XGECAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2N7/A2YKwBQJaYoQAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from guppylang.std.lang import comptime\n", "from guppylang.emulator import EmulatorInstance\n", "\n", "\n", "def compile_emulators(*, apply_z: bool) -> tuple[EmulatorInstance, EmulatorInstance]:\n", " @guppy\n", " def _rus() -> None:\n", " q = qubit()\n", " h(q)\n", " if comptime(apply_z):\n", " z(q)\n", " repeat_until_success(q)\n", " h(q)\n", " result(\"outcome\", measure(q))\n", " _rus.check()\n", "\n", " @guppy\n", " def _ref() -> None:\n", " q = qubit()\n", " h(q)\n", " if comptime(apply_z):\n", " z(q)\n", " unitary_func(q)\n", " h(q)\n", " result(\"outcome\", measure(q))\n", " _ref.check()\n", "\n", " return _rus.emulator(n_qubits=3), _ref.emulator(n_qubits=circ.n_qubits)\n", "\n", "def run_experiment(*, apply_z: bool, n_shots: int) -> None:\n", " rus_emulator, ref_emulator = compile_emulators(apply_z=apply_z)\n", "\n", " rus_shots = rus_emulator.with_seed(0).with_shots(n_shots).run()\n", " rus_positive_outcomes = sum(shot.as_dict()[\"outcome\"] for shot in rus_shots)\n", " \n", " ref_shots = ref_emulator.with_seed(0).with_shots(n_shots).run()\n", " ref_positive_outcomes = sum(shot.as_dict()[\"outcome\"] for shot in ref_shots)\n", "\n", " _, ax = plt.subplots(1, 1)\n", " ax.bar([-0.1, 0.9], [n_shots - rus_positive_outcomes, rus_positive_outcomes], width=0.2, color=\"b\")\n", " ax.bar([0.1, 1.1], [n_shots - ref_positive_outcomes, ref_positive_outcomes], width=0.2, color=\"g\")\n", " ax.set_title(f\"Outcomes of X measurement [Z: {apply_z}]\")\n", " ax.set_xlabel(\"Attempts\")\n", " ax.set_ylabel(\"Frequency\")\n", " ax.xaxis.set_major_locator(ticker.MultipleLocator(1.0))\n", " plt.show()\n", "\n", "run_experiment(apply_z=False, n_shots=10000)\n", "run_experiment(apply_z=True, n_shots=10000)" ] } ], "metadata": { "kernelspec": { "display_name": "guppylang", "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.11.2" } }, "nbformat": 4, "nbformat_minor": 5 }