{ "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", "\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", "\n", "\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": "iVBORw0KGgoAAAANSUhEUgAAAk4AAAHFCAYAAAAExnZzAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQBxJREFUeJzt3XlYlXX+//EX61EQMBFBFLfMpdwSyi3FXXNPTSsbc2uyckatscnym5oZTptZjVlpqaNpjXvaqjkuo2SplamZSwoKKgoCyip8fn80nJ9HUG/04GF5Pq7rXFfnc7/Pfd73DXle3Pfnvo+bMcYIAAAA1+Tu6gYAAABKCoITAACARQQnAAAAiwhOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCUCZVrlyZT355JMue/+cnBx5enraHy+++KLLesH1adasmf3nN2DAAFe3gyJGcAIu83//93/y9PRUu3btrlhTvXp1jRw5stDLiquS2LOzXLx4UTk5OU5dZ2H2pzFGOTk5eu6555SRkaFJkyY5tRdXSE1N1eLFi9W3b1/5+PjI09NTmZmZll8/ZMgQhzCZ96hcuXK+2osXL+rtt99WeHi4KlWqpCpVqqht27b65JNP8tXm5uZq1qxZaty4sXx9fRUaGqpRo0bp1KlTN7TenTt3KiMjQ3Xr1nX67xKKH4ITcImcnBx9+OGHCg4O1pYtW7R///4C6672YVsUH8RFrST2XJxdz/50d3eXp6en3N1L/j/LkydP1ueff66RI0eqZ8+eysnJUWG+3SsnJ0chISHKyMhweBQUcEaPHq2xY8dq5MiROnjwoH766Se1aNFCDzzwgN58802H2jFjxmjChAkaM2aMYmJitHbtWu3cuVPt2rVTSkrKda/Xw8NDnp6elrcPJVvJ/z8UcKJ169YpLi5OH3/8sSpVqqS5c+e6uiWgxHnjjTe0ePFi9enTRzab7brXc/kRJw8PD4flOTk5Wrhwobp06aInnnhCgYGBqlq1ql577TXVqFFDH330kb320KFDmjNnjv785z/rscceU2BgoJo3b64lS5bo4MGDeuONN65rvSh7CE7AJT744AOFh4crMjJSw4YN08KFC5WVlWVfnpmZKU9PT506dUoLFy60/4N+zz33XHXZpT755BO1adNGAQEBqlixorp166YdO3Y41OTNu4mOjlbr1q3l7++vFi1a6Pvvv5ckbdu2TW3atJGfn5/uuOMOffXVV/m2JW8d27ZtU6tWreTn56f69etr9uzZlrYnz7p16xQZGamgoCBVqVJFnTp10pdffnnNfWnl/a93v+zYsUORkZHy8/O76pygwvS+e/du+zrr1q2r9957L19Nbm6uXn/9dTVq1Ei+vr4KCQnRkCFDdOTIEcv7s7Duuece+3rKlSunsLAwDR8+XHFxcfaali1bqmnTpgW+vmvXrqpXr579iE9mZqb+/ve/KywsTAEBAerRo4eOHDmi9u3bq3379tfdpyt4eHjIx8enwKN07u7u8vPzsz+Pjo6WMUaRkZEOdQ0aNFBISIiWLFlyXetFGWQAGGOMOX78uPHw8DDz5s0zxhhz8OBB4+bmZpYuXepQl52dbYKDg83QoUNNdna2yc7ONhcvXrzmMmOMmTx5svH09DQzZswwsbGxJjY21owZM8bYbDazY8cOe11AQIDp3r27GThwoPn1119NXFyc6devn6lcubKJjo42ffv2Nfv27TPx8fFm4MCBxtfX1yQkJDj0GRAQYLp162Z69uxp9uzZY06ePGlmzJhh3N3dzT/+8Q9L2/P9998bDw8P88ILL5j4+HiTmJho/vOf/5h7773XnD9//qr70+r7F3a/5K3zp59+Mr///rtZsWJFge9vtfeAgADTo0cPM2DAALNnzx5z+vRpM2HCBCPJbNq0yWGdw4YNMzabzbz33nsmISHB7Ny504SHh5vKlSubo0ePWvoduFx2draRZCZPnlzg8osXL9rXk5qaarZu3WrCw8NN8+bNTVZWljHGmNmzZxtJ5rvvvnN47e+//27c3NzMtGnT7GODBg0yfn5+ZsmSJebs2bNm27ZtpkePHubOO+80bdq0cXh9//79jYeHxzUfAQEBV9y+IUOGGEkmPT39ijWXGzx4sPHy8jLBwcGmfPnypk6dOubJJ580p06dylf7zjvvGE9PTzNv3jxz/vx5k5iYaJ5//nlTrlw589VXX9nrFixYYCSZf//73/nWUa1aNePm5mbS0tIKvd5L1a9f3/Tt29fydqJkIjgB/zNt2jRzyy23OPzj2bVrV9O5c+d8tcHBweaRRx4pcD1XWnbw4EHj7u5uJkyYkG9ZRESE6dKli/15QECAqVixoklOTraPHT582Egy1atXN0lJSfbxo0ePGknmrbfeclhnQECAqVChgjl79qzD+EMPPWR8fX0d1n2lnl977TUjyVy4cKHAbb0aq+9f2P3i4+Njzpw5c833t9p73r4+d+6cfSw7O9uEhISYhx56yD62e/duI8lMmjTJ4fWxsbHG29vbDB8+3D52td+Py10rOBVk+/btRpL573//a4wx5ty5c8bHx8c89thjDnUvvPCCcXd3N7GxscYYY3bu3GkkmVdffdWhbteuXUZSvuDUt29fI+maD19f3yv2ej3B6dlnnzULFiwwx44dM6dOnTJLliwxVatWNTVq1DAnT57MVz9z5kzj5eVl78ff398sX77coWbPnj1Gkhk7dqzDeN4fSJLs+6kw670Uwals4FQdoD+ubJo3b56GDRum8uXL28efeOIJbdiwwX4q5kasW7dOubm5GjRoUL5lnTp10qZNmxwm0LZt21b+/v7253Xq1JHNZlPjxo1VsWJF+3jNmjXl4+Ojw4cP51tv27ZtValSJYex/v3768KFC9q+ffs1e27cuLEkaejQodqyZYuys7Ov+ZrCvv/17JfAwECn9t62bVsFBATYn3t6eqphw4YOP/f169dLUr7LzatXr65WrVrZlzvbr7/+qoceekhhYWEqV66cw6m/Q4cOSZICAgI0cOBALVmyROnp6ZL+OK04f/58devWTdWrV5ckffvtt5KkPn36OLzHnXfeqbCwsHzvvWLFCmVnZ1/zkZyc7NRtjoqK0tChQ1WjRg1VqVJFDzzwgD799FPFxMRoxowZDrUTJkzQhAkTNGvWLJ0+fVrHjx/X2LFjdf/992vevHn2ukaNGmnAgAF677339K9//UsXLlzQr7/+qocffth+Ss7Nza3Q60XZQ3ACJH3zzTc6evSoZs2a5TAZdcCAAfZQdaNOnjwp6Y85K+XKlZPNZpO3t7e8vb316quvKisrS6mpqfb6qlWr5ltHhQoVChz38/Mr8MMrODg431hISIgk6cyZM9fsuWvXrvrggw+0f/9+tWvXTgEBAerWrZu++OKLa77W6vsXdr9Uq1bN0nsXpveC9qm/v7/OnTtnf3727Nkr1oaEhCghIcFSX4Vx6tQptW7dWidOnNCKFSt0+vRpZWRkaNeuXZLkMP9u5MiRSklJ0bJlyyT9EfRiYmIcbouQt88L+rkUNJZ3pd+1HpdP2i4K99xzj4KCgrR161b72MGDB/X666/rscce0+OPP66goCBVq1ZNL774ojp37qxx48Y53AZh8eLFeuqpp/T888/L399fkZGR6tChg4YMGSIvLy8FBQVd13pRthCcAElz585Vjx49lJmZme8S6Ndff13z58+/4cv1846S7Nq1S+fPn9eFCxeUlpamtLQ0ZWZmKjs72+EI06V//V7qSuOmgMu9T58+nW8s75JuK0dtJGnUqFHau3ev4uPjNX/+fKWnp6tHjx7asGHDNV9r5f0Lu1+8vLws9V2Y3q3s07wjZwVdEn/q1CnL+7Mw1qxZo6SkJM2ePVt33XWX/P395enpqdjY2Hy17dq1U7169ewhf968eQoKCnI4upS3DQX9XAoaGzBggKXgdOkR0KLk5ubm8DM5cOCAjDFq0qRJvtqmTZvq/PnzDvvKZrNp+vTpiomJUU5Ojk6dOqWoqCj9/PPPatmypby9va9rvShbCE4o8xISErR69Wp17969wA+FHj16KC4uTuvWrbO/xtfX1+Gv/UtdaVmPHj3k5uamlStXXvEDyNm2bt2a70jUmjVrVL58ebVs2fKaPV8qJCREgwYN0qeffipJ2rx5s1Pe/2bsl+vp/XIdO3aUJK1evdph/OTJk4qOjrYvl6ztTyvyQsKlp48l6V//+leB9SNGjNDmzZu1Y8cOrV69WkOHDnUImh06dJCkfEfdfvnllwKDQE5OjqXHxYsXb2g7rdixY4dOnz6tVq1a2cfyTi/u3bs3X/0vv/wiLy8v+xHOK9m2bZt+/PFHjR071qnrRSnmqslVQHHx6quvGknmt99+u2JNrVq1TK9evezPe/fuberWrVvgRNWrLZs4caLx9vY2r7zyijl+/LjJzMw0Bw4cMG+99ZZ5/PHH7XUBAQH5JvoaY0xgYKAZOXJkvvGCJiMHBASYzp07m/vuu88cPnzYJCcnm7feest4eHiYKVOmWOr5pZdeMpMnTzZ79uwxGRkZJjEx0bzwwgtGkvnmm28K3lnX8f43ul8KYrX3K62zb9++pn79+g5jgwcPNj4+PmbRokUmNTXV7Nu3z7Rp08YEBASYgwcP2uuu9jtwuatNDj906JApV66cuf/++83p06fN6dOnzZQpU0z//v2NJPPBBx841J88edJ4enqamjVrGklm7969+dbZr18/c8stt5jVq1ebCxcumB9//NH07t3bNG3aNN/k8JycHPsVfVd7XO2qwWtNDh80aJDx8PCwT/jft2+fGTx4sNm8ebNJTEw0KSkpZs2aNaZGjRqmatWq5vjx4w6v79Kli/H29jbz5883KSkp5syZM2b69OlGkhk3bpxD7Ysvvmg+/vhjk5iYaNLS0syKFStMSEiIefTRR/P1VZj15mFyeNlAcEKZ16BBA1OnTp2r1jz++OPGw8PD/o/2vn37TMuWLY23t7fx8PBw+MC52jJjjPnkk0/MPffcY3x9fY3NZjP169c348ePN7///ru9xlnB6bHHHjMbNmwwTZo0MZ6eniYsLMy88sor+V5/pZ4TEhLMtGnTTOPGjY3NZjMVK1Y0kZGRZs2aNVfdX4V9/xvdLwWx2nthglNWVpaZOnWqqVOnjnF3dzf+/v6mX79+Zt++fQ511/oduNS1rqr74osvTLNmzYy3t7cJCQkxkyZNMr/++muBwSmvb0mmVatWBa4vLS3N/OUvfzGVKlUy3t7epn379ubAgQPmrrvuMh07drxin4WxYMEC+60K8q5Yy3seGRnpUDtgwAAjyX47jZycHLNixQrTuXNnExgYaDw8PEyNGjXM6NGjTVxcXL73unDhgnn55ZfN7bffbnx8fIy/v79p3ry5mTt3rsnJyXGojYmJMcOGDTNBQUHGZrOZ8PBwM2/ePJObm3tD681DcCob3IwpxH3wgVLo4sWLcnd3v+pXXZj/fZ+Yh4dHvvkweXOfCpoge7VlV5OTkyM3N7d8PRVmvGLFinrggQc0Z86cQr/39fR8uet9/6u50vYXxTpzc3NljLnh/XCt/Xnx4kV5eXlp8uTJmjJliuX1Xrx4scDfx7zf1Wv9Tl8uNDRUHTp00OLFiy2/5kryeiiIm5ubw77Izc1Vbm5uqfjKkgYNGqhBgwZatWqVq1tBEWKOE8o8K98P5ubmJk9PzwInEXt4eFzxQ/Fqy67Gw8OjwJ4KO349rrfnm8GZ23mtdbq7uztlP1jdny+++KI8PT2veif0S13p9zHvd7Uw+yk6Olrx8fFX/WLrwsjrwcoVeHlX7pVkzZo1k6enpw4cOODqVnATlOzfVgAo4Tw9PR3uMVXUX/L78ccfKykpSX379lWlSpUUHR2txx57THXr1tXDDz9cpO9dWu3cudM+kb80fEkzro6fMAC42KVHZIr6g7dHjx767bff1K5dO/n7+2vw4MFq1aqVNm3aJF9f3yJ979LKw8Pjpv384HrMcQJKqaKYD1SS3h8AigLBCQAAwCL+FAQAALCIyeFOlJubq7i4OPn5+V3xKxwAAEDxYoxRamqqQkNDrzm9gODkRHFxcQV+wzgAACj+YmNjVb169avWEJycyM/PT9IfO/7SLyUFAADFV0pKisLCwuyf41dDcHKivNNz/v7+BCcAAEoYK9NsmBwOAABgEcEJAADAIoITAACARQQnAAAAiwhOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACwiOAEAAFjk6eoGYF2tZ9e5uoUidXRGT1e3AADAVXHECQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACwiOAEAAFhEcAIAALCI4AQAAGARwQkAAMAighMAAIBFLg1Ou3bt0vDhwxUREaHOnTtr5syZyszMdKhJTU3VM888o/DwcLVp00ZvvfWWcnNzXVYDAADKLpd9V92+ffs0fvx4/fnPf9Zf//pXHTp0SE899ZR++uknzZ8/317Xv39/JSQk6LXXXlNSUpIee+wxJSQkaNq0aS6pAQAAZZfLglO9evW0adMm+/M777xTMTExmj59un1s8+bNWr9+vX7++Wc1btxYknTmzBk99dRTmjBhgvz9/W9qDQAAKNtcdqrO09Mxs6WlpWn9+vVq3bq1fWzjxo0KDQ21BxlJ6tmzpzIyMhQdHX3TawAAQNnm8snhI0aMUL169RQUFCRjjJYuXWpfFhsbq6pVqzrUh4SESJKOHz9+02sul5mZqZSUFIcHAAAovVwenKZOnarly5dr7ty52r9/v5566in7spycHHl7ezvUe3l5yd3dXRcvXrzpNZeLiopSQECA/REWFnYdewAAAJQULg9OYWFhaty4sR588EH985//1AcffKCYmBhJUmBgoM6cOeNQn5iYqNzcXAUGBt70mstNnDhRycnJ9kdsbOx17gUAAFASuDw4XapixYqS/rgtgCTdddddOnLkiBISEuw127ZtkyRFRETc9JrL2Ww2+fv7OzwAAEDp5WaMMa5446VLlyo4OFjt27eXm5ubTp8+rSFDhigmJkb79++Xu7u70tLSdNttt6lXr16aPXu20tLS1LlzZ1WqVElffPGFJN3UmmtJSUlRQECAkpOTiyRE1Xp2ndPXWZwcndHT1S0AAMqgwnx+u+yIU3h4uGbOnKmKFSuqRo0aqlGjhipUqKAvvvhC7u5/tOXj46PVq1dr48aNCgwMVFBQkHx8fBzu83QzawAAQNnmsiNOeTIyMpSQkKCqVavmu0XBpWJjY2Wz2VSlSpViUVMQjjjdGI44AQBcoTCf3y67AWaecuXKWboarbjVAACAsqdYTQ4HAAAozghOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACwiOAEAAFhEcAIAALCI4AQAAGARwQkAAMAighMAAIBFBCcAAACLCE4AAAAWEZwAAAAsIjgBAABYRHACAACwiOAEAABgEcEJAADAIoITAACARQQnAAAAiwhOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACwiOAEAAFhEcAIAALCI4AQAAGARwQkAAMAighMAAIBFBCcAAACLCE4AAAAWEZwAAAAsIjgBAABY5LLgZIzRqlWrdP/99ys8PFz9+vXTunXrHGrS0tLUoEGDfI+VK1c61KWmpuqZZ55ReHi42rRpo7feeku5ublFUgMAAMouT1e98axZs7Rp0yYNGTJEtWvX1pYtW9SvXz998MEHGjZsmCQpNzdXBw4c0NKlS9W0aVP7a6tWreqwrv79+yshIUGvvfaakpKS9NhjjykhIUHTpk1zeg0AACi73IwxxhVvnJWVJW9vb4exUaNGac+ePfruu+8kSefPn5efn5+2b9+uli1bFriezZs3KzIyUj///LMaN24sSXr33Xf11FNP6dSpU/L393dazbWkpKQoICBAycnJluoLq9az665dVIIdndHT1S0AAMqgwnx+u+xU3eWhSZLc3Qtu54knntCdd96pgQMH6ptvvnFYtnHjRoWGhtrDjiT17NlTGRkZio6OdmoNAAAo24rN5PDffvtNixcv1v333+8w3r59e73wwguaM2eOGjVqpB49eujDDz+0L4+Njc136i4kJESSdPz4cafWXC4zM1MpKSkODwAAUHq5bI7TpU6fPq1evXqpbdu2Gj9+vH3c19dXGzZssB+JatGihVJTUzVx4kSNGDFCkpSTk5Pv6JWXl5fc3d118eJFp9ZcLioqSlOnTr2BLQcAACWJy484JSQkqFOnTgoLC9PKlSvl4eFhX+bm5pbv9F27du10+vRpnTlzRpIUGBho/+88iYmJys3NVWBgoFNrLjdx4kQlJyfbH7GxsdexBwAAQEnh0uB05swZderUSZUrV9Znn32m8uXLX/M1MTEx8vT0lI+PjyTprrvu0pEjR5SQkGCv2bZtmyQpIiLCqTWXs9ls8vf3d3gAAIDSy2XBKTEx0R6a1q1bZw9Cl/r000+1fv165V349+OPPyoqKkr333+/vb53794KDg7WpEmTlJOTo9TUVL300kvq3r27atas6dQaAABQtrksOL3xxhv6+eefdeTIETVv3tx+c8u7777bXhMeHq63335bFStWVGhoqFq3bq2BAwfq/ffft9f4+Pho9erV2rhxowIDAxUUFCQfHx/Nnz/f6TUAAKBsc9l9nBISEnT27Nl84x4eHrrtttscxtLT05WYmKjQ0FC5ubldcZ2xsbGy2WyqUqVKkdcUhPs43Rju4wQAcIXCfH677Kq6oKAgBQUFWaotX768qlWrds26sLCwm1YDAADKHpdfVQcAAFBSEJwAAAAsIjgBAABYRHACAACwiOAEAABgEcEJAADAIoITAACARQQnAAAAiwhOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACwiOAEAAFhEcAIAALCI4AQAAGARwQkAAMAighMAAIBFBCcAAACLCE4AAAAWEZwAAAAsIjgBAABYRHACAACwiOAEAABgEcEJAADAIoITAACARQQnAAAAiwhOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACwiOAEAAFhEcAIAALDIpcFp7dq1evDBB9WiRQsNHDhQX331Vb6a8+fP67nnnlOLFi0UGRmp2bNnyxjjshoAAFB2ebrqjWfNmqX169dryJAhql27trZs2aJevXrpww8/1J/+9Cd73YABAxQfH69XXnlFSUlJevzxx3Xq1ClNnTrVJTUAAKDscjMuOqSSmZkpm83mMDZixAjt27dP0dHRkqQtW7aoXbt2+vHHH9W0aVNJ0uzZs/W3v/1Np06dkp+f302tuZaUlBQFBAQoOTlZ/v7+TttXeWo9u87p6yxOjs7o6eoWAABlUGE+v112qu7y0CRJnp6eys3NtT/fuHGjQkND7UFGknr27Kn09HR7uLqZNQAAoGwrNpPDDx48qMWLF2vgwIH2sdjYWFWtWtWhLu95bGzsTa+5XGZmplJSUhweAACg9CoWwSkhIUF9+vRR69at9fTTT9vHL168KG9vb4daLy8vubu7Kzs7+6bXXC4qKkoBAQH2R1hY2HVsPQAAKClcHpzOnj2rzp07Kzg4WKtXr5aHh4d9WWBgoM6ePetQn5SUpNzcXFWuXPmm11xu4sSJSk5Otj+udGQKAACUDoUOTt9995127drllDdPTExUp06dVLFiRa1bt04+Pj4Oy8PDw3X48GGdOXPGPrZt2zb7sptdczmbzSZ/f3+HBwAAKL0KHZz27Nmj8PBwNWvWTG+//bYSExOv642TkpLUuXNnBQQE6PPPP5evr2++mj59+igoKEiTJ09Wbm6uLly4oOnTp6tr166qVavWTa8BAABlW6GD06hRo3TgwAF1795dUVFRCg0N1eDBg/XVV185XBF3La+//rp2796t48ePq0WLFmrUqJEaNWqk1q1b22t8fX21evVqffnllwoKClJQUJA8PT21YMECl9QAAICy7Ybu45STk6MvvvhCH330kT777DOFhIRo2LBhGjlypGrWrHnV1546dUoJCQn5xj08PNSwYUOHMWOMjh49KpvNptDQ0ALXdzNrroT7ON0Y7uMEAHCFwnx+39Cdwz08PNS1a1dlZGQoLi5O0dHRmjdvnl5++WWNGDFCb7/9doH3a5Kk4OBgBQcHW3ofNzc31a5du9jUAACAsum6r6r76aefNHbsWIWGhmr06NFq2bKl9u7dqxMnTmjz5s3atGmTPvroI2f2CgAA4FKFPuK0detWjR07Vrt371bHjh31zjvvqH///g73QGrdurWGDx+uw4cPO7VZAAAAVyp0cPr999/VvXt3LVu27KqntIYPH37FG0cCAACURIUOTn/6058s1VmdvwQAAFBSXNccp+XLl+vHH390GDt06BCX7gMAgFKt0MHp8OHDeuGFF3T77bc7jN96662aM2eOvv/+e6c1BwAAUJwUOjh9++23at26db4vxHVzc1Pnzp319ddfO605AACA4qTQwclms13xy2xjYmIcvqQXAACgNCl0cOrSpYv+85//aM6cOQ5fsbJ06VItWbJEPXty92cAAFA6FTo4Va1aVe+9957++te/KigoSM2aNVNwcLCGDBmiqKgoNW7cuCj6BAAAcLnr+sqVRx55RJGRkVq9erVOnjypypUrq1evXqpfv76z+wMAACg2rvu76mrVqqWxY8c6sxcAAIBi7bqCkzFG0dHR+v3335WVleWwrFGjRoqIiHBKcwAAAMVJoYNTdna2unTpos2bNysoKEheXl4Oy0ePHk1wAgAApVKhg9PatWsVExOjY8eOKSwsrCh6AgAAKJYKfVXd6dOn1b17d0ITAAAocwodnJo2baq9e/cWRS8AAADFWqFP1dWsWVMZGRl69NFHNWjQIPn5+TksDw0NVY0aNZzWIAAAQHFR6OC0ePFi7dixQzt27NDcuXPzLX/66af12muvOaU5AACA4qTQwWns2LEaPXr0FZdf/uW/AAAApUWhg5OXl1e+WxAAAACUBdd95/D169dr27Ztatasmfr06aP4+HidO3dODRs2dGZ/AAAAxUahr6qT/rjJ5cCBA7VgwQJt3rxZkuTh4aG+ffvqwoULTm0QAACguCh0cPrhhx+0Zs0aHThwQE888YR9vEqVKmrZsqU+/fRTpzYIAABQXBQ6OO3cuVO9e/dWcHCw3NzcHJbdeuutOnjwoNOaAwAAKE4KHZy8vb2VnJxc4LK9e/eqcuXKN9wUAABAcVTo4NS1a1d9+eWXio6Oth9xMsbovffe08qVK9W7d2+nNwkAAFAcFPqqumrVqumdd95R+/btVb58eXl7e2vevHlKSUnRrFmzdNtttxVFnwAAAC53XbcjePjhh9W+fXutWrVKJ06cUGBgoHr37q369es7uz8AAIBi47rv41S9enWNGTPGmb0AAAAUa4UOTkeOHNG+ffuuuPzWW2/lJpgAAKBUKnRwWrNmjZ599lmHsezsbOXm5srDw0MTJkxQVFSU0xoEAAAoLgp9Vd24ceOUkZHh8EhPT9fKlStVv359Pffcc0XRJwAAgMtd11euXM7b21v9+vVTZGSkli1b5oxVAgAAFDtOCU55KlWqpGPHjjlzlQAAAMVGoec4nTt3TmfOnHEYy8nJ0Z49e/T+++9r9uzZTmsOAACgOCl0cJo7d64mTJiQb9zLy0ujR4/WgAEDnNIYAABAcVPo4PTnP/9ZAwcOdFyJp6dCQkLk6Xndt4UCAAAo9gqddPz9/eXv718UvQAAABRrTr8B5qW4GSYAAChNCh2c1q5dqwkTJigrK+uPFXh66uLFi5L+mOfk7e1trx07dqymT5/upFYBAABcq9C3I3j00UdVv359TZ48WSdPnlR2drbOnj2rmTNnKiwsTDExMTp//rzOnz9PaAIAAKVKoYPT+vXrVbt2bU2ZMkXBwcGS/rh/07hx49S5c2etWLHC6U0CAAAUB4UOTseOHbvi5HB/f39ugAkAAEqtQgeniIgILV++XGvXrnUY37Jli+bOnauIiAjL60pKStKbb76pVq1aaciQIfmWp6enq1mzZvkea9ascahLS0vTCy+8oDZt2qhTp056//33ZYwpkhoAAFB2FXpyeMuWLfX3v/9d9913n6pUqaLQ0FAlJCQoNjZWY8aMUd++fS2tJysrS40aNdKAAQMUEhKiAwcO5KvJycnRTz/9pIULF6px48b28Ro1ajjUDRw4UMeOHdM//vEPJSUlacyYMTp58qReeOEFp9cAAICy67ruWDl58mQNHTpUX331lU6cOKGQkBB17NixULce8PLy0qFDh1S+fHmNGzdOsbGxV6y97bbb1KxZswKX/fe//9UXX3yh3bt322uSk5P1zDPP6KmnnlKFChWcVgMAAMq26/6S39q1a2v06NGaNm2annzyyULfr8nNzU3ly5e3VDt+/Hi1atVKDz/8sLZs2eKwbMOGDapatapDsOrVq5fS09O1fft2p9YAAICy7bqD0/r16/Xiiy/a5xvFx8dr//79TmssT+vWrTV27FjNmDFD1atXV8eOHbVo0SL78tjYWFWtWtXhNaGhofZlzqy5XGZmplJSUhweAACg9LquU3WjR4/W0qVLFRgYqJSUFPXp00ceHh7q27evdu/eLV9fX6c05+Pjo82bN8vDw0OSFBkZqfT0dE2YMEEPP/ywJCk7O1s2m83hdV5eXnJ3d1d2drZTay4XFRWlqVOn3viGAgCAEqHQR5x++OEHrVmzRgcOHNATTzxhH69SpYpatmypTz/91HnNubvbQ1OeDh066OTJkzpz5owkKTAwUGfPnnWoSUpKUm5urgIDA51ac7mJEycqOTnZ/rjaPC0AAFDyFTo47dy5U71791ZwcLDc3Nwclt166606ePCg05oryIkTJ+Th4WGfHxUeHq7Dhw87hJ68OUnh4eFOrbmczWazf+kxX34MAEDpV+jg5O3treTk5AKX7d27V5UrV77hpvKsWLFCW7dutT/ft2+fZsyYofvuu89+OrBPnz6qXLmypk6dKmOM0tPT9fLLL6tTp06qXbu2U2sAAEDZVujg1LVrV3355ZeKjo62H3Eyxui9997TypUr1bt3b8vrGjhwoJo1a6bFixdr37599htcpqenS5LuuOMOTZs2TZUrV1adOnV055136t5779XcuXPt66hQoYJWrlypNWvWKDg4WFWqVFFubq4WLlzo9BoAAFC2uZnruDX2okWLNGrUKJUvX17e3t7KyspSSkqKZs2apTFjxlhez4EDB+wh6VJNmjSRu/v/z3TJyck6c+aMatSoIS8vrwLXlZubq8OHD8tms+W7Qaaza64kJSVFAQEBSk5OLpLTdrWeXef0dRYnR2f0dHULAIAyqDCf39cVnCTp+PHjWrVqlU6cOKHAwED17t1b9evXv66GSwuC040hOAEAXKEwn9+Fvh3Bp59+qrNnz+rxxx8v1NElAACAkq7Qc5zOnTunn376qSh6AQAAKNYKHZw6duyojRs3XvHKOgAAgNKq0Kfq4uPj5e3trfr166tnz54KCgpyWN6uXTv16NHDaQ0CAAAUF4UOTidPnlRwcLCCg4N17NgxHTt2zGF5nTp1nNYcAABAcWI5OMXGxiorK0v333+/7r///qLsCQAAoFiyPMfpk08+0bvvvmt/vnDhQs2cObNImgIAACiOCn2qLs/p06d18uRJZ/YCAABQrBX6qjoAAICyiuAEAABgUaFO1S1dulTR0dGSpBMnTig7O9v+PM+DDz6oJ5980nkdAgAAFBOWg1OTJk3UvXt3+/MGDRoUWFelSpUb7woAAKAYshycunbtqq5duxZlLwAAAMUac5wAAAAsIjgBAABYRHACAACwiOAEAABgEcEJAADAIoITAACARQQnAAAAiwhOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACzydHUDQJ5az65zdQtF6uiMnq5uAQBwgzjiBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACwiOAEAAFhEcAIAALCI4AQAAGARwQkAAMAighMAAIBFBCcAAACLCE4AAAAWuTQ4JScn65133lHbtm01dOjQAmvS09P14osvKjIyUt26ddOHH37o0hoAAFB2ebrqjbOystSwYUP169dPgYGB2rdvX4F1gwYN0qFDhxQVFaWkpCSNHTtW8fHxev75511SAwAAyi6XBScvLy8dPHhQvr6+GjdunI4fP56vZtu2bVq7dq127typ5s2bS5JSU1M1ceJEjRs3Tr6+vje1BgAAlG0uO1Xn5uZ2zTCyYcMGhYSE2IOMJPXu3VtpaWnavn37Ta8BAABlm8uOOFkRExOj0NBQh7Fq1arZl93smstlZmYqMzPT/jwlJcXilgEAgJKoWF9Vl52dLZvN5jDm5eUld3d3ZWdn3/Say0VFRSkgIMD+CAsLu/6NBQAAxV6xDk6BgYE6e/asw1hSUpJyc3MVGBh402suN3HiRCUnJ9sfsbGx17+xAACg2CvWwal58+Y6cuSIEhMT7WPfffedfdnNrrmczWaTv7+/wwMAAJRexTo49enTR5UqVdK0adMk/TGnKCoqSh06dFCdOnVueg0AACjbXBqcHnjgAUVERGjJkiXav3+/IiIiFBERofT0dEmSn5+fli9frmXLlik0NFRVqlRRenq6Fi5caF/HzawBAABlm5sxxrjqzffu3WsPSZdq3ry53N3/f6bLycnRb7/9JpvNdsWjPzez5kpSUlIUEBCg5OTkIjltV+vZdU5fJ26eozN6uroFAEABCvP57dLbEdxxxx2W6jw8PNSwYcNiUwMAAMqmYj3HCQAAoDghOAEAAFhEcAIAALCI4AQAAGARwQkAAMAighMAAIBFBCcAAACLCE4AAAAWEZwAAAAsIjgBAABYRHACAACwiOAEAABgEcEJAADAIoITAACARQQnAAAAiwhOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACwiOAEAAFhEcAIAALCI4AQAAGARwQkAAMAighMAAIBFBCcAAACLCE4AAAAWEZwAAAAsIjgBAABYRHACAACwiOAEAABgEcEJAADAIoITAACARQQnAAAAiwhOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYJGnqxu4mvT0dLVt2zbf+JQpU9SrVy+HuldffVUbNmxQuXLlNHjwYI0YMSLfupxRAwAAyq5iHZxycnK0c+dOffTRR2rUqJF9vHbt2g51gwYN0qFDhxQVFaWkpCSNHTtW8fHxev75551eAwAAyq5iHZzyNGjQQBEREQUu27Ztm9auXaudO3eqefPmkqTU1FRNnDhR48aNk6+vr9NqAABA2VYi5jj97W9/U9u2bTVs2DBt27bNYdmGDRsUEhJiDzuS1Lt3b6WlpWn79u1OrQEAAGVbsQ9OLVq00OjRozVlyhRVrlxZkZGRWrJkiX15TEyMQkNDHV5TrVo1+zJn1lwuMzNTKSkpDg8AAFB6FetTdT4+Ptq6das8Pf9os1OnTsrMzNTTTz+tBx98UJKUnZ0tm83m8DovLy+5u7srOzvbqTWXi4qK0tSpU298QwEAQIlQrI84ubu720NTnk6dOik+Pl5nz56VJAUGBtr/O09SUpJyc3MVGBjo1JrLTZw4UcnJyfZHbGzs9W8sAAAo9op1cCpIXFycPDw8VK5cOUlS8+bNdeTIESUmJtprvvvuO/syZ9Zczmazyd/f3+EBAABKr2IdnFatWqXo6Gj78wMHDmjGjBnq27ev/Sq3Pn36qFKlSpo2bZqkP+YdRUVFqUOHDqpTp45TawAAQNlWrINT/fr19fzzzys4OFj16tVTkyZN1LlzZ82bN89e4+fnp+XLl2vZsmUKDQ1VlSpVlJ6eroULFzq9BgAAlG1uxhjj6iauJTExUQkJCapVq1a+Cdx5cnJy9Ntvv8lms13xCJGzaq4kJSVFAQEBSk5OLpLTdrWeXef0deLmOTqjp6tbAAAUoDCf38X6qro8lSpVUqVKla5a4+HhoYYNG96UGgAAUDaViOAElAZl4YghR9UAlHbFeo4TAABAcUJwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACwiOAEAAFhEcAIAALCI4AQAAGARwQkAAMAighMAAIBFBCcAAACLCE4AAAAWEZwAAAAsIjgBAABYRHACAACwiOAEAABgEcEJAADAIoITAACARQQnAAAAiwhOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIs8Xd0AgNKj1rPrXN1CkTo6o6erWwDgYhxxAgAAsIjgBAAAYBHBCQAAwCKCEwAAgEUEJwAAAIsITgAAABYRnAAAACwiOAEAAFhEcAIAALCI4AQAAGARwQkAAMAivqsOACwq7d/FJ/F9fMC1cMTpEhkZGXr55ZfVqVMn9ezZUwsXLnR1SwAAoBjhiNMlHnjgAe3fv1/Tp09XUlKSnnzyScXFxenZZ591dWsAAKAYIDj9z/bt27V69Wp9//33ioiIkCRduHBBkyZN0l/+8hf5+vq6uEMAKHql/XQkpyJxozhV9z8bNmxQSEiIPTRJUt++fXXhwgVFR0e7sDMAAFBccMTpf44dO6bQ0FCHsWrVqtmXFSQzM1OZmZn258nJyZKklJSUIukxNzOtSNYLAGVFjfH/dnULReqXqd1c3UKJlPe5bYy5Zi3B6X+ys7Nls9kcxry8vOTu7q7s7OwCXxMVFaWpU6fmGw8LCyuSHgEAuJqAN13dQcmWmpqqgICAq9YQnP6nUqVKSkxMdBg7d+6ccnNzFRgYWOBrJk6cqKeeesr+PDc3V4mJiQoMDJSbm1uR9lvUUlJSFBYWptjYWPn7+7u6Hacr7dsnlf5tZPtKvtK+jWxfyWGMUWpqar4zTwUhOP1P8+bN9fbbbyspKUm33HKLJOm7776TJN15550FvsZms+U7SlWxYsUi7fNm8/f3L/H/Q1xNad8+qfRvI9tX8pX2bWT7SoZrHWnKw+Tw/+nbt68qVqyo6dOnS5KysrI0Y8YMRUZG6tZbb3VxdwAAoDggOP2Pn5+fli9fro8//lhhYWEKCQlRcnIyN8EEAAB2nKq7RLt27RQTE6P9+/fLZrOpXr16rm7JZWw2myZPnpzvVGRpUdq3Tyr928j2lXylfRvZvtLJzVi59g4AAACcqgMAALCK4AQAAGARwQkAAMAiJofDQd6VhMuWLdMdd9yh2bNnu7olp4qJidG7776rXbt2yc/PT926ddPw4cPl6Vl6/lf4/PPP9cknnyg2Nla1atXSqFGj1Lp1a1e35XQ5OTkaMmSIjh49qk8++UQ1a9Z0dUtOMWXKFH355ZcOY40aNdLcuXNd1FHRWLVqlT7++GMlJSWpS5cuGj9+vLy8vFzd1g37/vvv9Ze//KXAZTNnzlSrVq1uckfOl5ubq3/961/67LPPdPbsWVWvXl3Dhw9Xx44dXd3aTVF6Pi1ww5KTk9WwYUPdd999KleunPbt2+fqlpzq6NGj6tKli0aNGqWnn35a8fHxeu6557Rp0yYtWrTI1e05xRtvvKHo6Gj169dPISEh+vrrr9WuXTutXbtW3bt3d3V7TvXCCy9o7969+uWXX5Senu7qdpzm0KFDCgwM1P/93//Zx/z8/FzYkfM988wzmjt3rqZNm6ZGjRppw4YNmjp1ql566SVXt3bD6tevrzfffNNh7N1339WyZct0++23u6YpJ5syZYreeustvfrqq7rtttu0ceNGdenSRWvWrFHPnj1d3V6R46o62F28eFGZmZny9fXVqFGjdOjQIf3nP/9xdVtOk5mZKXd3d4e/alesWKEBAwbo1KlTqlKligu7c460tDT5+Pg4jLVp00YNGzYsVUcsvv32Wz366KN699131a1bN+3fv18NGjRwdVtO8fDDD8vT01Pz5893dStFYvv27WrdurW+/PJLdev2/7+QNiMjQ+XKlXNhZ0XDGKO6deuqXbt2+uijj1zdjlM0adJEnTp10syZM+1jLVu2VJMmTfT++++7sLObgzlOsPP09JSvr6+r2ygyNpst36mAChUqSPrjTvGlweWhKS4uTocOHVLTpk1d1JHzJSQk6JFHHtGCBQtKxdc8FGTz5s3q0KGDBgwYoHfeeUcXL150dUtOs2jRItWpU8chNEkqlaFJkjZu3KgjR47o0UcfdXUrThMREaGdO3cqMzNTkhQfH6/Dhw/r7rvvdnFnNwfBCWVWbm6uZsyYofDwcFWvXt3V7ThNenq6WrZsqWbNmqlevXr6y1/+ojFjxri6LacwxuiRRx7RsGHDdM8997i6nSLh5+enoUOH6rnnnlP37t31yiuv6N5771VpOTmwb98+RUREaMGCBeratav69OmjmTNnlpo/Xi43b9483X777aVqnuHs2bNVt25dVatWTc2aNVODBg303HPPadSoUa5u7aZgjhPKrPHjx2v37t3atm2bq1txKpvNpjfffFPnz5/X119/rRkzZqhFixbq0qWLq1u7Ya+//rrOnj2ryZMnu7qVIvPmm2863Ik57xTIunXr1KtXLxd25hwZGRn66quvlJaWpqefflqJiYn2uYarVq1ydXtOde7cOa1YsUJRUVGubsWp5s2bp9WrV+ull15S/fr1tWnTJk2dOlV33XVXqf2DxoEBCjBy5EgTGRnp6jaKzDPPPGP8/f3Nd9995+pWitzDDz9s7r77ble34RSNGjUyt956q2nRooVp0aKFueOOO4wk07RpU/Pyyy+7ur0iExwcbF566SVXt+EUPXr0MH5+fiY9Pd0+tnbtWiPJHDt2zIWdOd8777xjbDabOXPmjKtbcZqsrCxTvnx5M3PmTIfxwYMHm7Zt27qmqZuMI04oc5577jnNmTNHX3/9dZk4J1+1atVSc1Rt8eLFSktLsz/fu3evRo0apYkTJ+quu+5yYWdFJzMzU0lJSaVm/mFERIR++eUXhzlNVatWlSQlJSWpRo0armrN6ebNm6f+/fsrMDDQ1a04TUZGhtLT01WtWjWH8dDQUP3yyy8u6urmYo4TypRJkybpn//8p77++mu1aNHC1e043axZs5SYmGh/fuDAAS1atEj33nuvC7tyniZNmqhly5b2xx133CFJatq0qerUqePi7m5ccnKy3nzzTftk8KysLI0bN07u7u7q16+fa5tzkkceeUSnTp3SZ599JumPuYZz5sxRaGioGjZs6OLunGfXrl3avXt3qZoULv0xB69Zs2b64IMP7H/ExMXFadmyZWrbtq2Lu7s5OOIEB/fdd5/i4+N15MgRZWRkqGXLlpKk6OhoF3d243bt2qXp06eratWqGjt2rMOy2bNnq3nz5i7qzHkqV66s5s2bq1y5cjLGKDY2Vo888oheeeUVV7cGC3x9fRUfH6/g4GCFhobqxIkTCg4O1ueff65atWq5uj2nqFOnjj7++GMNHz5cQUFBSk5Olr+/v1asWCFvb29Xt+c08+bNU926ddW+fXtXt+J0ixYt0p/+9CdVq1ZNNWrU0MGDB9W5c2fNmDHD1a3dFNzHCQ52795tv8T0UnkBqiQ7f/78FQ8l33777aXm0nZjjA4fPqycnBzVrFmz1F7mLf3/n2mzZs1K1XZmZmbq4MGDCgwMtJ/GKm0yMzP166+/KiAgQDVq1JC7e+k6AbJnzx75+vqWiiOhVxIXF6eEhASFhYWpUqVKrm7npiE4AQAAWFS6Ij4AAEARIjgBAABYRHACAACwiOAEAABgEcEJAADAIoITAACARQQnAAAAiwhOAEqsDRs2aMWKFQUu2759u77//vtrjrlacewJwJXxlSsASqRz586pV69eysjI0A8//KDw8HCH5bNmzVKFChUcvvy3oDFXK449AbgyghOAEmnRokWqWbOm6tWrp7lz5zoEp127dikmJkblypXT0qVLJUkhISH5xrp166ZbbrlF0h9fN3Ts2DHVrFlTzZo1k5ubm319W7dulY+Pj+rWravdu3crLS1NkZGR8vHx0blz57Rt2zb5+PiodevWDt+3lve6W2+9Vbt371ZGRoYiIyNVvnz5K/aZ19Phw4e1b98+hYSE6M4775SnJ/9cA8UB/ycCKJHmzZunRx99VA0aNNCQIUP0+uuvy8fHR5L0008/6cSJE/L09NSqVaskSc2bN883dvfdd8sYo/vuu08xMTFq0qSJfvnlF1WrVk2rV6+2h6rXXntNMTExOnPmjBo3bqz9+/crJydHU6dO1ZQpU9SoUSPt2bNHoaGh2rJliz3kvPbaa4qLi9OpU6fUoEED+3cIbty4UbVq1Sqwz7vvvlsvv/yyPvjgA7Vt21Znz55Vdna2Vq1apWrVqt3UfQygAAYASpgffvjBeHt7m4SEBJOTk2Nq1KhhFixY4FAzePBgM3LkyGuODRo0yAwePNhcvHjRGGNMVlaW6dKli3nyySftNX379jUVK1Y0MTExxhhjzp8/bwIDA03lypVNXFycMcaYxMREU6FCBbN8+XKH13l4eJgffvjBvu4OHTqY/v37X7Gnc+fOGTc3N7Njxw772M8//2wOHjxY+B0FwOk44gSgxJk7d67uu+8+Va5cWZI0YsQIzZ07V0OHDi3UelJTU7V8+XJNmjRJK1eulDFGxhjVrFlTGzdudKjt0aOHwsLCJEm+vr5q3Lix6tSpo6pVq0qSbrnlFjVo0EC//fabw+s6dOhgP43o5eWl8ePHq1+/fsrKynI4rZfHw8NDXl5e+vnnnxURESE3Nzc1bty4UNsFoOgQnACUKOnp6VqyZImGDx9unxdUoUIFbdmyRb/99pvq1atneV2xsbHKycnR999/r19//dVhWZs2bRye5522y2Oz2Qocy8jIcBirVauWw/PatWsrNzdXx48fV506dfL1VKFCBX300Ud69tlnNWnSJLVv315DhgxRr169LG8XgKJDcAJQovz73/+WzWZTfHy8fV6QJNWvX1/z5s3TP/7xD8vr8vf3lySNHTtWXbt2dXarkqSkpKQCn+cdLSvIQw89pIceekj79+/X2rVrNXjwYL399tsaMWJEkfQIwDqCE4ASZe7cuRo+fLhmzJjhML5kyRKNHz9e06dPl6enpypUqJDv6M/lY9WrV9cdd9yhOXPm5AtOJ06ccMpk7A0bNig1NVV+fn6SpBUrVqhRo0b20HZ5T6mpqZIkPz8/NWzYUA0bNtTWrVsVHR1NcAKKAYITgBLj4MGD2rJli1555ZV8y3r27Klhw4Zp7dq16tevnyIiIjR58mS9//778vf3V7du3Qocmzt3rrp37657771Xffv21fnz5/Xll1+qZcuWeumll264Zw8PD3Xs2FEjR47U/v37NXv2bK1evdq+/PKeGjRooIEDB6p///66/fbbdfjwYX3zzTdXvNEngJuL4ASgxNi/f7+GDRumFi1a5Fvm7++vv//974qLi5MkjRo1SpK0Y8cOnT9/XnfffXeBYy1bttS+ffs0f/58bd++XSEhIfa5RXnatm2rSpUqObxf+/bt7ZPF83Tu3FmNGjVyGHvggQfUvXt3ffPNN8rMzNS3336rtm3b2pdf3tPLL7+s6OhoffTRR9q8ebOCgoK0ZcuWfDf4BOAabsYY4+omAKA06tevn6pXr6533nnH1a0AcBK+qw4AAMAiTtUBQBEp6BQfgJKNU3UAAAAWcaoOAADAIoITAACARQQnAAAAiwhOAAAAFhGcAAAALCI4AQAAWERwAgAAsIjgBAAAYBHBCQAAwKL/B27tOUS+NAElAAAAAElFTkSuQmCC", "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", "\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 synthesize the 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": "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", "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", "\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", "\n", " _ref.check()\n", "\n", " return _rus.emulator(n_qubits=3), _ref.emulator(n_qubits=circ.n_qubits)\n", "\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", "\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.12.12" } }, "nbformat": 4, "nbformat_minor": 5 }