From c079ec50800ccc869ea5eab50c1cb63ea83e574f Mon Sep 17 00:00:00 2001 From: Dave Bacon Date: Thu, 26 May 2022 20:04:50 +0000 Subject: [PATCH 1/6] Update to educators intro notebook --- docs/tutorials/educators/intro.ipynb | 372 +++++++++++---------------- 1 file changed, 157 insertions(+), 215 deletions(-) diff --git a/docs/tutorials/educators/intro.ipynb b/docs/tutorials/educators/intro.ipynb index ca371aa4f7e..c759b520655 100644 --- a/docs/tutorials/educators/intro.ipynb +++ b/docs/tutorials/educators/intro.ipynb @@ -104,6 +104,8 @@ " print(\"installed cirq.\")\n", " import cirq\n", "\n", + "%matplotlib inline\n", + "\n", "import matplotlib.pyplot as plt\n", "import numpy as np" ] @@ -117,7 +119,7 @@ "Let's check that Cirq has been successfully installed by importing Cirq and printing out a diagram of Google's Sycamore device.\n", "\n", "\n", - "![Google's Sycamore chip](https://4.bp.blogspot.com/-b9akad6ismU/WpmyaJo-cYI/AAAAAAAACa8/mCqPBJxv5oUivy6Jq42FSOQYkeRlTmkiwCLcBGAs/s1600/image1.png)" + "![Google's Sycamore chip](https://quantumai.google/site-assets/images/marketing/hardware/hardware-chips-sycamore.jpg)" ] }, { @@ -131,34 +133,34 @@ "name": "stdout", "output_type": "stream", "text": [ - " (0, 5)───(0, 6)\n", - " │ │\n", - " │ │\n", - " (1, 4)───(1, 5)───(1, 6)───(1, 7)\n", - " │ │ │ │\n", - " │ │ │ │\n", - " (2, 3)───(2, 4)───(2, 5)───(2, 6)───(2, 7)───(2, 8)\n", - " │ │ │ │ │ │\n", - " │ │ │ │ │ │\n", - " (3, 2)───(3, 3)───(3, 4)───(3, 5)───(3, 6)───(3, 7)───(3, 8)───(3, 9)\n", - " │ │ │ │ │ │ │ │\n", - " │ │ │ │ │ │ │ │\n", - " (4, 1)───(4, 2)───(4, 3)───(4, 4)───(4, 5)───(4, 6)───(4, 7)───(4, 8)───(4, 9)\n", - " │ │ │ │ │ │ │ │\n", - " │ │ │ │ │ │ │ │\n", - "(5, 0)───(5, 1)───(5, 2)───(5, 3)───(5, 4)───(5, 5)───(5, 6)───(5, 7)───(5, 8)\n", - " │ │ │ │ │ │ │\n", - " │ │ │ │ │ │ │\n", - " (6, 1)───(6, 2)───(6, 3)───(6, 4)───(6, 5)───(6, 6)───(6, 7)\n", - " │ │ │ │ │\n", - " │ │ │ │ │\n", - " (7, 2)───(7, 3)───(7, 4)───(7, 5)───(7, 6)\n", - " │ │ │\n", - " │ │ │\n", - " (8, 3)───(8, 4)───(8, 5)\n", - " │\n", - " │\n", - " (9, 4)\n" + " q(0, 5)───q(0, 6)\n", + " │ │\n", + " │ │\n", + " q(1, 4)───q(1, 5)───q(1, 6)───q(1, 7)\n", + " │ │ │ │\n", + " │ │ │ │\n", + " q(2, 3)───q(2, 4)───q(2, 5)───q(2, 6)───q(2, 7)───q(2, 8)\n", + " │ │ │ │ │ │\n", + " │ │ │ │ │ │\n", + " q(3, 2)───q(3, 3)───q(3, 4)───q(3, 5)───q(3, 6)───q(3, 7)───q(3, 8)───q(3, 9)\n", + " │ │ │ │ │ │ │ │\n", + " │ │ │ │ │ │ │ │\n", + " q(4, 1)───q(4, 2)───q(4, 3)───q(4, 4)───q(4, 5)───q(4, 6)───q(4, 7)───q(4, 8)───q(4, 9)\n", + " │ │ │ │ │ │ │ │\n", + " │ │ │ │ │ │ │ │\n", + "q(5, 0)───q(5, 1)───q(5, 2)───q(5, 3)───q(5, 4)───q(5, 5)───q(5, 6)───q(5, 7)───q(5, 8)\n", + " │ │ │ │ │ │ │\n", + " │ │ │ │ │ │ │\n", + " q(6, 1)───q(6, 2)───q(6, 3)───q(6, 4)───q(6, 5)───q(6, 6)───q(6, 7)\n", + " │ │ │ │ │\n", + " │ │ │ │ │\n", + " q(7, 2)───q(7, 3)───q(7, 4)───q(7, 5)───q(7, 6)\n", + " │ │ │\n", + " │ │ │\n", + " q(8, 3)───q(8, 4)───q(8, 5)\n", + " │\n", + " │\n", + " q(9, 4)\n" ] } ], @@ -377,7 +379,7 @@ "H = {1 \\over \\sqrt{2}} \\left[ \\begin{array}[cc] & 1 & 1 \\\\ 1 & -1 \\end{array}\\right] .\n", "$$\n", "\n", - "In Cirq, `cirq.H` is an instance of the `cirq.HPowGate` class, which itself is a subclass of `Gate` (along with other classes). We can use Cirq to see the unitary matrix of `Gate` objects as follows." + "In Cirq, `cirq.H` is an instance of the `cirq.HPowGate` class, which itself is a subclass of `cirq.Gate` (along with other classes). We can use Cirq to see the unitary matrix of `Gate` objects as follows." ] }, { @@ -412,7 +414,7 @@ "source": [ "We see that this agrees with the unitary for the Hadamard gate above.\n", "\n", - "`Gate` objects have the ability to be applied \"on\" one or more qubits. There are two ways to do this for gates, either using the `on` method or by directly calling the gate on the qubits as if the gate were a function and the qubits were arguments. For example to apply the `H` on qubit `a` we can say `cirq.H.on(a)` or `cirq.H(a)`.\n", + "`Gate` objects have the ability to be applied \"on\" one or more qubits. There are two ways to do this for gates, either using the `on` method or by directly calling the gate on the qubits as if the gate were a function and the qubits were arguments. For example to apply the `H` gate on qubit `a` we can say `cirq.H.on(a)` or `cirq.H(a)`.\n", "\n", "The result of those expressions is typically a `GateOperation` object, which is a type of `Operation`.\n", "\n", @@ -982,7 +984,7 @@ "output_type": "stream", "text": [ "Measurement results:\n", - "a,b=1, 0\n" + "a,b=0, 1\n" ] } ], @@ -1117,13 +1119,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Counter({0: 255, 1: 253, 2: 251, 3: 241})\n" + "Counter({0: 284, 3: 250, 2: 248, 1: 218})\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 20, @@ -1132,7 +1134,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1155,7 +1157,7 @@ "print(result.histogram(key=\"a,b\"))\n", "\n", "# Plot a state histogram of the result.\n", - "cirq.plot_state_histogram(result)" + "cirq.plot_state_histogram(result, plt.subplot())" ] }, { @@ -1181,7 +1183,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Counter({'disagree': 504, 'agree': 496})\n" + "Counter({'agree': 534, 'disagree': 466})\n" ] } ], @@ -1199,9 +1201,13 @@ "\n", "The very first indication that quantum computers could be more powerful than classical computers was provided by David Deutsch in his 1985 paper\n", "\n", - "> David Deutsch, \"[Quantum Theory, the Church-Turing Principle and the Universal Quantum Computer](https://people.eecs.berkeley.edu/~christos/classics/Deutsch_quantum_theory.pdf)\" *Proc. R. Soc. Lond.* A **400** 97–117. http://doi.org/10.1098/rspa.1985.0070\n", + "> David Deutsch, \"[Quantum Theory, the Church-Turing Principle and the Universal Quantum Computer](https://people.eecs.berkeley.edu/~christos/classics/Deutsch_quantum_theory.pdf)\" *Proc. R. Soc. Lond. A* **400** 97–117 (1985). http://doi.org/10.1098/rspa.1985.0070\n", + "\n", + "This algorithm was extended by Deutsch and Richard Jozsa to a more convincing algorithmic seperation and what is now called the Deutsch-Jozsa algorithm. A futher improvement was made by Cleve et al.\n", + "\n", + "> R. Cleve, A. Ekert, C. Macchiavello, M. Mosca, \"[Quantum algorithms revisited](https://arxiv.org/abs/quant-ph/9708016)\" *Proc. R. Soc. Lond. A* **454** 339–354 (1997). http://doi.org/10.1098/rspa.1998.0164\n", "\n", - "This algorithm was extended by Deutsch and Richard Jozsa to a more convincing algorithmic seperation and what is now called the Deutsch-Jozsa algorithm. In this section we will show how to write circuits for the Deutsch algorithm and then as an exercise in using Cirq for algorithms for a small version of the Deutsch-Jozsa algorithm.\n", + "In this section we will show how to write circuits for the Deutsch algorithm and then as an exercise in using Cirq for algorithms for a small version of the Deutsch-Jozsa algorithm.\n", "\n", "Let's begin with the Deutsch algorithm. In Deutsch's algorithm you are given access to a box which computes a one bit boolean function. That is it is a box which takes in a bit and outputs a bit. If we want to be a mathematician or theoretical computer scientist we write the function $f$ as $f: \\{0, 1\\} \\rightarrow \\{0, 1\\}$. There are exactly four such boolean functions which we can write out in a table\n", "\n", @@ -1417,10 +1423,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "oracle: f_0 results: 0=0000000000\n", - "oracle: f_1 results: 0=0000000000\n", - "oracle: f_x results: 0=1111111111\n", - "oracle: f_notx results: 0=1111111111\n" + "oracle: f_0 results: q(0)=0000000000\n", + "oracle: f_1 results: q(0)=0000000000\n", + "oracle: f_x results: q(0)=1111111111\n", + "oracle: f_notx results: q(0)=1111111111\n" ] } ], @@ -1545,16 +1551,16 @@ "text": [ "\n", "Your result on constant functions:\n", - "2=0000000000\n", - "2=1111111111\n", + "q(2)=0000000000\n", + "q(2)=1111111111\n", "\n", "Your result on balanced functions:\n", - "2=0000000000\n", - "2=0000000000\n", - "2=0000000000\n", - "2=1111111111\n", - "2=1111111111\n", - "2=1111111111\n" + "q(2)=0000000000\n", + "q(2)=0000000000\n", + "q(2)=0000000000\n", + "q(2)=1111111111\n", + "q(2)=1111111111\n", + "q(2)=1111111111\n" ] } ], @@ -1622,16 +1628,16 @@ "output_type": "stream", "text": [ "Result on constant functions:\n", - "2=0000000000\n", - "2=0000000000\n", + "q(2)=0000000000\n", + "q(2)=0000000000\n", "\n", "Result on balanced functions:\n", - "2=1111111111\n", - "2=1111111111\n", - "2=1111111111\n", - "2=1111111111\n", - "2=1111111111\n", - "2=1111111111\n" + "q(2)=1111111111\n", + "q(2)=1111111111\n", + "q(2)=1111111111\n", + "q(2)=1111111111\n", + "q(2)=1111111111\n", + "q(2)=1111111111\n" ] } ], @@ -1776,7 +1782,7 @@ "\n", "In addition to `cirq.unitary` another important method (behind the scenes, anyways) is `cirq.apply_unitary`. This allows you to apply a unitary gate onto a state. Of course we could have applied the unitary directly to the state, using `cirq.unitary`. We'll see below in understanding how these methods are implemented that the `cirq.apply_unitary` can be used to apply the gate more directly onto the state and can save allocations of memory to store the unitary. \n", "\n", - "If we apply `cirq.Rx` to a state we can see how it rotates the state. To do this let us introduce a new simulate method `simulate_moment_steps`. This allows us to simulate the circuit `Moment` by `Moment`. At each point we can access the state. For example here we can use this to create a circuit that is a series of small `cirq.Rx` rotations and plot the probability of measuring the state in the $|0\\rangle$ state:" + "If we apply `cirq.Rx` to a state we can see how it rotates the state. To do this let us introduce a new simulate method, `simulate_moment_steps`. This allows us to simulate the circuit `Moment` by `Moment`. At each point we can access the state. For example here we can use this to create a circuit that is a series of small `cirq.Rx` rotations and plot the probability of measuring the state in the $|0\\rangle$ state:" ] }, { @@ -1788,7 +1794,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1839,7 +1845,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1896,7 +1902,7 @@ "\\end{array} \\right]\n", "$$\n", "\n", - "Below is a simple implementation of this gate in Cirq. To do this we simply define a class that inherits from `cirq.SingleQubitGate` and implements the `cirq.SupportsUnitary` protocol by implementing the `_unitary_(self)` method. We also define an optional `__str__` representation which Cirq will use when printing this gate out in a circuit diagram." + "Below is a simple implementation of this gate in Cirq. To do this we simply define a class that inherits from `cirq.Gate`, implements the `num_qubits` method, and implements the `cirq.SupportsUnitary` protocol by implementing the `_unitary_(self)` method. We also define an optional `__str__` representation which Cirq will use when printing this gate out in a circuit diagram." ] }, { @@ -1908,7 +1914,10 @@ "outputs": [], "source": [ "\"\"\"Example of defining a custom gate in Cirq.\"\"\"\n", - "class RationalGate(cirq.SingleQubitGate):\n", + "class RationalGate(cirq.Gate):\n", + " \n", + " def num_qubits(self):\n", + " return 1\n", " \n", " def _unitary_(self):\n", " return np.array([[3 / 5, 4 / 5], [-4 / 5, 3 / 5]])\n", @@ -2195,7 +2204,10 @@ "outputs": [], "source": [ "\"\"\"Example of a custom gate which supports the decompose protocol.\"\"\"\n", - "class HXGate(cirq.SingleQubitGate):\n", + "class HXGate(cirq.Gate):\n", + " \n", + " def num_qubits(self):\n", + " return 1\n", " \n", " def _decompose_(self, qubits):\n", " return cirq.H(*qubits), cirq.X(*qubits)\n", @@ -2331,7 +2343,16 @@ "metadata": { "id": "YnaqZI6dRNxX" }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/google/home/dabacon/github/quantumlib/Cirq/cirq-core/cirq/ops/gateset.py:356: UserWarning: v0.14.1 is the last release `cirq.GlobalPhaseGate` is included by default. If you were relying on this behavior, you can include a `cirq.GlobalPhaseGate` in your `*gates`. If not, then you can ignore this warning. It will be removed in v0.16\n", + " warnings.warn(\n" + ] + } + ], "source": [ "# Insert a type (eg: cirq.XPowGate) to accept all instances of that type.\n", "# Insert an instance (eg: cirq.CNOT) to accept only one specific instance of the type.\n", @@ -2469,19 +2490,19 @@ "\n", "params: OrderedDict([('s', 0.125)])\n", "a=0000000000\n", - "b=0000000000\n", + "b=0000001000\n", "\n", "params: OrderedDict([('s', 0.25)])\n", - "a=0001000000\n", - "b=0010000000\n", + "a=1100000000\n", + "b=0000010000\n", "\n", "params: OrderedDict([('s', 0.375)])\n", - "a=0000010000\n", - "b=0001000100\n", + "a=0000010010\n", + "b=0001010001\n", "\n", "params: OrderedDict([('s', 0.5)])\n", - "a=0010110110\n", - "b=0101100011\n", + "a=1010000010\n", + "b=0110011100\n", "\n" ] } @@ -2525,10 +2546,7 @@ { "data": { "text/html": [ - "\n", - "
\n", - "
\n", - "
\n", + "
\n", "\n", - "\n", - " \n", - "
\n", - "
\n", - " " + "
" ], "text/plain": [ - " s a b\n", - "count 50.000000 50.000000 50.00000\n", - "mean 0.250000 0.260000 0.30000\n", - "std 0.178571 0.443087 0.46291\n", - "min 0.000000 0.000000 0.00000\n", - "25% 0.125000 0.000000 0.00000\n", - "50% 0.250000 0.000000 0.00000\n", - "75% 0.375000 0.750000 1.00000\n", - "max 0.500000 1.000000 1.00000" + " s a b\n", + "count 50.000000 50.000000 50.000000\n", + "mean 0.250000 0.180000 0.220000\n", + "std 0.178571 0.388088 0.418452\n", + "min 0.000000 0.000000 0.000000\n", + "25% 0.125000 0.000000 0.000000\n", + "50% 0.250000 0.000000 0.000000\n", + "75% 0.375000 0.000000 0.000000\n", + "max 0.500000 1.000000 1.000000" ] }, "execution_count": 49, @@ -2800,7 +2742,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 52, @@ -2809,7 +2751,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXEAAAEBCAYAAACOpZVlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABQDklEQVR4nO2dd3xUVfr/31PSew+ppFASeuhIEaQoYC8UBXW7Pxuua1kLumtf/bq7suti2V1XsYC9oVKll0CoIaEkkN57m2Qyc39/nEySIZM+KZOc9+uV12Tuvefe5zDhk5PnPEWlKIqCRCKRSGwSdV8bIJFIJJKuI0VcIpFIbBgp4hKJRGLDSBGXSCQSG0aKuEQikdgwUsQlEonEhtH25sOOHj3am4+TSCSSAcPEiRMtHu9VEYfWDekISUlJxMTEWNGa3kXa3/fY+hxs3X6w/Tn0hf1tLYClO0UikUhsGCniEolEYsNIEZdIJBIbRoq4RCKR2DBSxCUSicSG6ZCInzhxglWrVgGQlpbGihUrWLlyJc888wxGoxGAf/zjH9xyyy0sX76ckydP9pzFEolEImmk3RDDd955h2+++QYnJycAXnrpJdasWcPUqVNZu3Yt27dvJygoiMOHD/Ppp5+Sk5PD/fffz+eff25VQxVFwagoGI1tV85Vq1UWx7ZWcFelApWq5RiJRCJpFUWhVVFpDXXPOD7aFfGwsDDWrVvHo48+CkBiYiJTpkwBYPbs2ezbt4+IiAhmzpyJSqUiKCgIg8FAcXEx3t7eVjGytLqOua/9TEm1HrjY6nUqFTw0fzgPXDWs8VhNnYHV/zlE/KUSi2OmRXrz3t1TcLTTWMVWiUTST9nzf3D6C7jre3Dy7No9jAa8zn4CX/4b6io6N3bRizD93q49tw3aFfFFixaRmZnZ+F5RlMaVq4uLCxUVFVRWVuLp6dl4jem4JRFPSkrqtJEGo8LKMR4UVdWi1bZu8rnCWl7feg7X+jKmh7mgKAqv7yvgyKVKbh7lgZOd+W/CqjojX54pZs37+3hwhl+n7Wr+b9ERdDpdl+bfX7B1+8H252Dr9kMfzUFRiDr4b+yrsqj44HYyZ/4FVJ1bGTuUXmBI/IsEFp+hMnAaNb5jOjW+XB1JXQ/Mu9MZm+pmfxJUVVXh7u6Oq6srVVVVZsfd3Nwsju9qptPoUe1nSun0Bm576wB/3V/E3Ikx7E8pZFvKRdbMH8aa+cMtjhnyYzJv/pzCvHER3DYptMP2fHsim6e+Os23980kzMe5Q2NkplrfY+tzsHX7oY/mkHcGqrIgbDpu6XuJKdwMsx/p+Pj8JPjsF+DgTtb05wheeD+unXTDdn6Z2IRVMzZjY2M5dOgQALt372bSpEnExcWxd+9ejEYj2dnZGI1Gq7lSOoOjnYY3b49Do1Fx938P86dvzjBnuB8PzBvW6piHF47gimgfnvrqNAnpJVTo9FTo9OgNxlbHnM2t4NHPTlJWo+f7Uzk9MRWJRGJNkr8Xr7e+B2NuhR0vwLmfQFcuvurr2h5/5D+ACu7ZR3nYAuG77Sd0eiX+2GOP8fTTT/P6668TGRnJokWL0Gg0TJo0iWXLlmE0Glm7dm1P2NohQryceWP5BO7872GCPJz427LxFjc7TWjUKt5YPoGl6/Zy05v7G497Odvx5JJYbo4LNnOZVOj03LPhKK6OWoZ4OrL1TC73XBnVo3OSSCTd5Oz3EDIZ3ALh2r9D7mn46Lam8/auMO8pmPIbUF+2P6avgZMbIfY6MR7L+2t9RYdEPCQkhE2bNgEQERHBhg0bWlxz//33c//991vXui4ye7gfH/5qKqFezni52Ld7vY+rAxt/M50tZ3IBsen8U2Iuf/j0BF8fz2Lt0lh8XB1QFIUnvzxNWnE1H/96GgdTi/jrtnPkV+jwd3Ps6WlJJJKOYDSaws7E+7IsyD4GVz0j3tu7wOqvIPFLMBrEsdSd8OPjcOozuP4f4N/M3ZP0HejKYMKqXp1GR+n1Koa9xYwo305dH+bjzK9mRTa+/+XMCDYcSuOVH5JZ8NfdZtc+tSSGKRHeuDlqeX3rObYn5bNiSphV7JZIJN1AUWDj7VBdDKu/BjtHOLtZnBu5tOk6t0CYdk/T++n3wqlP4YfH4K3ZIoIlVEThkfA/8BoKQ2f12jQ6w4AV8e6iVqtYPX0o82MC2J6c3xif7u/mwNWjAwEYGehGqLcTWxJzpYhLJNakvg60Fv6Krq8DjV3rPumLu5pE+4dH4Lp1wh/uEw1+loMbAHG/sbdB5Fz493zYtBp+uxvqKuHSHuFq6aE47+4iRbwdgjydWDUt3OI5lUrFwthAPjiQRmVtPa4O8p9TIukW9bWw+zXY+1e49m8w4Y6mc7py+OdU8AgW4ux/WYSLosD258A9GEbfBPvXge8IIcIdjc929YPbPoB/LxDRKMETRSji+NutNkVr0z9/tdgQC2IDqDMY2X2uwCr3q603UN9GZIxEMmBJPwjrZ8Luv4CDK+x4XmwqmjjwT6jIhsLzsH4W7HxJiL6Jcz9C1hGY8yjM/xNEXglbngRjvbkrpT2GjIWlfxXiv+/vEL0A3IOsNk1rI0W8m0wK98LL2Y4tibndvleFTs/SN/Yy59Wf2WWlXwoSiU1QcgneWwJ6HdzxOSzbABU5EP9vcb66WIh4zLVw/1EYdSPseln4rzMOi83MHc+DV4RYNas1cPO/wT0EXAMgeFLn7Bm/EibeDSgQt9ras7UqUsS7iVaj5qqYAHYk57cZW3455Tq92YpbURQe+fQkqYVVaDUq7vzPYX6/8TglVe3Er0okA4Hs42LFvOwDiJ4PQ2cK//Te16G2Evb9Tfin5z4JLr5w8ztw+2fi3L8Xwoc3Q95pmPuE8JmDuO7uzXDHF13zZy9+FX7xE4xcYs2ZWh0p4lZgYWwA5bp69l0obPfaeoORd3anMuWFbSx5Yy/H0kXM6Tt7UvkxMZfHrx7JT2tmc/+8aL45kc2DG4/3sPUSST+g8Lx49W2WmDfvaagugu1/gkNviySd5n7wYQvg3oMitjtlJ/jFwOibze/rFQ6Bo7tmk8YOwqb1q8QeS8idOCswZ4Qfns52fHokkytH+Judyy3TUa7TA3Ayt4bHtu/nZGYZs4f7cS63gpv+tZ/rxwXx7ckcFo8J5FezIlCpVDy8cARFVXV8fzKn0zVaJBKbo/AceISKGG4TIRNhxGI4/DaoNHDl4y3HObjB4r/AxLvA0aNlos4gQIq4FXDQarhpQggfHLxEcVUd3g0JRhfyK7jm73vQG5pKVvq62vOPlRNYMmYIlbX1vPJjMhsOphPp58JfbhlnJtZRfq6U1egpqqrD19Wh1+clkfQahefMV+Em5j4JZ38QUSo+bWRGB8T2nG39HCniVmLZ5FD+s+8iXyRkNiYNvb71HPYaNa/dOgatWk12dia3zh6Hp7MQeTdHO56/YQx3TAvHx8WhRYhilJ9YlaQWVJmJeF29keq6+sb7SCQ2jaJA0QUIu6PlucDR8Osd4Dei9+2yEaRP3EqMCHRjfKgnm45koCgKp7PK2Hwql1/OjOD68cEsGTuEmeGuFoV3ZKA7fm4tV9pRfq4ApBRUmh3/v61nmf/6bnR6Q89MRiLpTSpyxKalT7Tl88Fx5m4WiRlSxK3IssmhnMur5FhGKa9vPYeHkx2/mh3Z/sBWCPZ0wkGrJiXfXMTjLxZTWFnLT1YIa5RI+pzCc+LVt42MSkmrSBG3IteOC8LZXsOfvklkR3I+v50TibujXZfvp1ariPB1MVuJG4wKSTmio8jG+Ixu2yyR9DmNkSlSxLuCFHEr4uqgZenYIZzILMPX1Z67Zgzt9j2j/F1JKWhquHGxsJIavYFof1f2pxSRVlRlcZyiKGQUV3f7+RIJIJJtakp75t6F58DeraHMq6SzSBG3MqZCWPfOjcbZvvv7xlF+rmSWVDf6v09nlQOikqJaBZ8eybQ47tuTOcx5dScXLnPFSCRd4qNl8Pkve+bepsgUGUbbJaSIW5kJYV5s+/1sq6zCQUSoGBVIKxKr6tNZZTho1cyM9mXOcD8+PZphsdbKz8n5GBWsVtNFMoipLobMeLi4x7yWSUcx6OHSPkj9GVJ/xrH4sj6TheelK6UbSBHvAaL93ayWnHN5hEpidjkjA93QatQsmxxGXnktu8+bC7WiKOxPKQJofJVIusylvYAChlrIONT58Uffg/cWw/vXw/vXE7H1blHvBETafHkW+LYSmSJpFyni/ZzIhljxlPxKEbqYXcaoYA8Arorxx9fVnk8Om29wphZWkVuuw81Ry6HUIlkVUdI9Lu4GO2dQa8X3neXCdvAMg7t/gDu/w6B1hqP/E+eKLohXuRLvMlLE+znO9lqCPBxJKagko7iGCl09o4OEiNtp1NwcF8L25HzyK3SNY0yr79/OjqSitp7T2eV9YrtkgHBxF4RfIWprp+7q3FhDPaTtg6h5ED4DImZRHjYfEr8Q9cFlZEq3kSJuA0T5u5JaWEVidhkAo4PdG8/dOikUg1Hhi4SsxmMHUgoJ8nBk2WSxybo/pf3CXADJueXU1ssEIkkzynPExmPEbPGVnSD6TZqoKoKilNbH5xyH2nIxtoHSiOtAXy2EvPCcaLrg3fV8isGOFHEbIMrPlZT8Sk5llaFVqxge4NZ4LtrflclDvdgULzJFjUaFAylFTI/yxc/NgREBbhzogF+8sLKWpW/sZf3PqT05FYmtYXKfmERcMULaAXFMUUQbs38vMG/OYDa+YeU+tEnEdT6jRMXBhA+EiHsNBa2sDdRVpIjbAFF+LlTVGdiRnM+wADcc7cwrtd02KZTUwiriL5WQlFtOSbWeK6J9AJgR7UP8peJ2V9gJaSXUGxV+OJ3TY/OQ2CAXd4OjJwSOhZApoHVsEuaUHZC2V5SLTf6+9fH+o0TbMxMqFcStEl14Un8GHwuFryQdRoq4DWCKUEnOrWBUkHuL80vGDsHVQcvG+Az2XxCr7ulRDSIe5YtOb+RYemmbzziWUdr4DJkkJAHESvviLoiYJZoq2DlC6FQhzIoCO54DjzBRQjbh/Zbj9TrRci1yTstzY5eD2g50pZarF0o6jBRxGyCyQcQBRlsQcWd7LdeOC+L7U9lsOZNLpK8LQzycAJgS4Y1a1X6oYUJaCYHujgBsOZNnReslNkvJRSjLgIhmIhwxW3TQSfgfZB+DKx8TZWJTd0JJmvn4zHio15n5wxtx8WnqmCM3NbuFFHEbIMDdARd74UIZ3RBeeDnLJ4ei0xuJv1TCjAZXCoCHkx1jQjzZ30bXoXqDkZOZZVw9OpARAW5W6RcqGQA0+sObiXjkleJ186Oi6uDY5Q2d4FVw/MOW41VqEZViiSm/Fs0eguOsbfmgQoq4DaBSqYjyd0WlgpghLVfiAGNDPBgZKDY8Z0T5mp2bEeXD8YxSqmrrLY5Nzq2gRm8gLtyLBbEBxF8qlr09bYn6uoaEHCtzcTe4Bpq7O4aMF3VODLVw5R9BowXPUBFCeGwDGJvtvVzcBUFxouOOJYbOhMfTIHCM9W0fREgRtxHiwrwYH+qJi4PleiwqlYq7ZgzF1UHL9Egfs3Ozon2pNyr8fNZyCn5CQ5/PuDBPFo4KwKjA9uR8605A0nOc2iQ6xZdcst49c05A0neiaXHz7GONFoYvgqAJMOqmpuNxq0TmZcpO8b62ArKOWnalNMfBre3zknaRnX1shKeXxmJUlDavWTY5lOvHB+Nkbx69MjXShyAPRzYeyWDJ2CEtxiWkleDv5kCwpxPBnk4EujuyJTGXWyaGWHUOkh7ClDBTfFGE67XGhe3CdeHk1fb9akpg4ypw9oH5z7Y8f+NboBjMO8iPWCyu3/N/UJYOxamie72lTU2JVZErcRtBo1Zhp2n741KpVC0E3DT2lkmh7DlfQGZJy8iThPRSJoR5olKpUKlULIgNYPf5AmrqZOKPTVDasKFY1kZ9+fRDsOEm+OdUOPN169cZjfDFb6A8G2573zw00IRG2zKuW+sAcXdC+n747iHYv078sgid2vn5SDqFXIkPEm6dGMK6Hef57Ggma+Y3RQMUVtaSXlzN7VPDGo8tHBXABwfT2HuhkAWxAX1hrqQzmKJCStsQ8eRvRUifa4BI0Bm51LKrI/cknN8Ci1+D0Mmds+OqtTD1d0DDX4wObmDn1Ll7SDqNFPFBQqi3MzOjffn0SCb3zxuGRi38nAlpDf7w8KY/sadG+ODmqGVLYq4UcVugcSVuubY8iiL825FzYMVGOPAP+PklSP7O8vUTVsHkX3XeDpUK3OTPS2/TJRHX6/U8/vjjZGVloVaree6559BqtTz++OOoVCqGDRvGM888g1otvTX9iWWTQ7nvo2PsvVDInOHiz+SE9FK0ahVjmoUu2mvVzB3hz/bkfAxGpVHwJf2Q2gqRMQmtu1MKkkXM94z7hStk5hqY+tvWa4M7e/eIqZKeoUsqu2vXLurr6/nkk0+49957+dvf/sZLL73EmjVr+Oijj1AUhe3bt1vbVkk3WRAbgJezHZua9eY8ll7CqCD3Fqn8C0cFUFxVx9GGlbqkn2JypWidoDTd8jWmlPgRi5uO2TkJsbb0JbEpuiTiERERGAwGjEYjlZWVaLVaEhMTmTJlCgCzZ89m//79VjVU0n0ctBpunBDCljO5/GPHef658wInM8uYENYyWmHOcD/sNWq2npGJP/0akysldLLYjDRa2IxO/l6UkXVvGZkksX265E5xdnYmKyuLa665hpKSEtavX098fHxjNxsXFxcqKiosjk1KSrJ4vCPodLpuje9r+oP90/z0fAi8tuUcAGoVRDtbtmtsoAPfHc/gxggR+dIf7O8utj6Hy+33OnuYQKDAZSR+xt2cP7aXemf/xvPa6nyGZSeQP+YeivrJvAfaZ9DXdEnE33vvPWbOnMnDDz9MTk4Od955J3q9vvF8VVUV7u6WMwtjYmK6ZiniF0B3xvc1/cH+GCBx8hgMDTHnalXroYs3ljvz5Jen0fqEMjzArV/Y311sfQ4t7L+kA3tX/MYugNNvM8zPEcKanY/fB4D/7Lvx9xvRy9ZaZsB9Br3A0aNHWz3XJXeKu7s7bm4i08rDw4P6+npiY2M5dEj039u9ezeTJk3qyq0lvYBWo8ZBq8FBq2kz9nx+jIg0kLVU+jElaeAZLlLfoeXmZvL34B0li0wNYLok4nfddReJiYmsXLmSO++8k4ceeoi1a9eybt06li1bhl6vZ9GiRda2VdLLBLg7Mj7Us9NVDS/kV7DzrEzb7xVK08ArHDwasmubi7iuTHSoH7nEPHVeMqDokjvFxcWFv//97y2Ob9iwodsGSfoXC0cF8Jcfz5JT1ko4mgVe2pzMkbQSTjyzsActk6Aool5KxByRWOPoaZ7wc2kfGPWi1olkwCIDuSVtsrAh2WdbB1fj9QYjhy4WU1ajp0Knb3+ApOtUFYpelV7h4r1nqHnCT+Zh0aE+eGLf2CfpFaSIS9okys+VMG9n9pzvWLPlk1llVDaUvM0u1fWkaRJTeKGp6JVHqLk7JSNelHmVqe8DGinikjZRqVRMDPfiWEYpSjtVFAGzpsxZpbLNW49iKj3r2bAS92i2EjfUi870IVP6xDRJ7yFFXNIucWGeFFTUkl9lualEc/ZdKMTPTVS4y5Ir8Z7FtBL3bChe5hECteVQUwr5icLVEipFfKAjRVzSLqaMzqT8WrPjO5Pz2ZHc5CvX6Q0cSSth6dgh2GlUZJV0fDNU0gVKLoGzLzg09GBtHmaYcVh8H9LJSoQSm0OKuKRdRga64WyvIamgaWVtNCr88YtTPPDx8cZWbglpJdTVG5kZ7csQDyeySqWI9yglaU2bmiA6z4NwqWTGi7KznmGWx0oGDFLEJe2i1agZG+JBUkHTSvxUVhm55Toqa+tZvzsFgP0pRWjUKqZEeBPs6US2FPGepTTNvJOPKVa8tGElHjJZxocPAqSISzpEXJgXqcW16PSiwNKWM7lo1CrmjfTnf/svkV+uY19KIWNDPHBztCPYy0m6U3oSo0GsuD2brcRd/EDjANnHROlZ6Q8fFEgRl3SIuDAvDIpYgQNsPZPH5KFerF0ai96g8MqPZzmZWcYVUb4ABHk6kVeho67e2Jdm9z+ObRChf92lPEv0sGzuTlGrxWrcVHpWRqYMCqSISzrEhDBPQPi9LxZWcS6vkoWxgQz1deG2SSF8npCJwagwI8oHgBBPJxQF8splhEojRiNsfkR01ukupjrizVfi0BChUiaSfILGd/85kn6PFHFJh/BxdWCIm5aE9JLGGuOm1m33zxuGvUaNvVbd2OYt2EskmGS24lLJKK7mpc1J6A2DaKVeniXC/kyhgd3BFCPudZmImyJUAsfKJJ9BguyxKekwMX6OJKSXUlRZR8wQd0K9nQHhOnlk0QgKq2obOwQFeQoBaW1z80/fnmFbUh5zR/ozLdKndybQ1xSKGu6Nq+jukJcouvl4hJofN72X/vBBg1yJSzpMjJ8DBRW1HEkraaypYuLXsyP54zVNNZaHeDgCWAwzPJZewrYkEV++/4J5On+5Ts+z3yRSVjMA664UnhevNcWgK+/evTLjIWgCaOzMj5tEXMaHDxqkiEs6zEg/x8bvF8S23dXc0U6Dr6uDxQiV17eew9vFnhEBbuxvlqYP8M3xbN7bf4k95wusY3R/wrQSh+65VPQ6yDkhWrJdTuQcGH41RM3r+v0lNoUUcUmHifCyx9leQ7CnE6OCLHduak6wlxPZl5WwPZhaxJ7zhfy/K6OYF+PP8YxSqmqb0vm3NlRLTCsagHVXCs+BnXBBdculknNClJi1FH3iEQIrN8qGx4MIKeKSDqNRq/jdnCgevGpYYz/VtgjxNI8VVxSF1346S4C7A3dMC+eKKF/qjQqHLxUDUKHTsz9FuFcuFVb1zCT6kqILovY3dG8lnilT6iVNSBGXdIoHrhrGbZND278QCPJ0JKu0prH64e7zhRxJK+G+ecNwtNMwMdwLe426sfLhz2cL0BsU3By0XCoaYCKuK4eKHLHhaO/WvZV4xmGRTu/WtktLMjiQIi7pMYI9naitN1LUUFvlgwOX8HNzYNkk8UvAyV5DXLgn+xo2N7eeycPHxZ6FowK5NNDcKUUNm5p+I0RYYFdX4ooiNjVlIo+kASnikh4j2Ev4f7NKasgt07EjOZ9bJ4Zgr236sZsR5cuZnHLyK3TsTM7nqhh/Iv1cKKioNfOV2zymyBSfYSJBp4srcW11XtOKXiJBirikBwnybAoz/DwhE6MCt00yd8XMiPJBUeBv285TUVsvskB9XIABtrlZeE5kUXpHNK3EO9Bk43Kcik6Jb6Q/XNKAFHFJjxHiKVbimSXVbDqSwbRIb4b6uphdMy7UE2d7DZ8cTsfJTsPMYb6E+4hxaQPJL154DrwiRFy311CRuVnV+TBKp6KGJJ/AMda3UWKTSBGX9BjuTlpc7DV8eSybtKJqlk9uWdvaTqNmSoQ3RgVmD/fF0U7TKOIDyi9eeAF8h4vvTfVOuuBScS48ZTnJRzJokSIu6TFUKhXBXk4k5ZTj5qjl6tGBFq8zVT5cGCvOuzna4etqb7thhkYDfP4ruLRXvDfUQ3EK+A4T7031Tlrb3Ez4AHa+1PK4Xodj6VnLST6SQYsUcUmPEtxQQ+XGCcGNdVUu5/oJQdw+NcxM5If6uNhumGHheTj1KXz/ByHopWlgqGu2Em/4i8RUxKo5igK7XoE9r4lemc3JOYHKWC8jUyRmSBGX9CimQljL2ogt93dz5IUbx+Di0FSPLdzHxXY3NnNOiNeCJDj9eVNkimklbu8iGjhYWonnnhQ9Mo31cGGb+bmMQ+JVbmpKmiFFXNKj3DYplD8sHM6oII9OjRvq40xuuY6aOkMPWdaD5JwArSMEjIadL0L+GXHcJ7rpmtbCDJM3Aypw9Gxq7mDi9GfoPIfJJB+JGVLEJT3KuFBP7ps3rNPjwhuiWNKLxWq8ps7AL96L51h6iVXt6zTl2fD+9VCR1/o1uSeFgM97SrRJO/APsfJuXs/Ea6hld0ry9xA2DWKvh/Nbob6hr2nOCcg5QWnkddacjWQAIEVc0i+JaIgVv9iwufn9qRx2JOfzw+ncvjQLUndB6s9w/ifL541GIbhDxopqgsGToLqoyR9uwitc9Mg0NEtoKkmDvFMwcon4qquAi3vEuYQPQONAWfiiHpmWxHaRIi7pl4RdFiu+MT4dgNMNPT77DFM52YzDls+XXoLachgyTnSav+ppcby5KwWEO0UxiG4/Js5uFq8jFotCWXYucPZ70NfAyU0Qex1G+/arR0oGF7Kzj6Rf4uFkh7eLPZeKqkkpqCT+UgnO9hpOZ5WhKEqHqij2CCYRz2yl2XHOSfE6ZJx4jZgDC59vql5oonmYoen75O/BLwZ8osT76KuEjzx0quibOWEV1FpvKpKBgVyJS/ot4T7OpBVVsSk+A41axW9nR1Guq2+1b2evUHRBvBYktwwBBOFKUWvBP1a8V6lgxv3CvdKcyxN+qoshbb9wo5gYuRQqc2Hbn4QPfegsa85EMkCQIi7pt0T4uJBSUMnnCZlcNdKfK0f4AX3oUjHUQ1GKyJgEyDra8pqcE2I1rXVo+14eIaDSNIUZnvtJuFdGLm66ZtgCcU1FNky4A9Tyv6ukJV3+qXjrrbdYtmwZN910E59++ilpaWmsWLGClStX8swzz2A0DqIu5pIeIdzHhbzyWgor61g2OZQRgW5o1CoSs7vZn7KrlKaJjjpjlwOqli4VRWnY1BzX/r00duARDPvXwV+i4LuHwC0IhkxousbZG4ZeASo1jL/dqlORDBy65BM/dOgQx44d4+OPP6ampob//Oc/vPTSS6xZs4apU6eydu1atm/fzoIFC6xtr2QQMdRXbG4GuDswZ7gfWo2aYf6unM7uo5W4yR8ePFG4Sy7f3KzIgerCjok4wILn4OLupvfDFrRcbc//ExScBfegrtstGdB0ScT37t3L8OHDuffee6msrOTRRx9l06ZNTJki0oFnz57Nvn37pIhLukV4Q5jhLRND0GqEuI0K8mDXufzGzU2jUeGu9+LxdbXnycUx+Li248boDiYR940W9UtOfylCCk3Ca8rU7KiIj7pBfLVFcJz4kkhaoUsiXlJSQnZ2NuvXryczM5N77rnHLGLAxcWFiooKi2OTkpK6bKxOp+vW+L5G2t857BSF30zyZk5AfeNz/bQ1FFbWsS/hND7OWo7n1LD7nCjpui0xh99O8WFuhGur0SvdmcOQC/G4Onpz/lIuHpoQgmrLSDn8I3UeEQD4nt6GLyrOltmh9NC/k63/DIHtz6G/2d8lEff09CQyMhJ7e3siIyNxcHAgN7cpCaOqqgp3d8vxrDExMV2zFPELoDvj+xppf+cZFWv+vtKpmPWHD1Dr7E9MTAD/On4Md0ctG341lbVfJ/LqngLi8+H5G0YT0tBZqDndmsP+AgiIFeP9tHD4eaLsCyGmYTPyeDb4DmPkmJ5bOdv6zxDY/hz6wv6jRy1sojfQpY3NiRMnsmfPHhRFIS8vj5qaGqZPn86hQ6JAz+7du5k0aVLXrJVI2iBmiDsqFZzOKqe0uo4fE3O5YUIwY0M8+fyeGaxdGsvhi8Us/Otu3tt3EYOx891zWqXwnHClAHhHifomzTc3c0523JUikViJLq3E586dS3x8PLfccguKorB27VpCQkJ4+umnef3114mMjGTRIpkeLLE+rg5aInxcSMwu46tjWdTVGxsrJGrUKn4xM4IFsQE8+dVpnv32DEk5Fbxyy9h27toBqoqgprgpfV6tFtUEM+KFXzzhPSjPlCI+SKiqquLhhx+mvLyc6Ohojh07xrffftsntnQ5Y/PRRx9tcWzDhg3dMkYi6Qijgj04eqmYjJIaxgR7tKiQGOrtzP/unsyTX53m0yMZPHr1iO5veDZuajargRI6RZSLfW8JpO8XyTgyFHBQ8NFHHzFixAgeeughEhIS2Lt3b5/ZIrMHJDbH6CB3sst0JOWUc1srdcpVKhV3zRiK3qDw5bEsi9d0ikYRb1aRMXQKoEBeIly3Du781rxSoWTAkpmZyZgxos9pXFwc9vb2fWaLFHGJzTE6WKy8He3UXDeu9fjp4QFuTAjzZGN8BkoXOsubUXhO1Aj3aPZLY+hsuOFfcN9hiFstUuwlg4IRI0Y0bjaePXuWurq6PrNFirjE5hgVJCKfFo8egodT2w2Dl00K5Xx+JccySrv30KILohKhulmLObUaxq8EN8u9QyUDl1tvvZWioiJuv/123n333T61RVYxlNgcns72vLt6EuNCPdu9dum4IP783Rk2Hs4gLsyrcw9SlKbVdeE5CLTCBqlkQGBnZ8df/vIXAGpra7nmmmv6zBa5EpfYJPNjA/Bza3+z0tVBy9KxQ/j2ZDaVtfXtXt/I8Y/hpVBR26SuWnThubyxg0TSD5AiLhnwLJscSnWdgc+PZlKmM1BcVWf2VVt/WR9PfQ1s/xOgwJanYP1MUIxSxCUWcXBwYMeOHX32fOlOkQx44sK8iPZ35ZlvEhuOmDcoDvN25uc/XIla3eA6if+3KGZ153dQVQA/NITT+o/sPaMlkg4iRVwy4FGpVPxzZRwHU4vIzc0lMLBpIzIpp5xP4jM4l1/ByEB3qK2Ava9D5JUQ0dCEIfJKUTs8cEyf2C+RtIUUccmgYESgGyMC3UhKqiEmZmjj8azSGj6Jz2DfhSIh4ofWi8bG89Y2DXb2FmViJZJ+iPSJSwY1wZ5ODPVx5kBKIdSUwL51olFxyMS+Nk0i6RBSxCWDnulRvhxKLcYQ/1/RkHjuE31tkmSAYjQaWbt2LcuWLWPVqlWkpaW1P6gdpIhLBj1XRPtQUVtPddIWCBgjfd+SHmPbtm3U1dWxceNGHn74YV5++eVu31OKuGTQMy3SBwfqcMo9CpFz+tocyQDm6NGjzJolNszHjx/P6dOnu31PubEpGfT4ujpwo08m2qo6iJjd1+ZIeonPj2ay6UhGp8dVV1fjvLvU4rnbJoVy88SQVsdWVlbi6ura+F6j0VBfX49W23UplitxiQRY4naOekWNLmhKX5siGcC4urpSVVXV+N5oNHZLwEGuxCUSAMboT3JCiaIuz8h01/avl9g+N08MaXPV3Brdac8WFxfHzp07Wbx4McePH2f48O5nAUsRl0h05XgUn+KA8VpqUwqZHuXT1xZJBigLFixg3759LF++HEVRePHFF7t9TyniEknaflSKgVyfqSSlFPFwX9sjGbCo1Wr+/Oc/W/eeVr2bRGKLXNwNGge8R17B8YxSMkuq+9oiiaTDSBGXSC7uhrCpLJ8+HI1KxbrtF/raIomkw0gRlwxuqgoh7xREzCHI04mVU8P4LCGTi4VV7Y+VSPoBUsQlg4OqQkj9Gee8eEj9uenryH/F+QiR5HPv3GjsNWr+uvVc41C9wUhakRR1Sf9EbmxKBgef3A4ZBwm3dM7JC4ImAODn5sBdVwxl/a4U/t/cKOoNCo9+dpKk3HJ2PHwlEb4uvWq2RNIeUsQlA5/8ZMg4CNPv45LTaIaGXyblHiGgafqv8NvZkWw4kMZv3j9KVmkNTnYaFEXUHpciLulvSHeKZOBz7ANQ28EVa6jxGw/hM8y/PMPMLvd0tud3V0aRXlzNrRND2PZ74WpJLajsA+MlA5ETJ06watUqq9xLrsQltkl+EngNBTuntq+rr4MTH8OIa8DVDyjs0O3/35VR3DghmCBPcf8gD0dSCqRfXNJ93nnnHb755hucnNr52e0gciUusT1qK+GtObDtT+1fe3az6NQTd2enHqFSqRoFHCDK35UUuRKXWIGwsDDWrVtntfvJlbjE9sg7DYZascKe/yzYObZ+bcL74B4CUXO79cgoP1c+PZKBoiioVKrG48czShkZ6IajnaZb95f0Acc/hmMbOj0srLoKDrayNzLhDhi/os3xixYtIjMzs9PPbQ25EpfYHjknxKuuFJK/a/260gxI2QETbgd190Q2ys+FqjoDeeW1jceOZ5Rywz/3sfiNPRy+WNyt+0skXUWuxCW2R84JcPYFexex0h5zi+XrTKus8bd3+5FRfqK0YUpBJYEeYuV/+GIRALo6A7e9dYA7poXx1JJYuSq3FcavaHfVbIn0blQx7AnkSlxie+ScgKDxMGEVXNwFxRfNz9dWwg+Pw65XYNhC8LIYHd4povyFiDePUElIKyXM25mtv5/D3VcMZcPBdD47ar0/kyWSjtAtES8qKmLOnDmkpKSQlpbGihUrWLlyJc888wxGo9FaNkokTeh1UJAMQ8bB+JWgUpv7NS9sgzenw6F/weRfws3vWuWx/m4OuNhrGiNUFEUhIb2ECWGeuDhoWbs0Fh8Xe05mllrleZKBTUhICJs2bbLKvbos4nq9nrVr1+LoKP60fOmll1izZg0fffQRiqKwfft2qxgokZiRfwaM9RA4FjyCIXo+HP8IKgvgi9/ChptB6wB3/whL/g8c3a3yWJVKZRahkl2mI7+ilrgwr8bzsUHunM4qt8rzJJKO0mURf+WVV1i+fDn+/v4AJCYmMmWKaG01e/Zs9u/fbx0LJYOb81tFrLcJ06bmkHHidcIqqMiGv4+F05/B7Efgd3shfLrVTYnycyUlX4h4QloJQKOIA4wO9uB8fgW19QarP1siaY0ubWx+8cUXeHt7M2vWLN5++20As9ArFxcXKioqLI5NSkrqoqmg0+m6Nb6vkfZ3DofSFCJ/up28cfdRPPIOAAKTduFu58q53BrISwLjUKJcgjE4eJAz+QlqPaPhwsVW79mdObhRTXaZjoSTiWw7XoyDRgVlWSRVZAPgpVSiNyhsOXiKaB+HLj2jPWz9Zwhsfw79zf4uifjnn3+OSqXiwIEDJCUl8dhjj1Fc3BRiVVVVhbu75T9ju7Or253edv0BaX8nSTwLQEDmjwTc8DyoVLAnDYInEBMb23RdzElQa4hsFr/dGt2Zw/T6HN4/VoK9TwiXKksZF+bFmFFNdjj7V/Hirnyq7L2JiQlr406C4xmlHE8vaXw/OcKbUUEeZtdkldaQU1rDpKHe3ba/v2Drc+gL+48ePdrquS6J+Icfftj4/apVq3j22Wd59dVXOXToEFOnTmX37t1MmzatK7eWSJooThWvRRcg/SCETIK8RJjya/PrNL0TKWuKUDmTU86Z7DJ+OTPS7HyolzNuDlpOZ5d16H4Pbzpulsof6efCjoevNLvm2W8S2X2ugMNPzMfD2a57E5AMSKwWYvjYY4+xbt06li1bhl6vZ9GiRda6tWSwUpwiysTau4l48MJzIlPT5A/vZcJ9nFGr4OvjWegNCnFhnmbn1eqOb24ajQoZxTXcNWMox55ewJOLY0gtqOJCflMIY02dgT3nC6itN/L1iSxrT0cyQOj2EuaDDz5o/H7Dhs6nsEokrVJ8EfxGgu9wOPVpk3j3kYg7aDWEejuzP0Uk+UxotqlpYnSwBx8eSqPeYESraX2NlFeho85gJNrfFS8Xe5aMHcILm5PYciaXaP9oAPacL0CnN+LqoGVjfAarpw/tkXlJbBuZ7CPpvxSngnekKF6lr4Y9r4GdM/hE95lJUX6uKAqEejvh59Zy83J0sDs6vZHUZu3dtiflkV1aY3ZdepFoxhzm7QxAkKcTY4I92Homr/GaLWfycHfU8tCC4SRml3M6q2NuGsngQoq4pH9SVwUVOeAdAcFx4B8LVQUQOKbbdVC6Q5SfKHwUZ2EVDjRuTJoENzG7jF/+7whv7041uy6jRIh6aIOIAyyMDeBYein55TrqDUa2J+Uxb6Q/t8SFYK9VszE+w+rzkdg+UsQl/RNTKr13lIhKiVst3veRK8WEqYZKayIe6euCo5260S/++hbRq7O5rxsgo7galQqCPJsqMC4cFQjA1qQ8jqaVUFKtZ+GoQDyc7Vg8OpCvjmdRWy8zoSXmSBGX9E9MkSneDREgY5eJJhDRC/rMJBBhgIHujswZ7mfxvFajJmaIO4nZZSSkl7A9OR9HO3WLWuQZJdUEujvioG36q2J4gKuoxXImjy1n8rDXqJnd8JzbJodSoatnX5psTCExR4q4pGcpuQSJX3V+XKOIR4hXZ2948AQMX2gty7pElJ8rB5+4iqFt9NocHeTBmexyXvvpLL6u9vziighyynRU1dY3XpNZXEOol7PZOJVKxcLYAPZfKOKHUzlcEe2Dq4OIPZgW4UO4jzM/nrecRCcZvEgRl/QsB/8Fn97ZstJgexSninKzjh7tX9vPGBXkTkVtPftTirjnymjGhog5XGy22ZlRUk2Id8v2XAtHBVJnMJJdpmt0r4AIX7xhfDCn8nSUVet7fhISm0GKuKRnKW3YjGurg0ptJRxcD4Zm4mSKTLFBRgcL0Q50d+T2qWFmtcgBausN5JbrGiNTmjMx3AtvF3tUKrgqxt/s3JQIkbV5XFZKlDRDirikZylLF6/HPwRDveVrTn4CPz4GZ39oOlacCj5RPW9fDzA8wI1RQe48sSQGRzsNYQ1JQqbiWVklNSJM0auliGvUKu6YFs5144LwdzNvOzcu1BO1qqn4lkQCsrOPpKcpzQCPUCjLgJTtMNxCJu/F3eL17GaIvQ70NVCeZbMrcXutmu8fmNX43kGrIczbuTHF3lJ4YXN+v2C4xeOuDlrCPe1JSJciLmlCrsQlPUdtheiDGXcnuPiJ1PnLMRrh4h7x/dkfxGq95JJ4b6Mibokov6Za5BnFItEn1IJPvD1G+jlwPKMUo1Gxqn0S20WKuKTnKGtoVeYdAeNWCJGuyDO/Ju801BTDyKVC8NP3t4xMGQBE+btysbAKg1Eho6Qae42agMvcJR0hxs+RCl09Fy4LWZQMXqSIS3oO06amR6hI1lEMcOJj82tMrpT5fwKNAyRvhqIUcWxArcRdqK03kl1aQ0ZxNcFeTqjV7ZfOvZwYP5HqL/3iEhNSxCU9R1mDiHuGgu8wCJshXCrN+69e3AU+w8A3GqLmQvL3DdULvUUFwwGCKULlQkElGcU1rfrD2yPY3Q5PZzvpF5c0IkVc0nOUZYBaC64B4v2kXwiBTvpGvDfoIW0/RMwW70cuEdEsZ38cUKtwgEhTmGF+JRkl1YR6dd4fDiIhaEKoJwnppVa0TmLLSBGXdI6Tm+BCB5tgl2WCe3BTwarRN4HvCNj5IhgNkJUAdZUQOUecH341oILK3AEn4t4u9ng523Eis4zSan2XV+Ig6rZcyK+krEYm/UikiEs6g2KEzY/AT0927PrSDPBs1qZMrYG5T0DhWVEf3OQPH9oQjufqD6FTxfcDTMRBuFT2nC8ALMeId5S4cOFmOp5Rag2zJDaOFHFJh7GvSBcRJAVJTZuPbVGWAR4h5sdirhPlZH9+ScSNB44RdVFMjFwiXgeoiJc2pMx3JbzQxLhQT1StJP2UVet5cXMSOr2hy/eX2BZSxCUdxqnwdNObs5vbvtigF/XAPULNj6vVMO9pEQuefgAi5pifH3MrRF4JEbMYaET5NxXN6s5K3NVBy4gAN4ubmzvP5vP27lR2nyvo8v0ltoUUcUmHcSo6JQpSBYwWUSTNOfM1HPlv0/vybOF+8bxMxAGGLYSQKeL7y0XcfQis/hrcg6xrfD8g0ldsbro5aPHsZtPjCWFeFpN+sho6CMmNz8GDFHFJh3EqOg0hk0ViTvpBqGxY7dWUwNf3w5anm+qjmMILL3engGjycM3LYiNz6MzeMb4fEOUvRDzE2xmVqvMx4s0ZHexOha6e3HKd2fEmEZchiIMFKeKSjqErx6EsVaygRy4GFDj3ozi3fx3UlkFdBeQcF8dM2ZoeYZbuBsETYeVGsO+6W8HWCPVywk6j6nJ4ofm9xL9bekMKv4mshrosJzNL0RtkF6DBgBRxScfIOooKBUImQeBY4etO/l6sxg+uh8i54rrUn8VrY7ZmcJ+Y2x/RatT8ZnYkN8VZ+Oukk5hCFDMuF/HSGuy1anR6I8k5soHEYECKuKRjZMajoBIirlLBiMWQuhN2Pg/1NbD4VeErN4UNlmWIold23V91DiQeWTSSq0cHtn9hOwR7OqFSNVVEBFAUhezSGuaNEHXIpUtlcCBFXNIxMg5T6x7R1Gln5BKo18HR92DcSpFWHzEbMg6BXtcQXmhhU1NiFey1aoa4O5LZbCVeWq2nus7ApKFeBLg7SBEfJEgRl7SP0QiZ8dT4jm46Fj4DHD1BbQdzHhXHIuYIYc883JDoI0W8JwnxdiajpEnETZuaIV5OxIV5SREfJEgRl7RP0QXQlVLjM6bpmMYOrnoaFr0IXuHiWPgMUGkgdZfY2JQr8R4l1MvZbGPTJOJBnkLEM4prKKio7SvzJL2E7OwjaZ/MwwDmK3GAyb8yf+/oDsFxkPil8JNLEe9RQr2dyCuvRac34GinaYxMCfZ0Ii7cExB+8UWjuu+Dl/Rf5Epc0j6Z8eDoQZ1bePvXRswWlQrBcoy4xGqYGi2bVuDZpTU42qnxdrFnVJAHdhqVdKkMAqSIS9on4zAETwJVB35cTGVlQfrEe5jLwwyzSmsI8nRCpVLhaKchNsiDY2mlfWihpDeQIi5pm7JMyD/T8VomoVNFhx6Q7pQexpTwYwozzCqtIdizKaQzLsyTk1ky6WegI0Vc0jZnfxCvI5d27Ho7JwidAnYuA6ozT3/E380Be626Mcwwu7SGEK/mIu6FTm/kTHZ5X5ko6QWkiEvaJvk78B0u4sA7ypzHYP6zIilI0mOo1SpCPJ1IL65GpzdQWFlHkEeTiE+L9EGlgp/PyoqGA5kuRafo9XqeeOIJsrKyqKur45577iE6OprHH38clUrFsGHDeOaZZ1Cr5e8Im6amFC7then3dW5cxKwBWUq2P2KKFc9u2NwMbrYS93NzYEKoJ1uTcnlwfid+CUtsii6p7DfffIOnpycfffQR7777Ls899xwvvfQSa9as4aOPPkJRFLZv72ALL0n/5fxWMNZ33JUi6XXCvJ3IKK5pjFBp7hMHWDgqkNNZ5Y3nJQOPLon41VdfzYMPPgiIeg0ajYbExESmTBE1omfPns3+/futZ6XEepRnw7+ugL+NFV/rJkHWUcvXJn8nmhwHT+xdGyUdJtTLmbIafWOxq6DLRTxWNKnediav122T9A5dcqe4uIgOJZWVlTzwwAOsWbOGV155pbFGsouLCxUVliuoJSUlddFU0Ol03Rrf1/QH+31Pv4tf3mnKwhehoMYjfQtFe/5LwTjzkrAqQx3Dzm2hPGwhuWfPAv3D/u5i63O43H5VdSUA206moVZBac4lKvPM9yJCPez4Mj6VKV79YzU+0D6DvqbLGZs5OTnce++9rFy5kmuvvZZXX3218VxVVRXu7u4Wx8XExHT1kSQlJXVrfF/T5/YbDfDjTxA5F4/Vm8Sxt+fiW5OK7+V2nd8K9dV4Tb8Dr2HiXJ/bbwVsfQ6X21/vVga78jlTWEeguyNjRsW2GLM0TcU7u1MJCo/Go5sdhazBQPsMeoOjR1v5a5kuulMKCwv5xS9+wSOPPMItt9wCQGxsLIcOHQJg9+7dTJo0qSu3lvQkqT+L6oJxq5qOhU6BrATRE7M5yd+Bvat58o6k32FquFyhq2/hSjGxMDaAeqPCzrP5vWmapJfo0kp8/fr1lJeX8+abb/Lmm28C8OSTT/L888/z+uuvExkZyaJFi6xqqMQKJLwvYrebb1SGTIZD6yHvNARNEMeMRhEfHj0ftA59Y6ukQ3g42eHmqKVCV28WmdKccSGe+Ls5sPVMHjdMCGbrmTxe+TGZkqq6FteqVPDrWZH8dk5UT5susRJdEvGnnnqKp556qsXxDRs2dNsgSQ9RVSg68Uz5tbkwhzY0LM6IbxLxrKNQmSejUmwAlUpFqJczZ3LKW0SmmFCrVcyPDeDrY1nc+2EC35/KYUSAG9eMaVkY60J+JS/9kEyUnyvzGzZFJf0bWcVwsHByIxj1MGGV+XGPUHANFEWupv5GHEv+DtRaGLag9+2UdJpQbyfO5JS36k4B4VL56FA6W8/k8YeFw/nN7CjstS29qTq9gZv/tZ+HNh3nu/tnEu7j0mE7PjiYxqs/JqM0vA/zduare6/ATiPzRXoS+a87GFAU4UoJngQBl218qVQQOrmx3CwgVuxDZ4KTZ6+aKekaphoqrblTAGYN8+OZa2PZ/OAs7ps3zKKAAzjaaVh/x0TUKhW/25BATZ2hQzYYjQrrf07B392RWyaGcEWUL4nZ5ZzMLOv8hCSdQoq4rbD3b/DZL9u+5uyP8OZ0qK00P56dAAXJELfa8riQKVBySTQ9LjgHReelK8WGCPMRIh7Sxkpco1Zx9xURRPu7tnu/UG9n/rZ8PMm55fx127kW51/+IZn7PkowO7YvpZCs0hoeuGoYz1w7ipduEg1EDqQUdmYqki4gRdxWOLsZznwF9W10atn3d1FxMP2A+fELOwAVxFxreZzJL555GM5+L74fcU13LZb0EjdMCObFG8d0SKA7ytwR/swb4c+WxFyz44qi8OmRDL47mcO+C00CvTE+Aw8nu8bkIi8Xe2KHuLPvQpHVbJJYRoq4rVB4XqTA559p5fwFSG/Ikk392fzcxV0QOAacvS2PHTJe9MrMOCxcKUPGy4YONoS7ox0rp4Y1JttZiyuifblUVG2Wsn82r4KihqiW17acRVEUSqrq2JKYx40TgnG00zReOyPKh6PpJej0ll0ySTnlXPHyDtKLqi2el3QMKeK2QFUR1BSL73NOWL7m2Puiv6V/LFzc3XRcXyM60LcV723nCEPGirDCzCOik71k0DMj2geA/c1W3PsbVtb3z4vmWHopO5Lz+fJYFnUGI8smh7YYX1dvJCHNcneh9w9cIqu0hiNpxT00g8GBFHFboLCZX9KSiBv0cPxjGH41jLoRck9BdcN/jIxDYKgTnejbImQyFJ4FFCniEgCG+7vh42LPgZQml8j+lCLCfZx54KphhPs489qWc2yMz2BciAcxQ8yztKdE+KBRq9hnwS9eVVvPN8ezAUgpqGxxXtJxpIjbAiYR9wyDnJMtz5/7CaryRSZmxGxAgUt7xLnUXSJcMHx6288ImSxevYaK1bxk0KNWq5ge5cO+lEIURaHeYORQahEzonyx06hZM38YSTnlnM2rYNnksBbjXR20jAvxYH9KS7/496dyqKoz4KBVk5Jf1RvTGbBIEbcFCs+JlmcjlojMSkO9+fljH4hY7+gFouKgnUuTS+XibnHMwa3tZ4ROFa8jlshmDpJGZkT5kldeS2phFaezy6morWdGlHCzXDcumGH+rjjZabh23JBWx5/MLKNCZ17WYVN8BpF+Lswa5idX4t1EirgtUHQBfKIhOA7qdebulfJsOL8Fxq8EjRY0dhA+Q4i3rkyEF3ak/olnKCz7EGb/oefmIbE5TIK9P6WI/Q1ukekNxzRqFf+6I45/3zkJN0fLhbVmRPtgMCocvtjk904vreNIWgnLJ4cS7e/KpaIq6mUf0C4jRdwWKDwn2qMFjhXvm/vFj38EihEm3NF0LGK2GHP6c3GuPX+4iZilrUewSAYl4T7OBHs6sf9CIfsvFDEy0A1f16ayDdH+bsyI9m11fFyYF/ZatZlLZcuFCrRqFTfFhRDl54LeoDQ2e5Z0Hini/Z36WpGIY+pzqXVqEnGjUbhShs4Cn2YFiyIbRHvXq6B1bPJ3SySdRKUSfvH9KUXEXypuXIV3FEc7DZPCvdh3oZDiqjoKKmrZllLBVTH++Lo6EOknYttTpUuly0gR7+8Up4rVtO9wUGtEvLdJxNP2CoG/PBMzYIyoVliRLXzddo69brZk4DAjyoeyGj219UZmRLW+6m6NK6J9Sc6tIO65rUx+YRtluqZwxCg/UZtF+sW7jiyA1RPoddYTTpP/2zdavA4ZByc+EavwhPfBwaNlJqZaLVbnSd80rcolki5iEm61CqZGdt7dtmp6OJ7OdtQbRGmsyuJ85o7wB8DT2R5fV3sZodIN5Erc2hScg5fDIPEr69zPJOI+Dd3Kh4yFugrIPgZnvoGxt4GdhZoZkVeK14grrWOHZNAS6OFItL8rY0M8cW9lA7Mt3B3tuH1qOHfOGMqdM4YyL8rNLLs00s9VrsS7gVyJW5uE/4GhFrb/SRSR0nTzn7jwArgHg0NDXYwh48TrlqfEc+JWWR43YRV4hUOIbHIs6T7r74hDq+6ZNV+Unys/ns7pkXsPBuRK3JrU18KJj8EjTPiyT3zU/XuaIlNM+MWIOifp+4Wgm0T9crT2ojOPRGIFov3dGOrb8drinSHKz4WSaj3FFjoNSdpHirg1ObsZqotg6esiwWbXX9quOtgeiiIKX/kObzqmtQf/hiatlzd4kEhskCh/GaHSHaSIW5OED8A9BKLmwbynRVPio+91/X4VucL/7TPM/HjwRBFqOObWbpkrkfQHonyFiEu/eNeQIm4tStMhZQdMuF2EAkZeCeEzYfdrot5J3hnsyy62TJkHkVlZb+FPycbIlMtE/Kq18OvtsvOOZEAQ7OWEvVZNSoHlCJXiqjqMRsXiOYkUcetx7EPxOv528apSwVVPi8JUb82Cf00n6scV8M5cyD4urjEa4OB6+L8Y+OBGUY2wOY0iPtz8uLM3BIzqsalIJL2JRq0i0teFlPyWK/Gs0hqueHkHf9t+vg8ssw1kdIo1MBrg+Idi9e0V3nQ8bBrctRmqCgDISU1kyNn/wTvzYOpvRXPizHjRhCFtL2x7Fha90DS+6IIoZuUe1JuzkUh6nSg/VxKzW/bjfGPbeWr0Bt7dk8rq6eFmKf/NKdfpsVOrcbLXWDw/kJErcWtwaa/wf1sK9xt6BYy6AUbdQGn0TXDvIeFyOfgmFKXAjW/Db36Gyb+GA/+AxC/FhubJTaJDfcAoWVVQMuCJ8nMho6SG2vqmLkAXC6v4LCGT+TEB6PQG3tyZ0mKc0ajwwYFLzHhpB7/8XzyKMvjcLlLErUHyd2KjcXgH+lI6ecF16+B3e+H+ozBumRDpRS+KGidf3ydcK1/8Gryj4Pp/9rz9EkkfE+XvisGomLVq+9u2c9hr1Lx00xhujgthw6E0csqaCmVdyK/ktrcO8PTXiXi72LM/pYg9580bUFTV1ncrdLGwshvRZb2EFPHuoiiQvBmi5oK9c8fHXd7zUmsPt/5PFKzKOAxXvwK/3AJ+w1u/h0QyQDB1BXriy1OkFFRyNreCb05kc9cVQ/Fzc+CBq4ahKArrdlygrt7Iuu3nWfz3PZzPr+S1W8ex9fezCfZ0auz7CaDTG7jtrQPcsn5/l1bo//o5hckvbCP+Uv9uHyd94t0l5wSUZ8LcP3b/Xh7B8Ls9oFKDW2D37yeR2AjDA9x47dZx/PnbRK75+x5CvZxwtdfy29mRAIR6O7N8chgfH07nyKVizuVVsnTsEJ65dhR+bsJP/uBVw3j085NsPZPHgtgAnv7qNInZ5YBo8Dwy0L3V51/OvguFvPpTMooCHx5MY/LQ/luiWa7Eu0vy90J0h19tnfu5B0kBlwxKbpkYwraH57AgJoCUgip+MzsST2f7xvP3zYvGTqOmvKaed1ZP4h8r4xoFHOCmuGAifF14fes5PjqczqdHM1k5NQyVCrYm5nXYjpyyGh74+BiRfq7cHBfCD6dzKavWtz+wj5Ar8faoqxYRJEpD5xG3wKaMSRBZmqHTwKXzJTolEok5/m6O/PP2OB7KryTysjT/AHdHtj08B08nO1wcWkqXtqHv54OfHOfJL08za5gvz10/muSccracyeP+q4a1GHM5tfUG/t+HCej0BtbfMRGd3sDnCZl8fSKL1dOHWmuaVkWKeFuk/gzfPihqdjfntvch9noovih6Xi58wdJoiUTSRaIbUvEvJ9jTQsXOZlw7Noi3dqVSVqPnjeUT0KhVLIgN5JUfk8kurSGojfEnMkp57POTJOdW8ObtcY02jApyZ2N8hhTxXqckDZx9mqr/tUdtBaQfAhSxWXnmazi+QUSI3PYBuPiJc1vXwlf3io7w57eIsSMX99QsJBJJJ1CrVWz87TRUKhWuDav1haMCeOXHZLYl5TUKsU5v4PDFYgwNG557zxfy330X8XNz4J3Vk1gQG9B4z+WTQ3n660ROZ5UxOtij1+fUHgNTxHNPw7vzwX8k3P1j+w0a9DXw32sg91TTMZUGZv4e5jxqXq/71v/BW7Nh4x1g7yrE3DuyZ+YhkUg6zeVNm6P8XIn0c2FLohBxg1Hhl/+LZ9+FIrPrbp8axmPXjGxRM/268cE8/30SG+MzBr6IG41Gnn32Wc6ePYu9vT3PP/884eHh7Q+0JjWlQmC1DqJxwo+PwbV/b/16RYHvHxYCfv0/wW+kOO4aIDrAX45HMNzyH/jgBuEnn/1IT8xCIpFYkYWxgby7R7hZ3tqVwr4LRTy5OIZJQ70A8HaxJ9zHcqldDyc7Fo8ZwlfHs3hicYzFa/oSq0anbNu2jbq6OjZu3MjDDz/Myy+/bM3bt4/RCF/dI7InV26CmQ+JKoKmuiaWOPqeSJmf85joGB8ySXxZEnATkXNEESpUwjcukUj6NQtiA6g3Kjzz9Wne/DmFFVNC+fXsSCaEeTEhzKtVATexcmoYFbp6bvrXfs4V9q8EIKuuxI8ePcqsWbMAGD9+PKdPn7bOjRUFLu3FLeMEGJNbvy79kIgWufoVCJsqSrZmHYXvfw+KARzczK/XlcEPj0LUVULEO8PMh2DcChkOKJHYABNCPfF1deCr49mMCfbgmWs7V0Bu8lBv3l41kae/Ps1Dm8s5WWZPXJhXp+5xRbSPWciktbCqiFdWVuLq2rSRqNFoqK+vR6ttekxSUlKn76vRFTPsm+sJUQztXlsWvohs99nQ8BzN2MeJyPsFdt/cb/H6OpcgLo15FMPZc522S1DS4St1Ol2X5t9fsHX7wfbnYOv2Q9/NYUaIAz9f1PPwNHcuXuj8//dQNfxzyRDePpzPv/de5N9c7NT4ZWM8uSvO+klDVhVxV1dXqqqaagIbjUYzAQeIiemiTykqkZQzCURFtrGJqNLg4TsMj8sLRsUeFS4WC9h7hjO8M+ny3SApKanr8+8H2Lr9YPtzsHX7oe/m8H/DjdToDV1q9twcF3s1z946lMpaC70B2iDKzxWNumvF7I4ePdrqOauKeFxcHDt37mTx4sUcP36c4cOtWPfDfQh1HpHmiTYdxcG1a+MkEsmAwU6jxk5jnW3AtuLNexuriviCBQvYt28fy5cvR1EUXnzxRWveXiKRSCSXYVURV6vV/PnPf7bmLSUSiUTSBrIAlkQikdgwUsQlEonEhpEiLpFIJDaMFHGJRCKxYaSISyQSiQ2jUnqxPXRbAesSiUQiaZ2JEydaPN6rIi6RSCQS6yLdKRKJRGLDSBGXSCQSG6bfibjRaGTt2rUsW7aMVatWkZaWZnZ+06ZN3HTTTdx2223s3Lmzj6xsnfbsf/7557nppptYtWoVq1atoqKioo8sbZ8TJ06watWqFsd37NjBzTffzLJly9i0aVMfWNYxWrP/vffeY8mSJY2fQWpqah9Y1zZ6vZ5HHnmElStXcsstt7B9+3az8/39M2jPflv4DAwGA3/84x9Zvnw5K1as4Nw588qH/eYzUPoZP/30k/LYY48piqIox44dU373u981nsvPz1eWLl2q1NbWKuXl5Y3f9yfasl9RFGX58uVKUVFRX5jWKd5++21l6dKlyq233mp2vK6uTpk/f75SWlqq1NbWKjfddJNSUFDQR1a2Tmv2K4qiPPzww8qpU6f6wKqO89lnnynPP/+8oiiKUlJSosyZM6fxnC18Bm3Zryi28Rls3bpVefzxxxVFUZSDBw+a/V/uT59Bv1uJt9VY4uTJk0yYMAF7e3vc3NwICwsjObmNJhF9QFv2G41G0tLSWLt2LcuXL+ezzz7rKzPbJSwsjHXr1rU4npKSQlhYGB4eHtjb2zNx4kTi4+P7wMK2ac1+gMTERN5++21WrFjBW2+91cuWdYyrr76aBx98EABFUdBoNI3nbOEzaMt+sI3PYP78+Tz33HMAZGdn4+7u3niuP30G/a5RcluNJSorK3Fza+rO4+LiQmVlZV+Y2Spt2V9dXc0dd9zB3XffjcFgYPXq1YwePZqRI0f2ocWWWbRoEZmZmS2O28JnAK3bD7BkyRJWrlyJq6sr9913Hzt37mTu3Lm9bGHbuLiIdmGVlZU88MADrFmzpvGcLXwGbdkPtvEZAGi1Wh577DG2bt3KG2+80Xi8P30G/W4l3lZjicvPVVVVmf1D9gfast/JyYnVq1fj5OSEq6sr06ZN63d/SbSHLXwGbaEoCnfeeSfe3t7Y29szZ84czpw509dmWSQnJ4fVq1dz/fXXc+211zYet5XPoDX7bekzAHjllVf46aefePrpp6murgb612fQ70Q8Li6O3bt3A7RoLDF27FiOHj1KbW0tFRUVpKSkWLfxhBVoy/5Lly6xYsUKDAYDer2ehIQERo3qXK+/viYqKoq0tDRKS0upq6vjyJEjTJgwoa/N6jCVlZUsXbqUqqoqFEXh0KFDjB49uq/NakFhYSG/+MUveOSRR7jlllvMztnCZ9CW/bbyGXz11VeNrh4nJydUKhVqtZDM/vQZ9Dt3iqXGEv/9738JCwvjqquuYtWqVaxcuRJFUXjooYdwcHDoa5PNaM/+66+/nttuuw07Ozuuv/56hg0b1tcmd4hvv/2W6upqli1bxuOPP84vf/lLFEXh5ptvJiAgoK/Na5fm9j/00EOsXr0ae3t7pk+fzpw5c/ravBasX7+e8vJy3nzzTd58800Abr31VmpqamziM2jPflv4DBYuXMgf//hHbr/9durr63niiSfYunVrv/t/IDM2JRKJxIbpd+4UiUQikXQcKeISiURiw0gRl0gkEhtGirhEIpHYMFLEJRKJxIbpdyGGEok1qa2t5ZtvviE3NxdfX19WrFjR7pjS0lL27NljlqAikfRX5EpcMqApKCjg008/7dSYs2fPsmPHjh6ySCKxLjJOXDKgeeqpp9i8eTPV1dXMnDkTvV5PaWkpDz74IPPmzeOHH37gvffeQ61WM3HiRP7whz9w9913k5yczJo1a5gwYQIvv/wyBoOBkpISnn32WeLi4vp6WhJJI1LEJQOazMxMfv/73zNr1ixyc3N54YUXOHToEO+++y6vvvoqK1eu5PPPP8fJyYlHHnmEG264Aa1WyyeffMJf//pXNm/eTFRUFCNGjODbb7/l0KFDPP/88309LYmkEekTlwwaTHVqfH190el0pKenU1xczG9+8xtAFDFKT08nMjKycYy/vz9vvvkmjo6OVFVVmVWolEj6A1LEJQMatVqN0WgEQKVSmZ0LCQlhyJAh/Oc//8HOzo4vvviCmJgYKisrG8e88MILvPbaa0RFRfHGG2+QlZXV63OQSNpCirhkQOPj44Ner0en07U45+3tzV133cWqVaswGAwEBwdzzTXXUF5ezrlz53jvvfe47rrrePDBB3F3dycwMJCSkpI+mIVE0jrSJy6RSCQ2jAwxlEgkEhtGirhEIpHYMFLEJRKJxIaRIi6RSCQ2jBRxiUQisWGkiEskEokNI0VcIpFIbBgp4hKJRGLD/H9X9RWgq1BGVQAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -3179,7 +3121,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "a=1001010101\n" + "a=0001000111\n" ] } ], @@ -3291,10 +3233,10 @@ " [0.17089382+0.j 0. +0.j 0. +0.j 0.34859255+0.j]]\n", "\n", "After step 2 state was\n", - "[[0.11555552+0.j 0. +0.j 0. +0.j 0. +0.j]\n", - " [0. +0.j 0.7511109 +0.j 0. +0.j 0. +0.j]\n", - " [0. +0.j 0. +0.j 0.01777777+0.j 0. +0.j]\n", - " [0. +0.j 0. +0.j 0. +0.j 0.11555552+0.j]]\n", + "[[0.01777777+0.j 0. +0.j 0. +0.j 0. +0.j]\n", + " [0. +0.j 0.11555552+0.j 0. +0.j 0. +0.j]\n", + " [0. +0.j 0. +0.j 0.11555552+0.j 0. +0.j]\n", + " [0. +0.j 0. +0.j 0. +0.j 0.7511109 +0.j]]\n", "\n" ] } @@ -3346,34 +3288,34 @@ "name": "stdout", "output_type": "stream", "text": [ - " (0, 5)───(0, 6)\n", - " │ │\n", - " │ │\n", - " (1, 4)───(1, 5)───(1, 6)───(1, 7)\n", - " │ │ │ │\n", - " │ │ │ │\n", - " (2, 3)───(2, 4)───(2, 5)───(2, 6)───(2, 7)───(2, 8)\n", - " │ │ │ │ │ │\n", - " │ │ │ │ │ │\n", - " (3, 2)───(3, 3)───(3, 4)───(3, 5)───(3, 6)───(3, 7)───(3, 8)───(3, 9)\n", - " │ │ │ │ │ │ │ │\n", - " │ │ │ │ │ │ │ │\n", - " (4, 1)───(4, 2)───(4, 3)───(4, 4)───(4, 5)───(4, 6)───(4, 7)───(4, 8)───(4, 9)\n", - " │ │ │ │ │ │ │ │\n", - " │ │ │ │ │ │ │ │\n", - "(5, 0)───(5, 1)───(5, 2)───(5, 3)───(5, 4)───(5, 5)───(5, 6)───(5, 7)───(5, 8)\n", - " │ │ │ │ │ │ │\n", - " │ │ │ │ │ │ │\n", - " (6, 1)───(6, 2)───(6, 3)───(6, 4)───(6, 5)───(6, 6)───(6, 7)\n", - " │ │ │ │ │\n", - " │ │ │ │ │\n", - " (7, 2)───(7, 3)───(7, 4)───(7, 5)───(7, 6)\n", - " │ │ │\n", - " │ │ │\n", - " (8, 3)───(8, 4)───(8, 5)\n", - " │\n", - " │\n", - " (9, 4)\n" + " q(0, 5)───q(0, 6)\n", + " │ │\n", + " │ │\n", + " q(1, 4)───q(1, 5)───q(1, 6)───q(1, 7)\n", + " │ │ │ │\n", + " │ │ │ │\n", + " q(2, 3)───q(2, 4)───q(2, 5)───q(2, 6)───q(2, 7)───q(2, 8)\n", + " │ │ │ │ │ │\n", + " │ │ │ │ │ │\n", + " q(3, 2)───q(3, 3)───q(3, 4)───q(3, 5)───q(3, 6)───q(3, 7)───q(3, 8)───q(3, 9)\n", + " │ │ │ │ │ │ │ │\n", + " │ │ │ │ │ │ │ │\n", + " q(4, 1)───q(4, 2)───q(4, 3)───q(4, 4)───q(4, 5)───q(4, 6)───q(4, 7)───q(4, 8)───q(4, 9)\n", + " │ │ │ │ │ │ │ │\n", + " │ │ │ │ │ │ │ │\n", + "q(5, 0)───q(5, 1)───q(5, 2)───q(5, 3)───q(5, 4)───q(5, 5)───q(5, 6)───q(5, 7)───q(5, 8)\n", + " │ │ │ │ │ │ │\n", + " │ │ │ │ │ │ │\n", + " q(6, 1)───q(6, 2)───q(6, 3)───q(6, 4)───q(6, 5)───q(6, 6)───q(6, 7)\n", + " │ │ │ │ │\n", + " │ │ │ │ │\n", + " q(7, 2)───q(7, 3)───q(7, 4)───q(7, 5)───q(7, 6)\n", + " │ │ │\n", + " │ │ │\n", + " q(8, 3)───q(8, 4)───q(8, 5)\n", + " │\n", + " │\n", + " q(9, 4)\n" ] } ], @@ -3437,7 +3379,7 @@ " │\n", "(6, 6): ───iSwap^0.5───\n", "error, as expected: \n", - "Operation does not use valid qubit target: ISWAP**0.5((5, 5), (6, 6)).\n" + "Operation does not use valid qubit target: ISWAP**0.5(q(5, 5), q(6, 6)).\n" ] } ], @@ -3793,9 +3735,9 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -3809,7 +3751,7 @@ " num_points=200,\n", " repetitions=1000,\n", ")\n", - "result.plot();" + "result.plot(plt.subplot());" ] }, { @@ -3862,13 +3804,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "// Generated from Cirq v0.15.0.dev20220329072625\n", + "// Generated from Cirq v0.15.0.dev\n", "\n", "OPENQASM 2.0;\n", "include \"qelib1.inc\";\n", "\n", "\n", - "// Qubits: [0, 1, 2]\n", + "// Qubits: [q(0), q(1), q(2)]\n", "qreg q[3];\n", "\n", "\n", From e70a5fc32016b8d1a5d65083616c3773ed8fb9e9 Mon Sep 17 00:00:00 2001 From: Dave Bacon Date: Thu, 2 Jun 2022 16:47:05 +0000 Subject: [PATCH 2/6] initial param docs --- docs/params.ipynb | 153 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 153 insertions(+) create mode 100644 docs/params.ipynb diff --git a/docs/params.ipynb b/docs/params.ipynb new file mode 100644 index 00000000000..da56fc946f3 --- /dev/null +++ b/docs/params.ipynb @@ -0,0 +1,153 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "be796cb3-8b58-460b-b717-733ec0bc3e4b", + "metadata": {}, + "source": [ + "##### Copyright 2022 The Cirq Developers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1552f54-54a2-4d4f-ae1a-1bb15d24dcab", + "metadata": {}, + "outputs": [], + "source": [ + "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "#\n", + "# https://www.apache.org/licenses/LICENSE-2.0\n", + "#\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License." + ] + }, + { + "cell_type": "markdown", + "id": "ccb2d671-f8af-4d79-b477-030de935156c", + "metadata": { + "id": "EQvWLKKRgZR9" + }, + "source": [ + "# Parameter Sweeps" + ] + }, + { + "cell_type": "markdown", + "id": "9d101fdc-94b6-4aff-b165-bf56a6a880bf", + "metadata": { + "id": "EvZ_JecKga2p" + }, + "source": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " View on QuantumAI\n", + " \n", + " Run in Google Colab\n", + " \n", + " View source on GitHub\n", + " \n", + " Download notebook\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b6858f27-50a0-4603-8979-10810fce18f5", + "metadata": { + "id": "bd9529db1c0b" + }, + "outputs": [], + "source": [ + "try:\n", + " import cirq\n", + "except ImportError:\n", + " print(\"installing cirq...\")\n", + " !pip install --quiet cirq\n", + " print(\"installed cirq.\")\n", + " import cirq" + ] + }, + { + "cell_type": "markdown", + "id": "3ed0b5c5-1e40-4fed-b867-e5a81247bdec", + "metadata": {}, + "source": [ + "## Concept of Circuit Parameterization and Sweeps\n", + "\n", + "Suppose one has a quantum circuit and in this circuit there is a gate with some parameter. One might wish to run this circuit for different values of this parameter. An example of this type of setup is a Rabi flop experiment. In this experiment, one runs a set of quantum computations where one 1) starts in $|0\\rangle$ state, 2) rotates the state by $\\theta$ about the $x$ axis, i.e. applies the gate $\\exp(i \\theta X)$, and 3) measures the state in the computational basis. Running this experiment for multiple values of $\\theta$, and plotting the probability of observing a $|1\\rangle$ outcome yields the quintessential $\\cos^2$ probability distribution as a function of the different parameters $\\theta$. To support this type of experiment, Cirq provides the concept of parameterized circuits and parameter sweeps. \n", + "\n", + "Let's illustrate parameter sweeps by a simple example. Suppose that we want to compare two quantum circuits that are very similar except for a single gate." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "773ec3c4-a068-4695-b598-c0ac35c66320", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "circuit1:\n", + "0: ───H───S───H───M───\n", + "circuit2:\n", + "0: ───H───T───H───M───\n" + ] + } + ], + "source": [ + "q0 = cirq.LineQubit(0)\n", + "\n", + "circuit1 = cirq.Circuit([cirq.H(q0), cirq.Z(q0)**0.5, cirq.H(q0), cirq.measure(q0)])\n", + "print(f\"circuit1:\\n{circuit1}\")\n", + "\n", + "circuit2 = cirq.Circuit([cirq.H(q0), cirq.Z(q0)**0.25, cirq.H(q0), cirq.measure(q0)])\n", + "print(f\"circuit2:\\n{circuit2}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6cfff8b9-7a3e-423b-b03d-0867fa5b31f0", + "metadata": {}, + "source": [ + "One could run (either on hardware or in simulation) these circuits separately, for example, and collect statistics on the results of these circuits. However we can use parameter sweeps to do this in a cleaner and more perfomant manner. \n", + "\n", + "First one defines a parameter, and constructs a circuit that depends on this parameter. We use " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From bc11b3cf6ed09aca7a3aece43977027362df5c90 Mon Sep 17 00:00:00 2001 From: Dave Bacon Date: Thu, 2 Jun 2022 16:50:47 +0000 Subject: [PATCH 3/6] try not pre --- docs/tutorials/educators/intro.ipynb | 1298 +++----------------------- 1 file changed, 140 insertions(+), 1158 deletions(-) diff --git a/docs/tutorials/educators/intro.ipynb b/docs/tutorials/educators/intro.ipynb index c759b520655..b2e07a88aa1 100644 --- a/docs/tutorials/educators/intro.ipynb +++ b/docs/tutorials/educators/intro.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "cellView": "form", "id": "906e07f6e562" @@ -82,15 +82,12 @@ "source": [ "To use Cirq one first needs to install Cirq. Installation instructions are available at [https://quantumai.google/cirq/install](https://quantumai.google/cirq/install). For the purpose of this tutorial, we run `pip install cirq` as shown in the following code cell to install the latest release of Cirq. \n", "\n", - "> Different notebook execution systems exist, but for most part they have \"run\" button on a cell which you can click, or \"shift + enter\" is often the shortcut to run the cell. \n", - "\n", - "\n", - "Note: this notebook relies on unreleased Cirq features. If you want to try these features, make sure you install cirq via `pip install cirq --pre`.\n" + "> Different notebook execution systems exist, but for most part they have \"run\" button on a cell which you can click, or \"shift + enter\" is often the shortcut to run the cell. " ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "id": "RlJBDvNgC00H" }, @@ -100,7 +97,7 @@ " import cirq\n", "except ImportError:\n", " print(\"installing cirq...\")\n", - " !pip install --quiet cirq --pre\n", + " !pip install --quiet cirq\n", " print(\"installed cirq.\")\n", " import cirq\n", "\n", @@ -124,46 +121,11 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": { "id": "FTrmLyq4C2gf" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " q(0, 5)───q(0, 6)\n", - " │ │\n", - " │ │\n", - " q(1, 4)───q(1, 5)───q(1, 6)───q(1, 7)\n", - " │ │ │ │\n", - " │ │ │ │\n", - " q(2, 3)───q(2, 4)───q(2, 5)───q(2, 6)───q(2, 7)───q(2, 8)\n", - " │ │ │ │ │ │\n", - " │ │ │ │ │ │\n", - " q(3, 2)───q(3, 3)───q(3, 4)───q(3, 5)───q(3, 6)───q(3, 7)───q(3, 8)───q(3, 9)\n", - " │ │ │ │ │ │ │ │\n", - " │ │ │ │ │ │ │ │\n", - " q(4, 1)───q(4, 2)───q(4, 3)───q(4, 4)───q(4, 5)───q(4, 6)───q(4, 7)───q(4, 8)───q(4, 9)\n", - " │ │ │ │ │ │ │ │\n", - " │ │ │ │ │ │ │ │\n", - "q(5, 0)───q(5, 1)───q(5, 2)───q(5, 3)───q(5, 4)───q(5, 5)───q(5, 6)───q(5, 7)───q(5, 8)\n", - " │ │ │ │ │ │ │\n", - " │ │ │ │ │ │ │\n", - " q(6, 1)───q(6, 2)───q(6, 3)───q(6, 4)───q(6, 5)───q(6, 6)───q(6, 7)\n", - " │ │ │ │ │\n", - " │ │ │ │ │\n", - " q(7, 2)───q(7, 3)───q(7, 4)───q(7, 5)───q(7, 6)\n", - " │ │ │\n", - " │ │ │\n", - " q(8, 3)───q(8, 4)───q(8, 5)\n", - " │\n", - " │\n", - " q(9, 4)\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Test successful installation by printing out the Sycamore device.\"\"\"\n", "import cirq_google\n", @@ -244,25 +206,11 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { "id": "pE88WsFeDGfs" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Circuit:\n", - "\n", - "a: ───H───────────\n", - "\n", - "b: ───H───@───H───\n", - " │\n", - "c: ───────X───────\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Creating a circuit.\"\"\"\n", "# Define three qubits.\n", @@ -306,7 +254,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { "cellView": "form", "id": "6a5TEN5bKAPz" @@ -324,30 +272,12 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": { "cellView": "form", "id": "Q52e1pX_JIdi" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Circuit:\n", - "\n", - " ┌──┐\n", - "0: ───H─────@────────\n", - " │\n", - "1: ───H────@┼────H───\n", - " ││\n", - "2: ────────X┼────────\n", - " │\n", - "3: ─────────X────────\n", - " └──┘\n" - ] - } - ], + "outputs": [], "source": [ "#@title Expand to view the solution\n", "\"\"\"Creating a circuit.\"\"\"\n", @@ -384,23 +314,11 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": { "id": "YKfg575v1DQB" }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 0.70710678+0.j, 0.70710678+0.j],\n", - " [ 0.70710678+0.j, -0.70710678+0.j]])" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "\"\"\"Get the unitary of a gate, here the Hadamard gate.\"\"\"\n", "cirq.unitary(cirq.H)" @@ -434,47 +352,11 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": { "id": "hH-y4JiEMv25" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Circuit:\n", - "\n", - "a: ───H───────────\n", - "\n", - "b: ───H───@───H───\n", - " │\n", - "c: ───────X───────\n", - "\n", - "Moments in the circuit:\n", - "\n", - "Moment 0: \n", - " ╷ None\n", - "╶─┼──────\n", - "a │ H\n", - " │\n", - "b │ H\n", - " │\n", - "Moment 1: \n", - " ╷ None\n", - "╶─┼──────\n", - "b │ @\n", - " │ │\n", - "c │ X\n", - " │\n", - "Moment 2: \n", - " ╷ None\n", - "╶─┼──────\n", - "b │ H\n", - " │\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Print out the moments in a circuit.\"\"\"\n", "print(\"Circuit:\\n\")\n", @@ -497,30 +379,11 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": { "id": "2Y6zG_peQG1y" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cirq.Circuit([\n", - " cirq.Moment(\n", - " cirq.H(cirq.NamedQubit('a')),\n", - " cirq.H(cirq.NamedQubit('b')),\n", - " ),\n", - " cirq.Moment(\n", - " cirq.CNOT(cirq.NamedQubit('b'), cirq.NamedQubit('c')),\n", - " ),\n", - " cirq.Moment(\n", - " cirq.H(cirq.NamedQubit('b')),\n", - " ),\n", - "])\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Print the repr of a circuit.\"\"\"\n", "print(repr(circuit))" @@ -578,29 +441,11 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": { "id": "QFoV-eOE1tGN" }, - "outputs": [ - { - "data": { - "text/html": [ - "
a: ───@───X───@───\n",
-       "      │   │   │\n",
-       "b: ───X───@───X───
" - ], - "text/plain": [ - "a: ───@───X───@───\n", - " │ │ │\n", - "b: ───X───@───X───" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "\"\"\"Creating a circuit from generator functions.\"\"\"\n", "def xor_swap(a, b):\n", @@ -632,7 +477,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": { "cellView": "form", "id": "LbIZIMINEzD9" @@ -644,7 +489,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": { "cellView": "form", "id": "5oqmyccsE1kK" @@ -720,25 +565,11 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": { "id": "wNek1WjpX4MR" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Circuit:\n", - "\n", - "a: ───@───H───\n", - " │\n", - "b: ───@───H───\n", - "\n", - "c: ───H───────\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Appending operations with InsertStrategy.EARLIEST.\"\"\"\n", "# Create an empty circuit.\n", @@ -788,25 +619,11 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": { "id": "qWVDhLxFYuRp" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Circuit:\n", - "\n", - "a: ───@───H───\n", - " │\n", - "b: ───@───H───\n", - "\n", - "c: ───────H───\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Appending operations with InsertStrategy.NEW_THEN_INLINE.\"\"\"\n", "# Create an empty circuit.\n", @@ -857,7 +674,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": { "cellView": "form", "id": "-HXXD801OFGF" @@ -869,26 +686,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": { "cellView": "form", "id": "jP4VkPeHcjJT" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Circuit:\n", - "\n", - "a: ───@───H───────────H───H───\n", - " │\n", - "b: ───@───────H───@───H───────\n", - " │\n", - "c: ───H───────────@───────────\n" - ] - } - ], + "outputs": [], "source": [ "#@title Expand to view the solution\n", "# Define three qubits.\n", @@ -926,21 +729,11 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": { "id": "V6tZk3qGqBoH" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "a: ───X^0.5───@───X^0.5───M───\n", - " │ │\n", - "b: ───X^0.5───@───X^0.5───M───\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Get a circuit to simulate.\"\"\"\n", "def basic_circuit(measure=True):\n", @@ -974,20 +767,11 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": { "id": "KmGuMjvGw_Ef" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Measurement results:\n", - "a,b=0, 1\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Example of simulating a circuit in Cirq.\"\"\"\n", "# Get a simulator.\n", @@ -1023,23 +807,11 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": { "id": "Apj7WiFZ0WFm" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "State vector:\n", - "[0.5+0.j 0. +0.5j 0. +0.5j 0.5+0.j ]\n", - "\n", - "Dirac notation:\n", - "0.5|00⟩ + 0.5j|01⟩ + 0.5j|10⟩ + 0.5|11⟩\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Simulating a circuit with the `simulate` method.\"\"\"\n", "# Get a circuit without measurements.\n", @@ -1110,41 +882,11 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": { "id": "QxkmBlo21lrQ" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Counter({0: 284, 3: 250, 2: 248, 1: 218})\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAX7ElEQVR4nO3de7QlZX3m8e8jICggl6ElXFqbRKKiMagdwIgJ3iKCBpgoooagoq2OjJfRzIBjFDXMImvUGGNChJEAI6KsAYUIBpGBELwg3QjIRSODzaJboFtRuUUU/M0f+z3F9nD69IY+e1ef7u9nrb1O1VtVu35nn+797Hqr9lupKiRJAnhU3wVIktYfhoIkqWMoSJI6hoIkqWMoSJI6hoIkqWMoaN5KckmSN/ZdxzgluTvJb/ZdhzYehoLmRJLlSf69vYndluSUJFtNcP+vS3LZWtZ5WpKvJLkjyU+TLEtyQFu2X5IVD3OfleRJ61DzQ7ZPcmySz0zNV9VWVXXTWp7nYdcurYmhoLn08qraCtgTeCZwTL/lPMQ/ARcCvwE8Hng7cGevFc0DSTbpuwZNjqGgOVdVtwEXMAgHAJLsk+Tr7RP61Un2G1r2uiQ3JbkryQ+SvLa1/9qn5iSL2qfrTYf3l+SpwD8Az2lHKj+dXlOSHYDdgJOq6hft8bWquizJlsCXgZ3b9ncn2TnJXkm+0Wq+Ncknkzy6Pd+l7amvbuu/qrW/LMlVbZuvJ3nGuryWw0cTSQ5Icn17nVYmec8stW+e5ONJftgeH0+y+dDz/tf2O/0wyRun7eeUJCckOT/JPcDzkxyY5NtJ7kxyS5JjZ/i7vL4t+0mStyT5vSTXtNfik+vyOmiCqsqHj3V+AMuBF7XpXYHvAH/T5ncBfgwcwOCDyIvb/AJgSwaf1p/c1t0JeFqbPhb4zNA+FgEFbNrmLwHe2KZfB1w2S30Bvg98CTgY2HHa8v2AFdPang3sA2za9n0D8M6h5QU8aWj+mcAqYG9gE+CI9rpsvoaafm37NfzO3TrArcDz2vR2wLNmqf1DwDcZHBEtAL4OfLgt2x+4DXga8FjgM9P2cwrwM+C57e+1RdvH77T5ZwC3AwdP+7v8Q1v3j4CfA19s+9+lvS5/2Pe/Ux9rf3ikoLn0xSR3AbcweBP4QGv/U+D8qjq/qn5VVRcCSxmEBMCvgKcneUxV3VpV1811YTV493o+gzfpjwK3Jrk0ye6zbLOsqr5ZVfdX1XLgU8AfzrKbJcCnquryqnqgqk4F7mMQLGtyZfsk/dN2hHP0LOv+EtgjyeOq6idVdeUs674W+FBVraqq1cAHgcPbskOBf6yq66rqXgZBNN05NTiS+lVV/byqLqmq77T5a4AzeOhr8eG27leAe4Az2v5XAv/KIDS1njMUNJcOrqqtGXyqfAqwQ2t/IvDKaW9++wI7VdU9wKuAtzB4oz4vyVPGUVxVraiqo6rqt1pN9wCnrWn9JL+d5EvtxPmdwP8Y+p1m8kTg3dN+z4XAzrNs86yq2nbqARw/y7p/wiBIb07yL0meM8u6OwM3D83fPFTHzgyCe8rw9IxtSfZOcnGS1Ul+xuDvNf21uH1o+t9nmJ/YhQd65AwFzbmq+hcGXRAfaU23AP97+M2vqrasquPb+hdU1YsZdB19FzipbXcPg+6NKb8x224fZo23AH8HPH2W7U9o9exeVY8D3sugG2pNbgGOm/Z7Praqzng4tc1S8xVVdRCDLpkvAmfOUvsPGYTUlCe0Nhh0Q+06tGzhTLubNv9Z4FxgYVVtw6CraLbXQvOUoaBx+Tjw4iS/y6DP+uVJXpJkkyRbtMsod02yY5KD2gnT+4C7GXQnAVwF/EGSJyTZhtmvZrod2HXqRPB0SbZL8sEkT0ryqHbi+Q0M+t2ntv8PbT9TtmZwvuPudvTy1hn2OfwdgpOAt7RP1UmyZTtBu/UsdY8kyaOTvDbJNlX1y1bX1Os0U+1nAO9LsqD9ru9n8HeAQZi8PslTkzwW+IsRStgauKOqfp5kL+A16/o7af1kKGgsWj/2acD726fygxh80l7N4BP1nzP49/co4L8w+BR7B4N+6re257gQ+DxwDbCMwUniNfm/wHXAbUl+NMPyXzA4IfpVBm+o1zIIode1fX2XwRvpTa3rZ2fgPQze/O5i8Ib/+WnPeSxwalv/0KpaCrwJ+CTwE+DGqeefI4cDy1tX1lsYnDdYU+1/yeC8zTUMTvpf2dqoqi8DnwAubjVOBeN9s+z7PwEfaueM3s+DRynawGRw/k3SxiqDS3qvZXCV1P1916N+eaQgbYSSHNK+y7Ad8FfAPxkIAkNB2li9mcFlw/8PeICHni/RRsruI0lSxyMFSVJn07Wvsv7aYYcdatGiRX2XIUnzyrJly35UVQtmWjavQ2HRokUsXbq07zIkaV5JcvOaltl9JEnqGAqSpI6hIEnqGAqSpI6hIEnqGAqSpI6hIEnqGAqSpI6hIEnqzOtvNK+LRUef13cJvVp+/IF9lyBpPeSRgiSpYyhIkjqGgiSpYyhIkjqGgiSpYyhIkjqGgiSpYyhIkjqGgiSpYyhIkjqGgiSpYyhIkjqGgiSpYyhIkjqGgiSpYyhIkjqGgiSpYyhIkjqGgiSpYyhIkjpjC4UkC5NcnOT6JNcleUdrPzbJyiRXtccBQ9sck+TGJN9L8pJx1SZJmtmmY3zu+4F3V9WVSbYGliW5sC3766r6yPDKSfYADgOeBuwMfDXJb1fVA2OsUZI0ZGxHClV1a1Vd2abvAm4Adpllk4OAz1XVfVX1A+BGYK9x1SdJeqiJnFNIsgh4JnB5azoqyTVJTk6yXWvbBbhlaLMVzB4ikqQ5Ns7uIwCSbAWcBbyzqu5McgLwYaDaz48Cb3gYz7cEWALwhCc8Ye4LljQvLDr6vL5L6NXy4w8cy/OONRSSbMYgEE6vqrMBqur2oeUnAV9qsyuBhUOb79rafk1VnQicCLB48eIaT+XS+PmmNp43Na2bcV59FODTwA1V9bGh9p2GVjsEuLZNnwsclmTzJLsBuwPfGld9kqSHGueRwnOBw4HvJLmqtb0XeHWSPRl0Hy0H3gxQVdclORO4nsGVS2/zyiNJmqyxhUJVXQZkhkXnz7LNccBx46pJkjQ7v9EsSeoYCpKkjqEgSeoYCpKkjqEgSeoYCpKkjqEgSeoYCpKkjqEgSeoYCpKkjqEgSeoYCpKkjqEgSeoYCpKkjqEgSeoYCpKkjqEgSeoYCpKkzjjv0awN3KKjz+u7hF4tP/7AvkuQ5pxHCpKkjqEgSeoYCpKkjqEgSeoYCpKkjqEgSeoYCpKkjqEgSeoYCpKkzthCIcnCJBcnuT7JdUne0dq3T3Jhku+3n9u19iT5RJIbk1yT5Fnjqk2SNLNxHincD7y7qvYA9gHelmQP4GjgoqraHbiozQO8FNi9PZYAJ4yxNknSDMYWClV1a1Vd2abvAm4AdgEOAk5tq50KHNymDwJOq4FvAtsm2Wlc9UmSHmoi5xSSLAKeCVwO7FhVt7ZFtwE7tuldgFuGNlvR2qY/15IkS5MsXb169fiKlqSN0NhDIclWwFnAO6vqzuFlVVVAPZznq6oTq2pxVS1esGDBHFYqSRprKCTZjEEgnF5VZ7fm26e6hdrPVa19JbBwaPNdW5skaULGefVRgE8DN1TVx4YWnQsc0aaPAM4Zav+zdhXSPsDPhrqZJEkTMM6b7DwXOBz4TpKrWtt7geOBM5McCdwMHNqWnQ8cANwI3Au8foy1SZJmMLZQqKrLgKxh8QtnWL+At42rHknS2vmNZklSx1CQJHUMBUlSZ62hkOSVo7RJkua/UY4UjhmxTZI0z63x6qMkL2VwieguST4xtOhxDAa7kyRtYGa7JPWHwFLgj4FlQ+13Ae8aZ1GSpH6sMRSq6mrg6iSfrapfTrAmSVJPRvny2l5JjgWe2NYPg++a/eY4C5MkTd4oofBpBt1Fy4AHxluOJKlPo4TCz6rqy2OvRJLUu1FC4eIk/xM4G7hvqnHqrmqSpA3HKKGwd/u5eKitgBfMfTmSpD6tNRSq6vmTKESS1L+1hkKS98/UXlUfmvtyJEl9GqX76J6h6S2AlwE3jKccSVKfRuk++ujwfJKPABeMrSJJUm8eydDZjwV2netCJEn9G+WcwncYXG0EsAmwAPB8giRtgEY5p/Cyoen7gdurylFSJWkDtNbuo6q6GdgWeDlwCLDHmGuSJPVklDuvvQM4HXh8e5ye5D+PuzBJ0uSN0n10JLB3Vd0DkOSvgG8AfzvOwiRJkzfK1Ufh10dHfaC1SZI2MKMcKfwjcHmSL7T5gxkMpy1J2sCM8uW1jyW5BNi3Nb2+qr491qokSb0Y5XsK+wDXTQ2VneRxSfauqsvHXp0kaaJGOadwAnD30PzdrW1WSU5OsirJtUNtxyZZmeSq9jhgaNkxSW5M8r0kL3k4v4QkaW6MdKK5qqa+0UxV/YrRzkWcAuw/Q/tfV9We7XE+QJI9gMOAp7Vt/j7JJiPsQ5I0h0YJhZuSvD3JZu3xDuCmtW1UVZcCd4xYx0HA56rqvqr6AXAjsNeI20qS5sgoofAW4PeBlcAKBndiW7IO+zwqyTWte2m71rYLcMvQOita20MkWZJkaZKlq1evXocyJEnTjTLMxaqqOqyqHl9VO1bVa6pq1SPc3wnAbwF7ArcCH5117ZnrObGqFlfV4gULFjzCMiRJM3kkQ2c/YlV1e1U90M5LnMSDXUQrgYVDq+7a2iRJEzTRUEiy09DsIcDUlUnnAocl2TzJbsDuwLcmWZskabTvKezWTv7O2jbDdmcA+wE7JFkBfADYL8meDO7PsBx4M0BVXZfkTOB6BsNzv62qHpjhaSVJYzTKpaVnAc+a1vZ/gGfPtlFVvXqG5jUOj1FVxwHHjVCPJGlM1hgKSZ7C4HsD2yT5j0OLHgdsMe7CJEmTN9uRwpMZ3HVtWwY32JlyF/CmMdYkSerJGkOhqs4BzknynKr6xgRrkiT1ZLbuo79lcEKYJA85P1BVbx9jXZKkHszWfbR0YlVIktYLs3UfnTrJQiRJ/RvlewoX07qRhlXVC8ZSkSSpN6N8T+E9Q9NbAH/C4AtmkqQNzCi341w2relrSRyCQpI2QKN0H20/NPsoBt9k3mZsFUmSejNK99EyBucUwqDb6AfAkeMsSpLUj1G6j3abRCGSpP6tdejsJK9MsnWbfl+Ss5NMHyBPkrQBGOV+Cn9RVXcl2Rd4EYORTk8Yb1mSpD6MEgpT9zU4EDixqs4DHj2+kiRJfRklFFYm+RTwKuD8JJuPuJ0kaZ4Z5c39UOAC4CVV9VNge+DPx1mUJKkfaw2FqroXWAXs25ruB74/zqIkSf0Y5eqjDwD/DTimNW0GfGacRUmS+jFK99EhwB8D9wBU1Q+BrcdZlCSpH6OEwi+qqnjwhjtbjrckSVJfRgmFM9vVR9smeRPwVeCk8ZYlSerDrMNcJAnweeApwJ3Ak4H3V9WFE6hNkjRhs4ZCVVWS86vqdwCDQJI2cKN0H12Z5PfGXokkqXejDJ29N/DaJDczuAIpDA4injHWyiRJEzdKKLxk7FVIktYLo9xP4eZJFCJJ6t/YBrZLcnKSVUmuHWrbPsmFSb7ffm7X2pPkE0luTHKN92uQpH6Mc7TTU4D9p7UdDVxUVbsDF7V5gJcCu7fHErxfgyT1YmyhUFWXAndMaz4IOLVNnwocPNR+Wg18k8EX5XYaV22SpJlN+r4IO1bVrW36NmDHNr0LcMvQeita20MkWZJkaZKlq1evHl+lkrQR6u1mOcPjKT3M7U6sqsVVtXjBggVjqEySNl6TDoXbp7qF2s9VrX0lsHBovV1bmyRpgiYdCucCR7TpI4Bzhtr/rF2FtA/ws6FuJknShIzy5bVHJMkZwH7ADklWAB8Ajmcw6uqRwM0MbvUJcD5wAHAjcC/w+nHVJUlas7GFQlW9eg2LXjjDugW8bVy1SJJG09uJZknS+sdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUmfTPnaaZDlwF/AAcH9VLU6yPfB5YBGwHDi0qn7SR32StLHq80jh+VW1Z1UtbvNHAxdV1e7ARW1ekjRB61P30UHAqW36VODg/kqRpI1TX6FQwFeSLEuypLXtWFW3tunbgB1n2jDJkiRLkyxdvXr1JGqVpI1GL+cUgH2ramWSxwMXJvnu8MKqqiQ104ZVdSJwIsDixYtnXEeS9Mj0cqRQVSvbz1XAF4C9gNuT7ATQfq7qozZJ2phNPBSSbJlk66lp4I+Aa4FzgSPaakcA50y6Nkna2PXRfbQj8IUkU/v/bFX9c5IrgDOTHAncDBzaQ22StFGbeChU1U3A787Q/mPghZOuR5L0oPXpklRJUs8MBUlSx1CQJHUMBUlSx1CQJHUMBUlSx1CQJHUMBUlSx1CQJHUMBUlSx1CQJHUMBUlSx1CQJHUMBUlSx1CQJHUMBUlSx1CQJHUMBUlSx1CQJHUMBUlSx1CQJHUMBUlSx1CQJHUMBUlSx1CQJHUMBUlSx1CQJHUMBUlSZ70LhST7J/lekhuTHN13PZK0MVmvQiHJJsDfAS8F9gBenWSPfquSpI3HehUKwF7AjVV1U1X9AvgccFDPNUnSRiNV1XcNnSSvAPavqje2+cOBvavqqKF1lgBL2uyTge9NvNC5sQPwo76LmOd8DdeNr9+6mc+v3xOrasFMCzaddCXrqqpOBE7su451lWRpVS3uu475zNdw3fj6rZsN9fVb37qPVgILh+Z3bW2SpAlY30LhCmD3JLsleTRwGHBuzzVJ0kZjveo+qqr7kxwFXABsApxcVdf1XNa4zPsusPWAr+G68fVbNxvk67denWiWJPVrfes+kiT1yFCQJHUMhR44lMcjl+TkJKuSXNt3LfNRkoVJLk5yfZLrkryj75rmkyRbJPlWkqvb6/fBvmuaa55TmLA2lMe/AS8GVjC44urVVXV9r4XNE0n+ALgbOK2qnt53PfNNkp2AnarqyiRbA8uAg/33N5okAbasqruTbAZcBryjqr7Zc2lzxiOFyXMoj3VQVZcCd/Rdx3xVVbdW1ZVt+i7gBmCXfquaP2rg7ja7WXtsUJ+sDYXJ2wW4ZWh+Bf6nVA+SLAKeCVzecynzSpJNklwFrAIurKoN6vUzFKSNUJKtgLOAd1bVnX3XM59U1QNVtSeDERf2SrJBdWMaCpPnUB7qVesLPws4varO7rue+aqqfgpcDOzfcylzylCYPIfyUG/aidJPAzdU1cf6rme+SbIgybZt+jEMLhj5bq9FzTFDYcKq6n5gaiiPG4AzN+ChPOZckjOAbwBPTrIiyZF91zTPPBc4HHhBkqva44C+i5pHdgIuTnINgw94F1bVl3quaU55SaokqeORgiSpYyhIkjqGgiSpYyhIkjqGgiSpYyhIa5HkdUk+uYZlX28/FyV5zcN83vfO5XrSXDAUpHVQVb/fJhcBDysUgFHf7A0FTYyhoI1Okv+e5N+SXJbkjCTvae2XJFncpndIsnxos4Vt+feTfGDouaZGzDweeF77Mti7pu1vpySXtmXXJnlekuOBx7S209t6X0yyrI3Tv6S1zbTen7Yx/a9K8qk2HLs0JzbtuwBpkpI8m8HQInsy+Pd/JYN7CqzNXsDTgXuBK5KcV1VLh5YfDbynql42w7avAS6oquPaG/hjq+pfkxzVBlab8oaquqMNn3BFkrOq6ujh9ZI8FXgV8Nyq+mWSvwdeC5w28osgzcJQ0MbmecAXqupegCSjjjt1YVX9uG1zNrAvsHT2TTpXACe3gei+WFVXrWG9tyc5pE0vBHYHfjxtnRcCz2YQGgCPYTCEszQnDAXpQffzYJfqFtOWTR8PZuTxYarq0nbHuAOBU5J8rKp+7ZN9kv2AFwHPqap7k1wyQw0AAU6tqmNG3b/0cHhOQRubS4GDkzym3Y7y5UPLljP4FA7wimnbvTjJ9q1r52Dga9OW3wVsPdMOkzwRuL2qTgL+F/CstuiX7egBYBvgJy0QngLsM/QUw+tdBLwiyePbc2/fnl+aE4aCNirtVpSfB64Gvsyga2fKR4C3Jvk2sMO0Tb/F4B4E1wBnTTufQGt/oN3Q/V3Tlu0HXN2e91XA37T2E4Fr2gnkfwY2TXIDg5PWw/f87dZr91J+H/CVNlLnhQxG7pTmhKOkaqOW5Fjg7qr6SN+1SOsDjxQkSR2PFCRJHY8UJEkdQ0GS1DEUJEkdQ0GS1DEUJEmd/w8v9kL9kyNpCAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "\"\"\"Simulate a circuit using 1000 repetitions.\"\"\"\n", "# Get a circuit with terminal measurements to simulate.\n", @@ -1174,19 +916,11 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": { "id": "rPqVUsD9snYf" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Counter({'agree': 534, 'disagree': 466})\n" - ] - } - ], + "outputs": [], "source": [ "print(result.histogram(key=\"a,b\", fold_func=lambda bits: \"agree\" if bits[0] == bits[1] else \"disagree\"))" ] @@ -1201,11 +935,11 @@ "\n", "The very first indication that quantum computers could be more powerful than classical computers was provided by David Deutsch in his 1985 paper\n", "\n", - "> David Deutsch, \"[Quantum Theory, the Church-Turing Principle and the Universal Quantum Computer](https://people.eecs.berkeley.edu/~christos/classics/Deutsch_quantum_theory.pdf)\" *Proc. R. Soc. Lond. A* **400** 97–117 (1985). http://doi.org/10.1098/rspa.1985.0070\n", + "> David Deutsch, \"[Quantum Theory, the Church-Turing Principle and the Universal Quantum Computer](https://people.eecs.berkeley.edu/~christos/classics/Deutsch_quantum_theory.pdf){:external}\" *Proc. R. Soc. Lond. A* **400** 97–117 (1985). http://doi.org/10.1098/rspa.1985.0070\n", "\n", "This algorithm was extended by Deutsch and Richard Jozsa to a more convincing algorithmic seperation and what is now called the Deutsch-Jozsa algorithm. A futher improvement was made by Cleve et al.\n", "\n", - "> R. Cleve, A. Ekert, C. Macchiavello, M. Mosca, \"[Quantum algorithms revisited](https://arxiv.org/abs/quant-ph/9708016)\" *Proc. R. Soc. Lond. A* **454** 339–354 (1997). http://doi.org/10.1098/rspa.1998.0164\n", + "> R. Cleve, A. Ekert, C. Macchiavello, M. Mosca, \"[Quantum algorithms revisited](https://arxiv.org/abs/quant-ph/9708016){:external}\" *Proc. R. Soc. Lond. A* **454** 339–354 (1997). http://doi.org/10.1098/rspa.1998.0164\n", "\n", "In this section we will show how to write circuits for the Deutsch algorithm and then as an exercise in using Cirq for algorithms for a small version of the Deutsch-Jozsa algorithm.\n", "\n", @@ -1292,7 +1026,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": { "id": "YtWiBHonly69" }, @@ -1354,38 +1088,11 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": { "id": "aMHzLxztj-gq" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Circuit for f_0:\n", - "0: ───H───H───M───\n", - "\n", - "1: ───X───H───────\n", - "\n", - "Circuit for f_1:\n", - "0: ───H───H───M───\n", - "\n", - "1: ───X───H───X───\n", - "\n", - "Circuit for f_x:\n", - "0: ───H───────@───H───M───\n", - " │\n", - "1: ───X───H───X───────────\n", - "\n", - "Circuit for f_notx:\n", - "0: ───H───────@───H───M───\n", - " │\n", - "1: ───X───H───X───X───────\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Creating the circuit used in Deutsch's algorithm.\"\"\"\n", "def deutsch_algorithm(oracle):\n", @@ -1414,22 +1121,11 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": { "id": "ImffrBgJvLme" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "oracle: f_0 results: q(0)=0000000000\n", - "oracle: f_1 results: q(0)=0000000000\n", - "oracle: f_x results: q(0)=1111111111\n", - "oracle: f_notx results: q(0)=1111111111\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Simulate each of the circuits.\"\"\"\n", "simulator = cirq.Simulator()\n", @@ -1471,7 +1167,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": { "id": "V5ZCXGCrxl4k" }, @@ -1511,7 +1207,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": { "cellView": "form", "id": "qJP_e68e1JBs" @@ -1540,30 +1236,11 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": { "id": "81da6ec6fc5a" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Your result on constant functions:\n", - "q(2)=0000000000\n", - "q(2)=1111111111\n", - "\n", - "Your result on balanced functions:\n", - "q(2)=0000000000\n", - "q(2)=0000000000\n", - "q(2)=0000000000\n", - "q(2)=1111111111\n", - "q(2)=1111111111\n", - "q(2)=1111111111\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Check your answer by running this cell.\"\"\"\n", "simulator = cirq.Simulator()\n", @@ -1581,7 +1258,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": { "cellView": "form", "id": "mUvm9rmRFb4p" @@ -1618,29 +1295,11 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": { "id": "c1b1e989dab2" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Result on constant functions:\n", - "q(2)=0000000000\n", - "q(2)=0000000000\n", - "\n", - "Result on balanced functions:\n", - "q(2)=1111111111\n", - "q(2)=1111111111\n", - "q(2)=1111111111\n", - "q(2)=1111111111\n", - "q(2)=1111111111\n", - "q(2)=1111111111\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Simulate the Deutsch-Jozsa circuit and check the results.\"\"\"\n", "print(\"Result on constant functions:\")\n", @@ -1683,23 +1342,11 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": { "id": "iIpoDaqK4yjV" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0: ───X───@───H───────@───×───@───@───iSwap──────Rx(0.5π)───X^0.5───\n", - " │ │ │ │ │ │\n", - "1: ───Y───@───@───T───@───×───×───@───iSwap──────Ry(0.5π)───────────\n", - " │ │ │ │\n", - "2: ───Z───────X───S───@───────×───X───Rz(0.5π)──────────────────────\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Examples of common gates defined in Cirq.\"\"\"\n", "# Get some qubits.\n", @@ -1741,22 +1388,11 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": { "id": "7SUAT5F17afR" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n", - " [0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n", - " [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n", - " [0.+0.j 0.+0.j 1.+0.j 0.+0.j]]\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Get the unitary of CNOT.\"\"\"\n", "print(cirq.unitary(cirq.CNOT))" @@ -1787,22 +1423,11 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": { "id": "UgoNBN1H8B6h" }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXsAAAEBCAYAAACZhwWsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAwnElEQVR4nO3de3wTZboH8F+aNG1oqKUWEArl0hWsWKUFPKhcdmERFoFWLqWAikd08YIcsHIrArWUFkEuu4Dg7aAil7IFu4goLoU9yEUPloIUSz2Wim5g5VpLSu+Z80dJ6CWTaUJmMvO+z/fz8WObkOSZd548nXnnfd/RCYIggBBCCNP8fB0AIYQQ+VGxJ4QQDlCxJ4QQDlCxJ4QQDlCxJ4QQDlCxJ4QQDhh8HYCY3NxcX4dACCGa06tXL6ePq7bYA+JBSykoKEBUVJSXo7l9FJf71BobxeUeist9nsTm6iCZunEIIYQDVOwJIYQDVOwJIYQDVOwJIYQDVOwJIYQDso3GOXnyJN58801s2rSpweP79+/HunXrYDAYMGbMGCQkJHjtM7PzLFi+txDnS8rRPuQCZg3tjviYcK+9P+FTdp4FKbtOo6S8GgDgpwNsAhBOOUa8pHGOtWrhj2d7hcCbA4VkKfbvvvsudu3aBZPJ1ODx6upqZGRkICsrCyaTCRMmTMCgQYMQFhZ225+ZnWfBvJ2nUF5dCwCwlJRjRuYJzMg8gfAQE30piVsaf/nqs91cFJxyjNwOVzl27UY1Vh2+hPD2Fq/llCzdOBEREVizZk2Tx4uKihAREYE77rgDRqMRvXr1wrFjx7zymcv3FjoKfWOWknLM23kK2XkWr3wWYVt2ngWz/nbS6ZdQDOUYcUdzcqzGVlfXvEWWI/uhQ4fiX//6V5PHrVYrWrZs6fg9KCgIVqtV9H0KCgqa/ZnnS8pdPl9eXYsFn5xE98DSZr+nt1VUVLi1TUpRa1yA8rHtP3sdKw5dchy9u4NyTBzFdYs7OXa+pNxr8Sk6g9ZsNqOsrMzxe1lZWYPi35g7s8fah1yARaLgX68SUFgR7LNTbbXO1lNrXICysWXnWbD263MeFXo7yjHnKK467uZY+xCTW/GpZgZtZGQkzp07h5KSElRVVeHbb79FTEyMV9571tDu0DXj3yVtP0mn2sSp1z89LdoV6A7KMSLGnRwz+NXVNW9R5Mj+008/xY0bNzB+/HjMnTsXU6ZMgSAIGDNmDNq2beuVz4iPCce3565i89c/w9UfzVpBwLydpxyvIQSoO+K6dqP5ffSuUI4RZ9zJMftoHG/mj2zFvkOHDti+fTsAYOTIkY7HBw0ahEGDBsnymWnx0ejdKRTpu/NxsaxG9N+VV9ciZddp+iISAHVfwqTtJ13+m1Yt/LFoZA/Ex4QjO89COUbc4m6OAe5ds2wOVa966Yn4mHB0DyxFYUVwg6GYjZWUVyM7z3vDmog22Yfs1gri54Orx/dskCeUY8QdnuSYHJgr9nb2hkvaflK0ke1/aenLyC+pPtQQk79oflCOESn2I3pXhd5VjnkTs8UeuPUFm5F5wunz1LfKN6k+VJO/Himjerh8D8oxIqY5R/TNyTFvYX5tnPiYcLRq4S/6fHl1rVcnLhDtcLXf9TodMkZHN6tAU44RZ1xN9ATcyzFvYL7YA8CikT1g8teLPi81Pp+wJzvP4nK/r0h4wK0vIeUYaczVPjf5693OsdvFRbGPjwlHxuho6HXOR+LrABoXzRH76bUYT/pQKcdIfdl5FtF5P0of0dtxUeyBui/jioQHnO4AAd5dg4Kom6vT69vpQ6UcI3bL9xY6ne+jg/tnjd7CTbEH6r6MYpdKLCXldOTFAanum9s94qIcI65yTIDvLtRzVewBIDzEJPocrVrINqnum/AQk1e+iJRj/GpOjvkKd8V+1tDuohfSaNQE26S6b7y1DgnlGL+UyjFPMD3O3hmpcdFSSyUT7XK1b715wYxyjF9K5ZgnuDuyB+q+jGKnU346HZ1mMypEZCy8t7pv6qMc45OSOeYuLos9IH6qbZ/xSF9GtmTnWWCtaLpwmb9eJ9upNeUYX3yRY+7gtti7GhdN/arsWb63ENVO7hgRZDTIdsRFOcYXX+SYO7gt9kDdl9Emsm4FzXhkh6uhcL+5cZ9ZT1CO8cGXOdZcXBd7oO62X87QjEc2SA2FE9v/3kQ5xjY15FhzcF/sxW5nSDMe2aCGoXCUY2xTQ441B/fF3tWMRxoip31qGApHOcY2NeRYc3Bf7AHxWW1qOf0inhPbh0oPhaMcY5dackwKFXuID5G7UVVDfaoa94d7WjfpQvHFqTXlGLvUkmNSqNjj1hC5EFPDCRHXblTTeGgNy86zYEeupUEXig7AmF7hih9xUY6xSU05JoWK/U3xMeEICmi6egSNh9YuZxfOBAAHzlzySTyUY+xRW465QsW+HrELLXQRTZvUuD/VGBPxnJb2JxX7esQutNxhEr+/KFGn7DwL/ETuGuXLi6KUY+xQa46JoWJfz6yh3eHv13TnldFFNE2xT3KpdTJz1dcXzijH2KDmHBNDxb6e+JhwmAOb9qlW1wrUp6ohYpNcfHXvz/oox9ig5hwTQ8W+kZIbztexUGMfHHFObF/ZBEEVX0LKMe1Te445Q8W+EbG+NjX2wRHn1L4P1R4fkabFfUjFvhGa/KJ9ap/kQjmmfWrPMWeo2DdCk1+0TQuTXCjHtE0LOeYMFXsnaPKLdmllkgvlmHZpJccak6XY22w2LFy4EOPHj8eTTz6Jc+fONXj+v//7vzF69GiMGTMG//jHP+QI4bZpabIEuUVL+01LsZJbtLrfmh5aeMG+fftQVVWFzMxMnDhxAkuXLsX69esBAKWlpfjoo4/w5Zdfory8HPHx8RgyZIgcYdyW9iEmp3eeockv6mWf5OJs7LMaL5xRjmmP1nKsPlmO7HNzc9G/f38AQM+ePZGfn+94zmQyoX379igvL0d5eTl0IjPQfI0mv2iLFie5UI5pixZzrD5ZjuytVivMZrPjd71ej5qaGhgMdR/Xrl07PPbYY6itrcXUqVNF36egoMCjz6+oqPD4tXbdAwGTvw7VlQ13bHWtgPTd+egeWOqTuOSg1riA5seWvvtnp5Nc/HTAtL6h6B5YioIC9/fZ7cblCuWY77kTlxZzrD5Zir3ZbEZZWZnjd5vN5ij0Bw8exMWLF5GTkwMAmDJlCmJjY3H//fc3eZ+oqCiPPr+goMDj19Z3vfKs08cvldV49P7eisvb1BoX0PzYLpU531eCALz02IPeDotyzE0sxKWFHMvNzRV9TrIbx2q1YtWqVZg3bx6+/PLLJhdbnYmNjcXBgwcBACdOnEC3bt0cz91xxx0IDAyE0WhEQEAAWrZsidJS7/019CYtTpzglVb3lVbj5pHW95VksU9OTkbHjh1x7tw5hIWFYf78+ZJvOmTIEBiNRiQmJiIjIwPz5s3Dxo0bkZOTg969eyM6OhoJCQkYP348OnfujEceecQrG+Ntzia/aKFvjkda3VdajZtHWt9Xkt04JSUlGDt2LHbt2oXY2FjYbDbJN/Xz80NqamqDxyIjIx0/T58+HdOnT/cgXGXZJ0gs31sIS0k59Dpdg3HQap5AwaMAg5+jT7VVC38sGtlD9fuIckxbtJhjds0ajVNUVAQA+Pe//w29vuk0b5bFx4Q7/qLbr8JbSspppqOK2EdJlJTfWmCsolr6oEQtKMfUT+s5BjSj2L/22mtITk7G999/j+nTp2PevHlKxKUqzmbM0UxH9WBh/7CwDSxjYf9IduNYLBZkZmY6ft+zZw/uvfdeWYNSG63OmOMFC/uHhW1gGQv7R7TYHzhwAMePH8dnn32GvLw8AHVDKHNycjB8+HDFAlQDsZmOWrkKzzoW9g8L28AyFvaPaDfOPffcg65duyIgIABdunRBly5d8Lvf/Q4rV65UMj5VcHYVXoe6ZU6Jb2XnWVBWWdPkcS2NkgAox9SMlRwTPbJv164dHn/8ccTFxcHP79bfhIsXLyoSmJrEx4Tj23NXsfnrnx3LmgoAduRa0LtTqGauxrPGftGscV+q1kZJAJRjasVSjkleoF2zZg369u2LXr16oUePHvjP//xPJeJSnQNnLqHxihhau0DDGrH7gLYwGjT1JbSjHFMflnJMstjv378fBw8exMiRI7Fnzx60bdtWibhUh4ULNKxhbZ+wtj0sYGmfSBb71q1bw2g0oqysDJ06dUJ1tfObJbNO61OlWcTaPmFte1jA0j6RLPZ33XUXsrKyYDKZsGLFCtWuYyM3um+o+mjxPqCuUI6pD0s5JjnOPjU1FRcuXMCwYcPwySefcDkaB7g1bT1l1+kGs+js9w2t/2+I/LR6H1BXKMfUhbUcEz2yr62tRVVVFaZPn442bdrAaDRi3LhxeP3115WMT1XovqHqodX7gEqhHFMP1nJM9Mh+x44d2LBhAy5fvoxhw4ZBEATo9Xr06tVLyfhUh6ULNlrG8n5gedu0hLX9IFrsExISkJCQgKysLIwdO1bJmFSNhZl0LGB5P7C8bVrC2n6QvEB73333IS8vDydPnsTkyZNx9OhRJeJSLa2vac0KlvcDy9umJaztB8lin5KSAqPRiPXr12PmzJlYu3atEnGpVnxMODJGRyPE5O94LNBflvu2ExHZeRZHf6r+5g3rw0NMyBgdrckLZ41RjvkeizkmORrHaDTi7rvvRnV1NXr27Nlg6QSeVdbcWsuaRksop/H09VpBcBxtsdb2lGO+wWqOSVZunU6H2bNnY8CAAdizZw/8/f2lXsI8Fta21ipe2p6X7VQjVtte8sh+1apVOHXqFAYMGIBvvvmG23H29bF2lV5LeGl7XrZTjVhte8kj+9DQUAwcOBA6nQ59+/ZFSEiIAmGpG0tTqLWGl7bnZTvViNW2pw54D7B2lV5LeGl7XrZTjVhte8luHNKU/SLN8r2FsJSUQ6/TNejT0/JFHC0IMPg5+lS1uK54c1CO+RaLOSZa7F3dWDwjI0OWYLTEvuPrX7W3lJTTiAkZObuRREW1zcUrtI1yTHks55hoN87w4cMxfPhw/Pbbb+jatSvGjh2L7t27o6qqSsn4VI3Vq/ZqxWN787jNvsRye4sW+/79+6N///6oqKjAc889h169euHpp5/G1atXlYxP1Vi9aq9WPLY3j9vsSyy3t+QF2hs3buDo0aOwWq346quvUFlZqURcmsDqVXu14rG9edxmX2K5vSWL/ZIlS/Dhhx9izJgxyMzMxBtvvKFEXJrA6lV7teKxvXncZl9iub0lR+NERkZiw4YNSsSiOc5uNkFrmMij8VoltYKA8BCT5qewS6EcUw7rOSZZ7Dds2ID33nsPgYGBjscOHToka1BaQ2uYyIvVtUrcQTkmLx5yTPIQYc+ePfjqq69w6NAhx3/kFpav3qsF723M+/YrgYc2liz2HTp0aHBUTxpi+eq9WvDexrxvvxJ4aGPJbpzq6mqMHDkS3bp1A1C3CuaKFStkD0wrWLubjRrx3sa8b78SeGhjyWL/3HPPuf2mNpsNKSkpKCwshNFoRFpaGjp16uR4/n/+53+wbt06CIKAHj16YNGiRdDdvEGA1swa2r3JjDtWrt6rBe9tzPv2K4GHNpYs9ufPn3f7Tfft24eqqipkZmbixIkTWLp0KdavXw8AsFqtWL58OT766COEhobi3XffxbVr1xAaGup+9CpAa5gog8W1SpqLckwZrOeYZLEvKioCAAiCgIKCAoSEhCA+Pt7la3Jzc9G/f38AQM+ePZGfn+94Li8vD926dcMbb7yBX375BePGjdNsobejNUzks//sdaz9+hyTa5W4g3JMPiyvh1OfZLFPSkpy/CwIAqZOnSr5plarFWaz2fG7Xq9HTU0NDAYDrl27hm+++QbZ2dlo0aIFJk2ahJ49e6JLly5N3qegoKC529FARUWFx6/1VPrun51ezU/fnY/ugaU+i6s51BoXAHyQe1WyXX2Bcsw9ao6rOe3qC95uM8liX3/hs0uXLuFf//qX5JuazWaUlZU5frfZbDAY6j4qJCQE0dHRaN26NQCgd+/eKCgocFrso6KipLfAiYKCAo9f66lLZWdFHq9xxOKLuJpDrXEBwOUb0u3qC5Rj7lFzXJfKapw+p8Ucy83NFX1OstgPGzbM8XNgYCCmTJki+YGxsbE4cOAAhg8fjhMnTjhG8gBAjx498MMPP+Dq1asIDg7GyZMnkZCQIPmeasfD1XxfaB1kwEUnX0Ye25VyTB68tKtksd+/fz8A4MqVK2jVqhX8/KSnag8ZMgSHDx9GYmIiBEFAeno6Nm7ciIiICAwePBhJSUl49tlnAdT9Man/x0CreLia7wuTY1th7ddXqV1BOSYXXtpVsth/8803mD9/PsxmM0pLS7F48WI88sgjLl/j5+eH1NTUBo9FRkY6fn7sscfw2GOPeRiyOtEaJt6XnWfBh8evMbtWibsox7xv/9nr2HLqAhc5JlnsV69ejc2bN6Nt27b49ddfMW3aNMlizzNaw8Q7eFirxFOUY96RnWfBX49cRmWtAID9HJM8LNDr9Wjbti0AoG3btggICJA9KK3iYX0NpVBbOkft4j3L9xY6Cr0dy20peWRvNpuxadMm9OnTB8eOHcMdd9yhRFyaxMP6GkqhtnSO2sV7eGtLySP75cuX4/z581i1ahUuXLiA9PR0JeLSJJbvcqM0akvnqF28h7e2lCz2KSkpmDNnDt5++23Mnj2bjuxdYPkuN0qjtnSO2sV7Zg3tjgB9wzW5WG7LZk2qOnPmDLp06eJYrMxoNMoemBZJrWHSnVaKdgvra5V4gnLMO+x3paqsFZgfhWMnWeyLi4vx4osvOn7X6XTIycmRNSgtc7WGybS+oVDhJELV4WWtEk9Rjt0eXkd6SRb73bt3KxEHU8RGTHx4/BpeYmt6gSxcjThh+cvoDsoxz/GaX5LF/tFHH0Vt7a2GMRgMaNeuHWbNmoUePXrIGpxWiV3NF1uDgzTE2ygJT1COeY7X/JK8QNu3b18sXrwYn3/+OdLT0xEdHY2pU6ciLS1Nifg0Sexqfusgyb+tBPyNkvAE5ZjneM0vyWJfXFyMhx9+GEajEf/xH/+BS5cu4aGHHmrWGjm8EhsxMTm2lY8i0hYacSKNcsxzvOaX5GGA0WjE1q1bERMTg7y8PBiNRuTn5zfo2iEN1R8xcb6kHO1vXuX35drYWiLWfiz3p7qLcsxzvOaXZLF/8803sWHDBuTk5KBbt25YtmwZvvvuOyxZskSJ+DQrPiYc8THhjiFeMzNPoHWQAckjgplPqtthby/7l/DV/q3x0mMP+josVWpctJbvLcTEaDONxpFQP8daBxm4KPRAM4p9q1atMG/evAaPDRw4ULaAWNJ4iNfFshpatMqFxu1lKSnHX49UILy9hdrLCWov9/H8naSOdxnRolXucdZelbUCtZcIai/38fydFC32x44dA9DwtoTEPbwO8fIUtZd7qL3cx3ObiRb7tLQ03LhxA1OmTEF1dTWqqqoc/5Hm4XWIl6eovdxD7eU+nttMtNj369cPo0aNwsmTJzF06FAMGzYMw4YNw5/+9Ccl49M0Xod4ecpZewXoddReIqi93Mfzd1L0Au2sWbMwa9YsrFu3Di+99JKSMTGDbiPXfPYREo1vDzcx2sz8hTNPOVsUrX6fPbVbQ85yrE2QAckj7uOirSRH44wePRrTp09HUVEROnfujOTkZISHs98w3kS3kXPN1cJUNG7cNVeLotV/nndiOTY5thU3bSR5mLlgwQLExcVh69atePzxx5GcnKxEXMzg+ep/c1Eb3R5qP2muFo7jhWSxr6ysxODBgxEcHIw//vGPNHPWTTxf/W8uaqPbQ+0njRaOa0axr62tRWFh3RGC/f+k+Xi++t9c1Ea3h9pPGi0c18xunOTkZAwYMADz58/Ha6+9pkRczOD56n9zURvdHmo/abRwXDMu0EZFRWHHjh1KxMIkqdvI8XJxSIrYLQgLCugCrRTKseZxlmM8DQCgcYAKiI8Jd9zcuFYQANwaMZGdZ/FxdL5lHyVhH5oK0C0IPUE5Jo5yrA4Ve4XYb25cH42YoJEk3kQ55hzlWB3JYp+amoqCggIlYmEajZhwjtrFe6gtnaN2qSNZ7H//+99jw4YNSExMxJYtW2C1WpWIizk0YsI5ahfvobZ0jtqljmSxHzBgAP7yl7/grbfeQm5uLvr374+5c+fi559/ViI+Ztj7U+ujERM0ksSbKMecoxyrI1nsi4qKsHz5cjzxxBMIDg7G5s2bMXHiRMyYMUOB8NgRHxOO6Q+HIcTk73iM93VyGq9VAgDhISZkjI6mESQeoBxrinLsFsmhl6+99hrGjRuHadOmwWS6ddozZswY0dfYbDakpKSgsLAQRqMRaWlp6NSpU5N/8+c//xmDBw/GhAkTbmMTtIXWyanjaj0c3trC2yjH6lCONST5Z79///4YPXq0o9CvWLECADBp0iTR1+zbtw9VVVXIzMxEUlISli5d2uTfrF69GqWl/IxxBYAPj1+jUQE30QgJeVCO3UI51pDokf3f/vY3ZGVloaioCAcPHgRQt3RCTU0NkpKSXL6pvW8fAHr27In8/PwGz3/xxRfQ6XSOf8MLsXU4eBsVANAICblQjt1COdaQaLGPi4vDQw89hLfffhvPP/88AMDPzw933nmn5JtarVaYzWbH73q9HjU1NTAYDPjhhx+we/du/PWvf8W6detcvo+nQz4rKipUOVw0rIUel240XUiudZDBp/H6or1aBxlw0UlhatwWat2Xao2LcuyW5uSYWvcj4P3YRIt9YWEhoqOj8eijj6K4uNjxeFFREfr16+fyTc1mM8rKyhy/22w2GAx1H5WdnY1ff/0VkydPhsVigb+/P8LDwzFgwIAm7xMVFeX2BgF1fyQ8fa2cnu51HWu/vtrg1NLkr0fyiPsQFeW7PkRftFfyiOAG/amA87ZQ675Ua1yUY7c0J8fUuh8Bz2LLzc0VfU602B89ehTR0dHYs2dPk+ekin1sbCwOHDiA4cOH48SJE+jWrZvjudmzZzt+XrNmDcLCwpwWehYN6toS4e3DaQ2Tm8TWwyGeoxxriHLsFtFi//TTT6Oqqgqvv/662286ZMgQHD58GImJiRAEAenp6di4cSMiIiIwePDg2wpY6+jOQk1HSQB8rlUiF8oxyjFnRIv9sGHDoNM1nKAhCAJ0Oh1ycnJcvqmfnx9SU1MbPBYZGdnk37388svuxMoMV6MEePgi8r79SuC9jXnffmdEi/3+/fuVjIMrvI8S4H37lcB7G/O+/c6IFvvU1FQsXLgQ48ePb3KEv23bNtkDY1n7EBMsTpKOl7U6eN9+JfDexrxvvzOixf7FF18EAKxcuVKxYHgxa2h3p6MEeFmrg/ftVwLvbcz79jsjWuzDwsIA1A2bXLZsGX766SfcfffdmDVrlmLBscreZ5iy67Tjhgq8rGHSeK2SWkFAeIiJ2ynscqEcoxxrTHLvJycnY+zYsdiyZQtGjBiB5ORkJeLigrM1TFi+q5B9hIT99Jr3tUqUQDlGOWYnWez1ej0GDhyIli1bYtCgQbDZ+B6+5C08rtvB4zb7Eo/tzeM2N5doN86hQ4cAACaTCe+++y769OmD7777ztG9Q24Pj6MFeNxmX+KxvXnc5uYSLfafffYZACAkJARnz57F2bNnAQBGo1GZyBjH42gBHrfZl3hsbx63ublEi31GRobTxy9evChbMDzhcbQAj9vsSzy2N4/b3FySNy/5y1/+gq1bt6K6uhoVFRXo3Lmz46ifeM5+sYi3NUxorRLlUI5RjtUneYF2//79OHjwIEaOHIk9e/agbdu2SsTFhfiYcMf9MWsFAcCtNUxYGzFhHyVhHwYI0FolSqAcoxyzkyz2rVu3htFoRFlZGTp16oTq6mqplxA38DJ6gJftVCNe2p6X7fSUZLG/6667kJWVBZPJhBUrVnB3K0G58TJ6gJftVCNe2p6X7fSUZLFPTU3Fww8/jNmzZ6NNmzaOe9AS7xAbJcDa6AFetlONeGl7XrbTU5LF/rfffsNHH32EV199FRcvXqQ+ey+z96fWx+LoAV62U414aXtettNTksV+zpw5iIiIwIwZM9C2bVvMmTNHibi4ER8TjozR0Qgx+TseY20Nk8ZrlQBAeIgJGaOjaZSEAijHKMeAZgy9rKysxMSJEwEA99xzD/bu3St7UDxytoYJoP3hcY3vGERrlfgO5RjfRP+8FxcXo7i4GK1atcLnn3+OS5cuIScnBx06dFAyPi6wPIqA5W3TEpb3A8vb5k2iR/YLFy50/LxlyxZs3brVcVtC4l0sjyJgedu0hOX9wPK2eZNosd+0aZPj52vXruGXX35Bhw4dEBoaqkhgPGF5PQ+Wt01LWN4PLG+bN0lepfn888+RmJiIDRs2YPz48fj73/+uRFxccTaKAABuVNVofpbjH+5pjcbngjRCQnmUY0TyAu0HH3yAnTt3IigoCFarFZMnT0ZcXJwSsXHD2V2FAO1fRMvOs2BHrgVCvcd0AMb0Ctfk9mgZ5RiRPLLX6XQICgoCAJjNZgQEBMgeFI/iY8IRFND0b6+WLzQ5u3AmADhw5pJvAuIc5RjfJI/sO3bsiKVLl6J379749ttvERERoURcXGLtQhNr28MC1vYJa9sjJ8kj+yVLlqBjx444cuQIOnbsiMWLFysRF5dYm+7N2vawgLV9wtr2yEmy2D///POYNGkSFi5ciEmTJsHf31/qJcRDrE33Zm17WMDaPmFte+Qk2Y0THByMnJwcdO7cGX5+dX8bunTpIntgPHJ2EU2r09obT1+vFQSEh5hoVqOPUY7xS7LYX7lyBR988IHjd51Oh48++kjOmLin9WntNH1d/SjH+OOy2FutVrzzzjswmaj/Symupn5rJYlZ2AaWsbB/WNgGpYmev3388ccYNWoU4uLi8NVXXykZE9dYGF3AwjawjIX9w8I2KE202O/evRtffPEFtm3bhg8//FDJmLjGwugCFraBZSzsHxa2QWmixd5oNMJoNCI0NJTuO6sgFqa10/R1daMc45PkBVoAEARB+h/VY7PZkJKSgsLCQhiNRqSlpaFTp06O5z/44AN89tlnAICBAwdi2rRpbr0/y7Q+rZ2mr6sf5RifRI/sf/zxRyQlJeGVV15x/Gz/T8q+fftQVVWFzMxMJCUlYenSpY7nfvnlF+zatQvbtm3D9u3bcejQIZw5c8Y7W8MILU9rp+nr2kA5xh/RI/vVq1c7fk5MTHTrTXNzc9G/f38AQM+ePZGfn+947q677sJ7770Hvb7uNLKmpobW23FCqxegtBo3j7S6r7Qat6+JFvsHH3zQ4ze1Wq0wm82O3/V6PWpqamAwGODv74/Q0FAIgoBly5bh3nvvFZ2kVVBQ4NHnV1RUePxaObkTV+sgAy6W1Th93Nvb5s328nbcLOxLJVGOufcZat2PgPdja1afvbvMZjPKysocv9tsNhgMtz6qsrISycnJCAoKwqJFi0TfJyoqyqPPLygo8Pi1cnInruQRwQ0mjQB1/ZKPRrf3+rZ5q72y8yyosjW9k5nJX4/kEfchKsr9/lQW9qWSKMfcyzG17kfAs9hyc3NFn5NlnnRsbCwOHjwIADhx4gS6devmeE4QBLz44ovo3r07UlNTHd05pKH4mHCM6RXeYMSBAGBHrkWVIybsMxrrX/ADgFYt/JExOpounKkQ5RhfZDmyHzJkCA4fPozExEQIgoD09HRs3LgRERERsNls+N///V9UVVU5Jmu98soriImJkSMUTTtw5hIaj4NS6yxBZxfNAKCF0aC6WMktlGP8kKXY+/n5ITU1tcFjkZGRjp9PnTolx8cyR0sXorQUK7lFS/tNS7GqkTaXu+OE2GxAP51OdafZIS2cL31NMxrVjXKMH1TsVUxspmOtIGDezlOq+TJm51lgrWg6OsJfr6MZjSpHOcYPKvYqFh8TjozR0dDrmo4+UNPkl+V7C1FtazrLOoj6UlWPcowfVOxVLj4mHDaR5SrU0lcpFsdv5bSmkhZQjvGBir0GqH2FP7XHR6SpfR+qPT4toGKvAc76VXWoW/nP17LzLCirbNqXSisQagvlGPuo2GuAWie/0CQXdlCOsY+KvUa4mvziKzTJhS2UY2yjYq8RapxQosaYiOfUuD/VGJNWUbHXCDVOfqFJLmyhHGMbFXuNUNvkF5rkwh7KMbZRsdcItU1+oUku7KEcYxsVew1R0+QXmuTCJsoxdlGx1xixvso7TM77NuWQnWeBn5OjP4D6UllAOcYmKvYaM2tod/j7Nf0SlFXVKNKnah/3XOvk6I8mubCBcoxNVOw1Jj4mHObAprchqK4VFOlTFRv3rNfpaJILIyjH2ETFXoNKbjjvs7SUlMt+5GUR6Ue1CQJ9CRniqxzLzrNQjsmEir0GueqzlHOIXHaeBc57UakflTW+yDF7940nMRFpVOw1SGw8NCDvELnlewubTKcH6hbMon5Utvgix8S6bwDqq/cGKvYaZB8PLUaOU21Xp9fCzZgIO5qTY97m6j2pr/72UbHXqPiYcIQrdKotdXrtKg6iXa5yTAd49YDCVRdheIiJCr0XULHXMKVOten0ml+zhnZ3WoQFwKtdOdRFKD8q9hqmxKm2q+4bgE6vWRcfE+60CAPe6y6kLkJlULHXODlPtZvTfUNfRPbJ2V1IXYTKoWLPAFen2knbT3r8ZXz909PUfUMkuwspx7SBij0DXJ1qe7o8bXaeBddEJtYA1H3DE6nuQsoxbaBizwhXp7ueXKx19e+p+4Y/UqO/KMfUj4o9I1ydagPuXayVuihLp9Z8ohzTNir2jHB14wm7mNQvJU+1X8s+hZmZJ0SfDzH50xEXpyjHtI2KPUPiY8KxIuEB0ckp125Uu+xbzc6zYPPXP4v2/5v89UgZ1cMrsRJtohzTLir2jHF1sRao61tN2XW6yePZeRYkbT/p8rV0wYwAlGNa1XTRai+w2WxISUlBYWEhjEYj0tLS0KlTJ8fz27dvx7Zt22AwGPDCCy/gD3/4gxxhcCs8xOSyP7SkvBqd537m9nvSl5DYUY5pjyxH9vv27UNVVRUyMzORlJSEpUuXOp67dOkSNm3ahG3btuH999/HypUrUVVVJUcY3JK6kOYumrJOGqMc0x5Zin1ubi769+8PAOjZsyfy8/Mdz3333XeIiYmB0WhEy5YtERERgTNnzsgRBrfsF9JCvHDPUB2ASX0j6IiLNEA5pj2ydONYrVaYzWbH73q9HjU1NTAYDLBarWjZsqXjuaCgIFitVqfvU1BQ4NHnV1RUePxaOSkZV/dAYGtCR4zf9hNKK20evYefDkjq1xqDuhp81p60L91DOeYete5HwPuxyVLszWYzysrKHL/bbDYYDAanz5WVlTUo/vVFRUV59PkFBQUev1ZOvogrNT4Y83aeEp2SLkYHYGVCT58fbdG+dA/lmHvUuh8Bz2LLzc0VfU6WbpzY2FgcPHgQAHDixAl069bN8dz999+P3NxcVFZW4vr16ygqKmrwPPEuT0636bSauINyTBtkObIfMmQIDh8+jMTERAiCgPT0dGzcuBEREREYPHgwnnzySUycOBGCIGDmzJkICAiQIwxyU3xMOOJjwpGdZ0HKrtMoKW+6HomfDrAJdSMiZg3tTl9C4hbKMfWTpdj7+fkhNTW1wWORkZGOnxMSEpCQkCDHRxMX7F/IxtR8Kku0hXJMvWhSFSGEcICKPSGEcICKPSGEcICKPSGEcICKPSGEcEAnCIKrReh8xtXkAEIIIc716tXL6eOqLfaEEEK8h7pxCCGEA1TsCSGEA7LMoPUFqRumKK26uhrJycmwWCyoqqrCCy+8gHbt2mHq1Kno3LkzAGDChAkYPny44rE9/vjjjlVJO3TogPHjx2PJkiXQ6/Xo168fpk2bpnhMALBz50588sknAIDKykoUFBRg5cqVeOONN9CuXTsAwMsvv4wHH3xQsZhOnjyJN998E5s2bcK5c+cwd+5c6HQ63H333Vi0aBH8/Pywdu1a/POf/4TBYEBycjLuv/9+ReMqKCjA4sWLodfrYTQa8cYbbyAsLAxpaWk4fvw4goKCAABvvfWW6KKDcsT1/fffO813X7fXzJkzcfnyZQCAxWLBAw88gFWrVuGFF17AtWvX4O/vj4CAALz33nuyxuSsRvzud7+TL8cERuzdu1eYM2eOIAiCkJeXJzz//PM+jScrK0tIS0sTBEEQrl27JgwcOFDYvn278P777/s0roqKCiEuLq7BY6NGjRLOnTsn2Gw24dlnnxVOnz7tm+DqSUlJEbZt2yasXLlS+OKLL3wSwzvvvCOMGDFCGDdunCAIgjB16lTh66+/FgRBEBYsWCB8+eWXQn5+vvDkk08KNptNsFgswujRoxWPa9KkScL3338vCIIgbN26VUhPTxcEQRASExOFK1euyB6PWFzO8l0N7WVXUlIijBo1Svj1118FQRCEP/3pT4LNZpM9HjtnNULOHGOmG8fVDVN8YdiwYfiv//ovAIAgCNDr9cjPz8c///lPTJo0CcnJyaLr+MvpzJkzKC8vxzPPPIOnnnoKx44dQ1VVFSIiIqDT6dCvXz8cOXJE8bjqO3XqFH788UeMHz8ep0+fxo4dOzBx4kQsXboUNTU1isURERGBNWvWOH4/ffq046xiwIABOHLkCHJzc9GvXz/odDq0b98etbW1uHr1qqJxrVy50rHuTG1tLQICAmCz2XDu3DksXLgQiYmJyMrKkjUmZ3E5y3c1tJfdmjVr8MQTT6BNmza4fPkySktL8fzzz2PChAk4cOCArDEBzmuEnDnGTLEXu2GKrwQFBcFsNsNqtWL69OmYMWMG7r//fsyePRubN29Gx44dsW7dOsXjCgwMxJQpU/D+++/j9ddfx7x582AymRrEff36dcXjqu/tt9/GSy+9BAB45JFHsGDBAmzevBk3btzAtm3bFItj6NChjvswAHVfSJ1OB+BWOzXOOyXar3Fcbdq0AQAcP34cH3/8MZ5++mncuHEDTzzxBJYvX4733nsPW7Zskf2OcI3jcpbvamgvALhy5QqOHj2K0aNHA6jrUnnmmWewbt06rF27FhkZGbhy5YqscTmrEXLmGDPF3tUNU3zlwoULeOqppxAXF4eRI0diyJAhuO+++wDULQP9/fffKx5Tly5dMGrUKOh0OnTp0gUtW7ZESUmJ4/mysjIEBwcrHpddaWkpiouL0bdvXwDAmDFj0LFjR+h0OgwePNgnbWbn53fr62JvJ3duxiOnPXv2YNGiRXjnnXcQGhoKk8mEp556CiaTCWazGX379lX89p/O8l0t7fXFF19gxIgR0Ovr7qMbFhaGxMREGAwG3HnnnYiKikJxcbHscTSuEXLmGDPF3tUNU3zh8uXLeOaZZzBr1iyMHTsWADBlyhR89913AICjR4+iR48eiseVlZXluAH8r7/+ivLycrRo0QI///wzBEHAoUOH0Lt3b8Xjsjt27BgeeughAHVH0qNGjcK///1vAL5rM7t7770X33zzDQDg4MGD6N27N2JjY3Ho0CHYbDacP38eNpsNoaGhisb197//HR9//DE2bdqEjh07AgB++uknTJgwAbW1taiursbx48cVbztn+a6G9rLHM2DAAMfvR44ccXSplJWV4f/+7//QtWtXWWNwViPkzDFmRuM4u2GKL23YsAGlpaV466238NZbbwEA5s6di/T0dPj7+yMsLAyLFy9WPK6xY8di3rx5mDBhAnQ6HdLT0+Hn54dXX30VtbW16NevHx544AHF47IrLi5Ghw4dAAA6nQ5paWmYNm0aAgMDERkZ6dP7IMyZMwcLFizAypUr0bVrVwwdOhR6vR69e/fG+PHjYbPZsHDhQkVjqq2txZIlS9CuXTu8/PLLAIA+ffpg+vTpiIuLQ0JCAvz9/REXF4e7775b0dhSUlKwePHiBvluNpt92l52xcXFjj+MADBw4EAcOnQICQkJ8PPzwyuvvCL7HyFnNWL+/PlIS0uTJcdoBi0hhHCAmW4cQggh4qjYE0IIB6jYE0IIB6jYE0IIB6jYE0IIB5gZekmIN7zzzjs4cuQIampqoNPpMGfOHPj7+6O0tBR9+vTxdXiEeIyKPSE3/fjjj9i/fz+2bt0KnU6HgoICzJkzB0OGDEFYWBgVe6JpVOwJually5Y4f/48srKyMGDAAERFRWH9+vV48skn4e/vjx49eqCiogKrVq2CXq9Hx44dkZqaik8//RT79u1DWVkZrl27hpdeeglDhw719eYQ0gBNqiKkntOnT+Pjjz/G0aNHERgYiJkzZ+KHH35wrJ0ybNgwbNmyBXfeeSdWr16N9u3bw2Aw4NNPP8X777+Pq1evYty4cfjHP/7h87WZCKmPspGQm86dOwez2YyMjAwAdUstP/fccxgxYgTCwsJw9epVXLx4ETNmzAAAVFRU4OGHH0anTp3Qp08f+Pn5ISwsDMHBwbh69apjNUpC1ICKPSE3FRYWIjMzE+vXr4fRaESXLl0QHByMkJAQ2Gw2tGrVCnfddZfjjk85OTlo0aIFLly4gNOnTwOoW9zKarXizjvv9PHWENIQFXtCbnr00UdRVFSEsWPHokWLFhAEAbNnz4bBYMCyZcsQGRmJ+fPn489//jMEQUBQUBCWLVuGCxcu4PLly5g8eTKuX7+ORYsWOZbOJUQtqM+ekNu0c+dOnD17Fq+++qqvQyFEFE2qIoQQDtCRPSGEcICO7AkhhANU7AkhhANU7AkhhANU7AkhhANU7AkhhANU7AkhhAP/D1Lf64p4lP3pAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "\"\"\"Plot the probability of measuring a qubit in the ground state.\"\"\"\n", "# Get a qubit.\n", @@ -1838,22 +1463,11 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": { "id": "iynhJEvoCIro" }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "\"\"\"Plot the probability of measuring a qubit in the ground state by sampling.\"\"\"\n", "# Number of times to sample.\n", @@ -1907,7 +1521,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "metadata": { "id": "Y2a7t2qmLDTb" }, @@ -1937,19 +1551,11 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "metadata": { "id": "28f06d1baf9b" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "a: ───ζ───\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Using the custom gate in a circuit.\"\"\"\n", "a = cirq.NamedQubit('a')\n", @@ -1968,20 +1574,11 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "metadata": { "id": "x9dHKNfgMoyz" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[ 0.6 0.8]\n", - " [-0.8 0.6]]\n" - ] - } - ], + "outputs": [], "source": [ "print(cirq.unitary(rg))" ] @@ -1997,19 +1594,11 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "metadata": { "id": "_RXBrSQ8PWnu" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0.6+0.j -0.8+0.j]\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Simulate a circuit with a custom gate.\"\"\"\n", "circuit = cirq.Circuit(rg(a))\n", @@ -2056,20 +1645,12 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "metadata": { "cellView": "form", "id": "9htgTzqAYHsA" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[]\n" - ] - } - ], + "outputs": [], "source": [ "#@title Attempt the solution here\n", "\"\"\"Define a custom controlled cirq.rx gate here.\"\"\"\n", @@ -2092,23 +1673,12 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "metadata": { "cellView": "form", "id": "XaG8n5bdGgf2" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[1. +0.j 0. +0.j 0. +0.j 0. +0.j ]\n", - " [0. +0.j 1. +0.j 0. +0.j 0. +0.j ]\n", - " [0. +0.j 0. +0.j 0.707+0.j 0. -0.707j]\n", - " [0. +0.j 0. +0.j 0. -0.707j 0.707+0.j ]]\n" - ] - } - ], + "outputs": [], "source": [ "#@title Expand to view the solution\n", "\"\"\"Defining a custom controlled cirq.Rx gate.\"\"\"\n", @@ -2146,22 +1716,11 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "metadata": { "id": "a1cd089df7ba" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Circuit diagram:\n", - "a: ───@───────────\n", - " │\n", - "b: ───Rx(0.25π)───\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Display a circuit with the custom gate.\"\"\"\n", "# Get qubits.\n", @@ -2197,7 +1756,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "metadata": { "id": "9G-9_29h09Mx" }, @@ -2227,22 +1786,11 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "metadata": { "id": "370e8528c762" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "a: ───HX───\n", - "\n", - "[[ 0.70710678+0.j -0.70710678+0.j]\n", - " [ 0.70710678+0.j 0.70710678+0.j]]\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Use the gate in a circuit.\"\"\"\n", "HX = HXGate()\n", @@ -2264,19 +1812,11 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": null, "metadata": { "id": "47ec94cdecf3" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "a: ───Y^0.5───X───X───\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Decompose the gate.\"\"\"\n", "print(cirq.Circuit(cirq.decompose(circuit)))" @@ -2293,19 +1833,11 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": null, "metadata": { "id": "AS-YMmAv6zUg" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "a: ───H───X───\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Decompose the gate once.\"\"\"\n", "print(cirq.Circuit(cirq.decompose_once(HX(a))))" @@ -2339,20 +1871,11 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": null, "metadata": { "id": "YnaqZI6dRNxX" }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/google/home/dabacon/github/quantumlib/Cirq/cirq-core/cirq/ops/gateset.py:356: UserWarning: v0.14.1 is the last release `cirq.GlobalPhaseGate` is included by default. If you were relying on this behavior, you can include a `cirq.GlobalPhaseGate` in your `*gates`. If not, then you can ignore this warning. It will be removed in v0.16\n", - " warnings.warn(\n" - ] - } - ], + "outputs": [], "source": [ "# Insert a type (eg: cirq.XPowGate) to accept all instances of that type.\n", "# Insert an instance (eg: cirq.CNOT) to accept only one specific instance of the type.\n", @@ -2381,23 +1904,11 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "metadata": { "id": "0afe36a32636" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Circuit with parameterized gates:\n", - "\n", - "a: ───X^s───\n", - "\n", - "b: ───X^s───\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Define a circuit with parameterized gates.\"\"\"\n", "# Import sympy for parameterized values.\n", @@ -2429,28 +1940,11 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": null, "metadata": { "id": "TIaVRzCD4deU" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "s=0: [1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n", - "\n", - "s=1: [ 0.6 +0.6j 0.25-0.25j 0.25-0.25j -0.1 -0.1j ]\n", - "\n", - "s=2: [0. +0.5j 0.5+0.j 0.5+0.j 0. -0.5j]\n", - "\n", - "s=3: [-0.1 +0.1j 0.25+0.25j 0.25+0.25j 0.6 -0.6j ]\n", - "\n", - "s=4: [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Simulate the circuit at multiple parameter values.\"\"\"\n", "simulator = cirq.Simulator()\n", @@ -2475,38 +1969,11 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": null, "metadata": { "id": "Gj_Y3Lrh49o9" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "params: OrderedDict([('s', 0.0)])\n", - "a=0000000000\n", - "b=0000000000\n", - "\n", - "params: OrderedDict([('s', 0.125)])\n", - "a=0000000000\n", - "b=0000001000\n", - "\n", - "params: OrderedDict([('s', 0.25)])\n", - "a=1100000000\n", - "b=0000010000\n", - "\n", - "params: OrderedDict([('s', 0.375)])\n", - "a=0000010010\n", - "b=0001010001\n", - "\n", - "params: OrderedDict([('s', 0.5)])\n", - "a=1010000010\n", - "b=0110011100\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Simulate the circuit at multiple parameter values.\"\"\"\n", "# Get a list of param resolvers.\n", @@ -2538,107 +2005,11 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": null, "metadata": { "id": "074f9fd5cdcd" }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
sab
count50.00000050.00000050.000000
mean0.2500000.1800000.220000
std0.1785710.3880880.418452
min0.0000000.0000000.000000
25%0.1250000.0000000.000000
50%0.2500000.0000000.000000
75%0.3750000.0000000.000000
max0.5000001.0000001.000000
\n", - "
" - ], - "text/plain": [ - " s a b\n", - "count 50.000000 50.000000 50.000000\n", - "mean 0.250000 0.180000 0.220000\n", - "std 0.178571 0.388088 0.418452\n", - "min 0.000000 0.000000 0.000000\n", - "25% 0.125000 0.000000 0.000000\n", - "50% 0.250000 0.000000 0.000000\n", - "75% 0.375000 0.000000 0.000000\n", - "max 0.500000 1.000000 1.000000" - ] - }, - "execution_count": 49, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "results = simulator.sample(\n", " program=circuit,\n", @@ -2660,29 +2031,11 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": null, "metadata": { "id": "zOymGxlb72Fk" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cirq.ParamResolver({'x': 0.0})\n", - "cirq.ParamResolver({'x': 0.1})\n", - "cirq.ParamResolver({'x': 0.2})\n", - "cirq.ParamResolver({'x': 0.3})\n", - "cirq.ParamResolver({'x': 0.4})\n", - "cirq.ParamResolver({'x': 0.5})\n", - "cirq.ParamResolver({'x': 0.6})\n", - "cirq.ParamResolver({'x': 0.7})\n", - "cirq.ParamResolver({'x': 0.8})\n", - "cirq.ParamResolver({'x': 0.9})\n", - "cirq.ParamResolver({'x': 1.0})\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Alternative method of getting a sequence of param resolvers.\"\"\"\n", "linspace = cirq.Linspace(start=0, stop=1.0, length=11, key='x')\n", @@ -2703,7 +2056,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": null, "metadata": { "cellView": "form", "id": "8yW2e3sq9JM8" @@ -2733,33 +2086,12 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": null, "metadata": { "cellView": "form", "id": "sl1UGhThC6rn" }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 52, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "#@title Expand to view the solution\n", "import pandas\n", @@ -2814,19 +2146,11 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": null, "metadata": { "id": "YclVFbKZ0aD4" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "a: ───D(0.2)───M───\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Create a circuit with a depolarizing channel.\"\"\"\n", "circuit = cirq.Circuit(cirq.depolarize(0.2)(a), cirq.measure(a))\n", @@ -2844,34 +2168,11 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": null, "metadata": { "id": "0ig_NSrS12PE" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Kraus operator 0 is:\n", - "[[0.89442719 0. ]\n", - " [0. 0.89442719]]\n", - "\n", - "Kraus operator 1 is:\n", - "[[0. +0.j 0.25819889+0.j]\n", - " [0.25819889+0.j 0. +0.j]]\n", - "\n", - "Kraus operator 2 is:\n", - "[[0.+0.j 0.-0.25819889j]\n", - " [0.+0.25819889j 0.+0.j ]]\n", - "\n", - "Kraus operator 3 is:\n", - "[[ 0.25819889+0.j 0. +0.j]\n", - " [ 0. +0.j -0.25819889+0.j]]\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "for i, kraus in enumerate(cirq.kraus(cirq.depolarize(0.2))):\n", " print(f\"Kraus operator {i} is:\", kraus, sep=\"\\n\", end=\"\\n\\n\")" @@ -2888,30 +2189,11 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": null, "metadata": { "id": "a2e5258ae33d" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Kraus operator 0 is:\n", - "0.894*I\n", - "\n", - "Kraus operator 1 is:\n", - "0.258*X\n", - "\n", - "Kraus operator 2 is:\n", - "0.258*Y\n", - "\n", - "Kraus operator 3 is:\n", - "0.258*Z\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "for i, kraus in enumerate(cirq.kraus(cirq.depolarize(0.2))):\n", " pauli_ex = cirq.expand_matrix_in_orthogonal_basis(kraus, cirq.PAULI_BASIS)\n", @@ -2929,24 +2211,11 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": null, "metadata": { "id": "skLIvXYq4yvX" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Circuit:\n", - "a: ───D(0.2)───\n", - "\n", - "Final density matrix:\n", - "[[0.8666666 +0.j 0. +0.j]\n", - " [0. +0.j 0.13333333+0.j]]\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Example of simulating a noisy circuit with the density matrix simulator.\"\"\"\n", "# Circuit to simulate.\n", @@ -2972,19 +2241,11 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": null, "metadata": { "id": "_SjPRrIX5F4O" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "True\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Simulating a circuit with measurements using the DensityMatrixSimulator.\"\"\"\n", "# Get a circuit with measurements.\n", @@ -3026,38 +2287,11 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": null, "metadata": { "id": "9Pt7o-Tq2SNz" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "prob = 0.8\n", - "unitary: \n", - "[[1. 0.]\n", - " [0. 1.]]\n", - "\n", - "prob = 0.06666666666666667\n", - "unitary: \n", - "[[0.+0.j 1.+0.j]\n", - " [1.+0.j 0.+0.j]]\n", - "\n", - "prob = 0.06666666666666667\n", - "unitary: \n", - "[[0.+0.j 0.-1.j]\n", - " [0.+1.j 0.+0.j]]\n", - "\n", - "prob = 0.06666666666666667\n", - "unitary: \n", - "[[ 1.+0.j 0.+0.j]\n", - " [ 0.+0.j -1.+0.j]]\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Use the cirq.mixture protocol on the cirq.depolarize channel.\"\"\"\n", "for p, u in cirq.mixture(cirq.depolarize(0.2)):\n", @@ -3075,20 +2309,11 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": null, "metadata": { "id": "HvhpBD334o1v" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "does cirq.depolarize(0.2) have _kraus_? no\n", - "does cirq.depolarize(0.2) have _mixture_? yes\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Check if cirq.depolarize has _kraus_ and _mixture_ methods.\"\"\"\n", "# Get a depolarizing channel.\n", @@ -3112,19 +2337,11 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": null, "metadata": { "id": "vDEhGG0v-UJy" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "a=0001000111\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Use the wavefunction simulator on a channel that implements the mixture protocol.\"\"\"\n", "circuit = cirq.Circuit(cirq.depolarize(0.5).on(a), cirq.measure(a))\n", @@ -3164,27 +2381,11 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": null, "metadata": { "id": "PfRP7K598wNQ" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Circuit with no noise:\n", - "a: ───H───@───M───\n", - " │ │\n", - "b: ───────X───M───\n", - "\n", - "Circuit with noise:\n", - "a: ───H───D(0.2)[cirq.VirtualTag()]───@───D(0.2)[cirq.VirtualTag()]───M───D(0.2)[cirq.VirtualTag()]───\n", - " │ │\n", - "b: ───────D(0.2)[cirq.VirtualTag()]───X───D(0.2)[cirq.VirtualTag()]───M───D(0.2)[cirq.VirtualTag()]───\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Adding noise to a circuit.\"\"\"\n", "# Get a noiseless circuit.\n", @@ -3211,36 +2412,11 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": null, "metadata": { "id": "uzxaFCGIz2aQ" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "After step 0 state was\n", - "[[0.43333328+0.j 0. +0.j 0.31777775+0.j 0. +0.j]\n", - " [0. +0.j 0.06666666+0.j 0. +0.j 0.04888888+0.j]\n", - " [0.31777775+0.j 0. +0.j 0.43333328+0.j 0. +0.j]\n", - " [0. +0.j 0.04888888+0.j 0. +0.j 0.06666666+0.j]]\n", - "\n", - "After step 1 state was\n", - "[[0.34859255+0.j 0. +0.j 0. +0.j 0.17089382+0.j]\n", - " [0. +0.j 0.15140739+0.j 0.02629136+0.j 0. +0.j]\n", - " [0. +0.j 0.02629136+0.j 0.15140739+0.j 0. +0.j]\n", - " [0.17089382+0.j 0. +0.j 0. +0.j 0.34859255+0.j]]\n", - "\n", - "After step 2 state was\n", - "[[0.01777777+0.j 0. +0.j 0. +0.j 0. +0.j]\n", - " [0. +0.j 0.11555552+0.j 0. +0.j 0. +0.j]\n", - " [0. +0.j 0. +0.j 0.11555552+0.j 0. +0.j]\n", - " [0. +0.j 0. +0.j 0. +0.j 0.7511109 +0.j]]\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Perform noisy simulation by defining a density matrix simulator with a noise model.\"\"\"\n", "# Define a noise model.\n", @@ -3279,46 +2455,11 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": null, "metadata": { "id": "BmzxGpDB9jJ4" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " q(0, 5)───q(0, 6)\n", - " │ │\n", - " │ │\n", - " q(1, 4)───q(1, 5)───q(1, 6)───q(1, 7)\n", - " │ │ │ │\n", - " │ │ │ │\n", - " q(2, 3)───q(2, 4)───q(2, 5)───q(2, 6)───q(2, 7)───q(2, 8)\n", - " │ │ │ │ │ │\n", - " │ │ │ │ │ │\n", - " q(3, 2)───q(3, 3)───q(3, 4)───q(3, 5)───q(3, 6)───q(3, 7)───q(3, 8)───q(3, 9)\n", - " │ │ │ │ │ │ │ │\n", - " │ │ │ │ │ │ │ │\n", - " q(4, 1)───q(4, 2)───q(4, 3)───q(4, 4)───q(4, 5)───q(4, 6)───q(4, 7)───q(4, 8)───q(4, 9)\n", - " │ │ │ │ │ │ │ │\n", - " │ │ │ │ │ │ │ │\n", - "q(5, 0)───q(5, 1)───q(5, 2)───q(5, 3)───q(5, 4)───q(5, 5)───q(5, 6)───q(5, 7)───q(5, 8)\n", - " │ │ │ │ │ │ │\n", - " │ │ │ │ │ │ │\n", - " q(6, 1)───q(6, 2)───q(6, 3)───q(6, 4)───q(6, 5)───q(6, 6)───q(6, 7)\n", - " │ │ │ │ │\n", - " │ │ │ │ │\n", - " q(7, 2)───q(7, 3)───q(7, 4)───q(7, 5)───q(7, 6)\n", - " │ │ │\n", - " │ │ │\n", - " q(8, 3)───q(8, 4)───q(8, 5)\n", - " │\n", - " │\n", - " q(9, 4)\n" - ] - } - ], + "outputs": [], "source": [ "print(cirq_google.Sycamore)" ] @@ -3336,19 +2477,11 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": null, "metadata": { "id": "HAwdWkprAPXN" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "25 ns\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Get the duration of an operation.\"\"\"\n", "op = cirq.X.on(cirq.GridQubit(5, 5))\n", @@ -3366,23 +2499,11 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": null, "metadata": { "id": "r5F4FUtmA5kW" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(5, 5): ───iSwap───────\n", - " │\n", - "(6, 6): ───iSwap^0.5───\n", - "error, as expected: \n", - "Operation does not use valid qubit target: ISWAP**0.5(q(5, 5), q(6, 6)).\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Validate operations on a device.\"\"\"\n", "# Get non-adjacent qubits on the Sycamore device.\n", @@ -3418,7 +2539,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": null, "metadata": { "cellView": "form", "id": "zDE-19I_a3on" @@ -3430,7 +2551,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": null, "metadata": { "cellView": "form", "id": "DuOcTG3XZfmb" @@ -3488,27 +2609,11 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": null, "metadata": { "id": "l7eFMVe1GEe2" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Before optimizing:\n", - "a: ───X───Z───@───X───\n", - " │\n", - "b: ───────────@───────\n", - "\n", - "After optimizing:\n", - "a: ───Y───────@───X───\n", - " │\n", - "b: ───────────@───────\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Example of writing a custom cirq transformer.\"\"\"\n", "@cirq.transformer\n", @@ -3551,20 +2656,12 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": null, "metadata": { "cellView": "form", "id": "S0PThmctKFxl" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "None\n" - ] - } - ], + "outputs": [], "source": [ "#@title Attempt the solution here\n", "@cirq.transformer\n", @@ -3584,32 +2681,12 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": null, "metadata": { "cellView": "form", "id": "O8pnDlAngS80" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Before optimizing:\n", - "a: ───H───@───H───@───\n", - " │ │\n", - "b: ───H───X───H───@───\n", - "\n", - "c: ───H───────────────\n", - "\n", - "After optimizing:\n", - "a: ───────X───────@───\n", - " │ │\n", - "b: ───────@───────@───\n", - "\n", - "c: ───H───────────────\n" - ] - } - ], + "outputs": [], "source": [ "#@title Expand to view the solution\n", "def simplify_flipped_cnots(circuit, *, context = None):\n", @@ -3658,45 +2735,11 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": null, "metadata": { "id": "ydDrxmlL18F1" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Original Circuit (depth 6): ┌──┐ ┌──┐\n", - "0: ───iSwap──────────────iSwap───iSwap────@─────\n", - " │ │ │ │\n", - "1: ───┼─────────×────T───iSwap───iSwap────┼×────\n", - " │ │ ││\n", - "2: ───┼────────T┼────────X────────────────@┼────\n", - " │ │ │\n", - "3: ───iSwap─────×──────────────────────────×────\n", - " └──┘ └──┘\n", - "Compiled circuit for CZ Target (depth 17): ┌──┐ ┌──────────────┐\n", - "0: ───PhX(-0.75)^0.5───@───PhX(0.25)^0.5────@───PhXZ(a=-0.75,x=0.5,z=0.5)──────────────────────────────────────────────PhXZ(a=-0.5,x=0,z=-1)─────────────────────────────────@────────────────────────────────────────\n", - " │ │ │\n", - "1: ────────────────────┼────────────────────┼───────────────────────────────@───PhX(0.5)^0.5───@───PhX(-0.5)^0.5───@───PhXZ(a=-1.11e-16,x=0.25,z=0.5)────@──────PhX(1)^0.5───┼────@───PhX(-2.22e-16)^0.5───@───S^-1───\n", - " │ │ │ │ │ │ │ │ │\n", - "2: ────────────────────┼────────────────────┼───────────────────────────────┼──────────────────┼───────────────────┼───PhXZ(a=0.25,x=0,z=0.25)───────────┼X──────────────────@────┼────────────────────────┼──────────\n", - " │ │ │ │ │ │ │ │\n", - "3: ───PhX(0.25)^0.5────@───PhX(-0.75)^0.5───@───PhXZ(a=0.25,x=0.5,z=0.5)────@───PhX(0.5)^0.5───@───PhX(-0.5)^0.5───@───PhXZ(a=-0.5,x=0,z=-1)─────────────@──────PhX(-0.5)^0.5─────@───PhX(0.5)^0.5─────────@───S──────\n", - " └──┘ └──────────────┘\n", - "Compiled circuit for Sqrt-Iswap Target (depth 16): ┌──────────────────┐ ┌──────────────────┐\n", - "0: ───PhXZ(a=-4.44e-16,x=0,z=0.5)───iSwap───────iSwap──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────PhXZ(a=-1.0,x=0.5,z=-0.5)─────────────iSwap────────PhXZ(a=-5.55e-17,x=1,z=0)──────────────iSwap────────PhXZ(a=-0.5,x=0.5,z=2.05e-08)───────────────────────────────────────────\n", - " │ │ │ │\n", - "1: ─────────────────────────────────┼───────────┼─────────────────────────────────────iSwap───────PhXZ(a=-0.83,x=0.5,z=0.83)───iSwap───────PhXZ(a=0.5,x=0.5,z=0)───iSwap───────PhXZ(a=-0.5,x=0.92,z=0.5)────iSwap────┼────────────PhXZ(a=0.17,x=0.5,z=-0.17)────iSwap────┼────────────PhXZ(a=0.5,x=0.5,z=0)───────────iSwap───────PhXZ(a=0.5,x=0.83,z=-0.5)───\n", - " │ │ │ │ │ │ │ │ │ │\n", - "2: ─────────────────────────────────┼───────────┼─────────────────────────────────────┼────────────────────────────────────────┼───────────────────────────────────┼───────────PhXZ(a=0.5,x=0.5,z=0)────────┼────────iSwap^0.5──────────────────────────────────┼────────iSwap^0.5────PhXZ(a=0.5,x=0.5,z=0.25)────────┼───────────────────────────────────────\n", - " │ │ │ │ │ │ │ │\n", - "3: ─────────────────────────────────iSwap^0.5───iSwap^0.5───PhXZ(a=-1.0,x=0,z=-0.5)───iSwap^0.5───PhXZ(a=-0.83,x=0.5,z=0.83)───iSwap^0.5───PhXZ(a=0.5,x=0.5,z=0)───iSwap^0.5───PhXZ(a=0.5,x=0.83,z=0.5)─────iSwap^0.5─────────────PhXZ(a=0.17,x=0.5,z=-0.17)────iSwap^0.5─────────────PhXZ(a=0.5,x=0.5,z=0)───────────iSwap^0.5───PhXZ(a=0.5,x=0.83,z=-1.0)───\n", - " └──────────────────┘ └──────────────────┘\n" - ] - } - ], + "outputs": [], "source": [ "circuit = cirq.testing.random_circuit(qubits=4, n_moments=6, op_density=0.8, random_state=1234)\n", "print(f\"Original Circuit (depth {len(circuit)}):\", circuit)\n", @@ -3728,22 +2771,11 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": null, "metadata": { "id": "Ih8YgwX19h2-" }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXsAAAEECAYAAADJSpQfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAyX0lEQVR4nO3de3hTdZ4/8HfaEm7l2lIol1YoItVxFou7yiPgCjKwIKhc6xwKK6IijEVgkEuxYiUIdhGUEatIkUuAsqgssoozgCOX+VmxWJCdIoK0gEUKBSy90LTN+f1xOCFtc3KSNjnJSd6v5+GhzUmTT26ffM/38vkaRFEUQUREAS3E1wEQEZH3MdkTEQUBJnsioiDAZE9EFASY7ImIggCTPRFREPBasj927BiSkpLqXb5//36MGTMGEyZMwPbt271190REZCfMGze6du1a7Nq1C82bN691eVVVFd544w3s2LEDzZs3x1NPPYVBgwYhMjLSG2EQEdEtXmnZx8TEYPXq1fUuP3PmDGJiYtCmTRsYjUb07dsXR44c8UYIRERkxyst+6FDh+LChQv1Li8tLUWrVq1sv7ds2RKlpaUObyMnJ8cboRERBbS+ffs6vNwryV5JeHg4ysrKbL+XlZXVSv51KQWtJi8vD/Hx8Q36W3+g9/gBP34MZjMwcyZQXKz9fYeGAhs2AIKgyd357WvgIsbvPmeNZE1n48TFxaGgoADXr1+HxWLBd999h/vuu0/LECiYmc3Ac8/5JtEDQE0NMHEiYDAAkZFSPEQa0aRl/9lnn6G8vBwTJkzA/Pnz8cwzz0AURYwZMwYdO3bUIgQiICUFKC/3dRSS4mJgyhTpZ41a+hTcvJbsu3btaptaOXLkSNvlgwYNwqBBg7x1t0T1mc1Soi8ocPlPRACGiAjg7bedJ2P72zYYAHeKyFoswOTJ0s9M+ORlXFRFgU3uunE10RsMwAsv4OQ//wlcuaKehAUByM+XkrzVKv0visDmzVIfvZqaGiApCZg+3bX4iBqIyZ4C28yZ6l03Ibc+BrGxwKZNwJo1jb9fQZAGY1u0UL+uKAIZGezDJ6/SdDYOkabMZtcGY2tqvHP/8lmBK7N/RJFdOuRVbNlTYDKbbydPZ2JjvRuHIEjdQZs3AxERzq8rd+kYDMAdd7ClTx7FZE+BR+6nV2uxt2gBmEzaxGSf9A0G5evJA7wFBdJjYMInD2Gyp8DjSj99bCzwwQfad5kIAjBtmvOELysvl2b6EHkAkz0FBrNZWqhkMDjvH2/RQmpd5+f7rm98zRppINiV2TpuTBclcobJnvTPbAaeflp9EDQ01DeteUfk2TpqLXyDgV055BFM9qRv8kBsVZX6dTWsS+MSQVBfhCXP0mHCp0Zisif9cnUgFpBmwvhTope5MhuopoaDtdRoTPakX64MxAJSP/3bb3s/noYwmVxbeMXBWmokJnvSJ1cXTEVE+E8/vSOCIMUnt/Cd9eGfO6dNTBSQmOxJn9RauRER0qwbV+rb+Jp9fR1ns3Tat9c0LAosTPakT85auXpJ8o7Is3SaNKl/rLiYdfCpwZjsSR/MZqmEQEjI7fn0jvjrQKw7BAFo3drxseJiDtZSgzDZk/+zL1MsilLCs1rrX8+fB2LddfWq8rHycmnHK9bPITcw2ZP/klvzEyeqz7rxpwVTnhATo36dggLWwieXMdmTf3J30xGrNXASPeD6lEzWwicXMdmTf3J3v1hXWsJ6Ik/JVCuLDEgJn3PwSQWTPfknd+eUa1WqWEtyWWRXcA4+qWCyJ//kTks9EGbgOONKSYVAO7Mhj2OyJ/9kMgHNm6tfL5Bm4ChR67/XchMW0i0me/JPggDMn+/8Or7agERr9iUVDAbpTEbuy2/SJDieA2o0JnvyD/aLpuT54z16KF/fYPDtBiRak0sqWK1SP/6VK9KgrNUKjB7t6+hIB5jsyffqLpqS91/95BPlv2EfNVBWJpU/btny9hek3Zdm3ODBnJJJNmG+DoDI4TTL8nLgyy+l0gjl5bWPs49aSuLvvy/9LH9BTpxY6yrGixelL00geM6ASBFb9uR7StMGy8uBhITa/dXB0k+vJiUFqKhQvx7r4NMtbNmT78XEKK+U/etfgR9/lFrywZ7g7bkzr55z8Als2ZM/GD7c+aYdch8++59vc2fMguMbBCZ78jWzWarfrrbxNrsjajOZnH9Byji+Qbcw2ZNvuVMDh90RtwkCMG2a04Rf3bYtxzfIhsmefMudBM7uiNrWrJG2MZTLKcjbGbZuDYSE4Kevv2aiJxsme/ItVxM4uyMcs9+/trpa+v/ddwGrFcaCAseL1SgocTYO+Y7ZDJSWql8vIkKqf8NWqmtunS31GDVK6uaRx0PkgW6Az2UQYsuefENeNVtcXPvyli2l5C7Pqdfz5uG+YDbbzoAMQP2Bbw50By227Mk3lAZmIyOlbglqGFcGvDnQHZS80rK3Wq1ITU3FhAkTkJSUhII6C2YyMzMxevRojBkzBn/729+8EQL5K7kPWWkRFRNR47jy/HGgOyh5pWW/d+9eWCwWZGVlITc3F8uWLcN7770HACgpKcHGjRvx17/+FRUVFXjiiScwZMgQb4RB/kbuunHW8mQiahxnq5FlHOgOSl5J9jk5ORgwYAAAoE+fPjhx4oTtWPPmzdG5c2dUVFSgoqICBifzhPPy8hp0/zdv3mzw3/oDvccPOH4McXPnwugk0VubNMHFGTNQ4gePXa+vQesZMxCdmoqQmzcdHq9u0wY/JSQAOnhsen0NZP4Wv1eSfWlpKcLDw22/h4aGorq6GmFh0t1FR0djxIgRqKmpwfPPP694O/Hx8Q26/7y8vAb/rT/Qe/yA3WMwm6V+5HPnVFfJhrRujS5z56KLRjE6o9vXID4e6NwZmDkTYnExajWlQkIQ9u67unlcun0NbvFF/Dk5OYrHvNJnHx4ejrKyMtvvVqvVlugPHDiAoqIi7Nu3D3//+9+xd+9eHD9+3BthkK/VrVOv5upV78cUDG5tVF745pu3q4UajdJrkJTE+fZByivJPiEhAQcOHAAA5ObmolevXrZjbdq0QbNmzWA0GtG0aVO0atUKJSUl3giDfM2dUggA++s9rOSxx6SZTZs2SYle/sfCckHJK904Q4YMweHDh5GYmAhRFLF06VKsX78eMTExGDx4MP7xj39g/PjxCAkJQUJCAh566CFvhEG+5s7MGq6Q9Z6UFKCqqvZl8nx7rl8IGl5J9iEhIUhLS6t1WVxcnO3n5ORkJCcne+OuyZ84mxnSujXQrp30hRATw3r13qT0pctprkGFK2jJe5y11EtKpONWa3BtHO4LSt1j7dtrGwf5FJM9eY8gAHazsuphv7E2TCagSZP6l9+4wec/iDDZk3eNGqV8jHVatCEIUrdZXRaLtEk5Z+cEBSZ78q7OnR23KmXsN9aGs2mtnJ0TFJjsybsKC4Fu3W5vsFEXp1tqQ+155llWwGOyJ+8qLJRa9yaTNL3SHqdbasfR818Xz7ICGpM9eZec7AVB2g9VXtEZG8v9UbUkP//y1oWO8CwroKkm+3Xr1uEql7FTQxUWAtHR0s/yFnqcbukbgiA990p4lhXQVJN9ixYtMGPGDCQnJ+Prr7+G6EqNEwpOdvudxg0eDKxbJ2072LmzryMjmVLrPSKCX74BTjXZP/XUU9i6dStefPFF7Nq1C4888ghWr16N3377TYv4SC/qFD0zXrwITJ0qHTt71rex0W1KfffFxZyCGeBUk31JSQm2bt2KV155BSUlJUhJScGdd97ptDQxBSFnRc8yMoDp07WNhxyzHzupi1MwA5pqbZyxY8di1KhReOutt9DZ7nTcn4rykx9Qm8mRkQE89BC7CvyBIEj/HG0PWV4OzJzJ1ykAqbbsp06dij/96U+2RL9x40YAwKxZs7wbGemLWp0VUeQ8bn+j9AVdXMzWfQBSbNnv3r0b+/fvR3Z2NrKzswEANTU1+OmnnzBp0iTNAiQdMJulwmZqOI/bvzirSjp5svQ/W/gBQzHZDxgwAB06dMD169cxYcIEAFLp4m7dumkWHOmEo3rpjnAet38xmaTaOI7U1Ej99wATfoBQTPYVFRV44IEHEBUVVevycnd2HqLg4EqLnatl/Y8gSP3zxcWOj3ODk4CimOwzMzOxcOFCpKam1rrcYDDY+u2JACh3B4SGSot4uDmJ/3r7bakFr9SIY9dbwFBM9gsXLgQAbNq0SbNgSIfMZqkueh3WZs0Q8uGHTPD+Tn59Jk+Wum7qYtdbwFBM9v3791f8o0OHDnklGNIZeSFV3VZhRAQuzpuHLkz0+iC/TnVfS4MBGD7cNzGRxykmeyZ0UqW0kCo8HCWPPYYu2kdEDSUIwOHD0noIuSSKKALvvQds3y519/DLW9cUk/2aNWswffp0zJ49GwaDodaxFStWeD0w0gFuZB1YPv/8dqK3V1zMmTkBQDHZDxo0CACQmJioWTCkM0oDs+zn1SdnX9Ll5dI0zZQUDrbrlOIK2t69ewMA7rzzTuzfvx+ZmZk4ePAg4uPjNQuO/JzJBBiNtS/jFEv9cuVLmvVzdEu1XMK8efMQExODl156CR07dsS8efO0iIv0wv60PyKCG5LomSu7WQHcwlCnVAuhVVZW4o9//CMAqbX/5Zdfej0o0gF5Jo79ytmKCt/FQ40nf0k7W2gl47iM7ii27M+ePYuzZ8+iXbt2+OKLL3D58mXs27cPXbt21TI+8kdmszQvu+5MHLb49E8QgCtXpLM0ZzguozuKLXv7lbNbtmzBli1bAKDezBwKMnKL3tECHIAtvkDhbCtSjsvokmKyV1o5W+VKwSsKXM42KQHY4gsUzkpgcFxGl1T77Ldt24b169ejuroaoiiiSZMm7LcPZs5a7mzxBQ6TyfHq6D//mYlep1Rn45jNZmzatAkDBw7EG2+8gbi4OC3iIn+l1HJniy+w2G9faDAAXW6th+7Rw7dxUYOpJvuoqChERUWhrKwMDzzwAG44KHpFQcRkApo2rX1ZixbAhg1M9IFGEID8fKlyaUEB0KQJ8PPPvo6KGkg12bdq1Qp79+6FwWDAtm3bcP36dQ3CIr8lCMCoUdLPBoPU8mOLPvCFhkqv9dmzvo6EGkg12S9ZsgRdunTB7NmzkZ+fj0WLFmkRF/m77t2lFl9+PhN9sOjenS17HVNN9kajEd999x0++OAD3HHHHbj//vu1iIv8ldkMfPqp1MK74w4umw8WZjPw//4f8N13QFiYdFbH119XXCqXcOnSJfTr1w8FBQW2TU0oCJnNwLPPAtXV0u+skxIc5LUVpaXS7/Iai4ICICmJiV8nVKdeXrlyBStXrgQAPProo5iotEGxHavVisWLF+PHH3+E0WjEkiVLEBsbazv+9ddf491334Uoirjnnnvw6quvcrGWHqSk1C+JwH1KA5+ztRVybST5ix/ge8FPKbbsLRYLLBYLunbtiuPHjwMATp48iTvuuEP1Rvfu3QuLxYKsrCzMmTMHy5Ytsx0rLS1Feno6MjIy8N///d/o0qULrl271vhHQp5jNksttZAQIDJS+mcwOF5kA3DVbKBz9fVluQy/ptiyHzZsGAwGA0RRRHZ2NoxGIywWC5rWnXbnQE5ODgYMGAAA6NOnD06cOGE79v3336NXr15Yvnw5zp8/j3HjxqF9+/YeeCjkEXW3GlQriAVw1WygU1pN6wi/+P2WYrLfv39/rd+Li4vRrl07hISodvOjtLQU4eHhtt9DQ0NRXV2NsLAwXLt2DdnZ2di5cydatGgBQRDQp08fdO/evd7t5OXlufNYbG7evNngv/UHvow/bu5cGJ2VQ6jD2qwZLs6YgZI68fI18D1PPYbWM2YgOjUVITdvql7X0qkTznjoedP7a+Bv8av22WdnZ2PhwoVo1aoVSkpK8Prrr+Ohhx5y+jfh4eEoKyuz/W61WhEWJt1V27Ztce+996JDhw4AgPvvvx95eXkOk31DN0rJy8vT9SYrPo3/11/dunrIhx+iiyDU22+Wr4HveewxxMcDnTtLXTTOWvgGA4zp6R573vT+Gvgi/pycHMVjqs30VatWYcuWLdi5cye2bt2KVatWqd5hQkICDhw4AADIzc1Fr169bMfuuecenDp1ClevXkV1dTWOHTuGnj17uvAwSBPudMnExnIwLljIq2lFEdi82fEmJ9Om8f3gx1Rb9qGhoejYsSMAoGPHji712Q8ZMgSHDx9GYmIiRFHE0qVLsX79esTExGDw4MGYM2cOpk6dCkAaG7D/MiAfGz4cyMhwvPG0PRY9C15yQk9JkfroRRF48klgzRrfxkVOqSb78PBwbNq0Cf/6r/+KI0eOoE2bNqo3GhISgrS0tFqX2RdQGzFiBEaMGNGAcMmrzGapxo1aoo+N5abTwU4Qbr/+cXH19yImv6PajZOeno7CwkKsXLkSFy9exNKlS7WIi3xBrVY9IE3BZIkEsterF3DqlK+jIBWqLfvFixdjxYoVWsRCvubKtDlOs6S6RBHIzZXWZcTE8KzPT6m27C0WC06ePInKykrbQisKUGqJnP30VJfZDOzfLyV8UWQJDT+m2rI/e/Yspk+fbltgZTAYsG/fPi1iI62ZTMAzzwCVlbcvMxikDzH76cmRlBSg7lalLKHhl1ST/e7du7WIg/yBIEittMxMKcnzlJzUKHX9ubriljSj2I3zxRdf4OGHH8bQoUNttXEoCLRpAzRvLlW25EAsqVHq+jMY2JXjZxST/YYNG7Br1y58+OGHWMP5s8Hj5EngrrukwTYiNSaTlNjrEkUWRfMzip9oo9GINm3aoFu3bqioW9aWAoN9dUu5HvnJk0Dv3r6OjPRCEJTXZbAoml9xqfkmqi2yIf2Rq1sWFNyeRTFxorQD1f/8D0/ByXV2e1XUEhLC95EfURygPX/+PN566y2Iomj7WTZ79mxNgiMvcraAqqICmDJF+pl99qTGZKpdFltWUyPtZHX4MEsp+AHFZJ+cnOzwZwoQaqfYFgunz5Fr5PfI5Mm3tyyUiaJUa+mhh/he8jHFZP/kk09qGQdpzZUNKdjnSq4SBKkV74goSl2EM2cCb7/NpO8jnHIRrEwmaYqlMyyNQO5Qe78UF0vdg+zH9wkm+2DmbHql0cjSCOQepWmY9uTuQdKc6gra0tJSrF27FkVFRXjkkUdw1113IVZp9J30oe4+s3VFRPB0m9wnCNJgrNp+COwe9AnVlv3ChQvRrVs3FBQUIDIyEin8VtY/pZk4sbHSh/TKFSZ6apg1a4BNm4DQUOXrsHvQJ1ST/fXr1zF27FiEhYUhISEBVqtVi7jIm5RaVmxxkScIgrQJTpMm9Y+xe9BnXOqzP3PmDADg119/Raizb2zSB6WWFVtc5CmCAKxfL3UJysLCpCJ7PGv0CdVkv2jRIixcuBD//Oc/kZycjAULFmgRF3mTySR98OyxVj15miBIXYKiCAwbdnuRlVyagzSlmux/+eUXZGVl4bvvvsP27duRn5+vQVjkVYIA9OwpnVIbDFJf/QcfsMVF3uFog5OkJGD6dF9HFlQUZ+N89dVXOHr0KP73f/8X33//PQDAarVi3759GD58uGYBkhdYrcAvvwBTpwLvvuvraCjQpaRIUy7tcWWt5hRb9r1790aPHj3QtGlTdO/eHd27d0fPnj1r1cghnTGbgchIaabEjRvAxo08nSbvUxr4ZxlkTSm27KOjo/Hkk0/i8ccfR4jd4puioiJNAiMPM5uBp5+uvYVcaSkLnpH3OSvNwRlgmlHts1+9ejUefPBB9O3bF/fccw+efvppLeIiTzKbpSJVdfcKBbiikbzP2cpalkHWjGqy379/Pw4cOICRI0fi888/R8eOHbWIizxFXi1btxqhPbauyJsEAZg2zXHCr6mR3p9M+F6nmuw7dOgAo9GIsrIyxMbGospR65D8l7O69TLOrydvc7aytrycZ5caUE32nTp1wo4dO9C8eXOsWLECJSUlWsRFnqLWaueKRtKKIEgzwRzh2aXXqSb7tLQ09OvXDy+//DKioqI4G0dvnLXaIyK4opG0pfR+bN9e2ziCkGKyr6mpgcViQXJyMqKiomA0GjFu3Di89tprWsZHjWUyAc2a1b6sRQtg82YWPCPtmUyOa+bcuMF+ey9TTPYff/wxhg0bhgMHDmDYsGEYNmwYRo4cic6dO2sZH3mCfd36iAiuliXfEQSgdev6l3NWmNcpzrMfP348xo8fjx07dmDs2LFaxkSe4qhufUWF7+IhAoCrVx1fzn57r1Js2VssFmzYsAFjxozBpUuXkJycjD//+c+4fPmylvFRYziaicOZD+RrrLrqE4rJPi0tDYWFhbBarVi8eDF69+6NoUOHYvHixRqGR43CuvXkj0wmadyortJS9tt7kWKyP336NBYsWIDq6mrk5OTg2WefxZAhQ3BV6RSM/A9bUOSPBEEaN7KvdQ9IG5KzGqbXKCb7li1bAgCOHj2Ke++9F01ujaBXVlZqExk1jtkszXCoi3XryR8IAhAeXv9yuRomW/ge5zTZZ2VlYe3atRgxYgSsVit27tyJ6OhoLeOjhpAHZuuehXEmDvkTVsPUlGKyX7x4Mc6dO4cBAwbgySefRHZ2Nr788kuX+uytVitSU1MxYcIEJCUlocBBxTur1YqpU6di69atjXoA5IBSiYTwcCZ68h/OuhM5ruRxilMv27dvj7lz59p+79evH/r16+fSje7duxcWiwVZWVnIzc3FsmXL8N5779W6zqpVq1h6wVs4MEt6YDJJffSiWP8Yx5U8TjHZN0ZOTg4GDBgAAOjTpw9OnDhR6/iePXtgMBhs11GSl5fXoPu/efNmg//WHzQ2/rhOnWC8eLHe5ZZOnXBGo+cl2F8Df+D3jyEhAR0nTEC7bdtgXw/T2qwZLs6Y4f/xq/C3+L2S7EtLSxFuN/gSGhqK6upqhIWF4dSpU9i9ezfeeecdvKuyJV58fHyD7j8vL6/Bf+sPGh1/erq0KYn9VnAtWsCYnq7Z8xL0r4Ef0MVj2LoVeOwxqevxVndvSEYGukyejBI9xO+EL57/nJwcxWOKyb6wsFDxj9RKJoSHh6OsrMz2u9VqRViYdFc7d+7EpUuXMHnyZPzyyy9o0qQJunTpgoEDBzq9TWqEiAjg7bfZX0/+SRCkfzNnAu+8I+2o9uqraD1jBqDjZO9vFJP9rFmzAADXr19HWVkZ7rzzTpw+fRqRkZH49NNPnd5oQkICvvrqKwwfPhy5ubno1auX7djLL79s+3n16tWIjIxkovckeSaOfaueJRLI35nNwNq10s+iCBQUIDo1FejcmY0UD1GcjZOVlYWsrCz07NkTe/bswfr16/Hll1+6tFPVkCFDYDQakZiYiDfeeAMLFizA+vXrsW/fPo8GTw6wRALpUUpKvUZJyM2bfN96kGqf/a+//mrrf2/RooVLtXFCQkKQlpZW67K4uLh613vxxRddjZNcxZk4pEdK70+ljcrJbarJvn///pg4cSJ+97vf4fjx43j00Ue1iIsawmyWyhk72m+WU9nIn8XEOE7sBoP0vmZXTqOpJvtZs2bhxIkTKCgowBNPPIHevXtrERe5y9nG4iyRQP5Oac69vJqWyb7RVLclvHTpEj766CN8/PHHOH78OI4dO6ZFXOQupVWzoaEskUD+TxAcL64CpBZ/SAhwxx2smdMIqsn+lVdewZgxY1BVVYX7778fJrYQ/ZNSn6fVykRP+hAbq3zs1gwdPPccE34DqSb7mzdvol+/fjAYDOjRoweaNm2qRVzkLpYzJr1TqnNvjzPLGkw12Tdt2hQHDx6E1WpFbm4ujEajFnGRu4YPr38Z++pJT+Q697da+AqdOpxZ1kCqyf7111/HJ598gmvXriEzMxOvvfaaFnGRGrNZ6sM0GKT+zDqF5mAwAJMnswuH9EUQgPx8YPZs5evwbLVBVGfjHDx4ECtXrrT9vnHjRkyaNMmrQZGKuhuJOxrYEkXg88+1jYvIU+69t1ZxNBuDwfFZLKlSTPa7d+/G/v37kZ2djW+++QaAVOPm1KlTTPa+pjTzpi6e7pJeXbjg+HJRBDZsAB56iGetblJM9gMGDECHDh1w/fp1TJgwAYC0MrZbt26aBUcKXF1VyNNd0iOzGVi6VPm4PEjLZO8WxWRfUVGBBx54AFFRUbUuL3elRUneYzZLp7JKc5JlHJwlvXJQJ6cenrW6TTHZr1+/HgsWLEBqaioMBgPEW8nFYDBg48aNmgVIdaSkqCd6ljQmPXMlkYeEsIyCmxST/YIFCwAAH374Ic6cOYO7774be/fuxcMPP6xZcOSAsw9CbKzUmucHgPRMqU6OvZoaaZICwPe7i1SnXs6dO9e2tdbZs2cxf/58rwdFTij1w8fGSlPW+MYnvXNlcRXABVZucqk2zpgxYwAAzz77LIqKirweFDlhMgF1F7axf54Cya3FVZboaGl8ylkZBfbdu0w12RsMBpw9exYAcO7cOVitVq8HRU4IAjBokPQhkD8ILHRGgUYQcGbfPqm2U36+csLnjDOXqS6qWrBgAWbNmoUrV64gKiqq3qYk5AMWC3D//cC33/o6EiJtmEy1FxICPKN1k2qy79SpE3bu3Gn7/f/+7/+8GQ85YzYDCxdKp67h4ZyNQMFDfp9Pnw6UlADdugFvvMH3vxtUu3GeeeYZHDp0CACQmZmJFA6I+IZcIkHuoywtZblXCi6CAKxfL/08dao0OMs69y5TTfYbNmxAZmYmnnjiCRQWFmL79u1axEUyueDZxIncSJzo/Hnp/1dflaZnynXuk5KkVj8pUk32J0+exOXLl/Ev//IvyMvLw6+//qpFXARIb96kJOdzjjkbgYKF3I3piCgCGRls4Tuh2me/evVqvP/+++jcuTNyc3MxY8YMfPbZZ1rEFtzMZunNq7ZalrMRKFioFQDkfrVOqSZ7s9mM0NBQAECfPn2wdetWrwdFcK0sgsHA2QgUPFw5i+WZriLFbpyXXnoJABAaGorMzEzb5dPZL6YNV960oshWDAUPV85i5Zo5VI9isi8uLrb9/Pe//932s6jW2iTPcOWN7WxlIVGgcaWMglwzhwm/HtUBWqB2gjcYHO4fQ55iNiNu8GD1QlBcUELBxn6PWoNBqu4a4iCFcZaaQ4rJ3j6pM8Fr5NZceuPFi/WPRURI/1gigYKZvEet1QpcuaI8ruXqBj9BRHGA9vTp05gzZw5EUaz185kzZ7SML7gozTaQK1oSUW1K5ZANBq4wr0Mx2a9atcr2c2JiosOfyYPMZuXWCGcYEDlmMklrUeq28DkNsx7FZP9v//ZvWsYR3ORSCEo4l57IMUGQVpc7wkZSLS4N0JKXqS0WGT5cu1iI9EZpVhqnYdbCZO8P1FogGzbwTUukRGlKJqdh1sJk7w/Uumk4lYxImTwl89ZK/1r42bFhsvcHJhPQrJnz67D/kUiZIEjTMR3hZwcAk71/EARgwgTn1+EgLZFzSp+R9u21jcNPeSXZW61WpKamYsKECUhKSkJBnSmFH330EcaNG4dx48bhL3/5izdC0BezGdixQ/q5fXtYmzSpfZyrZYnUmUxA3c8OANy4wX57eCnZ7927FxaLBVlZWZgzZw6WLVtmO3b+/Hns2rUL27Ztw/bt23Ho0CGcPHnSG2HogzztsqxM+v3qVWmOMFfLErlHEIDWretfbrEAkycHfcJXLXHcEDk5ORgwYAAAqSzyiRMnbMc6deqEDz/80FY2ubq6Gk2bNvVGGPrgYNplSHW1tMfslSs+CopIp65edXy5PDMHCNqGk1eSfWlpKcLDw22/h4aGorq6GmFhYWjSpAnat28PURTx5ptv4u6770b37t0d3k5eXl6D7v/mzZsN/lut9T53Do4qD4nnzuGkTh6DI3p6DRzRe/yA/h9DQ+KP69TJcW0pACgvR/WMGfgpIcED0anzt+ffK8k+PDwcZXK3BKQ+/LCw23dVWVmJhQsXomXLlnj11VcVbyc+Pr5B95+Xl9fgv9WU2Swt/KipqXfIEBOjj8egQDevgQK9xw/o/zE0KP70dKkFr7BIMey33xB/9KgmrXtfPP85OTmKx7zSZ5+QkIADBw4AAHJzc9GrVy/bMVEUMX36dNx1111IS0uzdecEHbmv3kGitzZrxgFZooZwNudeNnEicMcdQdeH75WW/ZAhQ3D48GEkJiZCFEUsXboU69evR0xMDKxWK7799ltYLBYcPHgQADB79mzcd9993gjF/5jNUj+9UtGz0FBcTEtDlyDtVyRqNPmzo1QzB5A+f0HWh++VZB8SEoK0tLRal8XFxdl+/uGHH7xxt/5Pbs07q4NjtaLkscfQRbuoiAKPIAAzZwJ2O+7VI6+uDZJkz0VVWlIreAZw8RSRp7z9tvo2hgUFQdOlw2TvLWaz9CYKCbn9ZlJbtm0wsK+eyFPk/vuICOfXk7t0AjzhM9l7g9xdU1AgLZCS30wtWzr/O1EMmlNKIk0IgrRmRU0QFEzzSp990HPUXaPWfQMo1+UmooZztRBagBdMY8veGxrypmH9GyLvcHUcLMA3O2Gy9wZ3B1lZ/4bIe5Q2N6krwDc7YbL3NLMZKC11/fqxsUB+PhM9kbfIA7WudJMGcN89k70nyQOzzub22mPXDZE2BEFqVG3erN7KD9C+eyZ7T3JlHr09dt0QacuVVn6ArnVhsvckd1oEsbFM9ES+oNbKLy0NyH57JntPkBdQiaJr1+fiKSLfk1v5dbctLC4OyIFaJvvGsl9A5QqDAZg2ja16In8gCECrVvUvD8CBWib7xnLWTx8bC7zwgvS/vMXgpk3AmjXaxkhEypS6XwNsoJYraBtLqUVvMEj9gkTk32JiHH+OA2ygli37xjCbpaTuSICvxiMKGEqLroqLaxcy1Dkm+8ZISVEelA3w1XhEAUMQgMmT619eWlq7kKHOP8tM9o2h1qcXgIM8RAHp88+dHw+AzzKTfWO40qcXYIM8RAHJlc9pQYGuW/dM9g0hz6t3ZbplgA3yEAUkVz+nOu7OYbJ3l7N59XUHa1n7hkgfXK2MWV4u7W2rQ0z27lKaVy/PobefU8/aN0T6IK+mDQ1Vv25xsS5b90z2ztjvIxsZKf1T6ropKLhdc8NqZdliIr0RBGDDBtda+DocrGWyV1J3H9niYueliw0GXX7bE5EdV2vf63CwlsleibvlikVRl9/2RFSHfIYuikBEhPL1kpKA6dM1C6uxmOyVNGTKJKdZEgWWt99W7tYRRSAjQzctfCZ7JQ2ZMslplkSBRe7WUSKKwMSJuiipwGSvxN0pk5xmSRSYBMG1Pnw/n4PPZO+I2QwsXOj69TnNkiiwmUzKRQ9lfl5Sgcm+LnkWjn3/u7MXWS5lzERPFLgEQdp0SC3h+/EsHSZ7mTynfuLE+rNwRFF5sQX76YmCw5o10sJJNX46S4fJHnBta8Gamvqj8uynJwourvTfiyLw3nvofffdfjVwy2QPSLUu1ObUy/3yLIdAFNxcrKNjAPxq4Da4k73ZLJVAcLYyVmYysRwCEbm+ylZWXi5tjuLjhB98yV7umzcYpL41VxJ9RAQTOxHdJjf8Nm9WH7QFpG7giROl6/qoayc4kr3cgjcYpCdc7ptX2lLQXosW0io6IqK6XJ2lY6+g4Hbij4zULPEHVrK/ldR733239ETK/yZOdK0FXxf75YlIjTxLx5XyyHUVF99O/Pb/vPAl4JVkb7VakZqaigkTJiApKQkFdWa5bN++HaNHj8b48ePx1VdfeeZOzWbg6aeB4mK48R3rWIsW0ukZ++WJyBWCII3leUpxMTBlikcTvleS/d69e2GxWJCVlYU5c+Zg2bJltmOXL1/Gpk2bsG3bNqxbtw5vvfUWLBZL4+80JQWoqmr87UREsDVPRO7z9Jobi8WjK3LDPHZLdnJycjBgwAAAQJ8+fXDixAnbsePHj+O+++6D0WiE0WhETEwMTp48id///vcOb8dlH3/c6Ljr3Llnb8/tu/ft/XuC3h+D3uMH9P8YdBW/p3OQzEPPgVeSfWlpKcLDw22/h4aGorq6GmFhYSgtLUWrVq1sx1q2bInS0tJ6t9G3b19vhEZEFJS80o0THh6OsrIy2+9WqxVhYWEOj5WVldVK/kRE5HleSfYJCQk4cOAAACA3Nxe9evWyHfv973+PnJwcVFZW4saNGzhz5kyt40RE5HkGUXRlsrl7rFYrFi9ejFOnTkEURSxduhQHDhxATEwMBg8ejO3btyMrKwuiKOL555/H0KFDPR0CERHZ8Uqy9wX5C+bHH3+E0WjEkiVLEOvqcmY/c+zYMfzXf/0XNrlSYc+PVFVVYeHChfjll19gsVjwwgsvYPDgwb4Oyy01NTVYtGgRzp49C4PBgNdee02XZ57FxcUYPXo0MjMzERcX5+tw3Pbkk0/axv26du2KN954w8cRuef999/H/v37UVVVhaeeegrjxo3zdUjeGaD1Bfvpnrm5uVi2bBnee+89X4fltrVr12LXrl1o3ry5r0Nx265du9C2bVukp6fj+vXreOKJJ3SX7OV1H9u2bUN2djZWrlypu/dRVVUVUlNT0axZM1+H0iCVlZUQRVF3jR1ZdnY2vv/+e2zduhUVFRXIzMz0dUgAAmgFrbPpnnoSExOD1atX+zqMBhk2bBhmzpwJABBFEaENWVHoY48++ihef/11AEBhYSFat27t44jct3z5ciQmJiIqKsrXoTTIyZMnUVFRgSlTpmDSpEnIzc31dUhuOXToEHr16oUZM2Zg2rRp+Pd//3dfhwQggFr2zqZ76snQoUNx4cIFX4fRIC1btgQgvRbJycl46aWXfBtQA4WFhWHevHn429/+hnfeecfX4bjlk08+Qfv27TFgwAB84GyjbD/WrFkzPPPMMxg3bhzy8/Px7LPPYs+ePbr5LF+7dg2FhYXIyMjAhQsX8MILL2DPnj0wuFM/xwsCpmXvbLonaefixYuYNGkSHn/8cYwcOdLX4TTY8uXL8eWXX+KVV15BudpeB37k448/xj/+8Q8kJSUhLy8P8+bNw+XLl30dllu6d++OUaNGwWAwoHv37mjbtq2uHkPbtm3Rv39/GI1G9OjRA02bNsXVq1d9HVbgJHtn0z1JG1euXMGUKVMwd+5cjB071tfhNMjOnTvx/vvvAwCaN28Og8GAkBD9fEzMZjM2b96MTZs2IT4+HsuXL0eHDh18HZZbduzYYSuxcunSJZSWlurqMfTt2xcHDx6EKIq4dOkSKioq0LZtW1+HFTjdOEOGDMHhw4eRmJhom+5J2srIyEBJSQnWrFmDNWvWAJAGnPU0UPiHP/wBCxYsgCAIqK6uxsKFC3UVfyAYO3YsFixYgKeeegoGgwFLly7V1Vn6I488giNHjmDs2LEQRRGpqal+MX4VMFMviYhImX7OT4mIqMGY7ImIggCTPRFREGCyJyIKAkz2RERBgMmefCo7Oxv9+vVDUlISkpKSMHr0aCQnJzvdqnL+/Pm2NRWyy5cvY/HixQ6vP23aNDz//PMNjjEpKQlnzpxx6boWiwVz586F1WpFUlISxo4di6SkJAiCgJEjR+Lrr792+X7Hjx+PCxcu4JNPPsG+ffvcjvu1117DlStX3P47Ckz6mbxKAevBBx/EypUrbb/PmTMH+/fvx7Bhw1y+jQ4dOjhM9oWFhSgvL0d1dTXOnz+Pbt26eSJkRR999BH+4z/+w7YQa/ny5baqkz///DOSk5Px8MMPu3Wbo0ePblAsSUlJWLFihe4qRpJ3MNmTX7FYLCgqKkKbNm1QU1OD1NRU/PrrrygqKsKgQYMwa9YsAMCWLVuwbt061NTUwGQyITQ0FLNnz8b27dtr3d7HH3+MwYMHo1mzZtiyZQvmzZsHQFo8lZCQgLNnzyIiIgKrV69GVVUVXn75ZRQVFSE6OhpHjhzBoUOHbLd148YNpKSk4Nq1awCARYsW4a677rIdF0URu3btwqeffurwsdkXVvv222/xl7/8BaIooqysDCtWrED37t2xcuVKHDx4EJ06dbLdz+rVqxEZGYnx48c7fD7mz58Po9GIX375BUVFRVi2bBnuuece9OjRAz///DOuXbuGdu3aeegVIr1isief++abb5CUlITi4mKEhIRg/Pjx6NevHy5cuIA+ffpg3LhxqKysxMCBA23JPiEhAc899xy+/vprpKenY/78+fVu12q1Yvfu3cjKykJYWBhGjBiBmTNnolmzZjh//jw2bNiA6OhoJCYm4ocffsCxY8fQtWtXvPPOOzhz5gwee+yxWreXkZGBBx98EH/84x+Rn5+PBQsWYOvWrbbj+fn5CA8PR5MmTWyXzZs3D2FhYSgsLESfPn1sreyffvoJ6enp6NixIzIyMrBnzx70798fR44cwY4dO1BeXo4//OEPte7/4sWLis9H586dkZaWZtsYKC0tDQDQo0cPHD16VHelpsnzmOzJ5+RunGvXrmHKlCno2rUrAKmg1A8//IBvvvkG4eHhtfrx77//fgDAfffdhzfffNPh7R48eBBlZWWYM2cOACn5f/bZZxg3bhzatWuH6OhoAEB0dDQqKytx5swZDBw4EAAQFxeH9u3b17q9U6dO4ZtvvsEXX3wBAPjtt99qHb927RoiIyNrXSZ342zbtg27d++23WfHjh1hMpnQokULXLp0CQkJCcjPz8fvfvc7hISEIDw8vF59J2fPR3x8PACgU6dOOHr0qO3yDh064Pr16w6fHwouHKAlv9GuXTukp6dj0aJFKCoqwieffIJWrVphxYoVmDJlCm7evAm5usfx48cBAN999x3uvPNOh7e3Y8cOLFmyBOvWrcO6deuwatUqbNmyBQAclpvt1asXvv/+ewDAuXPnbN0osh49euA///M/sWnTJqxatQqjRo2qdTwiIgIlJSUOY0lMTER0dLRtbOKVV17B0qVLsWzZMkRFRUEURfTs2RPHjx+H1WpFeXk5Tp8+Xes2nD0fSuVzf/vtN0RERDg8RsGFLXvyKz179kRSUhKWLFmCF198EXPmzEFubi6MRiNiY2NRVFQEQNq6cdKkSbZCWXVLPF25cgXHjh2rNfDbt29fVFZW1mr52hs7dizmz58PQRDQuXNnNG3atNbxadOmISUlBdu3b0dpaSn+9Kc/1ToeGxuLq1evKu6jkJKSglGjRuHxxx/HqFGjIAgCmjdvjsjISBQVFSE+Ph4DBw7E2LFjERUVVS9J9+vXT/H5UJKXl4e5c+c6vQ4FBxZCI7rl6NGjKC8vR//+/ZGfn4+pU6di7969bt3G+++/jx49emDIkCFeitJ1p0+fxvr162EymXwdCvkBJnuiWy5fvozZs2ejqqoK1dXVSE5OtvXhu+rmzZtISUlBenq6z+vgv/rqq5gxY4Zutyckz2KyJyIKAhygJSIKAkz2RERBgMmeiCgIMNkTEQUBJnsioiDw/wGaY9ut0ygvkAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "result = cirq.experiments.rabi_oscillations(\n", " sampler=cirq.Simulator(), # In case of Google QCS or other hardware providers, sampler could point at real hardware.\n", @@ -3765,7 +2797,7 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": null, "metadata": { "id": "j7FoZGKv90qe" }, @@ -3795,37 +2827,11 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": null, "metadata": { "id": "qH7xB-vZ-Jsn" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "// Generated from Cirq v0.15.0.dev\n", - "\n", - "OPENQASM 2.0;\n", - "include \"qelib1.inc\";\n", - "\n", - "\n", - "// Qubits: [q(0), q(1), q(2)]\n", - "qreg q[3];\n", - "\n", - "\n", - "h q[0];\n", - "h q[2];\n", - "cx q[0],q[1];\n", - "\n", - "// Gate: CCZ\n", - "h q[2];\n", - "ccx q[0],q[1],q[2];\n", - "h q[2];\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Export a circuit to Qasm.\"\"\"\n", "a, b, c = cirq.LineQubit.range(3)\n", @@ -3844,27 +2850,11 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": null, "metadata": { "id": "951a57e8e0fd" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "# Created using Cirq.\n", - "\n", - "H 0\n", - "H 2\n", - "CNOT 0 1\n", - "H 2\n", - "CCNOT 0 1 2\n", - "H 2\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Export a circuit to QUIL.\"\"\"\n", "print(circuit.to_quil())" @@ -3881,19 +2871,11 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": null, "metadata": { "id": "Ydst5b0S9IGE" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "http://algassert.com/quirk#circuit=%7B%22cols%22%3A%5B%5B%22H%22%2C1%2C%22H%22%5D%2C%5B%22%E2%80%A2%22%2C%22X%22%5D%2C%5B%22%E2%80%A2%22%2C%22%E2%80%A2%22%2C%22Z%22%5D%5D%7D\n" - ] - } - ], + "outputs": [], "source": [ "\"\"\"Export a circuit to a Quirk URL.\"\"\"\n", "from cirq.contrib.quirk.export_to_quirk import circuit_to_quirk_url\n", From 5b677baa3db9c88d0a7aa202c320ced8e0024fc1 Mon Sep 17 00:00:00 2001 From: Dave Bacon Date: Thu, 2 Jun 2022 16:55:45 +0000 Subject: [PATCH 4/6] uhoh --- .../custom_state_simulator.py | 91 ++ .../custom_state_simulator_test.py | 192 ++++ docs/build/_index.yaml | 60 ++ docs/experiments/_index.yaml | 45 + docs/hardware/_index.yaml | 133 +++ docs/noise/_index.yaml | 32 + docs/noisy_simulation.ipynb | 989 ++++++++++++++++++ docs/params.ipynb | 153 +++ docs/simulate/_index.yaml | 24 + docs/transform/_index.yaml | 14 + docs/transformers.ipynb | 644 ++++++++++++ 11 files changed, 2377 insertions(+) create mode 100644 cirq-core/cirq/contrib/custom_simulators/custom_state_simulator.py create mode 100644 cirq-core/cirq/contrib/custom_simulators/custom_state_simulator_test.py create mode 100644 docs/build/_index.yaml create mode 100644 docs/experiments/_index.yaml create mode 100644 docs/hardware/_index.yaml create mode 100644 docs/noise/_index.yaml create mode 100644 docs/noisy_simulation.ipynb create mode 100644 docs/params.ipynb create mode 100644 docs/simulate/_index.yaml create mode 100644 docs/transform/_index.yaml create mode 100644 docs/transformers.ipynb diff --git a/cirq-core/cirq/contrib/custom_simulators/custom_state_simulator.py b/cirq-core/cirq/contrib/custom_simulators/custom_state_simulator.py new file mode 100644 index 00000000000..c9e3c175505 --- /dev/null +++ b/cirq-core/cirq/contrib/custom_simulators/custom_state_simulator.py @@ -0,0 +1,91 @@ +# Copyright 2022 The Cirq Developers +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Any, Dict, Generic, Sequence, Type, TYPE_CHECKING + +import numpy as np + +from cirq import sim +from cirq.sim.simulation_state import TSimulationState + +if TYPE_CHECKING: + import cirq + + +class CustomStateStepResult(sim.StepResultBase[TSimulationState], Generic[TSimulationState]): + """The step result provided by `CustomStateSimulator.simulate_moment_steps`.""" + + pass + + +class CustomStateTrialResult( + sim.SimulationTrialResultBase[TSimulationState], Generic[TSimulationState] +): + """The trial result provided by `CustomStateSimulator.simulate`.""" + + pass + + +class CustomStateSimulator( + sim.SimulatorBase[ + CustomStateStepResult[TSimulationState], + CustomStateTrialResult[TSimulationState], + TSimulationState, + ], + Generic[TSimulationState], +): + """A simulator that can be used to simulate custom states.""" + + def __init__( + self, + state_type: Type[TSimulationState], + *, + noise: 'cirq.NOISE_MODEL_LIKE' = None, + split_untangled_states: bool = False, + ): + """Initializes a CustomStateSimulator. + + Args: + state_type: The class that represents the simulation state this simulator should use. + noise: The noise model used by the simulator. + split_untangled_states: True to run the simulation as a product state. This is only + supported if the `state_type` supports it via an implementation of `kron` and + `factor` methods. Otherwise a runtime error will occur during simulation.""" + super().__init__(noise=noise, split_untangled_states=split_untangled_states) + self.state_type = state_type + + def _create_simulator_trial_result( + self, + params: 'cirq.ParamResolver', + measurements: Dict[str, np.ndarray], + final_simulator_state: 'cirq.SimulationStateBase[TSimulationState]', + ) -> 'CustomStateTrialResult[TSimulationState]': + return CustomStateTrialResult( + params, measurements, final_simulator_state=final_simulator_state + ) + + def _create_step_result( + self, sim_state: 'cirq.SimulationStateBase[TSimulationState]' + ) -> 'CustomStateStepResult[TSimulationState]': + return CustomStateStepResult(sim_state) + + def _create_partial_simulation_state( + self, + initial_state: Any, + qubits: Sequence['cirq.Qid'], + classical_data: 'cirq.ClassicalDataStore', + ) -> TSimulationState: + return self.state_type( + initial_state=initial_state, qubits=qubits, classical_data=classical_data + ) diff --git a/cirq-core/cirq/contrib/custom_simulators/custom_state_simulator_test.py b/cirq-core/cirq/contrib/custom_simulators/custom_state_simulator_test.py new file mode 100644 index 00000000000..fd547779340 --- /dev/null +++ b/cirq-core/cirq/contrib/custom_simulators/custom_state_simulator_test.py @@ -0,0 +1,192 @@ +# Copyright 2022 The Cirq Developers +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import List, Sequence, Tuple + +import numpy as np +import sympy + +import cirq +from cirq.contrib.custom_simulators.custom_state_simulator import CustomStateSimulator + + +class ComputationalBasisState(cirq.qis.QuantumStateRepresentation): + def __init__(self, initial_state: List[int]): + self.basis = initial_state + + def copy(self, deep_copy_buffers: bool = True) -> 'ComputationalBasisState': + return ComputationalBasisState(self.basis) + + def measure(self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None): + return [self.basis[i] for i in axes] + + +class ComputationalBasisSimState(cirq.SimulationState[ComputationalBasisState]): + def __init__(self, initial_state, qubits, classical_data): + state = ComputationalBasisState( + cirq.big_endian_int_to_bits(initial_state, bit_count=len(qubits)) + ) + super().__init__(state=state, qubits=qubits, classical_data=classical_data) + + def _act_on_fallback_(self, action, qubits: Sequence[cirq.Qid], allow_decompose: bool = True): + gate = action.gate if isinstance(action, cirq.Operation) else action + if isinstance(gate, cirq.XPowGate): + i = self.qubit_map[qubits[0]] + self._state.basis[i] = int(gate.exponent + self._state.basis[i]) % qubits[0].dimension + return True + pass + + +def create_test_circuit(): + q0, q1 = cirq.LineQid.range(2, dimension=3) + x = cirq.XPowGate(dimension=3) + return cirq.Circuit( + x(q0), + cirq.measure(q0, key='a'), + x(q0).with_classical_controls('a'), + cirq.CircuitOperation( + cirq.FrozenCircuit(x(q1), cirq.measure(q1, key='b')), + repeat_until=cirq.SympyCondition(sympy.Eq(sympy.Symbol('b'), 2)), + use_repetition_ids=False, + ), + ) + + +def test_basis_state_simulator(): + sim = CustomStateSimulator(ComputationalBasisSimState) + circuit = create_test_circuit() + r = sim.simulate(circuit) + assert r.measurements == {'a': np.array([1]), 'b': np.array([2])} + assert r._final_simulator_state._state.basis == [2, 2] + + +def test_built_in_states(): + # Verify this works for the built-in states too, you just lose the custom step/trial results. + sim = CustomStateSimulator(cirq.StateVectorSimulationState) + circuit = create_test_circuit() + r = sim.simulate(circuit) + assert r.measurements == {'a': np.array([1]), 'b': np.array([2])} + assert np.allclose( + r._final_simulator_state._state._state_vector, [[0, 0, 0], [0, 0, 0], [0, 0, 1]] + ) + + +def test_product_state_mode_built_in_state(): + sim = CustomStateSimulator(cirq.StateVectorSimulationState, split_untangled_states=True) + circuit = create_test_circuit() + r = sim.simulate(circuit) + assert r.measurements == {'a': np.array([1]), 'b': np.array([2])} + + # Ensure the state is in product-state mode, and it's got three states (q0, q1, phase) + assert isinstance(r._final_simulator_state, cirq.SimulationProductState) + assert len(r._final_simulator_state.sim_states) == 3 + + assert np.allclose( + r._final_simulator_state.create_merged_state()._state._state_vector, + [[0, 0, 0], [0, 0, 0], [0, 0, 1]], + ) + + +def test_noise(): + x = cirq.XPowGate(dimension=3) + sim = CustomStateSimulator(ComputationalBasisSimState, noise=x**2) + circuit = create_test_circuit() + r = sim.simulate(circuit) + assert r.measurements == {'a': np.array([2]), 'b': np.array([2])} + assert r._final_simulator_state._state.basis == [1, 2] + + +def test_run(): + sim = CustomStateSimulator(ComputationalBasisSimState) + circuit = create_test_circuit() + r = sim.run(circuit) + assert np.allclose(r.records['a'], np.array([[1]])) + assert np.allclose(r.records['b'], np.array([[1], [2]])) + + +def test_parameterized_repetitions(): + q = cirq.LineQid(0, dimension=5) + x = cirq.XPowGate(dimension=5) + circuit = cirq.Circuit( + cirq.CircuitOperation( + cirq.FrozenCircuit(x(q), cirq.measure(q, key='a')), + repetitions=sympy.Symbol('r'), + use_repetition_ids=False, + ) + ) + + sim = CustomStateSimulator(ComputationalBasisSimState) + r = sim.run_sweep(circuit, [{'r': i} for i in range(1, 5)]) + assert np.allclose(r[0].records['a'], np.array([[1]])) + assert np.allclose(r[1].records['a'], np.array([[1], [2]])) + assert np.allclose(r[2].records['a'], np.array([[1], [2], [3]])) + assert np.allclose(r[3].records['a'], np.array([[1], [2], [3], [4]])) + + +class ComputationalBasisProductState(cirq.qis.QuantumStateRepresentation): + def __init__(self, initial_state: List[int]): + self.basis = initial_state + + def copy(self, deep_copy_buffers: bool = True) -> 'ComputationalBasisProductState': + return ComputationalBasisProductState(self.basis) + + def measure(self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None): + return [self.basis[i] for i in axes] + + def kron(self, other: 'ComputationalBasisProductState') -> 'ComputationalBasisProductState': + return ComputationalBasisProductState(self.basis + other.basis) + + def factor( + self, axes: Sequence[int], *, validate=True, atol=1e-07 + ) -> Tuple['ComputationalBasisProductState', 'ComputationalBasisProductState']: + extracted = ComputationalBasisProductState([self.basis[i] for i in axes]) + remainder = ComputationalBasisProductState( + [self.basis[i] for i in range(len(self.basis)) if i not in axes] + ) + return extracted, remainder + + def reindex(self, axes: Sequence[int]) -> 'ComputationalBasisProductState': + return ComputationalBasisProductState([self.basis[i] for i in axes]) + + @property + def supports_factor(self) -> bool: + return True + + +class ComputationalBasisSimProductState(cirq.SimulationState[ComputationalBasisProductState]): + def __init__(self, initial_state, qubits, classical_data): + state = ComputationalBasisProductState( + cirq.big_endian_int_to_bits(initial_state, bit_count=len(qubits)) + ) + super().__init__(state=state, qubits=qubits, classical_data=classical_data) + + def _act_on_fallback_(self, action, qubits: Sequence[cirq.Qid], allow_decompose: bool = True): + gate = action.gate if isinstance(action, cirq.Operation) else action + if isinstance(gate, cirq.XPowGate): + i = self.qubit_map[qubits[0]] + self._state.basis[i] = int(gate.exponent + self._state.basis[i]) % qubits[0].dimension + return True + pass + + +def test_product_state_mode(): + sim = CustomStateSimulator(ComputationalBasisSimProductState, split_untangled_states=True) + circuit = create_test_circuit() + r = sim.simulate(circuit) + assert r.measurements == {'a': np.array([1]), 'b': np.array([2])} + + # Ensure the state is in product-state mode, and it's got three states (q0, q1, phase) + assert isinstance(r._final_simulator_state, cirq.SimulationProductState) + assert len(r._final_simulator_state.sim_states) == 3 + assert r._final_simulator_state.create_merged_state()._state.basis == [2, 2] diff --git a/docs/build/_index.yaml b/docs/build/_index.yaml new file mode 100644 index 00000000000..8fd59714d98 --- /dev/null +++ b/docs/build/_index.yaml @@ -0,0 +1,60 @@ +book_path: /cirq/_book.yaml +project_path: /cirq/_project.yaml +title: Build a circuit +landing_page: + nav: left + rows: + - heading: Build a circuit + description: At the core of Cirq is the ability to construct quantum circuits. These are the methods and data structures necessary to do so. + - heading: Circuit construction + description: Read these to understand what goes into building a Cirq circuit (estimated reading time one hour). + items: + - heading: Circuits + description: The Circuit data structure and how to create them. + path: /cirq/circuits + icon: + name: menu_book + - heading: Qubits + description: The quantum bit data structure. + path: /cirq/qubits + icon: + name: menu_book + - heading: Gates and Operations + description: Quantum Gate and Operation data structures and how they are different. + path: /cirq/gates + icon: + name: menu_book + - heading: Custom gates + description: Create your own gates to add to circuits. + path: /cirq/custom_gates + icon: + name: menu_book + - heading: Import/export circuits + description: How to import or export a quantum circuit into/from Cirq. + path: /cirq/interop + icon: + name: menu_book + + - heading: Advanced + description: More elaborate ways to build quantum circuits. + items: + - heading: Operators + description: Operators, measurements and noise channels. + path: /cirq/operators + icon: + name: menu_book + - heading: Qudits + description: Moving from qubits to qutrits and further. + path: /cirq/qudits + icon: + name: menu_book + - heading: Protocols + description: The magic methods supported by Cirq's classes. + path: /cirq/protocols + icon: + name: menu_book + - heading: Tools ecosystem + description: External tools for circuit construction. + path: /cirq/ecosystem + icon: + name: menu_book diff --git a/docs/experiments/_index.yaml b/docs/experiments/_index.yaml new file mode 100644 index 00000000000..335c9bb1eb4 --- /dev/null +++ b/docs/experiments/_index.yaml @@ -0,0 +1,45 @@ +book_path: /cirq/_book.yaml +project_path: /cirq/_project.yaml +title: Experiments using quantum circuits +landing_page: + nav: left + rows: + - heading: Experiments using quantum circuits + description: This is a collection of algorithms and experiments written in and using Cirq. Some are hosted in Cirq, and some are hosted in ReCirq, a repository for research performed with Cirq. + - heading: Algorithms in Cirq + description: Algorithms and experiments executable with only default Cirq code. + items: + - heading: Textbook Algorithms Workshop + description: A workshop notebook with examples that covers algorithms commonly shown in quantum textbooks. + path: /cirq/tutorials/educators/textbook_algorithms + icon: + name: menu_book + - heading: Shor's Algorithm + description: The famous integer factorization algorithm by Peter Shor. + path: /cirq/tutorials/shor + icon: + name: menu_book + - heading: Variational Quantum Eigensolver + description: Compute the ground state of a Hamiltonian using the variational principle. + path: /cirq/tutorials/variational_algorithm + icon: + name: menu_book + - heading: Quantum Walks + description: The quantum analog of a random walk algorithm. + path: /cirq/tutorials/quantum_walks + icon: + name: menu_book + - heading: Fourier Checking + description: Demonstrate the separation between quantum and classical computers. + path: /cirq/tutorials/fourier_checking + icon: + name: menu_book + - heading: Hidden Linear Function problem + description: Show quantum separation with a constant depth solution. + path: /cirq/tutorials/hidden_linear_function + icon: + name: menu_book + + - heading: ReCirq Experiments + description: Research experiments that use additional library code reside in the external ReCirq repository. + - include: /cirq/experiments/_index_included.yaml diff --git a/docs/hardware/_index.yaml b/docs/hardware/_index.yaml new file mode 100644 index 00000000000..64117356417 --- /dev/null +++ b/docs/hardware/_index.yaml @@ -0,0 +1,133 @@ +book_path: /cirq/_book.yaml +project_path: /cirq/_project.yaml +title: Hardware +landing_page: + nav: left + rows: + - heading: Run circuits on quantum hardware + description: In order to run circuits on a quantum hardware device, Cirq maintains a representation of that device in software that determines if a circuit can be run on it. + items: + - heading: Devices + description: A data structure to represent the constraints a device imposes on runnable circuits. + path: /cirq/devices + icon: + name: menu_book + + - heading: AQT hardware + description: Cirq's interface with Alpine Quantum Technologies hardware + items: + - heading: Access and authentication + description: How to gain access. + path: /cirq/aqt/access + icon: + name: menu_book + - heading: Getting started with AQT hardware + description: How to run your first circuit. + path: /cirq/tutorials/aqt/getting_started + icon: + name: menu_book + + - heading: Azure Quantum + description: Cirq's interface with Microsoft Azure Quantum services. + items: + - heading: Access and authentication + description: How to gain access. + path: /cirq/azure-quantum/access + icon: + name: menu_book + - heading: Getting started with Honeywell on AQT hardware + description: How to run your first circuit on a Honeywell device. + path: /cirq/tutorials/azure-quantum/getting_started_honeywell + icon: + name: menu_book + - heading: Getting started with IonQ on AQT hardware + description: How to run your first circuit on an IonQ device. + path: /cirq/tutorials/azure-quantum/getting_started_ionq + icon: + name: menu_book + + - heading: IonQ hardware + description: Cirq's interface with IonQ hardware. + items: + - heading: Access and authentication + description: How to gain access. + path: /cirq/ionq/access + icon: + name: menu_book + - heading: Getting started with IonQ hardware + description: How to run your first circuit. + path: /cirq/tutorials/ionq/getting_started + icon: + name: menu_book + - heading: IonQ API Service + description: Using the IonQ API. + path: /cirq/ionq/service + icon: + name: menu_book + - heading: IonQ API circuits + description: Writing circuits for the IonQ API. + path: /cirq/ionq/circuits + icon: + name: menu_book + - heading: Running IonQ API jobs + description: How to run jobs with the IonQ API. + path: /cirq/ionq/jobs + icon: + name: menu_book + - heading: IonQ API calibrations + description: How to get hardware device calibration data through the IonQ API. + path: /cirq/ionq/calibrations + icon: + name: menu_book + + - heading: Pasqal hardware + description: Cirq's interface with Pasqal hardware. + items: + - heading: Access and authentication + description: How to gain access. + path: /cirq/pasqal/access + icon: + name: menu_book + - heading: Getting started with Pasqal hardware + description: How to run your first circuit. + path: /cirq/tutorials/pasqal/getting_started + icon: + name: menu_book + - heading: Pasqal devices + description: Device objects to specify Pasqal hardware. + path: /cirq/pasqal/devices + icon: + name: menu_book + - heading: Pasqal sampler + description: Sampler objects to run on Pasqal hardware. + path: /cirq/pasqal/sampler + icon: + name: menu_book + + - heading: Rigetti hardware + description: Cirq's interface with Rigetti hardware. + items: + - heading: Access and authentication + description: How to gain access. + path: /cirq/rigetti/access + icon: + name: menu_book + - heading: Getting started with Rigetti hardware + description: How to run your first circuit. + path: /cirq/tutorials/rigetti/getting_started + icon: + name: menu_book + + - heading: Custom devices + description: How to write custom Device classes for quantum hardware. + items: + - heading: Neutral atom device + description: A custom device class for a neutral atom device. + path: /cirq/tutorials/educators/neutral_atom + icon: + name: menu_book + - heading: Ion device + description: A custom device class for an ion device. + path: /cirq/tutorials/educators/ion_device + icon: + name: menu_book diff --git a/docs/noise/_index.yaml b/docs/noise/_index.yaml new file mode 100644 index 00000000000..7c37e4e75ad --- /dev/null +++ b/docs/noise/_index.yaml @@ -0,0 +1,32 @@ +book_path: /cirq/_book.yaml +project_path: /cirq/_project.yaml +title: Noise management for running circuits +landing_page: + nav: left + rows: + - heading: Manage noise when running circuits + description: Running circuits on real quantum devices means dealing with the noise those devices introduce to the computation. Cirq provides different ways to managing that noise, to improve the reliability of a circuit when run on hardware. + - heading: Characterization and compensation + description: By first characterizing how much and what kinds of error a device is exhibiting, compensation can be used to improve the reliability of the next run on the device or interpret the results of a previous run more accurately. + items: + - heading: Calibration FAQ + description: Frequently asked questions about characterization and compensation. + path: /cirq/tutorials/google/calibration_faq + icon: + name: menu_book + - heading: Floquet Calibration + description: A characterization method using Floquet theory. + path: /cirq/tutorials/google/floquet_calibration_example + icon: + name: menu_book + - heading: Cross Entropy Benchmarking (XEB) + description: A characterization benchmarking method using cross entropy. + path: /cirq/qcvv/xeb_theory + icon: + name: menu_book + - heading: Visualizing noise + description: Graphing and plotting methods for visualizing noise. + items: + - heading: Heatmaps + description: Functions to plot noise characteristics across a device. + path: /cirq/tutorials/heatmaps diff --git a/docs/noisy_simulation.ipynb b/docs/noisy_simulation.ipynb new file mode 100644 index 00000000000..9a5c77aa301 --- /dev/null +++ b/docs/noisy_simulation.ipynb @@ -0,0 +1,989 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "LnV7yIFGeryz" + }, + "source": [ + "##### Copyright 2020 The Cirq Developers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "1kkohf-9esQm" + }, + "outputs": [], + "source": [ + "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "#\n", + "# https://www.apache.org/licenses/LICENSE-2.0\n", + "#\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7zgataJVe0mU" + }, + "source": [ + "# Noise" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HYkRhx2pe2XX" + }, + "source": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " View on QuantumAI\n", + " \n", + " Run in Google Colab\n", + " \n", + " View source on GitHub\n", + " \n", + " Download notebook\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "846b32703c5c" + }, + "outputs": [], + "source": [ + "try:\n", + " import cirq\n", + "except ImportError:\n", + " print(\"installing cirq...\")\n", + " !pip install --quiet cirq\n", + " print(\"installed cirq.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7d3daa944d6b" + }, + "source": [ + "For simulation, it is useful to have `Gate` objects that enact noisy quantum evolution. Cirq supports modeling noise via *operator sum* representations of noise (these evolutions are also known as quantum operations or quantum dynamical maps). \n", + "\n", + "This formalism models evolution of the density matrix $\\rho$ via\n", + "\n", + "$$\n", + "\\rho \\rightarrow \\sum_{k = 1}^{m} A_k \\rho A_k^\\dagger\n", + "$$\n", + "\n", + "where $A_k$ are known as *Kraus operators*. These operators are not necessarily unitary but must satisfy the trace-preserving property\n", + "\n", + "$$\n", + "\\sum_k A_k^\\dagger A_k = I .\n", + "$$\n", + "\n", + "A channel with $m = 1$ unitary Kraus operator is called *coherent* (and is equivalent to a unitary gate operation), otherwise the channel is called *incoherent*. For a given noisy channel, Kraus operators are not necessarily unique. For more details on these operators, see [John Preskill's lecture notes](http://theory.caltech.edu/~preskill/ph219/chap3_15.pdf)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b989869680d4" + }, + "source": [ + "## Common channels" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "708b5b720a74" + }, + "source": [ + "Cirq defines many commonly used quantum channels in [`ops/common_channels.py`](https://github.com/quantumlib/Cirq/blob/master/cirq-core/cirq/ops/common_channels.py). For example, the single-qubit bit-flip channel\n", + "\n", + "$$\n", + "\\rho \\rightarrow (1 - p) \\rho + p X \\rho X\n", + "$$\n", + "\n", + "with parameter $p = 0.1$ can be created as follows." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "386a49be9dc7" + }, + "outputs": [], + "source": [ + "import cirq\n", + "\n", + "\"\"\"Get a single-qubit bit-flip channel.\"\"\"\n", + "bit_flip = cirq.bit_flip(p=0.1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "f1f501177e53" + }, + "source": [ + "To see the Kraus operators of a channel, the `cirq.kraus` protocol can be used. (See the [protocols guide](./protocols.ipynb).)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "7635588faafe" + }, + "outputs": [], + "source": [ + "for i, kraus in enumerate(cirq.kraus(bit_flip)):\n", + " print(f\"Kraus operator {i + 1} is:\\n\", kraus, end=\"\\n\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3f9ff40f980f" + }, + "source": [ + "As mentioned, all channels are subclasses of `cirq.Gate`s. As such, they can act on qubits and be used in circuits in the same manner as gates." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "91187990b395" + }, + "outputs": [], + "source": [ + "\"\"\"Example of using channels in a circuit.\"\"\"\n", + "# See the number of qubits a channel acts on.\n", + "nqubits = bit_flip.num_qubits()\n", + "print(f\"Bit flip channel acts on {nqubits} qubit(s).\\n\")\n", + "\n", + "# Apply the channel to each qubit in a circuit.\n", + "circuit = cirq.Circuit(\n", + " bit_flip.on_each(cirq.LineQubit.range(3))\n", + ")\n", + "print(circuit)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "59651802c358" + }, + "source": [ + "Channels can even be controlled." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "9be5383a7cd7" + }, + "outputs": [], + "source": [ + "\"\"\"Example of controlling a channel.\"\"\"\n", + "# Get the controlled channel.\n", + "controlled_bit_flip = bit_flip.controlled(num_controls=1)\n", + "\n", + "# Use it in a circuit.\n", + "circuit = cirq.Circuit(\n", + " controlled_bit_flip(*cirq.LineQubit.range(2))\n", + ")\n", + "print(circuit)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "755ba122d550" + }, + "source": [ + "In addition to the bit-flip channel, other common channels predefined in Cirq are shown below. Definitions of these channels can be found in their docstrings - e.g., `help(cirq.depolarize)`." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6a9c9c76fb8f" + }, + "source": [ + "* `cirq.phase_flip`\n", + "* `cirq.phase_damp`\n", + "* `cirq.amplitude_damp`\n", + "* `cirq.depolarize`\n", + "* `cirq.asymmetric_depolarize`\n", + "* `cirq.reset`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8b22bb323731" + }, + "source": [ + "For example, the asymmetric depolarizing channel is defined by\n", + "\n", + "$$\n", + "\\rho \\rightarrow (1-p_x-p_y-p_z) \\rho + p_x X \\rho X + p_y Y \\rho Y + p_z Z \\rho Z\n", + "$$\n", + "\n", + "and can be instantiated as follows." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "b6a0966a29f6" + }, + "outputs": [], + "source": [ + "\"\"\"Get an asymmetric depolarizing channel.\"\"\"\n", + "depo = cirq.asymmetric_depolarize(\n", + " p_x=0.10,\n", + " p_y=0.05,\n", + " p_z=0.15,\n", + ")\n", + "\n", + "circuit = cirq.Circuit(\n", + " depo.on_each(cirq.LineQubit(0))\n", + ")\n", + "print(circuit)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ddbc622c98da" + }, + "source": [ + "## The `kraus` and `mixture` protocols" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2dee355d2ae8" + }, + "source": [ + "We have seen the `cirq.kraus` protocol which returns the Kraus operators of a channel. Some channels have the interpretation of randomly applying a single unitary Kraus operator $U_k$ with probability $p_k$, namely\n", + "\n", + "$$\n", + "\\rho \\rightarrow \\sum_k p_k U_k \\rho U_k^\\dagger {\\rm ~where~} \\sum_k p_k =1 {\\rm ~and~ U_k U_k^\\dagger= I}.\n", + "$$\n", + "\n", + "For example, the bit-flip channel from above\n", + "\n", + "$$\n", + "\\rho \\rightarrow (1 - p) \\rho + p X \\rho X\n", + "$$\n", + "\n", + "can be interpreted as doing nothing (applying identity) with probability $1 - p$ and flipping the bit (applying $X$) with probability $p$. Channels with these interpretations support the `cirq.mixture` protocol. This protocol returns the probabilities and unitary Kraus operators of the channel." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "d4d84c4d4fa7" + }, + "outputs": [], + "source": [ + "\"\"\"Example of using the mixture protocol.\"\"\"\n", + "for prob, kraus in cirq.mixture(bit_flip):\n", + " print(f\"With probability {prob}, apply\\n\", kraus, end=\"\\n\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1ca339c3cbab" + }, + "source": [ + "Channels that do not have this interpretation do not support the `cirq.mixture` protocol. Such channels apply Kraus operators with probabilities that depend on the state $\\rho$. \n", + "\n", + "An example of a channel which does not support the mixture protocol is the amplitude damping channel with parameter $\\gamma$ defined by Kraus operators\n", + "\n", + "$$\n", + "M_0 = \\begin{bmatrix} 1 & 0 \\cr 0 & \\sqrt{1 - \\gamma} \\end{bmatrix} \n", + "\\text{and }\n", + "M_1 = \\begin{bmatrix} 0 & \\sqrt{\\gamma} \\cr 0 & 0 \\end{bmatrix} .\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "8e377332d2a7" + }, + "outputs": [], + "source": [ + "\"\"\"The amplitude damping channel is an example of a channel without a mixture.\"\"\"\n", + "channel = cirq.amplitude_damp(0.1)\n", + "\n", + "if cirq.has_mixture(channel):\n", + " print(f\"Channel {channel} has a _mixture_ or _unitary_ method.\")\n", + "else:\n", + " print(f\"Channel {channel} does not have a _mixture_ or _unitary_ method.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6f3ae4337219" + }, + "source": [ + "To summarize:\n", + "\n", + "* Every `Gate` in Cirq supports the `cirq.kraus` protocol.\n", + " - If magic method `_kraus_` is not defined, `cirq.kraus` looks for `_mixture_` then for `_unitary_`.\n", + "* A subset of channels which support `cirq.kraus` also support the `cirq.mixture` protocol.\n", + " - If magic method `_mixture_` is not defined, `cirq.mixture` looks for `_unitary_`.\n", + "* A subset of channels which support `cirq.mixture` also support the `cirq.unitary` protocol." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "67c8ddbc10f3" + }, + "source": [ + "For concrete examples, consider `cirq.X`, `cirq.BitFlipChannel`, and `cirq.AmplitudeDampingChannel` which are all subclasses of `cirq.Gate`.\n", + "\n", + "* `cirq.X` defines the `_unitary_` method. \n", + " - As a result, it supports the `cirq.unitary` protocol, the `cirq.mixture` protocol, and the `cirq.kraus` protocol.\n", + "* `cirq.BitFlipChannel` defines the `_mixture_` method but not the `_unitary_` method.\n", + " - As a result, it only supports the `cirq.mixture` protocol and the `cirq.kraus` protocol.\n", + "* `cirq.AmplitudeDampingChannel` defines the `_kraus_` method, but not the `_mixture_` method or the `_unitary_` method.\n", + " - As a result, it only supports the `cirq.kraus` protocol." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0f5b77825a8a" + }, + "source": [ + "## Custom channels" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7614e0351462" + }, + "source": [ + "There are two configurable channel types for channels not defined in `cirq.ops.common_channels`: `MixedUnitaryChannel` and `KrausChannel`.\n", + "\n", + "`MixedUnitaryChannel` takes a list of `(probability, unitary)` tuples and uses it to define the `_mixture_` method.\n", + "\n", + "`KrausChannel` takes a list of Kraus operators and uses it to define the `_channel` method.\n", + "\n", + "Both types also accept a measurement key as an optional parameter. This key will be used to store the index of the selected unitary or Kraus operator in the measurement results.\n", + "\n", + "An example of each type is shown below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "7cbd723fb567" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "q0 = cirq.LineQubit(0)\n", + "# This is equivalent to a bit-flip error with probability 0.1.\n", + "mix = [\n", + " (0.9, np.array([[1, 0], [0, 1]], dtype=np.complex64)),\n", + " (0.1, np.array([[0, 1], [1, 0]], dtype=np.complex64)),\n", + "]\n", + "bit_flip_mix = cirq.MixedUnitaryChannel(mix)\n", + "\n", + "# This is equivalent to an X-basis measurement.\n", + "ops = [\n", + " np.array([[1, 1], [1, 1]]) * 0.5,\n", + " np.array([[1, -1], [-1, 1]]) * 0.5,\n", + "]\n", + "x_meas = cirq.KrausChannel(ops, key='x')\n", + "\n", + "# These circuits have the same behavior.\n", + "circuit = cirq.Circuit(\n", + " bit_flip_mix.on(q0),\n", + " cirq.H(q0),\n", + " x_meas.on(q0),\n", + ")\n", + "equiv_circuit = cirq.Circuit(\n", + " cirq.bit_flip(0.1).on(q0),\n", + " cirq.H(q0),\n", + " # Measure in x-basis\n", + " cirq.H(q0),\n", + " cirq.measure(q0, key='x'),\n", + " cirq.H(q0),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "360d5a316769" + }, + "source": [ + "Alternatively, users can define their own channel types. Defining custom channels is similar to defining [custom gates](./custom_gates.ipynb).\n", + "\n", + "A minimal example for defining the channel\n", + "\n", + "$$\n", + "\\rho \\mapsto (1 - p) \\rho + p Y \\rho Y\n", + "$$\n", + "\n", + "is shown below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "55240879394e" + }, + "outputs": [], + "source": [ + "\"\"\"Minimal example of defining a custom channel.\"\"\"\n", + "class BitAndPhaseFlipChannel(cirq.SingleQubitGate):\n", + " def __init__(self, p: float) -> None:\n", + " self._p = p\n", + " \n", + " def _mixture_(self):\n", + " ps = [1.0 - self._p, self._p]\n", + " ops = [cirq.unitary(cirq.I), cirq.unitary(cirq.Y)]\n", + " return tuple(zip(ps, ops))\n", + " \n", + " def _has_mixture_(self) -> bool:\n", + " return True\n", + " \n", + " def _circuit_diagram_info_(self, args) -> str:\n", + " return f\"BitAndPhaseFlip({self._p})\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8ffff44ff2b2" + }, + "source": [ + "Note: The `_has_mixture_` magic method is not strictly required but is recommended." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2dea6bd62cfe" + }, + "source": [ + "We can now instantiate this channel and get its mixture:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "0350d9e193ca" + }, + "outputs": [], + "source": [ + "\"\"\"Custom channels can be used like any other channels.\"\"\"\n", + "bit_phase_flip = BitAndPhaseFlipChannel(p=0.05)\n", + "\n", + "for prob, kraus in cirq.mixture(bit_phase_flip):\n", + " print(f\"With probability {prob}, apply\\n\", kraus, end=\"\\n\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "72486a155131" + }, + "source": [ + "Note: Since `_mixture_` is defined, the `cirq.kraus` protocol can also be used." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ada775055c3f" + }, + "source": [ + "The custom channel can be used in a circuit just like other predefined channels." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1af5c9f60cab" + }, + "outputs": [], + "source": [ + "\"\"\"Example of using a custom channel in a circuit.\"\"\"\n", + "circuit = cirq.Circuit(\n", + " bit_phase_flip.on_each(*cirq.LineQubit.range(3))\n", + ")\n", + "circuit" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "46eb7a01e30d" + }, + "source": [ + "Note: If a custom channel does not have a mixture, it should instead define the `_kraus_` magic method to return a sequence of Kraus operators (as `numpy.ndarray`s). Defining a `_has_kraus_` method which returns `True` is optional but recommended." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b537c43e078c" + }, + "source": [ + "This method of defining custom channels is the most general, but simple channels such as the custom `BitAndPhaseFlipChannel` can also be created directly from a `Gate` with the convenient `Gate.with_probability` method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "0937f8dad808" + }, + "outputs": [], + "source": [ + "\"\"\"Create a channel with Gate.with_probability.\"\"\"\n", + "channel = cirq.Y.with_probability(probability=0.05)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0461f377ac46" + }, + "source": [ + "This produces the same mixture as the custom `BitAndPhaseFlip` channel above." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "f0a85b33680a" + }, + "outputs": [], + "source": [ + "for prob, kraus in cirq.mixture(channel):\n", + " print(f\"With probability {prob}, apply\\n\", kraus, end=\"\\n\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "c73ec3e63e23" + }, + "source": [ + "Note that the order of Kraus operators is reversed from above, but this of course does not affect the action of the channel." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "96a696b543f7" + }, + "source": [ + "## Simulating noisy circuits" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "d51d993ae869" + }, + "source": [ + "### Density matrix simulation" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "38dfcb60ef79" + }, + "source": [ + "The `cirq.DensityMatrixSimulator` can simulate any noisy circuit (i.e., can apply any quantum channel) because it stores the full density matrix $\\rho$. This simulation strategy updates the state $\\rho$ by directly applying the Kraus operators of each quantum channel." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "a2973a8faef0" + }, + "outputs": [], + "source": [ + "\"\"\"Simulating a circuit with the density matrix simulator.\"\"\"\n", + "# Get a circuit.\n", + "qbit = cirq.GridQubit(0, 0)\n", + "circuit = cirq.Circuit(\n", + " cirq.X(qbit),\n", + " cirq.amplitude_damp(0.1).on(qbit)\n", + ")\n", + "\n", + "# Display it.\n", + "print(\"Simulating circuit:\")\n", + "print(circuit)\n", + "\n", + "# Simulate with the density matrix simulator.\n", + "dsim = cirq.DensityMatrixSimulator()\n", + "rho = dsim.simulate(circuit).final_density_matrix\n", + "\n", + "# Display the final density matrix.\n", + "print(\"\\nFinal density matrix:\")\n", + "print(rho)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ac8a991a426b" + }, + "source": [ + "Note that the density matrix simulator supports the `run` method which only gives access to measurements as well as the `simulate` method (used above) which gives access to the full density matrix." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0c659bb20098" + }, + "source": [ + "### Monte Carlo wavefunction simulation" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6f3caf9cea92" + }, + "source": [ + "Noisy circuits with arbitrary channels can also be simulated with the `cirq.Simulator`. When simulating such a channel, a single Kraus operator is randomly sampled (according to the probability distribution) and applied to the wavefunction. This method is known as \"Monte Carlo (wavefunction) simulation\" or \"quantum trajectories.\"\n", + "\n", + "Note: For channels which do not support the `cirq.mixture` protocol, the probability of applying each Kraus operator depends on the state. In contrast, for channels which do support the `cirq.mixture` protocol, the probability of applying each Kraus operator is independent of the state." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "d80a2bc7ce14" + }, + "outputs": [], + "source": [ + "\"\"\"Simulating a noisy circuit via Monte Carlo simulation.\"\"\"\n", + "# Get a circuit.\n", + "qbit = cirq.NamedQubit(\"Q\")\n", + "circuit = cirq.Circuit(cirq.bit_flip(p=0.5).on(qbit))\n", + "\n", + "# Display it.\n", + "print(\"Simulating circuit:\")\n", + "print(circuit)\n", + "\n", + "# Simulate with the cirq.Simulator.\n", + "sim = cirq.Simulator()\n", + "psi = sim.simulate(circuit).dirac_notation()\n", + "\n", + "# Display the final wavefunction.\n", + "print(\"\\nFinal wavefunction:\")\n", + "print(psi)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4c485bbc1dfd" + }, + "source": [ + "To see that the output is stochastic, you can run the cell above multiple times. Since $p = 0.5$ in the bit-flip channel, you should get $|0\\rangle$ roughly half the time and $|1\\rangle$ roughly half the time. The `run` method with many repetitions can also be used to see this behavior." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "8143ae0c7a34" + }, + "outputs": [], + "source": [ + "\"\"\"Example of Monte Carlo wavefunction simulation with the `run` method.\"\"\"\n", + "circuit = cirq.Circuit(\n", + " cirq.bit_flip(p=0.5).on(qbit),\n", + " cirq.measure(qbit),\n", + ")\n", + "res = sim.run(circuit, repetitions=100)\n", + "print(res.histogram(key=qbit))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0f123f0e3c55" + }, + "source": [ + "## Adding noise to circuits" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "473ac025a226" + }, + "source": [ + "Often circuits are defined with just unitary operations, but we want to simulate them with noise. There are several methods for inserting noise in Cirq." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "d0de2c475f12" + }, + "source": [ + "For any circuit, the `with_noise` method can be called to insert a channel after every moment." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "568530c8707b" + }, + "outputs": [], + "source": [ + "\"\"\"One method to insert noise in a circuit.\"\"\"\n", + "# Define some noiseless circuit.\n", + "circuit = cirq.testing.random_circuit(\n", + " qubits=3, n_moments=3, op_density=1, random_state=11\n", + ")\n", + "\n", + "# Display the noiseless circuit.\n", + "print(\"Circuit without noise:\")\n", + "print(circuit)\n", + "\n", + "# Add noise to the circuit.\n", + "noisy = circuit.with_noise(cirq.depolarize(p=0.01))\n", + "\n", + "# Display it.\n", + "print(\"\\nCircuit with noise:\")\n", + "print(noisy)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "c2206a7b7dd4" + }, + "source": [ + "This circuit can then be simulated using the methods described above." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "029509de9787" + }, + "source": [ + "The `with_noise` method creates a `cirq.NoiseModel` from its input and adds noise to each moment. A `cirq.NoiseModel` can be explicitly created and used to add noise to a single operation, single moment, or series of moments as follows." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "10a2cd41bfe4" + }, + "outputs": [], + "source": [ + "\"\"\"Add noise to an operation, moment, or sequence of moments.\"\"\"\n", + "# Create a noise model.\n", + "noise_model = cirq.NoiseModel.from_noise_model_like(cirq.depolarize(p=0.01))\n", + "\n", + "# Get a qubit register.\n", + "qreg = cirq.LineQubit.range(2)\n", + "\n", + "# Add noise to an operation.\n", + "op = cirq.CNOT(*qreg)\n", + "noisy_op = noise_model.noisy_operation(op)\n", + "\n", + "# Add noise to a moment.\n", + "moment = cirq.Moment(cirq.H.on_each(qreg))\n", + "noisy_moment = noise_model.noisy_moment(moment, system_qubits=qreg)\n", + "\n", + "# Add noise to a sequence of moments.\n", + "circuit = cirq.Circuit(cirq.H(qreg[0]), cirq.CNOT(*qreg))\n", + "noisy_circuit = noise_model.noisy_moments(circuit, system_qubits=qreg)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "a440a2aefdcf" + }, + "source": [ + "Note: In the last two examples, the argument `system_qubits` can be a subset of the qubits in the moment(s)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "61cf807b3737" + }, + "source": [ + "The output of each \"noisy method\" is a `cirq.OP_TREE` which can be converted to a circuit by passing it into the `cirq.Circuit` constructor. For example, we create a circuit from the `noisy_moment` below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "3e84e3e17421" + }, + "outputs": [], + "source": [ + "\"\"\"Creating a circuit from a noisy cirq.OP_TREE.\"\"\"\n", + "cirq.Circuit(noisy_moment)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "11b18c640767" + }, + "source": [ + "Another technique is to directly pass a `cirq.NoiseModel`, or a value that can be trivially converted into one, to the density matrix simulator as shown below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "3d16924842bf" + }, + "outputs": [], + "source": [ + "\"\"\"Define a density matrix simulator with a `cirq.NOISE_MODEL_LIKE` object.\"\"\"\n", + "\n", + "noisy_dsim = cirq.DensityMatrixSimulator(\n", + " noise=cirq.generalized_amplitude_damp(p=0.1, gamma=0.5)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0dcd4cf202be" + }, + "source": [ + "This will not explicitly add channels to the circuit being simulated, but the circuit will be simulated as though these channels were present." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "99ac77a2c896" + }, + "source": [ + "Other than these general methods, channels can be added to circuits at any moment just as gates are. The channels can be different, be correlated, act on a subset of qubits, be custom defined, etc." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "de8a285b926c" + }, + "outputs": [], + "source": [ + "\"\"\"Defining a circuit with multiple noisy channels.\"\"\"\n", + "qreg = cirq.LineQubit.range(4)\n", + "circ = cirq.Circuit(\n", + " cirq.H.on_each(qreg),\n", + " cirq.depolarize(p=0.01).on_each(qreg),\n", + " cirq.qft(*qreg),\n", + " bit_phase_flip.on_each(qreg[1::2]),\n", + " cirq.qft(*qreg, inverse=True),\n", + " cirq.reset(qreg[1]),\n", + " cirq.measure(*qreg),\n", + " cirq.bit_flip(p=0.07).controlled(1).on(*qreg[2:]),\n", + ")\n", + "\n", + "print(\"Circuit with multiple channels:\\n\")\n", + "print(circ)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "a9bb97a17256" + }, + "source": [ + "Circuits can also be modified with standard methods like `insert` to add channels at any point in the circuit. For example, to model simple state preparation errors, one can add bit-flip channels to the start of the circuit as follows." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "524ded251565" + }, + "outputs": [], + "source": [ + "\"\"\"Example of inserting channels in circuits.\"\"\"\n", + "circ.insert(0, cirq.bit_flip(p=0.1).on_each(qreg))\n", + "print(circ)" + ] + } + ], + "metadata": { + "colab": { + "name": "noisy_simulation.ipynb", + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/docs/params.ipynb b/docs/params.ipynb new file mode 100644 index 00000000000..da56fc946f3 --- /dev/null +++ b/docs/params.ipynb @@ -0,0 +1,153 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "be796cb3-8b58-460b-b717-733ec0bc3e4b", + "metadata": {}, + "source": [ + "##### Copyright 2022 The Cirq Developers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1552f54-54a2-4d4f-ae1a-1bb15d24dcab", + "metadata": {}, + "outputs": [], + "source": [ + "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "#\n", + "# https://www.apache.org/licenses/LICENSE-2.0\n", + "#\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License." + ] + }, + { + "cell_type": "markdown", + "id": "ccb2d671-f8af-4d79-b477-030de935156c", + "metadata": { + "id": "EQvWLKKRgZR9" + }, + "source": [ + "# Parameter Sweeps" + ] + }, + { + "cell_type": "markdown", + "id": "9d101fdc-94b6-4aff-b165-bf56a6a880bf", + "metadata": { + "id": "EvZ_JecKga2p" + }, + "source": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " View on QuantumAI\n", + " \n", + " Run in Google Colab\n", + " \n", + " View source on GitHub\n", + " \n", + " Download notebook\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b6858f27-50a0-4603-8979-10810fce18f5", + "metadata": { + "id": "bd9529db1c0b" + }, + "outputs": [], + "source": [ + "try:\n", + " import cirq\n", + "except ImportError:\n", + " print(\"installing cirq...\")\n", + " !pip install --quiet cirq\n", + " print(\"installed cirq.\")\n", + " import cirq" + ] + }, + { + "cell_type": "markdown", + "id": "3ed0b5c5-1e40-4fed-b867-e5a81247bdec", + "metadata": {}, + "source": [ + "## Concept of Circuit Parameterization and Sweeps\n", + "\n", + "Suppose one has a quantum circuit and in this circuit there is a gate with some parameter. One might wish to run this circuit for different values of this parameter. An example of this type of setup is a Rabi flop experiment. In this experiment, one runs a set of quantum computations where one 1) starts in $|0\\rangle$ state, 2) rotates the state by $\\theta$ about the $x$ axis, i.e. applies the gate $\\exp(i \\theta X)$, and 3) measures the state in the computational basis. Running this experiment for multiple values of $\\theta$, and plotting the probability of observing a $|1\\rangle$ outcome yields the quintessential $\\cos^2$ probability distribution as a function of the different parameters $\\theta$. To support this type of experiment, Cirq provides the concept of parameterized circuits and parameter sweeps. \n", + "\n", + "Let's illustrate parameter sweeps by a simple example. Suppose that we want to compare two quantum circuits that are very similar except for a single gate." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "773ec3c4-a068-4695-b598-c0ac35c66320", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "circuit1:\n", + "0: ───H───S───H───M───\n", + "circuit2:\n", + "0: ───H───T───H───M───\n" + ] + } + ], + "source": [ + "q0 = cirq.LineQubit(0)\n", + "\n", + "circuit1 = cirq.Circuit([cirq.H(q0), cirq.Z(q0)**0.5, cirq.H(q0), cirq.measure(q0)])\n", + "print(f\"circuit1:\\n{circuit1}\")\n", + "\n", + "circuit2 = cirq.Circuit([cirq.H(q0), cirq.Z(q0)**0.25, cirq.H(q0), cirq.measure(q0)])\n", + "print(f\"circuit2:\\n{circuit2}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6cfff8b9-7a3e-423b-b03d-0867fa5b31f0", + "metadata": {}, + "source": [ + "One could run (either on hardware or in simulation) these circuits separately, for example, and collect statistics on the results of these circuits. However we can use parameter sweeps to do this in a cleaner and more perfomant manner. \n", + "\n", + "First one defines a parameter, and constructs a circuit that depends on this parameter. We use " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/simulate/_index.yaml b/docs/simulate/_index.yaml new file mode 100644 index 00000000000..bd3795e7aaf --- /dev/null +++ b/docs/simulate/_index.yaml @@ -0,0 +1,24 @@ +book_path: /cirq/_book.yaml +project_path: /cirq/_project.yaml +title: Simulate a circuit +landing_page: + nav: left + rows: + - heading: Simulate a circuit + description: Cirq provides different ways to compute the effects of a quantum circuit, by simulating a quantum computer with a classical one. + items: + - heading: Exact Simulation + description: Simulate a perfect and noiseless quantum computer, as the mathematical theory intended. + path: /cirq/simulation + icon: + name: menu_book + - heading: Noisy Simulation + description: Simulate a more realistic quantum computer, subject to error and noise, which affects the accuracy of the results. + path: /cirq/noisy_simulation + icon: + name: menu_book + - heading: State Histograms + description: Visualize the results of simulation as a histogram over basis states. + path: /cirq/tutorials/state_histograms + icon: + name: menu_book diff --git a/docs/transform/_index.yaml b/docs/transform/_index.yaml new file mode 100644 index 00000000000..a995d1a0d41 --- /dev/null +++ b/docs/transform/_index.yaml @@ -0,0 +1,14 @@ +book_path: /cirq/_book.yaml +project_path: /cirq/_project.yaml +title: Transform a circuit +landing_page: + nav: left + rows: + - heading: Transform a circuit + description: Cirq provides different ways of transforming a provided circuit, which may be necessary to prepare it to run on quantum hardware device, or to improve its reliability on a device. + items: + - heading: Circuit Transformers + description: The Transformer class to represent some process to change a supplied circuit. + path: /cirq/transformers + icon: + name: menu_book diff --git a/docs/transformers.ipynb b/docs/transformers.ipynb new file mode 100644 index 00000000000..37e70e4072b --- /dev/null +++ b/docs/transformers.ipynb @@ -0,0 +1,644 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "906e07f6e562" + }, + "outputs": [], + "source": [ + "#@title Copyright 2022 The Cirq Developers\n", + "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "#\n", + "# https://www.apache.org/licenses/LICENSE-2.0\n", + "#\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8bbd73c03ac2" + }, + "source": [ + "# Installing Cirq" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "25eb74f260d6" + }, + "source": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " View on QuantumAI\n", + " \n", + " Run in Google Colab\n", + " \n", + " View source on GitHub\n", + " \n", + " Download notebook\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "846b32703c5c" + }, + "outputs": [], + "source": [ + "try:\n", + " import cirq\n", + "except ImportError:\n", + " print(\"installing cirq...\")\n", + " !pip install --quiet cirq\n", + " import cirq\n", + " print(\"installed cirq.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9d3d49b9ca2a" + }, + "source": [ + "# What is a Transformer?\n", + "A transformer in Cirq is any callable, that satisfies the `cirq.TRANSFORMER` API, and *transforms* an input circuit into an output circuit.\n", + "\n", + "Circuit transformations are often necessary to compile a user-defined circuit to an equivalent circuit, which can be executed on a specific device or simulator. The compilation process often involves steps like:\n", + "- Gate Decompositions: Rewrite the circuit using only gates that belong to the device target gateset, i.e. set of gates which the device can execute. \n", + "- Qubit Mapping and Routing: Map the logic qubits in the input circuit to physical qubits on the device and insert appropriate swap operations such that final circuit respects the hardware topology. \n", + "- Circuit Optimizations: Perform hardware specific optimizations, like merging and replacing connected components of 1 and 2 operations with more efficient rewrites, commuting Z gates through the circuit, aligning gates in moments etc.\n", + "\n", + "\n", + "Cirq provides many out-of-the-box transformers which can be used as individual compilation passes and also provides a general framework for users to create their own transformers using powerful primitives and bundle a bunch of transformers together to enable compiling circuits for specific targets. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KUor1pGZi0Iw" + }, + "source": [ + "# Built-in Transformers in Cirq" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "861ea1ada088" + }, + "source": [ + "## Overview\n", + "Transformers that come with cirq can be found in the `cirq.transformers` package.\n", + "\n", + "A few notable examples are:\n", + "* **`cirq.align_left` / `cirq.align_right`**: Align gates to the left/right of the circuit.\n", + "* **`cirq.defer_measurements`**: Moves all (non-terminal) measurements in a circuit to the end of circuit by implementing the deferred measurement principle.\n", + "* **`cirq.drop_empty_moments`** / **`cirq.drop_negligible_operations`**: Removes moments that are empty or operations that have very small effects, respectively.\n", + "* **`cirq.eject_phased_paulis`**: Pushes X, Y, and PhasedX gates towards the end of the circuit, potentially absorbing Z gates and modifying gates along the way.\n", + "* **`cirq.eject_z`**: Pushes Z gates towards the end of the circuit, potentially adjusting phases of gates that they pass through.\n", + "* **`cirq.expand_composite`**: Uses `cirq.decompose` to expand composite gates.\n", + "* **`cirq.merge_k_qubit_unitaries`**: Replaces connected components of unitary operations, acting on <= k qubits, with op-tree given by `rewriter(circuit_op)`.\n", + "* **`cirq.optimize_for_target_gateset`**: Attempts to convert a circuit into an equivalent circuit using only gates from a given target gateset.\n", + "* **`cirq.stratified_circuit`**: Repacks the circuit to ensure that moments only contain operations from the same category.\n", + "* **`cirq.synchronize_terminal_measurements`**: Moves all terminal measurements in a circuit to the final moment, if possible.\n", + "\n", + "\n", + "Below you can see how to implement a transformer pipeline called `optimize_circuit`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "AqTylIpssdex" + }, + "outputs": [], + "source": [ + "def optimize_circuit(circuit, context = None, k=2):\n", + " # Merge 2-qubit connected components into circuit operations.\n", + " optimized_circuit = cirq.merge_k_qubit_unitaries(circuit, k=k, rewriter=lambda op: op.with_tags(\"merged\"), context=context)\n", + "\n", + " # Drop operations with negligible effect / close to identity.\n", + " optimized_circuit = cirq.drop_negligible_operations(optimized_circuit, context=context)\n", + "\n", + " # Expand all remaining merged connected components. \n", + " optimized_circuit = cirq.expand_composite(optimized_circuit, no_decomp=lambda op: \"merged\" not in op.tags, context=context)\n", + "\n", + " # Synchronize terminal measurements to be in the same moment. \n", + " optimized_circuit = cirq.synchronize_terminal_measurements(optimized_circuit, context=context)\n", + "\n", + " # Assert the original and optimized circuit are equivalent.\n", + " cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(circuit, optimized_circuit)\n", + " \n", + " return optimized_circuit\n", + "\n", + "q = cirq.LineQubit.range(3)\n", + "circuit = cirq.Circuit(\n", + " cirq.H(q[1]), cirq.CNOT(*q[1:]), \n", + " cirq.H(q[0]), cirq.CNOT(*q[:2]), cirq.H(q[1]), \n", + " cirq.CZ(*q[:2]), cirq.H.on_each(*q[:2]),\n", + " cirq.CNOT(q[2], q[0]),\n", + " cirq.measure_each(*q)\n", + ")\n", + "print(\"Original Circuit:\", circuit, sep=\"\\n\")\n", + "print(\"Optimized Circuit:\", optimize_circuit(circuit), sep=\"\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mu83U5hGzNcH" + }, + "source": [ + "## Inspecting transformer actions\n", + "\n", + "Every transformer in Cirq accepts a `cirq.TransformerContext` instance, which stores common configurable options useful for all transformers. \n", + "\n", + "One of the members of transformer context dataclass is `cirq.TransformerLogger` instance. When a logger instance is specified, every cirq transformer logs its action on the input circuit using the given logger instance. The logs can then be inspected to understand the action of each individual transformer on the circuit.\n", + "\n", + "Below, you can inspect the action of each transformer in the `optimize_circuit` method defined above. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1cqUa2Kc0Hni" + }, + "outputs": [], + "source": [ + "context = cirq.TransformerContext(logger=cirq.TransformerLogger())\n", + "optimized_circuit = optimize_circuit(circuit, context)\n", + "context.logger.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kLm-5LHr0YAd" + }, + "source": [ + "## Support for no-compile tags\n", + "\n", + "Cirq also supports tagging operations with no-compile tags such that these tagged operations are ignored when applying transformations on the circuit. This allows users to gain more fine-grained conrol over the compilation process. \n", + "\n", + "Any valid tag can be used as a \"no-compile\" tag by adding it to the `tags_to_ignore` field in `cirq.TransformerContext`. When called with a context, cirq transformers will inspect the `context.tags_to_ignore` field and ignore an operation if `op.tags & context.tags_to_ignore` is not empty. \n", + "\n", + "Below, you can use no-compile tags when transforming a circuit using the `optimize_circuit` mehod defined above." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "HEhXziehR29V" + }, + "outputs": [], + "source": [ + "# Echo pulses inserted in the circuit to prevent dephasing during idling should be ignored.\n", + "circuit = cirq.Circuit(\n", + " cirq.H(q[0]), cirq.CNOT(*q[:2]),\n", + " [op.with_tags(\"spin_echoes\") for op in [cirq.X(q[0]) ** 0.5, cirq.X(q[0])** -0.5]],\n", + " [cirq.CNOT(*q[1:]), cirq.CNOT(*q[1:])],\n", + " [cirq.CNOT(*q[:2]), cirq.H(q[0])],\n", + " cirq.measure_each(*q),\n", + ")\n", + "# Original Circuit\n", + "print(\"Original Circuit:\", circuit, \"\\n\", sep=\"\\n\")\n", + "\n", + "# Optimized Circuit without tags_to_ignore\n", + "print(\"Optimized Circuit without specifying tags_to_ignore:\")\n", + "print(optimize_circuit(circuit, k=1), \"\\n\")\n", + "\n", + "# Optimized Circuit ignoring operations marked with tags_to_ignore. \n", + "print(\"Optimized Circuit while ignoring operations marked with tags_to_ignore:\")\n", + "context=cirq.TransformerContext(tags_to_ignore=[\"spin_echoes\"])\n", + "print(optimize_circuit(circuit, k=1, context=context), \"\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3f3c7851a571" + }, + "source": [ + "## Support for recursively transforming sub-circuits\n", + "\n", + "By default, an operation `op` of type `cirq.CircuitOperation` is considered as a single top-level operation by cirq transformers. As a result, the sub-circuits wrapped inside circuit operations will often be left as it is and a transformer will only modify the top-level circuit. \n", + "\n", + "If you wish to recursively run a transformer on every nested sub-circuit wrapped inside a `cirq.CircuitOperation`, you can set `context.deep=True` in the `cirq.TransformerContext` object. Note that tagged circuit operations marked with any of `context.tags_to_ignore` will be ignored even if `context.deep is True`. See the example below for a better understanding. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "994ffb523487" + }, + "outputs": [], + "source": [ + "q = cirq.LineQubit.range(2)\n", + "circuit_op = cirq.CircuitOperation(\n", + " cirq.FrozenCircuit(\n", + " cirq.I.on_each(*q),\n", + " cirq.CNOT(*q),\n", + " cirq.I(q[0]).with_tags(\"ignore\"),\n", + " )\n", + ")\n", + "circuit = cirq.Circuit(\n", + " cirq.I(q[0]), cirq.I(q[1]).with_tags(\"ignore\"),\n", + " circuit_op,\n", + " circuit_op.with_tags(\"ignore\"),\n", + ")\n", + "print(\"Original Circuit:\", circuit, \"\\n\", sep=\"\\n\\n\")\n", + "\n", + "context = cirq.TransformerContext(tags_to_ignore=[\"ignore\"], deep=True)\n", + "print(\"Optimized Circuit with deep=True and tags_to_ignore=['ignore']:\\n\")\n", + "print(cirq.drop_negligible_operations(circuit, context=context), \"\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iIHUZvLRlHFj" + }, + "source": [ + "## Compiling to NISQ targets: `cirq.CompilationTargetGateset`\n", + "Cirq's philosophy on compiling circuits for execution on a NISQ target device or simulator is that it would often require running only a handful of individual compilation passes on the input circuit, one after the other.\n", + "\n", + "**`cirq.CompilationTargetGateset`** is an abstraction in Cirq to represent such compilation targets as well as the bundles of transformer passes which should be executed to compile a circuit to this target. Cirq has implementations for common target gatesets like `cirq.CZTargetGateset`, `cirq.SqrtIswapTargetGateset` etc.\n", + "\n", + "\n", + "**`cirq.optimize_for_target_gateset`** is a transformer which compiles a given circuit for a `cirq.CompilationTargetGateset` via the following steps:\n", + "\n", + "1. Run all `gateset.preprocess_transformers`\n", + "2. Convert operations using built-in `cirq.decompose` + `gateset.decompose_to_target_gateset`.\n", + "3. Run all `gateset.postprocess_transformers`\n", + "\n", + "\n", + "The preprocess transformers often includes optimizations like merging connected components of 1/2 qubit unitaries into a single unitary matrix, which can then be replaced with an efficient analytical decomposition as part of step-2. \n", + "\n", + "The post-process transformers often includes cleanups and optimizations like dropping negligible operations, \n", + "converting single qubit rotations into desired form, circuit alignments etc. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "-QFPCdW0qS3R" + }, + "outputs": [], + "source": [ + "# Original QFT Circuit on 3 qubits.\n", + "q = cirq.LineQubit.range(3)\n", + "circuit = cirq.Circuit(cirq.QuantumFourierTransformGate(3).on(*q), cirq.measure(*q))\n", + "print(\"Original Circuit:\", circuit, \"\\n\", sep=\"\\n\")\n", + "\n", + "# Compile the circuit for CZ Target Gateset.\n", + "gateset = cirq.CZTargetGateset(allow_partial_czs=True)\n", + "cz_circuit = cirq.optimize_for_target_gateset(circuit, gateset = gateset)\n", + "cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(circuit, cz_circuit)\n", + "print(\"Circuit compiled for CZ Target Gateset:\", cz_circuit, \"\\n\", sep=\"\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b963809fa20b" + }, + "source": [ + "`cirq.optimize_for_target_gateset` also supports all the features discussed above, using `cirq.TransformerContext`. For example, you can compile the circuit for sqrt-iswap target gateset and inspect action of individual transformers using `cirq.TransformerLogger`, as shown below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "140330585db5" + }, + "outputs": [], + "source": [ + "context = cirq.TransformerContext(logger=cirq.TransformerLogger())\n", + "gateset = cirq.SqrtIswapTargetGateset()\n", + "sqrt_iswap_circuit = cirq.optimize_for_target_gateset(circuit, gateset = gateset, context=context)\n", + "cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(circuit, sqrt_iswap_circuit)\n", + "context.logger.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jyNdxrkI4CYX" + }, + "source": [ + "# Building custom transformers" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6da0Ra7bz2St" + }, + "source": [ + "## `cirq.TRANSFORMER` API and `@cirq.transformer` decorator\n", + "\n", + "Any callable that satisfies the `cirq.TRANSFORMER` contract, i.e. takes a `cirq.AbstractCircuit` and `cirq.TransformerContext` and returns a transformed `cirq.AbstractCircuit`, is a valid transformer in Cirq. \n", + "\n", + "You can create a custom transformer by simply decorating a class/method, that satisfies the above contract, with `@cirq.transformer` decorator. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "e2893a817870" + }, + "outputs": [], + "source": [ + "@cirq.transformer\n", + "def reverse_circuit(circuit, *, context = None):\n", + " \"\"\"Transformer to reverse the input circuit.\"\"\"\n", + " return circuit[::-1]\n", + "\n", + "\n", + "@cirq.transformer\n", + "class SubstituteGate:\n", + " \"\"\"Transformer to substitute `source` gates with `target` in the input circuit.\"\"\"\n", + " def __init__(self, source, target):\n", + " self._source = source\n", + " self._target = target\n", + "\n", + " def __call__(self, circuit, *, context = None):\n", + " batch_replace = []\n", + " for i, op in circuit.findall_operations(lambda op: op.gate == self._source):\n", + " batch_replace.append((i, op, self._target.on(*op.qubits)))\n", + " transformed_circuit = circuit.unfreeze(copy=True)\n", + " transformed_circuit.batch_replace(batch_replace)\n", + " return transformed_circuit\n", + "\n", + "q = cirq.NamedQubit(\"q\")\n", + "circuit = cirq.Circuit(cirq.X(q), cirq.CircuitOperation(cirq.FrozenCircuit(cirq.X(q), cirq.Y(q))), cirq.Z(q))\n", + "substitute_gate = SubstituteGate(cirq.X, cirq.S)\n", + "print(\"Original Circuit:\", circuit, \"\\n\", sep=\"\\n\")\n", + "print(\"Reversed Circuit:\", reverse_circuit(circuit), \"\\n\", sep=\"\\n\")\n", + "print(\"Substituted Circuit:\", substitute_gate(circuit), sep=\"\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OLJrXdyTCGev" + }, + "source": [ + "## `cirq.TransformerContext` to store common configurable options\n", + "`cirq.TransformerContext` is a dataclass that stores common configurable options for all transformers. All cirq transformers should accept the transformer context as an optional keyword argument. \n", + "\n", + "The `@cirq.transformer` decorator can inspect the `cirq.TransformerContext` argument and automatically append useful functionality, like support for automated logging and recursively running the transformer on nested sub-circuits.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5OuMLlNAFPcW" + }, + "source": [ + "### `cirq.TransformerLogger` and support for automated logging\n", + "The `cirq.TransformerLogger` class is used to log the actions of a transformer on an input circuit. `@cirq.transformer` decorator automatically adds support for logging the initial and final circuits for each transfomer step. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1-1r6Ha9F1c3" + }, + "outputs": [], + "source": [ + "context = cirq.TransformerContext(logger=cirq.TransformerLogger())\n", + "transformed_circuit = reverse_circuit(circuit, context=context)\n", + "transformed_circuit = substitute_gate(transformed_circuit, context=context)\n", + "context.logger.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UvFdvxQ6MZD9" + }, + "source": [ + "### Support for `deep=True`\n", + "You can call `@cirq.transformer(add_deep_support=True)` to automatically add the functionality of recursively running the custom transformer on circuits wrapped inside `cirq.CircuitOperation`. The recursive execution behavior of the transformer can then be controlled by setting `deep=True` in the transformer context. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "BobP3UFBJhP1" + }, + "outputs": [], + "source": [ + "@cirq.transformer(add_deep_support=True)\n", + "def reverse_circuit_deep(circuit, *, context = None):\n", + " \"\"\"Transformer to reverse the input circuit.\"\"\"\n", + " return circuit[::-1]\n", + "\n", + "\n", + "@cirq.transformer(add_deep_support=True)\n", + "class SubstituteGateDeep(SubstituteGate):\n", + " \"\"\"Transformer to substitute `source` gates with `target` in the input circuit.\"\"\"\n", + " pass\n", + "\n", + "context = cirq.TransformerContext(deep=True)\n", + "substitute_gate_deep = SubstituteGateDeep(cirq.X, cirq.S)\n", + "print(\"Original Circuit:\", circuit, \"\\n\", sep=\"\\n\")\n", + "print(\"Reversed Circuit with deep=True:\", reverse_circuit_deep(circuit, context=context), \"\\n\", sep=\"\\n\")\n", + "print(\"Substituted Circuit with deep=True:\", substitute_gate_deep(circuit, context=context), sep=\"\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bDizgWMmPLq0" + }, + "source": [ + "# Transformer Primitives and Decompositions\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sXbcG1VdPRkm" + }, + "source": [ + "## Moment preserving transformer primitives\n", + "\n", + "Cirq provides useful abstractions to implement common transformer patterns, while preserving the moment structure of input circuit. Some of the notable transformer primitives are:\n", + "\n", + "- **`cirq.map_operations`**: Applies local transformations on operations, by calling `map_func(op)` for each `op`.\n", + "- **`cirq.map_moments`**: Applies local transformation on moments, by calling `map_func(m)` for each moment `m`.\n", + "- **`cirq.merge_operations`**: Merges connected component of operations by iteratively calling `merge_func(op1, op2)` for every pair of mergeable operations `op1` and `op2`.\n", + "- **`cirq.merge_moments`**: Merges adjacent moments, from left to right, by iteratively calling `merge_func(m1, m2)` for adjacent moments `m1` and `m2`.\n", + "\n", + "\n", + "An important property of these primitives is that they have support for common configurable options present in `cirq.TransformerContext`, such as `tags_to_ignore` and `deep`. See the example below for a better understanding." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "BCXc94owfIJh" + }, + "outputs": [], + "source": [ + "@cirq.transformer\n", + "def substitute_gate_using_primitives(circuit, *, context = None, source = cirq.X, target= cirq.S):\n", + " \"\"\"Transformer to substitute `source` gates with `target` in the input circuit.\n", + " \n", + " The transformer is implemented using `cirq.map_operations` primitive and hence\n", + " has built-in support for \n", + " 1. Recursively running the transformer on sub-circuits if `context.deep is True`.\n", + " 2. Ignoring operations tagged with any of `context.tags_to_ignore`. \n", + " \"\"\"\n", + " return cirq.map_operations(\n", + " circuit, \n", + " map_func=lambda op, _: target.on(*op.qubits) if op.gate == source else op,\n", + " deep = context.deep if context else False,\n", + " tags_to_ignore=context.tags_to_ignore if context else ()\n", + " )\n", + "\n", + "x_y_x = [cirq.X(q), cirq.Y(q), cirq.X(q).with_tags(\"ignore\")]\n", + "circuit = cirq.Circuit(x_y_x, cirq.CircuitOperation(cirq.FrozenCircuit(x_y_x)), x_y_x)\n", + "context = cirq.TransformerContext(deep=True, tags_to_ignore=(\"ignore\",))\n", + "print(\"Original Circuit:\", circuit, \"\\n\", sep=\"\\n\")\n", + "print(\"Substituted Circuit:\", substitute_gate_using_primitives(circuit, context=context), \"\\n\", sep=\"\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NzTPE_wGjWkJ" + }, + "source": [ + "## Analytical Gate Decompositions\n", + "\n", + "Gate decomposition is the process of implementing / decomposing a given unitary `U` using only gates that belong to a specific target gateset. \n", + "\n", + "Cirq provides many analytical decomposition methods, often based on [KAK Decomposition](https://arxiv.org/abs/quant-ph/0507171), to decompose two qubit unitaries into specific target gatesets. Some notable decompositions are:\n", + "\n", + "* **`cirq.single_qubit_matrix_to_pauli_rotations`**: Decomposes a single qubit matrix to ZPow/XPow/YPow rotations. \n", + "* **`cirq.single_qubit_matrix_to_phased_x_z`**: Decomposes a single-qubit matrix to a PhasedX and Z gate.\n", + "* **`cirq.two_qubit_matrix_to_sqrt_iswap_operations`**: Decomposes any two-qubit unitary matrix into ZPow/XPow/YPow/sqrt-iSWAP gates.\n", + "* **`cirq.two_qubit_matrix_to_cz_operations`**: Decomposes any two-qubit unitary matrix into ZPow/XPow/YPow/CZ gates.\n", + "* **`cirq.three_qubit_matrix_to_operations`**: Decomposes any three-qubit unitary matrix into CZ/CNOT and single qubit rotations.\n", + "\n", + "\n", + "\n", + "You can use these analytical decomposition methods to build transformers which can rewrite a given circuit using only gates from the target gateset. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Pb7sXwEFcIxB" + }, + "outputs": [], + "source": [ + "@cirq.transformer\n", + "def convert_to_cz_target(circuit, *, context=None, atol=1e-8, allow_partial_czs=True):\n", + " \"\"\"Transformer to rewrite the given circuit using CZs + 1-qubit rotations.\n", + "\n", + " Note that the transformer decomposes only operations on <= 2-qubits and is\n", + " presented as an illustration of using transformer primitives + analytical \n", + " decomposition methods. \n", + " \"\"\"\n", + " def map_func(op: cirq.Operation, _) -> cirq.OP_TREE:\n", + " if not (cirq.has_unitary(op) and cirq.num_qubits(op) <= 2):\n", + " return op\n", + " mat = cirq.unitary(op)\n", + " q = op.qubits\n", + " if cirq.num_qubits(op) == 1:\n", + " g = cirq.single_qubit_matrix_to_phxz(mat)\n", + " return g.on(*q) if g else []\n", + " return cirq.two_qubit_matrix_to_cz_operations(*q, mat, allow_partial_czs=allow_partial_czs, atol=atol)\n", + " \n", + " return cirq.map_operations_and_unroll(\n", + " circuit, \n", + " map_func,\n", + " deep=context.deep if context else False,\n", + " tags_to_ignore=context.tags_to_ignore if context else ()\n", + " )\n", + "circuit = cirq.testing.random_circuit(qubits=3, n_moments=5, op_density=0.8, random_state=1234)\n", + "converted_circuit = convert_to_cz_target(circuit)\n", + "cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(circuit, converted_circuit)\n", + "print(f\"Original Circuit\", circuit, \"\\n\", sep=\"\\n\")\n", + "print(f\"Circuit compiled for CZ Target Gateset using custom transformer\", converted_circuit, \"\\n\", sep=\"\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jE7XXZs7bmTJ" + }, + "source": [ + "## Heuristic Gate Decompositions\n", + "Cirq also provides heuristic methods for decomposing any two qubit unitary matrix in terms of any specified two qubit target unitary + single qubit rotations. These methods are useful when accurate analytical decompositions for the target unitary are not known or when gate decomposition fidelity (i.e. accuracy of decomposition) can be traded off against decomposition depth (i.e. number of 2q gates in resulting decomposition) to achieve a higher overall gate fidelity. \n", + "\n", + "\n", + "See the following resources for more details on heuristic gate decomposition:\n", + "\n", + "* **`cirq.two_qubit_gate_product_tabulation`**\n", + "* **https://arxiv.org/pdf/2106.15490.pdf**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aTNKFcPesNpy" + }, + "source": [ + "# Summary\n", + "Cirq provides a flexible and powerful framework to\n", + "* Use built-in transformer primitives and analytical tools to create powerful custom transformers AND \n", + "* Easily integrate custom transformers with built-in infrastructure to augment functionality like automated logging, recursive execution on sub-circuits, support for no-compile tags etc.\n", + "\n", + "Cirq also provides a plethora of built-in transformers which can be composed together into useful abstractions, like `cirq.CompilationTargetGateset`, which in-turn can be serialized and can be used as a parameter in larger compilation pipelines and experiment workflows. \n", + "\n", + "Try using these transformers to compile your circuits and refer to the API reference docs of [`cirq.transformers`](https://quantumai.google/reference/python/cirq/transformers) for more details. " + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "transformers.ipynb", + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 8ca90b40aecb46c18fe78cb706d890be91ba2e62 Mon Sep 17 00:00:00 2001 From: Dave Bacon Date: Thu, 2 Jun 2022 16:57:00 +0000 Subject: [PATCH 5/6] remove extra --- docs/params.ipynb | 153 ---------------------------------------------- 1 file changed, 153 deletions(-) delete mode 100644 docs/params.ipynb diff --git a/docs/params.ipynb b/docs/params.ipynb deleted file mode 100644 index da56fc946f3..00000000000 --- a/docs/params.ipynb +++ /dev/null @@ -1,153 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "be796cb3-8b58-460b-b717-733ec0bc3e4b", - "metadata": {}, - "source": [ - "##### Copyright 2022 The Cirq Developers" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e1552f54-54a2-4d4f-ae1a-1bb15d24dcab", - "metadata": {}, - "outputs": [], - "source": [ - "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n", - "# you may not use this file except in compliance with the License.\n", - "# You may obtain a copy of the License at\n", - "#\n", - "# https://www.apache.org/licenses/LICENSE-2.0\n", - "#\n", - "# Unless required by applicable law or agreed to in writing, software\n", - "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", - "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", - "# See the License for the specific language governing permissions and\n", - "# limitations under the License." - ] - }, - { - "cell_type": "markdown", - "id": "ccb2d671-f8af-4d79-b477-030de935156c", - "metadata": { - "id": "EQvWLKKRgZR9" - }, - "source": [ - "# Parameter Sweeps" - ] - }, - { - "cell_type": "markdown", - "id": "9d101fdc-94b6-4aff-b165-bf56a6a880bf", - "metadata": { - "id": "EvZ_JecKga2p" - }, - "source": [ - "\n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " View on QuantumAI\n", - " \n", - " Run in Google Colab\n", - " \n", - " View source on GitHub\n", - " \n", - " Download notebook\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "b6858f27-50a0-4603-8979-10810fce18f5", - "metadata": { - "id": "bd9529db1c0b" - }, - "outputs": [], - "source": [ - "try:\n", - " import cirq\n", - "except ImportError:\n", - " print(\"installing cirq...\")\n", - " !pip install --quiet cirq\n", - " print(\"installed cirq.\")\n", - " import cirq" - ] - }, - { - "cell_type": "markdown", - "id": "3ed0b5c5-1e40-4fed-b867-e5a81247bdec", - "metadata": {}, - "source": [ - "## Concept of Circuit Parameterization and Sweeps\n", - "\n", - "Suppose one has a quantum circuit and in this circuit there is a gate with some parameter. One might wish to run this circuit for different values of this parameter. An example of this type of setup is a Rabi flop experiment. In this experiment, one runs a set of quantum computations where one 1) starts in $|0\\rangle$ state, 2) rotates the state by $\\theta$ about the $x$ axis, i.e. applies the gate $\\exp(i \\theta X)$, and 3) measures the state in the computational basis. Running this experiment for multiple values of $\\theta$, and plotting the probability of observing a $|1\\rangle$ outcome yields the quintessential $\\cos^2$ probability distribution as a function of the different parameters $\\theta$. To support this type of experiment, Cirq provides the concept of parameterized circuits and parameter sweeps. \n", - "\n", - "Let's illustrate parameter sweeps by a simple example. Suppose that we want to compare two quantum circuits that are very similar except for a single gate." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "773ec3c4-a068-4695-b598-c0ac35c66320", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "circuit1:\n", - "0: ───H───S───H───M───\n", - "circuit2:\n", - "0: ───H───T───H───M───\n" - ] - } - ], - "source": [ - "q0 = cirq.LineQubit(0)\n", - "\n", - "circuit1 = cirq.Circuit([cirq.H(q0), cirq.Z(q0)**0.5, cirq.H(q0), cirq.measure(q0)])\n", - "print(f\"circuit1:\\n{circuit1}\")\n", - "\n", - "circuit2 = cirq.Circuit([cirq.H(q0), cirq.Z(q0)**0.25, cirq.H(q0), cirq.measure(q0)])\n", - "print(f\"circuit2:\\n{circuit2}\")" - ] - }, - { - "cell_type": "markdown", - "id": "6cfff8b9-7a3e-423b-b03d-0867fa5b31f0", - "metadata": {}, - "source": [ - "One could run (either on hardware or in simulation) these circuits separately, for example, and collect statistics on the results of these circuits. However we can use parameter sweeps to do this in a cleaner and more perfomant manner. \n", - "\n", - "First one defines a parameter, and constructs a circuit that depends on this parameter. We use " - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.9.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 445d351bd8efc7e7ff5578a1b6df92d164736c62 Mon Sep 17 00:00:00 2001 From: Dave Bacon Date: Thu, 2 Jun 2022 18:21:28 +0000 Subject: [PATCH 6/6] fix test --- dev_tools/notebooks/isolated_notebook_test.py | 1 - 1 file changed, 1 deletion(-) diff --git a/dev_tools/notebooks/isolated_notebook_test.py b/dev_tools/notebooks/isolated_notebook_test.py index f5cd6c1a306..9316aa7a6b9 100644 --- a/dev_tools/notebooks/isolated_notebook_test.py +++ b/dev_tools/notebooks/isolated_notebook_test.py @@ -54,7 +54,6 @@ 'docs/tutorials/google/visualizing_calibration_metrics.ipynb', 'docs/tutorials/google/xeb_calibration_example.ipynb', 'docs/named_topologies.ipynb', - 'docs/tutorials/educators/intro.ipynb', ] # By default all notebooks should be tested, however, this list contains exceptions to the rule