1{
2 "cells": [
3  {
4   "cell_type": "markdown",
5   "metadata": {
6    "id": "cedf868076a2"
7   },
8   "source": [
9    "##### Copyright 2020 The Cirq Developers"
10   ]
11  },
12  {
13   "cell_type": "code",
14   "execution_count": 1,
15   "metadata": {
16    "cellView": "form",
17    "id": "906e07f6e562"
18   },
19   "outputs": [],
20   "source": [
21    "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
22    "# you may not use this file except in compliance with the License.\n",
23    "# You may obtain a copy of the License at\n",
24    "#\n",
25    "# https://www.apache.org/licenses/LICENSE-2.0\n",
26    "#\n",
27    "# Unless required by applicable law or agreed to in writing, software\n",
28    "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
29    "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
30    "# See the License for the specific language governing permissions and\n",
31    "# limitations under the License."
32   ]
33  },
34  {
35   "cell_type": "markdown",
36   "metadata": {
37    "id": "19599098c1f9"
38   },
39   "source": [
40    "# Introduction to Cirq"
41   ]
42  },
43  {
44   "cell_type": "markdown",
45   "metadata": {
46    "id": "8bd3406cf99e"
47   },
48   "source": [
49    "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
50    "  <td>\n",
51    "    <a target=\"_blank\" href=\"https://quantumai.google/cirq/tutorials/educators/intro\"><img src=\"https://quantumai.google/site-assets/images/buttons/quantumai_logo_1x.png\" />View on QuantumAI</a>\n",
52    "  </td>\n",
53    "  <td>\n",
54    "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/quantumlib/Cirq/blob/master/docs/tutorials/educators/intro.ipynb\"><img src=\"https://quantumai.google/site-assets/images/buttons/colab_logo_1x.png\" />Run in Google Colab</a>\n",
55    "  </td>\n",
56    "  <td>\n",
57    "    <a target=\"_blank\" href=\"https://github.com/quantumlib/Cirq/blob/master/docs/tutorials/educators/intro.ipynb\"><img src=\"https://quantumai.google/site-assets/images/buttons/github_logo_1x.png\" />View source on GitHub</a>\n",
58    "  </td>\n",
59    "  <td>\n",
60    "    <a href=\"https://storage.googleapis.com/tensorflow_docs/Cirq/docs/tutorials/educators/intro.ipynb\"><img src=\"https://quantumai.google/site-assets/images/buttons/download_icon_1x.png\" />Download notebook</a>\n",
61    "  </td>\n",
62    "</table>"
63   ]
64  },
65  {
66   "cell_type": "markdown",
67   "metadata": {
68    "id": "8m9ye4AS6dE4"
69   },
70   "source": [
71    "[Cirq](https://github.com/quantumlib/cirq) is a framework for writing quantum algorithms for noisy intermediate scale quantum (NISQ) devices. Roughly speaking, NISQ devices are those with O(100) qubits that can enact O(1000) gates.  Because the resources for NISQ devices are so constrained, we believe that a framework for writing programs on these devices needs to be aware of all of the architectural properties of the device on which the algorithm is written. This is in contrast to other frameworks where there is a clean separation between the abstract model being used and the details of the device.  \n",
72    "\n",
73    "In this tutorial we will walk through the basics of writing quantum algorithms in Cirq. Our final goal will be to write a variational ansatz for use in an optimization algorithm."
74   ]
75  },
76  {
77   "cell_type": "markdown",
78   "metadata": {
79    "id": "cc948e49cecb"
80   },
81   "source": [
82    "## Installing Cirq"
83   ]
84  },
85  {
86   "cell_type": "markdown",
87   "metadata": {
88    "id": "rPgPbry6-mF3"
89   },
90   "source": [
91    "To use Cirq one first needs to install Cirq.  Installation instructions are available at [quantumai.google/cirq under \"Installing Cirq\"](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",
92    "\n",
93    "> 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. "
94   ]
95  },
96  {
97   "cell_type": "code",
98   "execution_count": 1,
99   "metadata": {
100    "id": "RlJBDvNgC00H"
101   },
102   "outputs": [],
103   "source": [
104    "try:\n",
105    "    import cirq\n",
106    "except ImportError:\n",
107    "    print(\"installing cirq...\")\n",
108    "    !pip install --quiet cirq --pre\n",
109    "    print(\"installed cirq.\")\n",
110    "    import cirq\n",
111    "\n",
112    "import matplotlib.pyplot as plt\n",
113    "import numpy as np"
114   ]
115  },
116  {
117   "cell_type": "markdown",
118   "metadata": {
119    "id": "GPjUqrK8DJTq"
120   },
121   "source": [
122    "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",
123    "Let's check that Cirq has been successfully installed by importing Cirq and printing out a diagram of Google's Bristlecone device shown below.\n",
124    "\n",
125    "![Google's Bristecone chip](https://4.bp.blogspot.com/-b9akad6ismU/WpmyaJo-cYI/AAAAAAAACa8/mCqPBJxv5oUivy6Jq42FSOQYkeRlTmkiwCLcBGAs/s1600/image1.png)"
126   ]
127  },
128  {
129   "cell_type": "code",
130   "execution_count": 2,
131   "metadata": {
132    "id": "FTrmLyq4C2gf"
133   },
134   "outputs": [
135    {
136     "name": "stdout",
137     "output_type": "stream",
138     "text": [
139      "                                             (0, 5)────(0, 6)\n",
140      "                                             │         │\n",
141      "                                             │         │\n",
142      "                                    (1, 4)───(1, 5)────(1, 6)────(1, 7)\n",
143      "                                    │        │         │         │\n",
144      "                                    │        │         │         │\n",
145      "                           (2, 3)───(2, 4)───(2, 5)────(2, 6)────(2, 7)───(2, 8)\n",
146      "                           │        │        │         │         │        │\n",
147      "                           │        │        │         │         │        │\n",
148      "                  (3, 2)───(3, 3)───(3, 4)───(3, 5)────(3, 6)────(3, 7)───(3, 8)───(3, 9)\n",
149      "                  │        │        │        │         │         │        │        │\n",
150      "                  │        │        │        │         │         │        │        │\n",
151      "         (4, 1)───(4, 2)───(4, 3)───(4, 4)───(4, 5)────(4, 6)────(4, 7)───(4, 8)───(4, 9)───(4, 10)\n",
152      "         │        │        │        │        │         │         │        │        │        │\n",
153      "         │        │        │        │        │         │         │        │        │        │\n",
154      "(5, 0)───(5, 1)───(5, 2)───(5, 3)───(5, 4)───(5, 5)────(5, 6)────(5, 7)───(5, 8)───(5, 9)───(5, 10)───(5, 11)\n",
155      "         │        │        │        │        │         │         │        │        │        │\n",
156      "         │        │        │        │        │         │         │        │        │        │\n",
157      "         (6, 1)───(6, 2)───(6, 3)───(6, 4)───(6, 5)────(6, 6)────(6, 7)───(6, 8)───(6, 9)───(6, 10)\n",
158      "                  │        │        │        │         │         │        │        │\n",
159      "                  │        │        │        │         │         │        │        │\n",
160      "                  (7, 2)───(7, 3)───(7, 4)───(7, 5)────(7, 6)────(7, 7)───(7, 8)───(7, 9)\n",
161      "                           │        │        │         │         │        │\n",
162      "                           │        │        │         │         │        │\n",
163      "                           (8, 3)───(8, 4)───(8, 5)────(8, 6)────(8, 7)───(8, 8)\n",
164      "                                    │        │         │         │\n",
165      "                                    │        │         │         │\n",
166      "                                    (9, 4)───(9, 5)────(9, 6)────(9, 7)\n",
167      "                                             │         │\n",
168      "                                             │         │\n",
169      "                                             (10, 5)───(10, 6)\n"
170     ]
171    }
172   ],
173   "source": [
174    "\"\"\"Test successful installation by printing out the Bristlecone device.\"\"\"\n",
175    "import cirq_google\n",
176    "print(cirq_google.Bristlecone)"
177   ]
178  },
179  {
180   "cell_type": "markdown",
181   "metadata": {
182    "id": "09zRgohCMiBs"
183   },
184   "source": [
185    "This cell should run successfully, and the output should in fact be the grid of qubits for the Bristlecone device. If so, the install worked!\n",
186    "\n",
187    "> Be aware that Cirq is still alpha software, meaning **breaking changes can happen at any time**. If you don't want your project to suddenly go from working to not working when we a new version is released, you should depend on a *specific version* of Cirq and periodically bump that version to the latest one. For example, you can run `pip install cirq==x.y.z` to install version `x.y.z` of Cirq."
188   ]
189  },
190  {
191   "cell_type": "markdown",
192   "metadata": {
193    "id": "3340594dd8c1"
194   },
195   "source": [
196    "## Qubits, Operations, Moments and Circuits"
197   ]
198  },
199  {
200   "cell_type": "markdown",
201   "metadata": {
202    "id": "8A7a3jcql1l5"
203   },
204   "source": [
205    "In Cirq, circuits are represented either by a `Circuit` object. Conceptually:\n",
206    "\n",
207    "- A `Circuit` is a collection of `Moment`s. \n",
208    "- A `Moment` is a collection of `Operation`s that all act during the same abstract time slice. \n",
209    "- An `Operation` is a an effect that operates on a specific subset of Qubits. \n",
210    "  - The most common type of `Operation` is a `Gate` applied to several qubits (a \"`GateOperation`\"). \n",
211    "- The `Qubit`s of a circuit are implicitly defined by the operations - you can't allocate qubits to a Circuit\n",
212    "  "
213   ]
214  },
215  {
216   "cell_type": "markdown",
217   "metadata": {
218    "id": "03b7d753ecd5"
219   },
220   "source": [
221    "<img width=\"50%\" src=\"data:image/png;base64,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\"/>"
222   ]
223  },
224  {
225   "cell_type": "markdown",
226   "metadata": {
227    "id": "ca7d9d7b3953"
228   },
229   "source": [
230    "These ideas are illustrated by the above diagram, where time goes from left to right, horizontal lines are different qubits, operations acting on qubits are the boxes (sometimes spanning multiple qubits) and a moment is a group of operations that \"happen at the same time\". "
231   ]
232  },
233  {
234   "cell_type": "markdown",
235   "metadata": {
236    "id": "9768d38c9151"
237   },
238   "source": [
239    "### Create a `Circuit`"
240   ]
241  },
242  {
243   "cell_type": "markdown",
244   "metadata": {
245    "id": "VFwmWPf7D057"
246   },
247   "source": [
248    "A typical way to create a `Circuit` is shown below."
249   ]
250  },
251  {
252   "cell_type": "code",
253   "execution_count": 3,
254   "metadata": {
255    "id": "pE88WsFeDGfs"
256   },
257   "outputs": [
258    {
259     "name": "stdout",
260     "output_type": "stream",
261     "text": [
262      "Circuit:\n",
263      "\n",
264      "a: ───H───────────\n",
265      "\n",
266      "b: ───H───@───H───\n",
267      "          │\n",
268      "c: ───────X───────\n"
269     ]
270    }
271   ],
272   "source": [
273    "\"\"\"Creating a circuit.\"\"\"\n",
274    "# Define three qubits.\n",
275    "a = cirq.NamedQubit(\"a\")\n",
276    "b = cirq.NamedQubit(\"b\")\n",
277    "c = cirq.NamedQubit(\"c\")\n",
278    "\n",
279    "# Define a list of operations.\n",
280    "ops = [cirq.H(a), cirq.H(b), cirq.CNOT(b, c), cirq.H(b)]\n",
281    "\n",
282    "# Create a circuit from the list of operations.\n",
283    "circuit = cirq.Circuit(ops)\n",
284    "print(\"Circuit:\\n\")\n",
285    "print(circuit)"
286   ]
287  },
288  {
289   "cell_type": "markdown",
290   "metadata": {
291    "id": "j0qHxsoyIrcj"
292   },
293   "source": [
294    "### Exercise: Create a Circuit\n",
295    "\n",
296    "Write a program to create the following circuit.\n",
297    "\n",
298    "```\n",
299    "          ┌──┐\n",
300    "0: ───H─────@────────\n",
301    "            │\n",
302    "1: ───H────@┼────H───\n",
303    "           ││\n",
304    "2: ────────X┼────────\n",
305    "            │\n",
306    "3: ─────────X────────\n",
307    "          └──┘\n",
308    "```\n",
309    "\n",
310    "Note that the circuit has a total of 3 different moments."
311   ]
312  },
313  {
314   "cell_type": "code",
315   "execution_count": 4,
316   "metadata": {
317    "cellView": "form",
318    "id": "6a5TEN5bKAPz"
319   },
320   "outputs": [],
321   "source": [
322    "#@title Attempt the solution here\n",
323    "\n",
324    "# Define 4 qubits.\n",
325    "\n",
326    "# Define a list of operations.\n",
327    "\n",
328    "# Create a circuit from the list of operations."
329   ]
330  },
331  {
332   "cell_type": "code",
333   "execution_count": 5,
334   "metadata": {
335    "cellView": "form",
336    "id": "Q52e1pX_JIdi"
337   },
338   "outputs": [
339    {
340     "name": "stdout",
341     "output_type": "stream",
342     "text": [
343      "Circuit:\n",
344      "\n",
345      "          ┌──┐\n",
346      "0: ───H─────@────────\n",
347      "            │\n",
348      "1: ───H────@┼────H───\n",
349      "           ││\n",
350      "2: ────────X┼────────\n",
351      "            │\n",
352      "3: ─────────X────────\n",
353      "          └──┘\n"
354     ]
355    }
356   ],
357   "source": [
358    "#@title Expand to view the solution\n",
359    "\"\"\"Creating a circuit.\"\"\"\n",
360    "# Define four line qubits. NamedQubits would also work, however this demonstrates a more succint syntax.\n",
361    "q = cirq.LineQubit.range(4)\n",
362    "\n",
363    "# Define a list of operations.\n",
364    "ops = [cirq.H(q[0]), cirq.H(q[1]), cirq.CNOT(q[1], q[2]), cirq.CNOT(q[0], q[3]), cirq.H(q[1])]\n",
365    "\n",
366    "# Create a circuit from the list of operations.\n",
367    "print(\"Circuit:\\n\")\n",
368    "print(cirq.Circuit(ops))"
369   ]
370  },
371  {
372   "cell_type": "markdown",
373   "metadata": {
374    "id": "-06jQwEdI4DJ"
375   },
376   "source": [
377    "### Unpacking the circuit\n",
378    "We can unpack this a bit and see all of the components for the circuit.\n",
379    "\n",
380    "The first thing we do is pick some qubits to use. There are many different types of qubits in Cirq, and you can define your own by inheriting from the `cirq.Qid` class. There's nothing inherently special or magical about these quantum id types such as `cirq.NamedQubit`. They simply identify what you wish to operate on, which is relevant when you are targeting a specific device. For example, if we were creating a circuit for the Bristlecone device and wanted to refer to the qubit in the left-most position, we would use `cirq.GridQubit(5, 0)`. (See the first diagram of the Bristlecone device we printed out.) For simplicity, in the previous cell we defined `cirq.NamedQubit`s which are simply qubits that can be identified by a name.\n",
381    "\n",
382    "Next, we encounter the object `cirq.H` which is a Hadamard gate with unitary\n",
383    "\n",
384    "$$\n",
385    "H = {1 \\over \\sqrt{2}} \\left[ \\begin{array}[cc]  & 1 & 1  \\\\ 1 & -1 \\end{array}\\right] .\n",
386    "$$\n",
387    "\n",
388    "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."
389   ]
390  },
391  {
392   "cell_type": "code",
393   "execution_count": 6,
394   "metadata": {
395    "id": "YKfg575v1DQB"
396   },
397   "outputs": [
398    {
399     "data": {
400      "text/plain": [
401       "array([[ 0.70710678+0.j,  0.70710678+0.j],\n",
402       "       [ 0.70710678+0.j, -0.70710678+0.j]])"
403      ]
404     },
405     "execution_count": 6,
406     "metadata": {},
407     "output_type": "execute_result"
408    }
409   ],
410   "source": [
411    "\"\"\"Get the unitary of a gate, here the Hadamard gate.\"\"\"\n",
412    "cirq.unitary(cirq.H)"
413   ]
414  },
415  {
416   "cell_type": "markdown",
417   "metadata": {
418    "id": "hJMAciW21KEg"
419   },
420   "source": [
421    "We see that this agrees with the unitary for the Hadamard gate above.\n",
422    "\n",
423    "`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",
424    "\n",
425    "The result of those expressions is a `GateOperation` object, which is a type of `Operation`.\n",
426    "\n",
427    "> **Note**: In Cirq, there is a strong distinction between `Operation`s and `Gate`s. An `Operation` is associated with specific qubits and can be put in `Circuit`s. A `Gate` has unspecified qubits, and will produce an operation when acting on qubits.\n",
428    "\n",
429    "Once you have a collection of operations, you can construct a `Circuit` by passing the operations into the constructor for a `Circuit`:\n",
430    "\n",
431    "```\n",
432    "ops = [list of operations]\n",
433    "circuit = cirq.Circuit(ops)\n",
434    "```\n",
435    "\n",
436    "The last thing we did in the example code was use the (surprisingly useful) ability to print the circuit as a text diagram.\n",
437    "\n",
438    "The diagram is visually helpful, but it doesn't really get into the internal details of how the `Circuit` is represented. As mentioned, a `Circuit` is made up of a sequence of `Moment` objects, and each `Moment` object is a list of non-overlapping `Operation`s. To see this internal structure, we can iterate over the `Moment`s in the `Circuit` and print them out."
439   ]
440  },
441  {
442   "cell_type": "code",
443   "execution_count": 7,
444   "metadata": {
445    "id": "hH-y4JiEMv25"
446   },
447   "outputs": [
448    {
449     "name": "stdout",
450     "output_type": "stream",
451     "text": [
452      "Circuit:\n",
453      "\n",
454      "a: ───H───────────\n",
455      "\n",
456      "b: ───H───@───H───\n",
457      "          │\n",
458      "c: ───────X───────\n",
459      "\n",
460      "Moments in the circuit:\n",
461      "\n",
462      "Moment 0: \n",
463      "  ╷ None\n",
464      "╶─┼──────\n",
465      "a │ H\n",
466      "  │\n",
467      "b │ H\n",
468      "  │\n",
469      "Moment 1: \n",
470      "  ╷ None\n",
471      "╶─┼──────\n",
472      "b │ @\n",
473      "  │ │\n",
474      "c │ X\n",
475      "  │\n",
476      "Moment 2: \n",
477      "  ╷ None\n",
478      "╶─┼──────\n",
479      "b │ H\n",
480      "  │\n"
481     ]
482    }
483   ],
484   "source": [
485    "\"\"\"Print out the moments in a circuit.\"\"\"\n",
486    "print(\"Circuit:\\n\")\n",
487    "print(circuit)\n",
488    "\n",
489    "# Inspecting individual moments.\n",
490    "print(\"\\nMoments in the circuit:\\n\")\n",
491    "for i, moment in enumerate(circuit):\n",
492    "    print('Moment {}: \\n{}'.format(i, moment))"
493   ]
494  },
495  {
496   "cell_type": "markdown",
497   "metadata": {
498    "id": "pm5iC7MNQY6-"
499   },
500   "source": [
501    "We see that this circuit consists of three moments. For even more on the underlying structure of a circuit, we can print the circuit's `repr`. This returns a more detailed (and usually less readable) expression."
502   ]
503  },
504  {
505   "cell_type": "code",
506   "execution_count": 8,
507   "metadata": {
508    "id": "2Y6zG_peQG1y"
509   },
510   "outputs": [
511    {
512     "name": "stdout",
513     "output_type": "stream",
514     "text": [
515      "cirq.Circuit([\n",
516      "    cirq.Moment(\n",
517      "        cirq.H(cirq.NamedQubit('a')),\n",
518      "        cirq.H(cirq.NamedQubit('b')),\n",
519      "    ),\n",
520      "    cirq.Moment(\n",
521      "        cirq.CNOT(cirq.NamedQubit('b'), cirq.NamedQubit('c')),\n",
522      "    ),\n",
523      "    cirq.Moment(\n",
524      "        cirq.H(cirq.NamedQubit('b')),\n",
525      "    ),\n",
526      "])\n"
527     ]
528    }
529   ],
530   "source": [
531    "\"\"\"Print the repr of a circuit.\"\"\"\n",
532    "print(repr(circuit))"
533   ]
534  },
535  {
536   "cell_type": "markdown",
537   "metadata": {
538    "id": "zyVbU8yfW_qi"
539   },
540   "source": [
541    "Although it is less readable, the usefulness of printing the `repr` is that it includes *all* the gory details which can be useful when debugging. The `repr` is also a valid python expression that evaluates to the circuit.\n",
542    "For example, if we notice that a circuit generated in some complicated way triggers a bug in a simulator, copy-pasting the generated circuit's `repr` into a test, and then working from there, is a simple way to decouple the reproduction of the bug from the circuit generation code."
543   ]
544  },
545  {
546   "cell_type": "markdown",
547   "metadata": {
548    "id": "0bb8611c3865"
549   },
550   "source": [
551    "### More ways to create `Circuit`s"
552   ]
553  },
554  {
555   "cell_type": "markdown",
556   "metadata": {
557    "id": "uaDb6B_jPgrb"
558   },
559   "source": [
560    "Above we created a `Circuit` by passing in a list of operations to its constructor.  In Cirq, there are many ways to construct and modify circuits, and each of these is useful in different contexts.  Here are a few examples:\n",
561    "\n",
562    "\n",
563    "1. `Circuit(...)`: This is the simplest way to make a circuit. Give this method some operations, and out pops a circuit.\n",
564    "2.  `append`:  `Circuit`s are mutable. You can start with an empty `circuit = cirq.Circuit()` and simply `circuit.append(operations)` to add on more and more operations .\n",
565    "3. `insert`:  Instead of appending, you can insert before a particular moment location (labeled by an integer index).\n",
566    "\n",
567    "One interesting, and extremely convenient, fact about `Circuit(...)`, `append`, and `insert` is that they \"auto flatten\" whatever you give them.\n",
568    "You *can* give them a list of operations, but you can also give them\n",
569    "\n",
570    "- a list *of lists* of operations,\n",
571    "- a generator function that sometimes yields tuples of operations and other times yields individual operations,\n",
572    "- or just a single operation (without a list around it).\n",
573    "\n",
574    "If it can recursively iterated into individual operations, these three methods will take it.\n",
575    "\n",
576    "> The above idea uses a concept we call an `OP_TREE` in Cirq. An `OP_TREE` is not a class, but a contract. The basic idea is that if the input can be iteratively flattened into a list of operations, then the input is an `OP_TREE`.\n",
577    "\n",
578    "The main place where auto-flattening is useful is when you are building a circuit's operations using generators. \n",
579    "\n",
580    "> Recall that, in Python, functions that have a `yield` statement are *generators*. Generators are functions that act as *iterators*. \n",
581    "\n",
582    "In this context, auto-flattening means that generators producing operations for a circuit can simply `yield` sub-generators (instead of iterating over them and yielding their items). We show an example of this below."
583   ]
584  },
585  {
586   "cell_type": "code",
587   "execution_count": 9,
588   "metadata": {
589    "id": "QFoV-eOE1tGN"
590   },
591   "outputs": [
592    {
593     "data": {
594      "text/html": [
595       "<pre style=\"overflow: auto; white-space: pre;\">a: ───@───X───@───\n",
596       "      │   │   │\n",
597       "b: ───X───@───X───</pre>"
598      ],
599      "text/plain": [
600       "a: ───@───X───@───\n",
601       "      │   │   │\n",
602       "b: ───X───@───X───"
603      ]
604     },
605     "execution_count": 9,
606     "metadata": {},
607     "output_type": "execute_result"
608    }
609   ],
610   "source": [
611    "\"\"\"Creating a circuit from generator functions.\"\"\"\n",
612    "def xor_swap(a, b):\n",
613    "    \"\"\"Swaps two qubits with three CNOTs.\"\"\"\n",
614    "    yield cirq.CNOT(a, b) # |a> |b> --> |a> |a ^ b>\n",
615    "    yield cirq.CNOT(b, a) # |a> |a ^ b> --> |a ^ a ^ b> | a ^ b> = |b>|a^b>\n",
616    "    yield cirq.CNOT(a, b) # |b> |a ^ b> --> |b>|a ^ b ^ b> = |b> |a>\n",
617    "\n",
618    "cirq.Circuit(xor_swap(a, b))"
619   ]
620  },
621  {
622   "cell_type": "markdown",
623   "metadata": {
624    "id": "Z76Kcs27EcY5"
625   },
626   "source": [
627    "### Exercise: Create a circuit to left rotate 5 qubits. \n",
628    "\n",
629    "Now that we've learnt how to build a circuit to swap the state of two qubits, use this to build a circuit which left rotates 5 qubits i.e. on applying the circuit on 5 qubits (0 - 4), the state of qubits should change as follows:\n",
630    "``` \n",
631    "0 --> 4 \n",
632    "4 --> 3\n",
633    "3 --> 2\n",
634    "2 --> 1\n",
635    "1 --> 0\n",
636    "```"
637   ]
638  },
639  {
640   "cell_type": "code",
641   "execution_count": 10,
642   "metadata": {
643    "cellView": "form",
644    "id": "LbIZIMINEzD9"
645   },
646   "outputs": [],
647   "source": [
648    "#@title Attempt the solution here"
649   ]
650  },
651  {
652   "cell_type": "code",
653   "execution_count": 11,
654   "metadata": {
655    "cellView": "form",
656    "id": "5oqmyccsE1kK"
657   },
658   "outputs": [],
659   "source": [
660    "#@title Expand to view the solution\n",
661    "def left_rotate(qubits):\n",
662    "    \"\"\"Rotates qubits to the left.\"\"\"\n",
663    "    for i in range(len(qubits) - 1):\n",
664    "        a, b = qubits[i: i + 2]\n",
665    "        yield xor_swap(a, b)\n",
666    "\n",
667    "\n",
668    "# Get five qubits on a line.\n",
669    "line = cirq.LineQubit.range(5)\n",
670    "\n",
671    "# Create a circuit which rotates the qubits to the left.\n",
672    "# uncomment the next line to compare with your circuit\n",
673    "# print(cirq.Circuit(left_rotate(line)))"
674   ]
675  },
676  {
677   "cell_type": "markdown",
678   "metadata": {
679    "id": "ae159315c56d"
680   },
681   "source": [
682    "One can see how this method of creating circuits is quite powerful. \n",
683    "\n",
684    "> Note that `cirq.SWAP` is a pre-defined gate in Cirq. We used three `cirq.CNOT`s instead of `cirq.SWAP` in the above example to demonstrate auto-flattening with generators."
685   ]
686  },
687  {
688   "cell_type": "markdown",
689   "metadata": {
690    "id": "60d8516a19b2"
691   },
692   "source": [
693    "### Insert strategies"
694   ]
695  },
696  {
697   "cell_type": "markdown",
698   "metadata": {
699    "id": "p9LUxAU41wWs"
700   },
701   "source": [
702    "You may have noticed that there is a hole in what we've explained so far. We have been passing a one-dimensional sequence of operations, but the output is a two-dimensional circuit (a list-of-lists-of-operations). There is a degree of freedom that hasn't been account for. Specifically, how does Cirq choose the moment that each operation will be placed within?\n",
703    "\n",
704    "The answer is the concept of a `cirq.InsertStrategy`. An `InsertStrategy` defines how `Operation`s are placed in a `Circuit` when requested to be inserted at a given location. Here a `location` is identified by the index of the `Moment` in the `Circuit` that operations should be placed before. \n",
705    "\n",
706    "> *Note*: In the case of `Circuit.append` this means inserting at the index `len(circuit)` which is one more than the largest moment index and so represents the end of the circuit.\n",
707    "\n",
708    "There are currently four insertion strategies in Cirq:\n",
709    "\n",
710    "1. `InsertStrategy.EARLIEST` (the default),\n",
711    "2. `InsertStrategy.NEW`,\n",
712    "3. `InsertStrategy.INLINE`,\n",
713    "4. `InsertStrategy.NEW_THEN_INLINE`.\n",
714    "\n",
715    "The strategy `InsertStrategy.EARLIEST` is defined as follows:\n",
716    "\n",
717    "> `InsertStrategy.EARLIEST`: Scans backward from the insert\n",
718    "> location until a moment with operations touching qubits affected by the\n",
719    "> operation to insert is found. The operation is added into the moment just\n",
720    "> after that location.\n",
721    "\n",
722    "For example, if we first create an `Operation` in a single moment,\n",
723    "and then use `InsertStrategy.EARLIEST` the `Operation` can slide back to this\n",
724    "first `Moment` if there is space."
725   ]
726  },
727  {
728   "cell_type": "code",
729   "execution_count": 12,
730   "metadata": {
731    "id": "wNek1WjpX4MR"
732   },
733   "outputs": [
734    {
735     "name": "stdout",
736     "output_type": "stream",
737     "text": [
738      "Circuit:\n",
739      "\n",
740      "a: ───@───H───\n",
741      "      │\n",
742      "b: ───@───H───\n",
743      "\n",
744      "c: ───H───────\n"
745     ]
746    }
747   ],
748   "source": [
749    "\"\"\"Appending operations with InsertStrategy.EARLIEST.\"\"\"\n",
750    "# Create an empty circuit.\n",
751    "circuit = cirq.Circuit()\n",
752    "\n",
753    "# Append an operation.\n",
754    "# Note: InsertStrategy.EARLIEST is used by default if not otherwise specified.\n",
755    "circuit.append([cirq.CZ(a, b)])\n",
756    "\n",
757    "# Append more operations.\n",
758    "# Note: InsertStrategy.EARLIEST is used by default if not otherwise specified.\n",
759    "circuit.append([cirq.H(a), cirq.H(b), cirq.H(c)])\n",
760    "\n",
761    "# Display the circuit.\n",
762    "print(\"Circuit:\\n\")\n",
763    "print(circuit)"
764   ]
765  },
766  {
767   "cell_type": "markdown",
768   "metadata": {
769    "id": "4d93a69cfcb8"
770   },
771   "source": [
772    "After creating the first moment with a `CZ` gate, the second\n",
773    "append uses the `InsertStrategy.EARLIEST` strategy. The\n",
774    "`H` on ``a`` and ``b`` cannot slide back, while the `H` on ``c`` can and so ends up in the first `Moment`."
775   ]
776  },
777  {
778   "cell_type": "markdown",
779   "metadata": {
780    "id": "TcHeZM6qXvbS"
781   },
782   "source": [
783    "While `InsertStrategy.EARLIEST` is the default strategy, the second most important strategy is `InsertStrategy.NEW_THEN_INLINE`, defined as follows:\n",
784    "\n",
785    "> `InsertStrategy.NEW_THEN_INLINE`: For the first operation, add it to a new \n",
786    "> `Moment` the insertion point.  Attempts to add the operation after the first \n",
787    "> operation to insert into the moment just before the desired insert location. \n",
788    "> But, if there's already an existing operation affecting any of the qubits\n",
789    "> touched by the operation to insert, a new moment is created instead and this \n",
790    "> `Moment` is the one that is subsequently used for insertions.\n",
791    "\n",
792    "To see an example of this strategy, we create a circuit with the same operations but inserting them with a different strategy."
793   ]
794  },
795  {
796   "cell_type": "code",
797   "execution_count": 13,
798   "metadata": {
799    "id": "qWVDhLxFYuRp"
800   },
801   "outputs": [
802    {
803     "name": "stdout",
804     "output_type": "stream",
805     "text": [
806      "Circuit:\n",
807      "\n",
808      "a: ───@───H───\n",
809      "      │\n",
810      "b: ───@───H───\n",
811      "\n",
812      "c: ───────H───\n"
813     ]
814    }
815   ],
816   "source": [
817    "\"\"\"Appending operations with InsertStrategy.NEW_THEN_INLINE.\"\"\"\n",
818    "# Create an empty circuit.\n",
819    "circuit = cirq.Circuit()\n",
820    "\n",
821    "# Append an operation.\n",
822    "circuit.append([cirq.CZ(a, b)], strategy=cirq.InsertStrategy.NEW_THEN_INLINE)\n",
823    "\n",
824    "# Append more operations.\n",
825    "circuit.append([cirq.H(a), cirq.H(b), cirq.H(c)], strategy=cirq.InsertStrategy.NEW_THEN_INLINE)\n",
826    "\n",
827    "# Display the circuit.\n",
828    "print(\"Circuit:\\n\")\n",
829    "print(circuit)"
830   ]
831  },
832  {
833   "cell_type": "markdown",
834   "metadata": {
835    "id": "69a53a1f5de2"
836   },
837   "source": [
838    "In contrast to the previous codeblock using `InsertStrategy.EARLIEST`, we see that the three `cirq.H` gates appended after the `cirq.CZ` gate appear in the same moment when we use `InsertStrategy.NEW_THEN_INLINE`."
839   ]
840  },
841  {
842   "cell_type": "markdown",
843   "metadata": {
844    "id": "y9conKPAPn26"
845   },
846   "source": [
847    "### Exercise: Create the given circuit using least number of appends\n",
848    "\n",
849    "Now that you've learned about `InsertStrategy`s, here is an exercise to validate your understanding.  Create, **using the least number of appends**, the following circuit:\n",
850    "\n",
851    "\n",
852    "\n",
853    "```\n",
854    "a: ───@───H───────────H───H───\n",
855    "      │\n",
856    "b: ───@───────H───@───H───────\n",
857    "                  │\n",
858    "c: ───H───────────@───────────\n",
859    "```\n",
860    "\n",
861    "Here imagine that you want exactly the moments indicated by the spacing of the circuit so that there are six moments in this circuit."
862   ]
863  },
864  {
865   "cell_type": "code",
866   "execution_count": 14,
867   "metadata": {
868    "cellView": "form",
869    "id": "-HXXD801OFGF"
870   },
871   "outputs": [],
872   "source": [
873    "#@title Attempt the solution here"
874   ]
875  },
876  {
877   "cell_type": "code",
878   "execution_count": 15,
879   "metadata": {
880    "cellView": "form",
881    "id": "jP4VkPeHcjJT"
882   },
883   "outputs": [
884    {
885     "name": "stdout",
886     "output_type": "stream",
887     "text": [
888      "Circuit:\n",
889      "\n",
890      "a: ───@───H───────────H───H───\n",
891      "      │\n",
892      "b: ───@───────H───@───H───────\n",
893      "                  │\n",
894      "c: ───H───────────@───────────\n"
895     ]
896    }
897   ],
898   "source": [
899    "#@title Expand to view the solution\n",
900    "# Define three qubits.\n",
901    "a = cirq.NamedQubit('a')\n",
902    "b = cirq.NamedQubit('b')\n",
903    "c = cirq.NamedQubit('c')\n",
904    "\n",
905    "# Get an empty circuit.\n",
906    "circuit = cirq.Circuit()\n",
907    "\n",
908    "# Append these gates using cirq.InsertStrategy.EARLIEST (the default strategy).\n",
909    "circuit.append([cirq.CZ(a, b), cirq.H(c), cirq.H(a)])\n",
910    "\n",
911    "# Append these gates using cirq.InsertStrategy.NEW_THEN_INLINE.\n",
912    "circuit.append(\n",
913    "    [cirq.H(b), cirq.CZ(b, c), cirq.H(b), cirq.H(a), cirq.H(a)],\n",
914    "    strategy=cirq.InsertStrategy.NEW_THEN_INLINE\n",
915    ")\n",
916    "\n",
917    "# Display the circuit.\n",
918    "print(\"Circuit:\\n\")\n",
919    "print(circuit)"
920   ]
921  },
922  {
923   "cell_type": "markdown",
924   "metadata": {
925    "id": "X15yPl_KQ20Z"
926   },
927   "source": [
928    "## Simulations of a Circuit\n",
929    "\n",
930    "Now that we know how to construct `Circuit`s in Cirq, let's see how to execute them on a simulator. First we create a simple circuit to simulate in the following cell."
931   ]
932  },
933  {
934   "cell_type": "code",
935   "execution_count": 16,
936   "metadata": {
937    "id": "V6tZk3qGqBoH"
938   },
939   "outputs": [
940    {
941     "name": "stdout",
942     "output_type": "stream",
943     "text": [
944      "a: ───X^0.5───@───X^0.5───M───\n",
945      "              │           │\n",
946      "b: ───X^0.5───@───X^0.5───M───\n"
947     ]
948    }
949   ],
950   "source": [
951    "\"\"\"Get a circuit to simulate.\"\"\"\n",
952    "def basic_circuit(measure=True):\n",
953    "    \"\"\"Returns a simple circuit with some one- and two-qubit gates,\n",
954    "    as well as (optionally) measurements.\n",
955    "    \"\"\"\n",
956    "    # Gates we will use in the circuit.\n",
957    "    sqrt_x = cirq.X**0.5\n",
958    "    cz = cirq.CZ\n",
959    "    \n",
960    "    # Yield the operations.\n",
961    "    yield sqrt_x(a), sqrt_x(b)\n",
962    "    yield cz(a, b)\n",
963    "    yield sqrt_x(a), sqrt_x(b)\n",
964    "    if measure:\n",
965    "        yield cirq.measure(a,b)\n",
966    "\n",
967    "# Create a circuit including measurements.\n",
968    "circuit = cirq.Circuit(basic_circuit())\n",
969    "print(circuit)"
970   ]
971  },
972  {
973   "cell_type": "markdown",
974   "metadata": {
975    "id": "WpywVOeDqi4Q"
976   },
977   "source": [
978    "The main simulator in Cirq is the `cirq.Simulator`. The general pattern of simulation is to instantiate this simulator, then pass in a circuit to either the `run` or `simulate` methods (more on this below)."
979   ]
980  },
981  {
982   "cell_type": "code",
983   "execution_count": 17,
984   "metadata": {
985    "id": "KmGuMjvGw_Ef"
986   },
987   "outputs": [
988    {
989     "name": "stdout",
990     "output_type": "stream",
991     "text": [
992      "Measurement results:\n",
993      "a,b=1, 0\n"
994     ]
995    }
996   ],
997   "source": [
998    "\"\"\"Example of simulating a circuit in Cirq.\"\"\"\n",
999    "# Get a simulator.\n",
1000    "simulator = cirq.Simulator()\n",
1001    "\n",
1002    "# Pass the circuit to the simulator.run method.\n",
1003    "result = simulator.run(circuit, repetitions=1)\n",
1004    "print(\"Measurement results:\")\n",
1005    "print(result)"
1006   ]
1007  },
1008  {
1009   "cell_type": "markdown",
1010   "metadata": {
1011    "id": "aHugx9T0z047"
1012   },
1013   "source": [
1014    "Running this multiple times should result in different measurement results, since the circuit produces a superposition over all computational basis states."
1015   ]
1016  },
1017  {
1018   "cell_type": "markdown",
1019   "metadata": {
1020    "id": "416e9c012263"
1021   },
1022   "source": [
1023    "Above we used the `run` method of the `simulator`. In Cirq, `run` methods mimic the actual hardware in that they don't give one access to unphysical objects like the wavefunction. The `repetitions` argument is how many times to sample from the circuit.\n",
1024    "\n",
1025    "\n",
1026    "\n",
1027    "If one wants to get the wavefunction, the `simulate` methods can be used as shown below."
1028   ]
1029  },
1030  {
1031   "cell_type": "code",
1032   "execution_count": 18,
1033   "metadata": {
1034    "id": "Apj7WiFZ0WFm"
1035   },
1036   "outputs": [
1037    {
1038     "name": "stdout",
1039     "output_type": "stream",
1040     "text": [
1041      "State vector:\n",
1042      "[0.5+0.j  0. +0.5j 0. +0.5j 0.5+0.j ]\n",
1043      "\n",
1044      "Dirac notation:\n",
1045      "0.5|00⟩ + 0.5j|01⟩ + 0.5j|10⟩ + 0.5|11⟩\n"
1046     ]
1047    }
1048   ],
1049   "source": [
1050    "\"\"\"Simulating a circuit with the `simulate` method.\"\"\"\n",
1051    "# Get a circuit without measurements.\n",
1052    "circuit = cirq.Circuit(basic_circuit(measure=False))\n",
1053    "\n",
1054    "# Simulate the circuit.\n",
1055    "result = simulator.simulate(circuit, qubit_order=[a, b])\n",
1056    "\n",
1057    "# Print the final state vector (wavefunction).\n",
1058    "print(\"State vector:\")\n",
1059    "print(np.around(result.final_state_vector, 3))\n",
1060    "\n",
1061    "# Print the state vector in Dirac notation.\n",
1062    "print(\"\\nDirac notation:\")\n",
1063    "print(result.dirac_notation())"
1064   ]
1065  },
1066  {
1067   "cell_type": "markdown",
1068   "metadata": {
1069    "id": "t18-sIJc0cvf"
1070   },
1071   "source": [
1072    "Notice that we passed a `qubit_order` into the `simulate` method.  This order helps define the order of the kronecker (tensor) product used in the resulting `final_state_vector`.  \n",
1073    "\n",
1074    "> *Note*: The `qubit_order` argument is optional. When it is omitted, qubits are sorted ascending according to the ordering methods defined by their Python class (for example `cirq.NamedQubit` sorts lexicographically by name).\n",
1075    "If there are multiple types of qubits in one circuit, the name of the type is used as a tie breaker.\n",
1076    "\n",
1077    "The simplest `qubit_order` value you can provide is a list of the qubits in the desired order. Any qubits from the circuit that are not in the list will be ordered using the  default `__str__` ordering, but come after qubits that are in the list. \n",
1078    "\n",
1079    "> **Note**: Be aware that all qubits in the list are included in the simulation, even if they are not operated on by the circuit.\n",
1080    "\n",
1081    "The mapping from the order of the qubits to the order of the  amplitudes in the wave function can be tricky to understand.  Basically, it is the same as the ordering used by `numpy.kron`.\n",
1082    "\n",
1083    "> If the state vector is the array \n",
1084    ">> (0.1, 0.2, 0.3, 0.4),\n",
1085    "\n",
1086    "> then this is \n",
1087    ">> 0.1|00⟩ + 0.2|01⟩ + 0.3|10⟩ + 0.4|11⟩ \n",
1088    "\n",
1089    "> in Dirac notation. If \n",
1090    ">> qubit order = [a, b]\n",
1091    "\n",
1092    "> then |00> means qubit a is in 0 and qubit b is in 0, |01> means \n",
1093    "> qubit a is 0 and qubit b is 1, etc.\n",
1094    "\n",
1095    "Another way to think about the qubit-to-amplitude ordering is as \"for loop ordering\":\n",
1096    "\n",
1097    "```\n",
1098    "for a in [0, 1]:\n",
1099    "    for b in [0, 1]:\n",
1100    "        print(a, b)\n",
1101    "```\n",
1102    "\n",
1103    "The first index (the outermost loop) is the slowest to vary."
1104   ]
1105  },
1106  {
1107   "cell_type": "markdown",
1108   "metadata": {
1109    "id": "YLpiz0aN1Jd6"
1110   },
1111   "source": [
1112    "### Repetitions and histograms\n",
1113    "\n",
1114    "As mentioned, the simulator `run` methods also take an option for repeating the circuit, namely, the `repetitions` argument. If the measurements in the circuit are terminal and all other operations are unitary, this simulator is optimized to not recompute the state vector before sampling from the circuit."
1115   ]
1116  },
1117  {
1118   "cell_type": "code",
1119   "execution_count": 19,
1120   "metadata": {
1121    "id": "QxkmBlo21lrQ"
1122   },
1123   "outputs": [
1124    {
1125     "name": "stdout",
1126     "output_type": "stream",
1127     "text": [
1128      "Counter({2: 265, 0: 250, 3: 247, 1: 238})\n"
1129     ]
1130    }
1131   ],
1132   "source": [
1133    "\"\"\"Simulate a circuit using 1000 repetitions.\"\"\"\n",
1134    "# Get a circuit with terminal measurements to simulate.\n",
1135    "circuit = cirq.Circuit(basic_circuit())\n",
1136    "\n",
1137    "# Sample from the circuit 1000 times.\n",
1138    "result = simulator.run(circuit, repetitions=1000)\n",
1139    "\n",
1140    "# Get a histogram of measurement results.\n",
1141    "print(result.histogram(key=\"a,b\"))"
1142   ]
1143  },
1144  {
1145   "cell_type": "markdown",
1146   "metadata": {
1147    "id": "bD0zX0zP2HxQ"
1148   },
1149   "source": [
1150    "Here we have also demonstrated the use of the `histogram` method on the `result` which sums over all the different results for all of the different repetitions.\n",
1151    "\n",
1152    "The `histogram` method can also be given a `fold_func` argument, in order to group measurement results under some key before counting them up.\n",
1153    "For example, we can group by whether or not the two measurement results agreed:"
1154   ]
1155  },
1156  {
1157   "cell_type": "code",
1158   "execution_count": 20,
1159   "metadata": {
1160    "id": "rPqVUsD9snYf"
1161   },
1162   "outputs": [
1163    {
1164     "name": "stdout",
1165     "output_type": "stream",
1166     "text": [
1167      "Counter({'disagree': 503, 'agree': 497})\n"
1168     ]
1169    }
1170   ],
1171   "source": [
1172    "print(result.histogram(key=\"a,b\", fold_func=lambda bits: \"agree\" if bits[0] == bits[1] else \"disagree\"))"
1173   ]
1174  },
1175  {
1176   "cell_type": "markdown",
1177   "metadata": {
1178    "id": "qFsytBIbOVD8"
1179   },
1180   "source": [
1181    "## The Deutsch-Jozsa Algorithm\n",
1182    "\n",
1183    "The very first indication that quantum computers could be more powerful than classical computers was provided by David Deutsch in his 1985 paper\n",
1184    "\n",
1185    "> 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",
1186    "\n",
1187    "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",
1188    "\n",
1189    "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",
1190    "\n",
1191    "| $x$ | $f_0$ | $f_1$ | $f_x$ | $f_{\\bar{x}}$ |\n",
1192    "| --- |  --- | --- | --- | --- |\n",
1193    "| 0 | 0 | 1 | 0 | 1\n",
1194    "| 1 | 0 | 1 | 1 | 0\n",
1195    "\n",
1196    "The first two of these are *constant* functions, $f_0$ and $f_1$.  That is they always output a constant value (independent of the input).  The other two $f_x$ and $f_\\bar{x}$ are *balanced*.  Over their inputs $0$ and $1$, they have an equal number of $0$s and $1$s in their truth table.  \n",
1197    "\n",
1198    "We can now state Deutsch's problem:\n",
1199    "\n",
1200    "> Given access to a one bit input one bit output boolean function, determine by querying the function whether the function is *balanced* or *constant*.\n",
1201    "\n",
1202    "It shouldn't take you much to convince yourself that in order to solve this problem classically you need to call the function on both possible input values.  The easiest way to see this is just to consider what happens if you query the function on one particular input and notice that, for either input, learning the value of the function does not separate the constant from balanced functions. In summary:\n",
1203    "\n",
1204    "*Classically one must query the binary function twice to distinguish the constant function from the balanced function.*"
1205   ]
1206  },
1207  {
1208   "cell_type": "markdown",
1209   "metadata": {
1210    "id": "UAec5ZBuSWYU"
1211   },
1212   "source": [
1213    "Now lets turn to the quantum approach to this problem.  There is one bit of book keeping we need to take care of.  Above we have described a classical function on bits that is not reversible.  That is, knowing the values of the output does not allow us to determine uniquely the value of the input.  In order to run this on a quantum computer, however we need to make this computation reversible.  A trick for taking a classical non-reversible function and making it \"quantum happy\" is to compute the value in an extra register and store the input.  Suppose we have an $n$ bit input $x$ and we are computing a (potentially non-reverisble) boolean function $f(x)$.  Then we can implement this via a Unitary $U_f$ that acts like on $n + 1$ qubits\n",
1214    "\n",
1215    "$$\n",
1216    "U_f |x\\rangle |y\\rangle = |x\\rangle | y \\oplus f(x)\\rangle .\n",
1217    "$$\n",
1218    "\n",
1219    "Here $\\oplus$ is addition modulo $2$ (XOR) and we have identified how $U_f$ acts by its action on all computational basis states $|x\\rangle$ ($n$ input qubits) and $|y\\rangle$ ($1$ output qubit). To see that this is reversible one can note that applying the transformation twice returns the state to its original form.\n",
1220    "\n",
1221    "Let's see how to implement these functions in Cirq.\n",
1222    "\n",
1223    "$f_0$ enacts the transform\n",
1224    "$$\n",
1225    "\\begin{eqnarray}\n",
1226    "|00\\rangle &\\rightarrow&  |00\\rangle \\\\\n",
1227    "|01\\rangle &\\rightarrow&  |01\\rangle \\\\\n",
1228    "|10\\rangle &\\rightarrow&  |10\\rangle \\\\\n",
1229    "|11\\rangle &\\rightarrow&  |11\\rangle \\\\\n",
1230    "\\end{eqnarray}\n",
1231    "$$\n",
1232    "Well this is just the identity transform, i.e. an empty circuit.\n",
1233    "\n",
1234    "$f_1$ enacts the transform\n",
1235    "$$\n",
1236    "\\begin{eqnarray}\n",
1237    "|00\\rangle &\\rightarrow&  |01\\rangle \\\\\n",
1238    "|01\\rangle &\\rightarrow&  |00\\rangle \\\\\n",
1239    "|10\\rangle &\\rightarrow&  |11\\rangle \\\\\n",
1240    "|11\\rangle &\\rightarrow&  |10\\rangle \\\\\n",
1241    "\\end{eqnarray}\n",
1242    "$$\n",
1243    "This is the `cirq.X` bit flip gate on the second qubit.\n",
1244    "\n",
1245    "$f_x$ enacts the transform\n",
1246    "$$\n",
1247    "\\begin{eqnarray}\n",
1248    "|00\\rangle &\\rightarrow&  |00\\rangle \\\\\n",
1249    "|01\\rangle &\\rightarrow&  |01\\rangle \\\\\n",
1250    "|10\\rangle &\\rightarrow&  |11\\rangle \\\\\n",
1251    "|11\\rangle &\\rightarrow&  |10\\rangle \\\\\n",
1252    "\\end{eqnarray}\n",
1253    "$$\n",
1254    "This is nothing more than a `cirq.CNOT` from the first bit to the second bit.\n",
1255    "\n",
1256    "Finally $f_\\bar{x}$ enacts the transform\n",
1257    "$$\n",
1258    "\\begin{eqnarray}\n",
1259    "|00\\rangle &\\rightarrow&  |01\\rangle \\\\\n",
1260    "|01\\rangle &\\rightarrow&  |00\\rangle \\\\\n",
1261    "|10\\rangle &\\rightarrow&  |10\\rangle \\\\\n",
1262    "|11\\rangle &\\rightarrow&  |11\\rangle \\\\\n",
1263    "\\end{eqnarray}\n",
1264    "$$\n",
1265    "which is a `cirq.CNOT` from the first bit to the second bit followed by a `cirq.X` on the second bit.\n",
1266    "\n",
1267    "We can encapulate these functions into a dictionary from a oracle name to the operations in the circuit needed to enact this function."
1268   ]
1269  },
1270  {
1271   "cell_type": "code",
1272   "execution_count": 21,
1273   "metadata": {
1274    "id": "YtWiBHonly69"
1275   },
1276   "outputs": [],
1277   "source": [
1278    "\"\"\"Store the operations to query each function in a dictionary.\"\"\"\n",
1279    "# Get qubits for the operations to act on.\n",
1280    "q0, q1 = cirq.LineQubit.range(2)\n",
1281    "\n",
1282    "# Define the dictionary of operations. The key of each dictionary entry\n",
1283    "# is the subscript of the function f in the above explanatory text.\n",
1284    "oracles = {\n",
1285    "    '0': [],\n",
1286    "    '1': [cirq.X(q1)],\n",
1287    "    'x': [cirq.CNOT(q0, q1)],\n",
1288    "    'notx': [cirq.CNOT(q0, q1), cirq.X(q1)]\n",
1289    "}    "
1290   ]
1291  },
1292  {
1293   "cell_type": "markdown",
1294   "metadata": {
1295    "id": "axCSYj3EmAEo"
1296   },
1297   "source": [
1298    "We now turn to Deutsch's algorithm.  Suppose we are given access to the reversible oracle functions we have defined above.  By a similar argument for our irreversible classical functions you can show that you cannot distinguish the balanced from the constant functions by using this oracle only once.  But now we can ask the question: what if we are allowed to query this box in superposition, i.e. what if we can use the power of quantum computing?\n",
1299    "\n",
1300    "Deutsch was able to show that you could solve this problem now, with quantum computers, using only a single query.  To see how this works we need two simple insights.\n",
1301    "\n",
1302    "Suppose that we prepare the second qubit in the superposition state $|-\\rangle=\\frac{1}{\\sqrt{2}}(|0\\rangle-|1\\rangle)$ and apply the oracle.  Then we can check that\n",
1303    "$$ \n",
1304    "U_f |x\\rangle |-\\rangle = U_f|x\\rangle \\frac{1}{\\sqrt{2}}(|0\\rangle -|1\\rangle ) = |x\\rangle \\frac{1}{\\sqrt{2}}(|f(x)\\rangle -|f(x) \\oplus 1\\rangle ) =  (-1)^{f(x)} |x\\rangle |-\\rangle .\n",
1305    "$$  \n",
1306    "This is the so called \"phase kickback trick\".  By applying $U_f$ onto a target which is in superposition, the value of the function ends up showing up in the global phase.  \n",
1307    "\n",
1308    "How can we leverage this to distinguish between the constant and balanced functions?  Note that for the constant functions the phase that is applied is the same for all inputs $|x\\rangle$, whereas for the balanced functions the phase is different for each value of $x$.  In other words, if we use the phase kickback trick then for each of the oracles we apply the following transform on the first qubit:\n",
1309    "\n",
1310    "$$\n",
1311    "\\begin{eqnarray}\n",
1312    "f_0 \\rightarrow I, &&\n",
1313    "f_1 \\rightarrow -I, &&\n",
1314    "f_x \\rightarrow Z, &&\n",
1315    "f_\\bar{x} \\rightarrow -Z &&\n",
1316    "\\end{eqnarray}\n",
1317    "$$\n",
1318    "\n",
1319    "Now we only need, on the first qubit, to distinguish between the identity gate and the $Z$ gate.  But we can do this by recalling the identity\n",
1320    "\n",
1321    "$$ \n",
1322    "H Z H = X\n",
1323    "$$\n",
1324    "\n",
1325    "where $H$ is the Hamadard gate.\n",
1326    "\n",
1327    "This means that we can turn a phase flip into a bit flip by applying Hadamards before and after the phase flip.  If we look at the constant and balanced functions we see that this means that the constant functions will be proportional to $I$ and the balanced functions will be proportional to $X$.  If we feed in $|0\\rangle$ to this register, then in the first cases we will only see $|0\\rangle$ and in the second case we will only see $|1\\rangle$.  In other words we will be able to distinguish constant from balanced using a single query of the oracle.\n",
1328    "\n",
1329    "Let's code this up."
1330   ]
1331  },
1332  {
1333   "cell_type": "code",
1334   "execution_count": 22,
1335   "metadata": {
1336    "id": "aMHzLxztj-gq"
1337   },
1338   "outputs": [
1339    {
1340     "name": "stdout",
1341     "output_type": "stream",
1342     "text": [
1343      "Circuit for f_0:\n",
1344      "0: ───H───H───M───\n",
1345      "\n",
1346      "1: ───X───H───────\n",
1347      "\n",
1348      "Circuit for f_1:\n",
1349      "0: ───H───H───M───\n",
1350      "\n",
1351      "1: ───X───H───X───\n",
1352      "\n",
1353      "Circuit for f_x:\n",
1354      "0: ───H───────@───H───M───\n",
1355      "              │\n",
1356      "1: ───X───H───X───────────\n",
1357      "\n",
1358      "Circuit for f_notx:\n",
1359      "0: ───H───────@───H───M───\n",
1360      "              │\n",
1361      "1: ───X───H───X───X───────\n",
1362      "\n"
1363     ]
1364    }
1365   ],
1366   "source": [
1367    "\"\"\"Creating the circuit used in Deutsch's algorithm.\"\"\"\n",
1368    "def deutsch_algorithm(oracle):\n",
1369    "    \"\"\"Returns the circuit for Deutsch's algorithm given an input\n",
1370    "    oracle, i.e., a sequence of operations to query a particular function.\n",
1371    "    \"\"\"\n",
1372    "    yield cirq.X(q1)\n",
1373    "    yield cirq.H(q0), cirq.H(q1)\n",
1374    "    yield oracle\n",
1375    "    yield cirq.H(q0)\n",
1376    "    yield cirq.measure(q0)\n",
1377    "\n",
1378    "for key, oracle in oracles.items():\n",
1379    "    print(f\"Circuit for f_{key}:\")\n",
1380    "    print(cirq.Circuit(deutsch_algorithm(oracle)), end=\"\\n\\n\")"
1381   ]
1382  },
1383  {
1384   "cell_type": "markdown",
1385   "metadata": {
1386    "id": "Zy-2ysxzweyv"
1387   },
1388   "source": [
1389    "Lets run these circuits a bunch of times to see that the measurement result ends up correctly distinguishing constant from balanced."
1390   ]
1391  },
1392  {
1393   "cell_type": "code",
1394   "execution_count": 23,
1395   "metadata": {
1396    "id": "ImffrBgJvLme"
1397   },
1398   "outputs": [
1399    {
1400     "name": "stdout",
1401     "output_type": "stream",
1402     "text": [
1403      "oracle: f_0    results: 0=0000000000\n",
1404      "oracle: f_1    results: 0=0000000000\n",
1405      "oracle: f_x    results: 0=1111111111\n",
1406      "oracle: f_notx results: 0=1111111111\n"
1407     ]
1408    }
1409   ],
1410   "source": [
1411    "\"\"\"Simulate each of the circuits.\"\"\"\n",
1412    "simulator = cirq.Simulator()\n",
1413    "for key, oracle in oracles.items():\n",
1414    "    result = simulator.run(cirq.Circuit(deutsch_algorithm(oracle)), \n",
1415    "                          repetitions=10)\n",
1416    "    print('oracle: f_{:<4} results: {}'.format(key, result))"
1417   ]
1418  },
1419  {
1420   "cell_type": "markdown",
1421   "metadata": {
1422    "id": "845af7bfc7d6"
1423   },
1424   "source": [
1425    "We interpret the simulation results as follows:\n",
1426    "\n",
1427    "- For the first two functions $f_0$ and $f_1$, we always measure $0$. Therefore, we know that these functions are constant.\n",
1428    "- For the second two functions $f_x$ and $f_{\\bar{x}}$, we always measure $1$. Therefore, we know that these functions are balanced."
1429   ]
1430  },
1431  {
1432   "cell_type": "markdown",
1433   "metadata": {
1434    "id": "5edb6fe11163"
1435   },
1436   "source": [
1437    "### Exercise: Two Bit Deutsch-Jozsa Algorithm"
1438   ]
1439  },
1440  {
1441   "cell_type": "markdown",
1442   "metadata": {
1443    "id": "v4ka34Kuj4K0"
1444   },
1445   "source": [
1446    "All boolean functions for one input bit are either constant or balanced.  For boolean functions from two input bits not all functions are constant or balanced.  There are two constant functions, $f(x_0, x_1) = 0$ and $f(x_0, x_1)=1$, while there are ${4 \\choose 2} = 6$ balanced functions.  The following code gives you the operations for these functions where we take two input qubits and compute the function in the third qubit."
1447   ]
1448  },
1449  {
1450   "cell_type": "code",
1451   "execution_count": 24,
1452   "metadata": {
1453    "id": "V5ZCXGCrxl4k"
1454   },
1455   "outputs": [],
1456   "source": [
1457    "\"\"\"Operations to query all possible functions on two bits.\n",
1458    "Two of these functions are constant, and six of these functions are balanced.\n",
1459    "\"\"\"\n",
1460    "# Define three qubits to use.\n",
1461    "q0, q1, q2 = cirq.LineQubit.range(3)\n",
1462    "\n",
1463    "# Define the operations to query each of the two constant functions.\n",
1464    "constant = (\n",
1465    "    [], \n",
1466    "    [cirq.X(q2)]\n",
1467    ")\n",
1468    "\n",
1469    "# Define the operations to query each of the six balanced functions.\n",
1470    "balanced = (\n",
1471    "    [cirq.CNOT(q0, q2)], \n",
1472    "    [cirq.CNOT(q1, q2)], \n",
1473    "    [cirq.CNOT(q0, q2), cirq.CNOT(q1, q2)],\n",
1474    "    [cirq.CNOT(q0, q2), cirq.X(q2)], \n",
1475    "    [cirq.CNOT(q1, q2), cirq.X(q2)], \n",
1476    "    [cirq.CNOT(q0, q2), cirq.CNOT(q1, q2), cirq.X(q2)]\n",
1477    ")"
1478   ]
1479  },
1480  {
1481   "cell_type": "markdown",
1482   "metadata": {
1483    "id": "mr9ltXSJyB79"
1484   },
1485   "source": [
1486    "An extension of Deutsch's orginal algorithm is the Deutsch-Jozsa algorithm, which can distinguish constant from balanced functions like these using a single query to the oracle.  **The goal of this exercise** is to write a quantum circuit that can distinguish these."
1487   ]
1488  },
1489  {
1490   "cell_type": "code",
1491   "execution_count": 25,
1492   "metadata": {
1493    "cellView": "form",
1494    "id": "qJP_e68e1JBs"
1495   },
1496   "outputs": [],
1497   "source": [
1498    "#@title Attempt the solution here\n",
1499    "\"\"\"Exercise: Write a quantum circuit that can distinguish \n",
1500    "constant from balanced functions on two bits.\n",
1501    "\"\"\"\n",
1502    "def your_circuit(oracle):\n",
1503    "    # Your code here!\n",
1504    "    yield oracle\n",
1505    "    # Your code here!\n",
1506    "    yield cirq.measure(q2)"
1507   ]
1508  },
1509  {
1510   "cell_type": "markdown",
1511   "metadata": {
1512    "id": "3e75a276e239"
1513   },
1514   "source": [
1515    "You can check your circuit by running the follow cell which simulates the circuit for all oracles."
1516   ]
1517  },
1518  {
1519   "cell_type": "code",
1520   "execution_count": 26,
1521   "metadata": {
1522    "id": "81da6ec6fc5a"
1523   },
1524   "outputs": [
1525    {
1526     "name": "stdout",
1527     "output_type": "stream",
1528     "text": [
1529      "\n",
1530      "Your result on constant functions:\n",
1531      "2=0000000000\n",
1532      "2=1111111111\n",
1533      "\n",
1534      "Your result on balanced functions:\n",
1535      "2=0000000000\n",
1536      "2=0000000000\n",
1537      "2=0000000000\n",
1538      "2=1111111111\n",
1539      "2=1111111111\n",
1540      "2=1111111111\n"
1541     ]
1542    }
1543   ],
1544   "source": [
1545    "\"\"\"Check your answer by running this cell.\"\"\"\n",
1546    "simulator = cirq.Simulator()\n",
1547    "    \n",
1548    "print(\"\\nYour result on constant functions:\")\n",
1549    "for oracle in constant:\n",
1550    "    result = simulator.run(cirq.Circuit(your_circuit(oracle)), repetitions=10)\n",
1551    "    print(result)\n",
1552    "    \n",
1553    "print(\"\\nYour result on balanced functions:\")\n",
1554    "for oracle in balanced:\n",
1555    "    result = simulator.run(cirq.Circuit(your_circuit(oracle)), repetitions=10)\n",
1556    "    print(result)"
1557   ]
1558  },
1559  {
1560   "cell_type": "code",
1561   "execution_count": 27,
1562   "metadata": {
1563    "cellView": "form",
1564    "id": "mUvm9rmRFb4p"
1565   },
1566   "outputs": [],
1567   "source": [
1568    "#@title Expand to view the solution\n",
1569    "def dj_circuit(oracle):\n",
1570    "    # Phase kickback trick.\n",
1571    "    yield cirq.X(q2), cirq.H(q2)\n",
1572    "    \n",
1573    "    # Get an equal superposition over input bits.\n",
1574    "    yield cirq.H(q0), cirq.H(q1)\n",
1575    "    \n",
1576    "    # Query the function.\n",
1577    "    yield oracle\n",
1578    "    \n",
1579    "    # Use interference to get result, put last qubit into |1>.\n",
1580    "    yield cirq.H(q0), cirq.H(q1), cirq.H(q2)\n",
1581    "    \n",
1582    "    # Use a final OR gate to put result in final qubit.\n",
1583    "    yield cirq.X(q0), cirq.X(q1), cirq.CCX(q0, q1, q2)\n",
1584    "    yield cirq.measure(q2)"
1585   ]
1586  },
1587  {
1588   "cell_type": "markdown",
1589   "metadata": {
1590    "id": "79348c9be8a9"
1591   },
1592   "source": [
1593    "As above, we can check the solution by running the circuit with each of the oracles."
1594   ]
1595  },
1596  {
1597   "cell_type": "code",
1598   "execution_count": 28,
1599   "metadata": {
1600    "id": "c1b1e989dab2"
1601   },
1602   "outputs": [
1603    {
1604     "name": "stdout",
1605     "output_type": "stream",
1606     "text": [
1607      "Result on constant functions:\n",
1608      "2=0000000000\n",
1609      "2=0000000000\n",
1610      "\n",
1611      "Result on balanced functions:\n",
1612      "2=1111111111\n",
1613      "2=1111111111\n",
1614      "2=1111111111\n",
1615      "2=1111111111\n",
1616      "2=1111111111\n",
1617      "2=1111111111\n"
1618     ]
1619    }
1620   ],
1621   "source": [
1622    "\"\"\"Simulate the Deutsch-Jozsa circuit and check the results.\"\"\"\n",
1623    "print(\"Result on constant functions:\")\n",
1624    "for oracle in constant:\n",
1625    "    result = simulator.run(cirq.Circuit(dj_circuit(oracle)), repetitions=10)\n",
1626    "    print(result)\n",
1627    "    \n",
1628    "print(\"\\nResult on balanced functions:\")\n",
1629    "for oracle in balanced:\n",
1630    "    result = simulator.run(cirq.Circuit(dj_circuit(oracle)), repetitions=10)\n",
1631    "    print(result)"
1632   ]
1633  },
1634  {
1635   "cell_type": "markdown",
1636   "metadata": {
1637    "id": "2d62c4a01340"
1638   },
1639   "source": [
1640    "As with the single-bit case (Deutsch's algorithm), we always measure $0$ for constant functions and always measure $1$ for balanced functions."
1641   ]
1642  },
1643  {
1644   "cell_type": "markdown",
1645   "metadata": {
1646    "id": "mmhbPIhT4YAI"
1647   },
1648   "source": [
1649    "## Gates"
1650   ]
1651  },
1652  {
1653   "cell_type": "markdown",
1654   "metadata": {
1655    "id": "F5ubTic94X79"
1656   },
1657   "source": [
1658    "Cirq comes with a plethora of common quantum gates.  Here we show a few of them."
1659   ]
1660  },
1661  {
1662   "cell_type": "code",
1663   "execution_count": 29,
1664   "metadata": {
1665    "id": "iIpoDaqK4yjV"
1666   },
1667   "outputs": [
1668    {
1669     "name": "stdout",
1670     "output_type": "stream",
1671     "text": [
1672      "0: ───X───@───H───────@───×───@───@───iSwap──────Rx(0.5π)───X^0.5───\n",
1673      "          │           │   │   │   │   │\n",
1674      "1: ───Y───@───@───T───@───×───×───@───iSwap──────Ry(0.5π)───────────\n",
1675      "              │       │       │   │\n",
1676      "2: ───Z───────X───S───@───────×───X───Rz(0.5π)──────────────────────\n"
1677     ]
1678    }
1679   ],
1680   "source": [
1681    "\"\"\"Examples of common gates defined in Cirq.\"\"\"\n",
1682    "# Get some qubits.\n",
1683    "q0, q1, q2 = cirq.LineQubit.range(3)\n",
1684    "\n",
1685    "# Get a bunch of common gates defined in Cirq.\n",
1686    "ops = [\n",
1687    "    cirq.X(q0),                     # Pauli-X.\n",
1688    "    cirq.Y(q1),                     # Pauli-Y.\n",
1689    "    cirq.Z(q2),                     # Pauli-Z.\n",
1690    "    cirq.CZ(q0,q1),                 # Controlled-Z gate.\n",
1691    "    cirq.CNOT(q1,q2),               # Controlled-X gate.\n",
1692    "    cirq.H(q0),                     # Hadamard gate.\n",
1693    "    cirq.T(q1),                     # T gate.\n",
1694    "    cirq.S(q2),                     # S gate.\n",
1695    "    cirq.CCZ(q0, q1, q2),           # Controlled CZ gate.\n",
1696    "    cirq.SWAP(q0, q1),              # Swap gate.\n",
1697    "    cirq.CSWAP(q0, q1, q2),         # Controlled swap gate.\n",
1698    "    cirq.CCX(q0, q1, q2),           # Toffoli (CCNOT) gate.\n",
1699    "    cirq.ISWAP(q0, q1),             # ISWAP gate.\n",
1700    "    cirq.Rx(rads=0.5 * np.pi)(q0),  # Rotation about X.\n",
1701    "    cirq.Ry(rads=0.5 * np.pi)(q1),  # Rotation about Y.\n",
1702    "    cirq.Rz(rads=0.5 * np.pi)(q2),  # Rotation about Z.\n",
1703    "    cirq.X(q0) ** 0.5,              # Sqrt of NOT gate.\n",
1704    "]\n",
1705    "\n",
1706    "# Display a circuit with all of these operations.\n",
1707    "print(cirq.Circuit(ops))"
1708   ]
1709  },
1710  {
1711   "cell_type": "markdown",
1712   "metadata": {
1713    "id": "FKRGtncT7R0v"
1714   },
1715   "source": [
1716    "For each of these gates, you can figure out how they act on the computational basis by calling `cirq.unitary` on the gate.  For example, to see the unitary of `CNOT`, we can do:"
1717   ]
1718  },
1719  {
1720   "cell_type": "code",
1721   "execution_count": 30,
1722   "metadata": {
1723    "id": "7SUAT5F17afR"
1724   },
1725   "outputs": [
1726    {
1727     "name": "stdout",
1728     "output_type": "stream",
1729     "text": [
1730      "[[1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
1731      " [0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n",
1732      " [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n",
1733      " [0.+0.j 0.+0.j 1.+0.j 0.+0.j]]\n"
1734     ]
1735    }
1736   ],
1737   "source": [
1738    "\"\"\"Get the unitary of CNOT.\"\"\"\n",
1739    "print(cirq.unitary(cirq.CNOT))"
1740   ]
1741  },
1742  {
1743   "cell_type": "markdown",
1744   "metadata": {
1745    "id": "flm4CcqT2DoI"
1746   },
1747   "source": [
1748    "For single qubit gates, we have named gates like `cirq.H` for the Hadmard gate as well as the single qubit rotation gates defined as follows.\n",
1749    "\n",
1750    "$$ \n",
1751    "{\\tt cirq.Rx(\\theta)}: \\exp(-i \\frac{\\theta}{2} X) = cos \\frac{\\theta}{2} I - i \\sin \\frac{\\theta}{2} X =\\left[ \\begin{array} ~\\cos \\frac{\\theta}{2} & -i \\sin \\frac{\\theta}{2} \\\\ -i \\sin \\frac{\\theta}{2} & \\cos \\frac{\\theta}{2}\\end{array} \\right] \\\\\n",
1752    "$$ \n",
1753    "$$ \n",
1754    "{\\tt cirq.Ry(\\theta)}: \\exp(-i \\frac{\\theta}{2} Y) = cos \\frac{\\theta}{2} I - i \\sin \\frac{\\theta}{2} Y =\\left[ \\begin{array} ~\\cos \\frac{\\theta}{2} &  -\\sin \\frac{\\theta}{2} \\\\  \\sin \\frac{\\theta}{2} & \\cos \\frac{\\theta}{2}\\end{array} \\right] \\\\\n",
1755    "$$ \n",
1756    "$$ \n",
1757    "{\\tt cirq.Rz(\\theta)}: \\exp(-i \\frac{\\theta}{2} Z) = cos \\frac{\\theta}{2} I - i \\sin \\frac{\\theta}{2} Z =\\left[ \\begin{array} ~e^{i \\frac{\\theta}{2}} & 0 \\\\ 0 & e^{-i \\frac{\\theta}{2}} \\end{array} \\right] \\\\\n",
1758    "$$ \n",
1759    "\n",
1760    "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",
1761    "\n",
1762    "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:"
1763   ]
1764  },
1765  {
1766   "cell_type": "code",
1767   "execution_count": 31,
1768   "metadata": {
1769    "id": "UgoNBN1H8B6h"
1770   },
1771   "outputs": [
1772    {
1773     "data": {
1774      "image/png": "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\n",
1775      "text/plain": [
1776       "<Figure size 432x288 with 1 Axes>"
1777      ]
1778     },
1779     "metadata": {},
1780     "output_type": "display_data"
1781    }
1782   ],
1783   "source": [
1784    "\"\"\"Plot the probability of measuring a qubit in the ground state.\"\"\"\n",
1785    "# Get a qubit.\n",
1786    "a = cirq.NamedQubit('a')\n",
1787    "\n",
1788    "# Get a circuit of a bunch of X rotations.\n",
1789    "num_angles = 200\n",
1790    "circuit = cirq.Circuit([cirq.Rx(rads=np.pi / 50.0)(a) for theta in range(num_angles)])\n",
1791    "\n",
1792    "# List to store probabilities of the ground state.\n",
1793    "probs = []\n",
1794    "\n",
1795    "# Step through the simulation results.\n",
1796    "for step in simulator.simulate_moment_steps(circuit):\n",
1797    "    prob = np.abs(step.state_vector()) ** 2\n",
1798    "    probs.append(prob[0])\n",
1799    "\n",
1800    "# Plot the probability of the ground state at each simulation step.\n",
1801    "plt.style.use('seaborn-whitegrid')\n",
1802    "plt.plot(probs, 'o')\n",
1803    "plt.xlabel(\"Step\")\n",
1804    "plt.ylabel(\"Probability of ground state\");"
1805   ]
1806  },
1807  {
1808   "cell_type": "markdown",
1809   "metadata": {
1810    "id": "6q0YkXSZBvzd"
1811   },
1812   "source": [
1813    "Above we have given ourselves direct access to the wave function and calculated the exact probabilities.  Suppose we wanted to sample from the wave function at each point instead.  "
1814   ]
1815  },
1816  {
1817   "cell_type": "code",
1818   "execution_count": 32,
1819   "metadata": {
1820    "id": "iynhJEvoCIro"
1821   },
1822   "outputs": [
1823    {
1824     "data": {
1825      "image/png": "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\n",
1826      "text/plain": [
1827       "<Figure size 432x288 with 1 Axes>"
1828      ]
1829     },
1830     "metadata": {},
1831     "output_type": "display_data"
1832    }
1833   ],
1834   "source": [
1835    "\"\"\"Plot the probability of measuring a qubit in the ground state by sampling.\"\"\"\n",
1836    "# Number of times to sample.\n",
1837    "repetitions = 100\n",
1838    "\n",
1839    "# List to store the probability of the ground state.\n",
1840    "sampled_probs = []\n",
1841    "\n",
1842    "for i, step in enumerate(simulator.simulate_moment_steps(circuit)):\n",
1843    "    samples = step.sample([a], repetitions=repetitions)\n",
1844    "    prob = np.sum(samples, axis=0)[0] / repetitions\n",
1845    "    sampled_probs.append(prob)\n",
1846    "    \n",
1847    "\n",
1848    "# Plot the probability of the ground state at each simulation step.\n",
1849    "plt.style.use('seaborn-whitegrid')\n",
1850    "plt.plot(sampled_probs, 'o')\n",
1851    "plt.xlabel(\"Step\")\n",
1852    "plt.ylabel(\"Probability of ground state\");"
1853   ]
1854  },
1855  {
1856   "cell_type": "markdown",
1857   "metadata": {
1858    "id": "2483adccd339"
1859   },
1860   "source": [
1861    "## Custom gates"
1862   ]
1863  },
1864  {
1865   "cell_type": "markdown",
1866   "metadata": {
1867    "id": "RACz4Z5GDMAf"
1868   },
1869   "source": [
1870    "Suppose there is a gate that you want Cirq to support, but it is not implemented in Cirq.  How do you go about defining your new gate?  \n",
1871    "\n",
1872    "Cirq aims to be Pythonic.  One way in which it does this is that it relies on Python's **protocol** pattern.  Protocols are similar to interfaces, in that they define a collection of methods that an object must support to implement a protocol, but different in that this requirement is more informal and not a part of a class or interface declaration.  An object supports a protocol if it implements the methods that the protocol defines.  You're probably familiar with this if you've ever done something like defined your own `Container` in Python.  To do this for an object you simply define the `__contains__`, `__setitem__`, and `__getitem__` methods on your object, and then you can use this object anywere the Container protocol is supported.  \n",
1873    "\n",
1874    "Let's see how this works for defining a custom gate.  The gate we will define is a single qubit gate that has only rational amplitudes. This is based on the famous 3, 4, 5 triangle you may remember from a long ago math class: $3^2 + 4^2 = 5^2$.  Using this observation we can construct normalized vectors and a unitary transform using the ratios of $3$, $4$, and $5$: \n",
1875    "$$\n",
1876    "\\zeta =\\left[ \\begin{array}\n",
1877    "~\\frac{3}{5} & \\frac{4}{5} \\\\\n",
1878    "-\\frac{4}{5} & \\frac{3}{5}\n",
1879    "\\end{array} \\right]\n",
1880    "$$\n",
1881    "\n",
1882    "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."
1883   ]
1884  },
1885  {
1886   "cell_type": "code",
1887   "execution_count": 33,
1888   "metadata": {
1889    "id": "Y2a7t2qmLDTb"
1890   },
1891   "outputs": [],
1892   "source": [
1893    "\"\"\"Example of defining a custom gate in Cirq.\"\"\"\n",
1894    "class RationalGate(cirq.SingleQubitGate):\n",
1895    "    \n",
1896    "    def _unitary_(self):\n",
1897    "        return np.array([[3 / 5, 4 / 5], [-4 / 5, 3 / 5]])\n",
1898    "    \n",
1899    "    def __str__(self):\n",
1900    "        return 'ζ'"
1901   ]
1902  },
1903  {
1904   "cell_type": "markdown",
1905   "metadata": {
1906    "id": "6d262b57bb0c"
1907   },
1908   "source": [
1909    "We can now use this custom gate just like any other gate in Cirq."
1910   ]
1911  },
1912  {
1913   "cell_type": "code",
1914   "execution_count": 34,
1915   "metadata": {
1916    "id": "28f06d1baf9b"
1917   },
1918   "outputs": [
1919    {
1920     "name": "stdout",
1921     "output_type": "stream",
1922     "text": [
1923      "a: ───ζ───\n"
1924     ]
1925    }
1926   ],
1927   "source": [
1928    "\"\"\"Using the custom gate in a circuit.\"\"\"\n",
1929    "a = cirq.NamedQubit('a')\n",
1930    "rg = RationalGate()\n",
1931    "print(cirq.Circuit(rg(a)))"
1932   ]
1933  },
1934  {
1935   "cell_type": "markdown",
1936   "metadata": {
1937    "id": "3132dcbe8413"
1938   },
1939   "source": [
1940    "We can also get its unitary, as shown below, because the `RationalGate` defines a `_unitary_` method."
1941   ]
1942  },
1943  {
1944   "cell_type": "code",
1945   "execution_count": 35,
1946   "metadata": {
1947    "id": "x9dHKNfgMoyz"
1948   },
1949   "outputs": [
1950    {
1951     "name": "stdout",
1952     "output_type": "stream",
1953     "text": [
1954      "[[ 0.6  0.8]\n",
1955      " [-0.8  0.6]]\n"
1956     ]
1957    }
1958   ],
1959   "source": [
1960    "print(cirq.unitary(rg))"
1961   ]
1962  },
1963  {
1964   "cell_type": "markdown",
1965   "metadata": {
1966    "id": "xmF-uscmPP_G"
1967   },
1968   "source": [
1969    "Let's check that we can use this gate in a simulation."
1970   ]
1971  },
1972  {
1973   "cell_type": "code",
1974   "execution_count": 36,
1975   "metadata": {
1976    "id": "_RXBrSQ8PWnu"
1977   },
1978   "outputs": [
1979    {
1980     "name": "stdout",
1981     "output_type": "stream",
1982     "text": [
1983      "[ 0.6+0.j -0.8+0.j]\n"
1984     ]
1985    }
1986   ],
1987   "source": [
1988    "\"\"\"Simulate a circuit with a custom gate.\"\"\"\n",
1989    "circuit = cirq.Circuit(rg(a))\n",
1990    "simulator = cirq.Simulator()\n",
1991    "result = simulator.simulate(circuit)\n",
1992    "print(result.final_state_vector)"
1993   ]
1994  },
1995  {
1996   "cell_type": "markdown",
1997   "metadata": {
1998    "id": "9da706cd9038"
1999   },
2000   "source": [
2001    "> *Note on simulating circuits with custom gates.* The `_unitary_` method is extremely inefficient for gates over many qubits. In most cases the method `_apply_unitary_` will be used instead, if it is available.\n",
2002    "This method allows much more fine grained control on how a unitary is applied to a state, but it is harder to implement, for example because it is expected to use the pre-allocated workspace buffer that was given to it.\n",
2003    "Almost all of the basic gates we have defined in Cirq have this method implemented. If you need to get performant, custom multi-qubit gates, you should implement a custom `_apply_unitary_` method for such gates."
2004   ]
2005  },
2006  {
2007   "cell_type": "markdown",
2008   "metadata": {
2009    "id": "y63aDja8R4rc"
2010   },
2011   "source": [
2012    "### Exercise: Custom Controlled Rx gate\n",
2013    "\n",
2014    "Recall that the `cirq.Rx` gate is a rotation about the $X$ Pauli axis:\n",
2015    "$$ \n",
2016    "{\\tt cirq.Rx(θ)}: \\exp(-i \\frac{\\theta}{2} X) = cos \\frac{\\theta}{2} I - i \\sin \\frac{\\theta}{2} X =\\left[ \\begin{array} ~\\cos \\frac{\\theta}{2} & -i \\sin \\frac{\\theta}{2} \\\\ -i \\sin \\frac{\\theta}{2} & \\cos \\frac{\\theta}{2}\\end{array} \\right] . \\\\\n",
2017    "$$ \n",
2018    "\n",
2019    "As an exercise, create a two-qubit controlled `cirq.Rx` gate defined as follows:\n",
2020    "$$\n",
2021    "{\\tt CRx(\\theta)}:\n",
2022    "\\left[\\begin{array}\n",
2023    "~1 & 0 & 0 & 0 \\\\\n",
2024    "0 & 1 & 0 & 0  \\\\\n",
2025    "0 & 0 & \\cos \\frac{\\theta}{2} & -i \\sin \\frac{\\theta}{2} \\\\\n",
2026    "0 & 0 & -i \\sin \\frac{\\theta}{2} & \\cos \\frac{\\theta}{2}\n",
2027    "\\end{array} \\right] .\n",
2028    "$$"
2029   ]
2030  },
2031  {
2032   "cell_type": "code",
2033   "execution_count": 37,
2034   "metadata": {
2035    "cellView": "form",
2036    "id": "9htgTzqAYHsA"
2037   },
2038   "outputs": [
2039    {
2040     "name": "stdout",
2041     "output_type": "stream",
2042     "text": [
2043      "[]\n"
2044     ]
2045    }
2046   ],
2047   "source": [
2048    "#@title Attempt the solution here\n",
2049    "\"\"\"Define a custom controlled cirq.rx gate here.\"\"\"\n",
2050    "class CRx(cirq.TwoQubitGate):\n",
2051    "    def __init__(self, theta):\n",
2052    "        self.theta = theta\n",
2053    "\n",
2054    "    def _unitary_(self):\n",
2055    "        return np.array([\n",
2056    "            # Your code here!\n",
2057    "        ])\n",
2058    "\n",
2059    "\n",
2060    "# Print out its unitary.\n",
2061    "print(np.around(cirq.unitary(CRx(0.5 * np.pi)), 3))     "
2062   ]
2063  },
2064  {
2065   "cell_type": "code",
2066   "execution_count": 38,
2067   "metadata": {
2068    "cellView": "form",
2069    "id": "XaG8n5bdGgf2"
2070   },
2071   "outputs": [
2072    {
2073     "name": "stdout",
2074     "output_type": "stream",
2075     "text": [
2076      "[[1.   +0.j    0.   +0.j    0.   +0.j    0.   +0.j   ]\n",
2077      " [0.   +0.j    1.   +0.j    0.   +0.j    0.   +0.j   ]\n",
2078      " [0.   +0.j    0.   +0.j    0.707+0.j    0.   -0.707j]\n",
2079      " [0.   +0.j    0.   +0.j    0.   -0.707j 0.707+0.j   ]]\n"
2080     ]
2081    }
2082   ],
2083   "source": [
2084    "#@title Expand to view the solution\n",
2085    "\"\"\"Defining a custom controlled cirq.Rx gate.\"\"\"\n",
2086    "class CRx(cirq.TwoQubitGate):\n",
2087    "    def __init__(self, theta):\n",
2088    "        self.theta = theta\n",
2089    "\n",
2090    "    def _unitary_(self):\n",
2091    "        return np.array([\n",
2092    "            [1, 0, 0, 0],\n",
2093    "            [0, 1, 0, 0],\n",
2094    "            [0, 0, np.cos(self.theta/2), -1j * np.sin(self.theta/2)],\n",
2095    "            [0, 0, -1j * np.sin(self.theta/2), np.cos(self.theta/2)]\n",
2096    "        ])\n",
2097    "    \n",
2098    "    def _circuit_diagram_info_(self, args):\n",
2099    "        return '@', 'Rx({}π)'.format(self.theta / np.pi)\n",
2100    "\n",
2101    "\n",
2102    "# Print out its unitary.\n",
2103    "print(np.around(cirq.unitary(CRx(0.5 * np.pi)), 3))    "
2104   ]
2105  },
2106  {
2107   "cell_type": "markdown",
2108   "metadata": {
2109    "id": "af7add86ab34"
2110   },
2111   "source": [
2112    "Note that we also define the `_circuit_diagram_info_` method which tells Cirq how to display the gate in a circuit diagram. The first string in the tuple is the symbol for the top wire, and the second string in the tuple is the symbol for the bottom wire. We can use this in a circuit to see the diagram info as shown below."
2113   ]
2114  },
2115  {
2116   "cell_type": "code",
2117   "execution_count": 39,
2118   "metadata": {
2119    "id": "a1cd089df7ba"
2120   },
2121   "outputs": [
2122    {
2123     "name": "stdout",
2124     "output_type": "stream",
2125     "text": [
2126      "Circuit diagram:\n",
2127      "a: ───@───────────\n",
2128      "      │\n",
2129      "b: ───Rx(0.25π)───\n"
2130     ]
2131    }
2132   ],
2133   "source": [
2134    "\"\"\"Display a circuit with the custom gate.\"\"\"\n",
2135    "# Get qubits.\n",
2136    "a = cirq.NamedQubit('a')\n",
2137    "b = cirq.NamedQubit('b')\n",
2138    "\n",
2139    "# Display the circuit.\n",
2140    "print('Circuit diagram:')\n",
2141    "print(cirq.Circuit(CRx(0.25 * np.pi)(a, b)))"
2142   ]
2143  },
2144  {
2145   "cell_type": "markdown",
2146   "metadata": {
2147    "id": "9W_Vlgpzz0D1"
2148   },
2149   "source": [
2150    "### Gate decompositions"
2151   ]
2152  },
2153  {
2154   "cell_type": "markdown",
2155   "metadata": {
2156    "id": "Uun4giev4N8F"
2157   },
2158   "source": [
2159    "In many contexts, the notion of what gate you can apply is defined either by the physical hardware you are running or perhaps by the quantum error correcting code you are working with.  In quantum computing we typically talk about **gate sets** and work with respect to a given gate set.  Cirq supports gate decomposition via the `decompose` protocol.  Below we show how one can construct a gate that can be decomposed into two gates."
2160   ]
2161  },
2162  {
2163   "cell_type": "code",
2164   "execution_count": 40,
2165   "metadata": {
2166    "id": "9G-9_29h09Mx"
2167   },
2168   "outputs": [],
2169   "source": [
2170    "\"\"\"Example of a custom gate which supports the decompose protocol.\"\"\"\n",
2171    "class HXGate(cirq.SingleQubitGate):\n",
2172    "    \n",
2173    "    def _decompose_(self, qubits):\n",
2174    "        return cirq.H(*qubits), cirq.X(*qubits)\n",
2175    "    \n",
2176    "    def __str__(self):\n",
2177    "        return 'HX'"
2178   ]
2179  },
2180  {
2181   "cell_type": "markdown",
2182   "metadata": {
2183    "id": "1a88ad617867"
2184   },
2185   "source": [
2186    "We can use this gate in a circuit as follows."
2187   ]
2188  },
2189  {
2190   "cell_type": "code",
2191   "execution_count": 41,
2192   "metadata": {
2193    "id": "370e8528c762"
2194   },
2195   "outputs": [
2196    {
2197     "name": "stdout",
2198     "output_type": "stream",
2199     "text": [
2200      "a: ───HX───\n"
2201     ]
2202    }
2203   ],
2204   "source": [
2205    "\"\"\"Use the gate in a circuit.\"\"\"\n",
2206    "HX = HXGate()\n",
2207    "\n",
2208    "a = cirq.NamedQubit('a')\n",
2209    "circuit = cirq.Circuit(HX(a))\n",
2210    "print(circuit)"
2211   ]
2212  },
2213  {
2214   "cell_type": "markdown",
2215   "metadata": {
2216    "id": "eb4e74261590"
2217   },
2218   "source": [
2219    "The symbol `HX` is a single gate, not a product of two gates. We can decompose the `HXGate` using `cirq.decompose` as shown below."
2220   ]
2221  },
2222  {
2223   "cell_type": "code",
2224   "execution_count": 42,
2225   "metadata": {
2226    "id": "47ec94cdecf3"
2227   },
2228   "outputs": [
2229    {
2230     "name": "stdout",
2231     "output_type": "stream",
2232     "text": [
2233      "a: ───Y^0.5───X───X───\n"
2234     ]
2235    }
2236   ],
2237   "source": [
2238    "\"\"\"Decompose the gate.\"\"\"\n",
2239    "print(cirq.Circuit(cirq.decompose(circuit)))"
2240   ]
2241  },
2242  {
2243   "cell_type": "markdown",
2244   "metadata": {
2245    "id": "RLF1narS66iB"
2246   },
2247   "source": [
2248    "Note that this not only decomposed the `HX` gate into `H` and `X`, it also decomposed `H` into `Y**0.5` and `X`.  In order to decompose only once, one can use `cirq.decompose_once`:"
2249   ]
2250  },
2251  {
2252   "cell_type": "code",
2253   "execution_count": 43,
2254   "metadata": {
2255    "id": "AS-YMmAv6zUg"
2256   },
2257   "outputs": [
2258    {
2259     "name": "stdout",
2260     "output_type": "stream",
2261     "text": [
2262      "a: ───H───X───\n"
2263     ]
2264    }
2265   ],
2266   "source": [
2267    "\"\"\"Decompose the gate once.\"\"\"\n",
2268    "print(cirq.Circuit(cirq.decompose_once(HX(a))))"
2269   ]
2270  },
2271  {
2272   "cell_type": "markdown",
2273   "metadata": {
2274    "id": "sQ5N0UR26G_v"
2275   },
2276   "source": [
2277    "When we define a gate, it is good practice to give a default decomposition in terms of common gates.  However, often you will want to change this decomposition at run time for the specific hardware or context you are working in.  To do this we can define an interceptor function which does this decomposition before falling back to the default."
2278   ]
2279  },
2280  {
2281   "cell_type": "code",
2282   "execution_count": 44,
2283   "metadata": {
2284    "id": "0sJ1uY6X7l3t"
2285   },
2286   "outputs": [
2287    {
2288     "data": {
2289      "text/html": [
2290       "<pre style=\"overflow: auto; white-space: pre;\">a: ───Z───Y^0.5───X───</pre>"
2291      ],
2292      "text/plain": [
2293       "a: ───Z───Y^0.5───X───"
2294      ]
2295     },
2296     "execution_count": 44,
2297     "metadata": {},
2298     "output_type": "execute_result"
2299    }
2300   ],
2301   "source": [
2302    "\"\"\"Define a custom decomposer.\"\"\"\n",
2303    "def my_decompose(op):\n",
2304    "    if isinstance(op, cirq.GateOperation) and isinstance(op.gate, HXGate):\n",
2305    "        return cirq.Z(*op.qubits), cirq.H(*op.qubits)\n",
2306    "\n",
2307    "# Decompose the circuit according to this custom decomposer.\n",
2308    "cirq.Circuit(cirq.decompose(HX(a), intercepting_decomposer=my_decompose))"
2309   ]
2310  },
2311  {
2312   "cell_type": "markdown",
2313   "metadata": {
2314    "id": "OChSQ05Z06mL"
2315   },
2316   "source": [
2317    "You can also define a predicate that says which gates to keep without decomposing further. This predicate should return `True` for all gates that should not be decomposed further, and `False` for all gates that should be decomposed further.\n",
2318    "\n",
2319    "> The default predicate is to only keep gates that cannot be decomposed."
2320   ]
2321  },
2322  {
2323   "cell_type": "code",
2324   "execution_count": 45,
2325   "metadata": {
2326    "id": "KQ2in0ol05S9"
2327   },
2328   "outputs": [
2329    {
2330     "name": "stdout",
2331     "output_type": "stream",
2332     "text": [
2333      "[cirq.H(cirq.NamedQubit('a')), cirq.X(cirq.NamedQubit('a'))]\n"
2334     ]
2335    }
2336   ],
2337   "source": [
2338    "\"\"\"Define a predicate of which gates to keep without decomposing.\"\"\"\n",
2339    "def keep_h_and_x(op):\n",
2340    "    return isinstance(op, cirq.GateOperation) and op.gate in [cirq.H, cirq.X]\n",
2341    "\n",
2342    "\n",
2343    "# Decompose the HXGate using a custom predicate for which gates to not decompose.\n",
2344    "print(cirq.decompose(HX(a), keep=keep_h_and_x))"
2345   ]
2346  },
2347  {
2348   "cell_type": "markdown",
2349   "metadata": {
2350    "id": "e7486a8ea9d1"
2351   },
2352   "source": [
2353    "In this case, we see that neither `H` nor `X` have been decomposed, as we have specified in `keep_h_and_x`."
2354   ]
2355  },
2356  {
2357   "cell_type": "markdown",
2358   "metadata": {
2359    "id": "3HtlMxa6QpVo"
2360   },
2361   "source": [
2362    "## Parameterized Circuits\n",
2363    "\n",
2364    "In addition to circuit gates with fixed values, Cirq also supports parameterized gates with symbolic values via `sympy`. These are placeholder values, such as `sympy.Symbol('x')`, that will only be resolved at *run-time*. For simulators these values are resolved by providing a `ParamResolver`.  A `ParamResolver` provides a map from the `Symbol`'s name to its assigned value.  \n",
2365    "\n",
2366    "> Plain Python dictionaries can also be used whenever a `ParamResolver` is needed."
2367   ]
2368  },
2369  {
2370   "cell_type": "code",
2371   "execution_count": 46,
2372   "metadata": {
2373    "id": "0afe36a32636"
2374   },
2375   "outputs": [
2376    {
2377     "name": "stdout",
2378     "output_type": "stream",
2379     "text": [
2380      "Circuit with parameterized gates:\n",
2381      "\n",
2382      "a: ───X^s───\n",
2383      "\n",
2384      "b: ───X^s───\n"
2385     ]
2386    }
2387   ],
2388   "source": [
2389    "\"\"\"Define a circuit with parameterized gates.\"\"\"\n",
2390    "# Import sympy for parameterized values.\n",
2391    "import sympy as sp\n",
2392    "\n",
2393    "# Get qubits to use in the circuit.\n",
2394    "a = cirq.NamedQubit(\"a\")\n",
2395    "b = cirq.NamedQubit(\"b\")\n",
2396    "\n",
2397    "# Define a parameterized value.\n",
2398    "val = sp.Symbol(\"s\")\n",
2399    "\n",
2400    "# Create a circuit.\n",
2401    "circuit = cirq.Circuit(cirq.X.on(a) ** val, cirq.X.on(b) ** val)\n",
2402    "\n",
2403    "# Display it.\n",
2404    "print(\"Circuit with parameterized gates:\\n\")\n",
2405    "print(circuit)"
2406   ]
2407  },
2408  {
2409   "cell_type": "markdown",
2410   "metadata": {
2411    "id": "c67ac3447a5f"
2412   },
2413   "source": [
2414    "When we simulate this circuit, we must provide a `param_resolver` as mentioned."
2415   ]
2416  },
2417  {
2418   "cell_type": "code",
2419   "execution_count": 47,
2420   "metadata": {
2421    "id": "TIaVRzCD4deU"
2422   },
2423   "outputs": [
2424    {
2425     "name": "stdout",
2426     "output_type": "stream",
2427     "text": [
2428      "s=0: [1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
2429      "\n",
2430      "s=1: [ 0.6 +0.6j   0.25-0.25j  0.25-0.25j -0.1 -0.1j ]\n",
2431      "\n",
2432      "s=2: [0. +0.5j 0.5+0.j  0.5+0.j  0. -0.5j]\n",
2433      "\n",
2434      "s=3: [-0.1 +0.1j   0.25+0.25j  0.25+0.25j  0.6 -0.6j ]\n",
2435      "\n",
2436      "s=4: [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n",
2437      "\n"
2438     ]
2439    }
2440   ],
2441   "source": [
2442    "\"\"\"Simulate the circuit at multiple parameter values.\"\"\"\n",
2443    "simulator = cirq.Simulator()\n",
2444    "\n",
2445    "# Simulate the circuit for several values of the parameter.\n",
2446    "num_params = 5\n",
2447    "for y in range(num_params):\n",
2448    "    result = simulator.simulate(circuit, param_resolver={\"s\": y / 4.0})\n",
2449    "    print(\"s={}: {}\\n\".format(y, np.around(result.final_state_vector, 2)))"
2450   ]
2451  },
2452  {
2453   "cell_type": "markdown",
2454   "metadata": {
2455    "id": "1_2i73Oo4aM1"
2456   },
2457   "source": [
2458    "Here we see that the `Symbol` is used in two gates, and then the resolver provides this value at run time.\n",
2459    "\n",
2460    "Parameterized values are most useful in defining what we call a `cirq.Sweep`.  A `cirq.Sweep` is a collection of parameter resolvers. Our `cirq.Simulator` and `cirq.Sampler` (for real devices) interfaces support parameter sweeps. The `run_sweep` method allows the user to a parameterized circuit with each of the configurations. Within each run, the user might specify the number of repetitions as well which determines the sample size for each run.  Running parameter sweeps returns a list of `cirq.Result`s, one per set of fixed parameter values and repetitions. Example:\n"
2461   ]
2462  },
2463  {
2464   "cell_type": "code",
2465   "execution_count": 48,
2466   "metadata": {
2467    "id": "Gj_Y3Lrh49o9"
2468   },
2469   "outputs": [
2470    {
2471     "name": "stdout",
2472     "output_type": "stream",
2473     "text": [
2474      "params: OrderedDict([('s', 0.0)])\n",
2475      "a=0000000000\n",
2476      "b=0000000000\n",
2477      "\n",
2478      "params: OrderedDict([('s', 0.125)])\n",
2479      "a=0000000000\n",
2480      "b=1000000000\n",
2481      "\n",
2482      "params: OrderedDict([('s', 0.25)])\n",
2483      "a=0000000000\n",
2484      "b=1000101001\n",
2485      "\n",
2486      "params: OrderedDict([('s', 0.375)])\n",
2487      "a=0000000100\n",
2488      "b=0000000101\n",
2489      "\n",
2490      "params: OrderedDict([('s', 0.5)])\n",
2491      "a=1010111000\n",
2492      "b=1011010110\n",
2493      "\n"
2494     ]
2495    }
2496   ],
2497   "source": [
2498    "\"\"\"Simulate the circuit at multiple parameter values.\"\"\"\n",
2499    "# Get a list of param resolvers.\n",
2500    "num_params = 5\n",
2501    "resolvers = [cirq.ParamResolver({'s': y / 8.0}) for y in range(num_params)]\n",
2502    "\n",
2503    "# Add measurements to the circuit.\n",
2504    "circuit.append([cirq.measure(a), cirq.measure(b)])\n",
2505    "\n",
2506    "# Simulate the circuit using run_sweep.\n",
2507    "results = simulator.run_sweep(\n",
2508    "    program=circuit,\n",
2509    "    params=resolvers,\n",
2510    "    repetitions=10\n",
2511    ")\n",
2512    "\n",
2513    "for i, result in enumerate(results):\n",
2514    "    print('params: {}\\n{}\\n'.format(result.params.param_dict, result))"
2515   ]
2516  },
2517  {
2518   "cell_type": "markdown",
2519   "metadata": {
2520    "id": "d31ac13186d3"
2521   },
2522   "source": [
2523    "A very similar method to `run_sweep` is the `sample` method. This returns a pandas `DataFrame`, where each column is a parameter/measurement key and each row is a repetition.\n"
2524   ]
2525  },
2526  {
2527   "cell_type": "code",
2528   "execution_count": 49,
2529   "metadata": {
2530    "id": "074f9fd5cdcd"
2531   },
2532   "outputs": [
2533    {
2534     "data": {
2535      "text/html": [
2536       "<div>\n",
2537       "<style scoped>\n",
2538       "    .dataframe tbody tr th:only-of-type {\n",
2539       "        vertical-align: middle;\n",
2540       "    }\n",
2541       "\n",
2542       "    .dataframe tbody tr th {\n",
2543       "        vertical-align: top;\n",
2544       "    }\n",
2545       "\n",
2546       "    .dataframe thead th {\n",
2547       "        text-align: right;\n",
2548       "    }\n",
2549       "</style>\n",
2550       "<table border=\"1\" class=\"dataframe\">\n",
2551       "  <thead>\n",
2552       "    <tr style=\"text-align: right;\">\n",
2553       "      <th></th>\n",
2554       "      <th>s</th>\n",
2555       "      <th>a</th>\n",
2556       "      <th>b</th>\n",
2557       "    </tr>\n",
2558       "  </thead>\n",
2559       "  <tbody>\n",
2560       "    <tr>\n",
2561       "      <th>count</th>\n",
2562       "      <td>50.000000</td>\n",
2563       "      <td>50.000000</td>\n",
2564       "      <td>50.000000</td>\n",
2565       "    </tr>\n",
2566       "    <tr>\n",
2567       "      <th>mean</th>\n",
2568       "      <td>0.250000</td>\n",
2569       "      <td>0.200000</td>\n",
2570       "      <td>0.260000</td>\n",
2571       "    </tr>\n",
2572       "    <tr>\n",
2573       "      <th>std</th>\n",
2574       "      <td>0.178571</td>\n",
2575       "      <td>0.404061</td>\n",
2576       "      <td>0.443087</td>\n",
2577       "    </tr>\n",
2578       "    <tr>\n",
2579       "      <th>min</th>\n",
2580       "      <td>0.000000</td>\n",
2581       "      <td>0.000000</td>\n",
2582       "      <td>0.000000</td>\n",
2583       "    </tr>\n",
2584       "    <tr>\n",
2585       "      <th>25%</th>\n",
2586       "      <td>0.125000</td>\n",
2587       "      <td>0.000000</td>\n",
2588       "      <td>0.000000</td>\n",
2589       "    </tr>\n",
2590       "    <tr>\n",
2591       "      <th>50%</th>\n",
2592       "      <td>0.250000</td>\n",
2593       "      <td>0.000000</td>\n",
2594       "      <td>0.000000</td>\n",
2595       "    </tr>\n",
2596       "    <tr>\n",
2597       "      <th>75%</th>\n",
2598       "      <td>0.375000</td>\n",
2599       "      <td>0.000000</td>\n",
2600       "      <td>0.750000</td>\n",
2601       "    </tr>\n",
2602       "    <tr>\n",
2603       "      <th>max</th>\n",
2604       "      <td>0.500000</td>\n",
2605       "      <td>1.000000</td>\n",
2606       "      <td>1.000000</td>\n",
2607       "    </tr>\n",
2608       "  </tbody>\n",
2609       "</table>\n",
2610       "</div>"
2611      ],
2612      "text/plain": [
2613       "               s          a          b\n",
2614       "count  50.000000  50.000000  50.000000\n",
2615       "mean    0.250000   0.200000   0.260000\n",
2616       "std     0.178571   0.404061   0.443087\n",
2617       "min     0.000000   0.000000   0.000000\n",
2618       "25%     0.125000   0.000000   0.000000\n",
2619       "50%     0.250000   0.000000   0.000000\n",
2620       "75%     0.375000   0.000000   0.750000\n",
2621       "max     0.500000   1.000000   1.000000"
2622      ]
2623     },
2624     "execution_count": 49,
2625     "metadata": {},
2626     "output_type": "execute_result"
2627    }
2628   ],
2629   "source": [
2630    "results = simulator.sample(\n",
2631    "    program=circuit,\n",
2632    "    params=resolvers,\n",
2633    "    repetitions=10\n",
2634    ")\n",
2635    "\n",
2636    "results.describe()"
2637   ]
2638  },
2639  {
2640   "cell_type": "markdown",
2641   "metadata": {
2642    "id": "av09E7pH44YO"
2643   },
2644   "source": [
2645    "Above we passed in a list of `ParamResolver`s to the `params` parameter of `run_sweep` and `sample`.  But one can also pass in a `Sweepable`.  There are some useful methods for generating `Sweepable`s, for example to generate an equally spaced set of `ParamResolver`s one can use `Linspace`\n"
2646   ]
2647  },
2648  {
2649   "cell_type": "code",
2650   "execution_count": 50,
2651   "metadata": {
2652    "id": "zOymGxlb72Fk"
2653   },
2654   "outputs": [
2655    {
2656     "name": "stdout",
2657     "output_type": "stream",
2658     "text": [
2659      "cirq.ParamResolver({'x': 0.0})\n",
2660      "cirq.ParamResolver({'x': 0.1})\n",
2661      "cirq.ParamResolver({'x': 0.2})\n",
2662      "cirq.ParamResolver({'x': 0.3})\n",
2663      "cirq.ParamResolver({'x': 0.4})\n",
2664      "cirq.ParamResolver({'x': 0.5})\n",
2665      "cirq.ParamResolver({'x': 0.6})\n",
2666      "cirq.ParamResolver({'x': 0.7})\n",
2667      "cirq.ParamResolver({'x': 0.8})\n",
2668      "cirq.ParamResolver({'x': 0.9})\n",
2669      "cirq.ParamResolver({'x': 1.0})\n"
2670     ]
2671    }
2672   ],
2673   "source": [
2674    "\"\"\"Alternative method of getting a sequence of param resolvers.\"\"\"\n",
2675    "linspace = cirq.Linspace(start=0, stop=1.0, length=11, key='x')\n",
2676    "for p in linspace:\n",
2677    "    print(p)"
2678   ]
2679  },
2680  {
2681   "cell_type": "markdown",
2682   "metadata": {
2683    "id": "r-CjbPwkRI_I"
2684   },
2685   "source": [
2686    "### Exercise: Rotate a qubit\n",
2687    "\n",
2688    "Let's do the equivalent of a Rabi-flop experiment.  That is, let's apply a `XPowGate` rotating about the `X` axis for a linearly spaced set of values followed by a computational basis measurement.  The end result should be a plot of the sampled fraction that were $|1\\rangle$ as a function of gates of $X^t$ for $t$ between 0 and $1$ for 100 values of $t$ and each result sampled 100 times."
2689   ]
2690  },
2691  {
2692   "cell_type": "code",
2693   "execution_count": 51,
2694   "metadata": {
2695    "cellView": "form",
2696    "id": "8yW2e3sq9JM8"
2697   },
2698   "outputs": [],
2699   "source": [
2700    "#@title Attempt the solution here\n",
2701    "import pandas\n",
2702    "q = cirq.NamedQubit(\"q\")\n",
2703    "theta = sp.Symbol(\"theta\")\n",
2704    "parameterized_circuit = cirq.Circuit(\n",
2705    "    # your code here\n",
2706    "    cirq.measure(q)\n",
2707    ")\n",
2708    "# replace None with something else\n",
2709    "param_resolvers = None\n",
2710    "repetitions = 100\n",
2711    "results = cirq.Simulator().sample(\n",
2712    "    program=parameterized_circuit,\n",
2713    "    params=param_resolvers,\n",
2714    "    repetitions=repetitions\n",
2715    ")\n",
2716    "\n",
2717    "# You can test with the following plot\n",
2718    "# pandas.crosstab(results.theta, results.q).plot()"
2719   ]
2720  },
2721  {
2722   "cell_type": "code",
2723   "execution_count": 52,
2724   "metadata": {
2725    "cellView": "form",
2726    "id": "sl1UGhThC6rn"
2727   },
2728   "outputs": [
2729    {
2730     "data": {
2731      "text/plain": [
2732       "<AxesSubplot:xlabel='theta'>"
2733      ]
2734     },
2735     "execution_count": 52,
2736     "metadata": {},
2737     "output_type": "execute_result"
2738    },
2739    {
2740     "data": {
2741      "image/png": "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\n",
2742      "text/plain": [
2743       "<Figure size 432x288 with 1 Axes>"
2744      ]
2745     },
2746     "metadata": {},
2747     "output_type": "display_data"
2748    }
2749   ],
2750   "source": [
2751    "#@title Expand to view the solution\n",
2752    "import pandas\n",
2753    "q = cirq.NamedQubit(\"q\")\n",
2754    "parameterized_circuit = cirq.Circuit([cirq.Rx(rads=sp.Symbol(\"theta\"))(q), cirq.measure(q)])\n",
2755    "param_resolvers = cirq.Linspace(start=0, stop=np.pi, length=100, key='theta')\n",
2756    "results = cirq.Simulator().sample(\n",
2757    "    program=parameterized_circuit,\n",
2758    "    params=param_resolvers,\n",
2759    "    repetitions=repetitions\n",
2760    ")\n",
2761    "pandas.crosstab(results.theta, results.q).plot()"
2762   ]
2763  },
2764  {
2765   "cell_type": "markdown",
2766   "metadata": {
2767    "id": "930ee2edd71b"
2768   },
2769   "source": [
2770    "## Noise"
2771   ]
2772  },
2773  {
2774   "cell_type": "markdown",
2775   "metadata": {
2776    "id": "FEM73JPALREa"
2777   },
2778   "source": [
2779    "In addition to circuits with unitary gates, Cirq also has support for modeling noisy quantum evolutions. This is useful when modeling what will happen when running on actual hardware.\n",
2780    "\n",
2781    "Cirq currently supports noise that fits within the context of *operator sum representations* of noise (a.k.a quantum operations, quantum dyanamical maps, superoperators, etc).  This formalism models the evolution of a density matrix via \n",
2782    "\n",
2783    "$$ \n",
2784    "\\rho \\rightarrow \\sum_k A_k \\rho A_k^\\dagger \n",
2785    "$$\n",
2786    "\n",
2787    "where the $A_k$ are *Kraus operators*.  These operators are not necessarily unitary and satisfy the property\n",
2788    "\n",
2789    "$$ \n",
2790    "\\sum_k A_k^\\dagger A_k = I . \n",
2791    "$$\n",
2792    "\n",
2793    "An example of a noise operator is the depolarizing channel on one qubit.  This takes\n",
2794    "\n",
2795    "$$\n",
2796    "\\rho \\rightarrow (1-p) \\rho + \\frac{p}{3} (X \\rho X + Y \\rho Y + Z \\rho Z) .\n",
2797    "$$\n",
2798    "\n",
2799    "In Cirq we can define such a channel and use it in a quantum circuit:"
2800   ]
2801  },
2802  {
2803   "cell_type": "code",
2804   "execution_count": 53,
2805   "metadata": {
2806    "id": "YclVFbKZ0aD4"
2807   },
2808   "outputs": [
2809    {
2810     "name": "stdout",
2811     "output_type": "stream",
2812     "text": [
2813      "a: ───D(0.2)───M───\n"
2814     ]
2815    }
2816   ],
2817   "source": [
2818    "\"\"\"Create a circuit with a depolarizing channel.\"\"\"\n",
2819    "circuit = cirq.Circuit(cirq.depolarize(0.2)(a), cirq.measure(a))\n",
2820    "print(circuit)"
2821   ]
2822  },
2823  {
2824   "cell_type": "markdown",
2825   "metadata": {
2826    "id": "CvteYd9s00t_"
2827   },
2828   "source": [
2829    "Previously we saw that gates could implement that `_unitary_` protocol, and by doing so they could be used to perform wave function simulation.  For noise the gates implement the `_kraus_` protocol.  Classes that implement this protocol return the Krauss operators on their `_kraus_` method.  Thus"
2830   ]
2831  },
2832  {
2833   "cell_type": "code",
2834   "execution_count": 54,
2835   "metadata": {
2836    "id": "0ig_NSrS12PE"
2837   },
2838   "outputs": [
2839    {
2840     "name": "stdout",
2841     "output_type": "stream",
2842     "text": [
2843      "Kraus operator 0 is:\n",
2844      "[[0.89442719 0.        ]\n",
2845      " [0.         0.89442719]]\n",
2846      "\n",
2847      "Kraus operator 1 is:\n",
2848      "[[0.        +0.j 0.25819889+0.j]\n",
2849      " [0.25819889+0.j 0.        +0.j]]\n",
2850      "\n",
2851      "Kraus operator 2 is:\n",
2852      "[[0.+0.j         0.-0.25819889j]\n",
2853      " [0.+0.25819889j 0.+0.j        ]]\n",
2854      "\n",
2855      "Kraus operator 3 is:\n",
2856      "[[ 0.25819889+0.j  0.        +0.j]\n",
2857      " [ 0.        +0.j -0.25819889+0.j]]\n",
2858      "\n"
2859     ]
2860    }
2861   ],
2862   "source": [
2863    "for i, kraus in enumerate(cirq.kraus(cirq.depolarize(0.2))):\n",
2864    "    print(f\"Kraus operator {i} is:\", kraus, sep=\"\\n\", end=\"\\n\\n\")"
2865   ]
2866  },
2867  {
2868   "cell_type": "markdown",
2869   "metadata": {
2870    "id": "4ee0055e4015"
2871   },
2872   "source": [
2873    "The Kraus operators are often more conveniently represented in a Pauli basis. We can do this in Cirq as shown below."
2874   ]
2875  },
2876  {
2877   "cell_type": "code",
2878   "execution_count": 55,
2879   "metadata": {
2880    "id": "a2e5258ae33d"
2881   },
2882   "outputs": [
2883    {
2884     "name": "stdout",
2885     "output_type": "stream",
2886     "text": [
2887      "Kraus operator 0 is:\n",
2888      "0.894*I\n",
2889      "\n",
2890      "Kraus operator 1 is:\n",
2891      "0.258*X\n",
2892      "\n",
2893      "Kraus operator 2 is:\n",
2894      "0.258*Y\n",
2895      "\n",
2896      "Kraus operator 3 is:\n",
2897      "0.258*Z\n",
2898      "\n"
2899     ]
2900    }
2901   ],
2902   "source": [
2903    "for i, kraus in enumerate(cirq.kraus(cirq.depolarize(0.2))):\n",
2904    "    pauli_ex = cirq.expand_matrix_in_orthogonal_basis(kraus, cirq.PAULI_BASIS)\n",
2905    "    print(f\"Kraus operator {i} is:\", pauli_ex, sep=\"\\n\", end=\"\\n\\n\")"
2906   ]
2907  },
2908  {
2909   "cell_type": "markdown",
2910   "metadata": {
2911    "id": "spU2l26r0tQS"
2912   },
2913   "source": [
2914    "In addition to the wavefunction simulator, Cirq also has a density matrix simulator.  Instead of keeping track of the wavefunction, this simulator keeps track of the density matrix.  It has the same `run` and `simulate` type methods.  For example we can use this to simulate depolarizing channel and return the final density matrix of the system."
2915   ]
2916  },
2917  {
2918   "cell_type": "code",
2919   "execution_count": 56,
2920   "metadata": {
2921    "id": "skLIvXYq4yvX"
2922   },
2923   "outputs": [
2924    {
2925     "name": "stdout",
2926     "output_type": "stream",
2927     "text": [
2928      "Circuit:\n",
2929      "a: ───D(0.2)───\n",
2930      "\n",
2931      "Final density matrix:\n",
2932      "[[0.8666666 +0.j 0.        +0.j]\n",
2933      " [0.        +0.j 0.13333333+0.j]]\n"
2934     ]
2935    }
2936   ],
2937   "source": [
2938    "\"\"\"Example of simulating a noisy circuit with the density matrix simulator.\"\"\"\n",
2939    "# Circuit to simulate.\n",
2940    "circuit = cirq.Circuit(cirq.depolarize(0.2)(a))\n",
2941    "print('Circuit:\\n{}\\n'.format(circuit))\n",
2942    "\n",
2943    "# Get the density matrix simulator.\n",
2944    "simulator = cirq.DensityMatrixSimulator()\n",
2945    "\n",
2946    "# Simulate the circuit and get the final density matrix.\n",
2947    "matrix = simulator.simulate(circuit).final_density_matrix\n",
2948    "print('Final density matrix:\\n{}'.format(matrix))"
2949   ]
2950  },
2951  {
2952   "cell_type": "markdown",
2953   "metadata": {
2954    "id": "Eudp7NYo51LT"
2955   },
2956   "source": [
2957    "One thing to note is that the density matrix simulator simulates measurement statistically, and not as a channel where the outcome is not known. Consider the following example."
2958   ]
2959  },
2960  {
2961   "cell_type": "code",
2962   "execution_count": 57,
2963   "metadata": {
2964    "id": "_SjPRrIX5F4O"
2965   },
2966   "outputs": [
2967    {
2968     "name": "stdout",
2969     "output_type": "stream",
2970     "text": [
2971      "True\n"
2972     ]
2973    }
2974   ],
2975   "source": [
2976    "\"\"\"Simulating a circuit with measurements using the DensityMatrixSimulator.\"\"\"\n",
2977    "# Get a circuit with measurements.\n",
2978    "circuit = cirq.Circuit(cirq.depolarize(0.5)(a), cirq.measure(a))\n",
2979    "\n",
2980    "# Simulate with the density matrix multiple times.\n",
2981    "dmat1 = simulator.simulate(circuit).final_density_matrix\n",
2982    "dmat2 = simulator.simulate(circuit).final_density_matrix\n",
2983    "\n",
2984    "print(np.allclose(dmat1, dmat2))"
2985   ]
2986  },
2987  {
2988   "cell_type": "markdown",
2989   "metadata": {
2990    "id": "286ab4baf9fd"
2991   },
2992   "source": [
2993    "Because the final density matrix is statistical due to the measurements, the output of the above cell will change when executed multiple times."
2994   ]
2995  },
2996  {
2997   "cell_type": "markdown",
2998   "metadata": {
2999    "id": "3qUM-Kpi8Iy4"
3000   },
3001   "source": [
3002    "### Monte carlo simulations\n",
3003    "\n",
3004    "Density matrix simulations are more expensive than pure state wave function simulations.  However some channels allow an interpreation of randomly applying one of a fixed set of unitaries with differing probabilites.  For example the depolarizing channel above can be interpretted as: \n",
3005    "\n",
3006    "- With probability $1-p$ apply the identity to the state, and\n",
3007    "- with probability $p$ apply one of the three Pauli matrices $X$, $Y$, or $Z$ with equal probability.\n",
3008    "\n",
3009    "Channels that can be interpretted in this form can be simulating using a wavefunction simulator: when this channel is simulated the simulation will sample a unitary with the appropriate probability.  \n",
3010    "\n",
3011    "For channels of these type, the channel can, instead of implementing the `_kraus_` protocol, implement the `_mixture_` protocol:"
3012   ]
3013  },
3014  {
3015   "cell_type": "code",
3016   "execution_count": 58,
3017   "metadata": {
3018    "id": "9Pt7o-Tq2SNz"
3019   },
3020   "outputs": [
3021    {
3022     "name": "stdout",
3023     "output_type": "stream",
3024     "text": [
3025      "prob = 0.8\n",
3026      "unitary: \n",
3027      "[[1. 0.]\n",
3028      " [0. 1.]]\n",
3029      "\n",
3030      "prob = 0.06666666666666667\n",
3031      "unitary: \n",
3032      "[[0.+0.j 1.+0.j]\n",
3033      " [1.+0.j 0.+0.j]]\n",
3034      "\n",
3035      "prob = 0.06666666666666667\n",
3036      "unitary: \n",
3037      "[[0.+0.j 0.-1.j]\n",
3038      " [0.+1.j 0.+0.j]]\n",
3039      "\n",
3040      "prob = 0.06666666666666667\n",
3041      "unitary: \n",
3042      "[[ 1.+0.j  0.+0.j]\n",
3043      " [ 0.+0.j -1.+0.j]]\n",
3044      "\n"
3045     ]
3046    }
3047   ],
3048   "source": [
3049    "\"\"\"Use the cirq.mixture protocol on the cirq.depolarize channel.\"\"\"\n",
3050    "for p, u in cirq.mixture(cirq.depolarize(0.2)):\n",
3051    "    print(\"prob = {}\\nunitary: \\n{}\\n\".format(p, u))"
3052   ]
3053  },
3054  {
3055   "cell_type": "markdown",
3056   "metadata": {
3057    "id": "z4FIsadc4Nmg"
3058   },
3059   "source": [
3060    "In fact the depolarizing channel does not implement `_kraus_`.  Instead it only implements `_mixture_` and the `cirq.channel` method notices this and derives the channel from the mixture."
3061   ]
3062  },
3063  {
3064   "cell_type": "code",
3065   "execution_count": 59,
3066   "metadata": {
3067    "id": "HvhpBD334o1v"
3068   },
3069   "outputs": [
3070    {
3071     "name": "stdout",
3072     "output_type": "stream",
3073     "text": [
3074      "does cirq.depolarize(0.2) have _kraus_? no\n",
3075      "does cirq.depolarize(0.2) have _mixture_? yes\n"
3076     ]
3077    }
3078   ],
3079   "source": [
3080    "\"\"\"Check if cirq.depolarize has _kraus_ and _mixture_ methods.\"\"\"\n",
3081    "# Get a depolarizing channel.\n",
3082    "d = cirq.depolarize(0.2)\n",
3083    "\n",
3084    "# Check if it has _kraus_ implemented.\n",
3085    "print('does cirq.depolarize(0.2) have _kraus_? {}'.format('yes' if getattr(d, '_kraus_', None) else 'no'))\n",
3086    "\n",
3087    "# Check if it has _mixture_ implemented.\n",
3088    "print('does cirq.depolarize(0.2) have _mixture_? {}'.format('yes' if getattr(d, '_mixture_', None) else 'no'))"
3089   ]
3090  },
3091  {
3092   "cell_type": "markdown",
3093   "metadata": {
3094    "id": "OMCyapOd28h2"
3095   },
3096   "source": [
3097    "When channels implement mixture then, as we said, we can use the wavefunction simulator:"
3098   ]
3099  },
3100  {
3101   "cell_type": "code",
3102   "execution_count": 60,
3103   "metadata": {
3104    "id": "vDEhGG0v-UJy"
3105   },
3106   "outputs": [
3107    {
3108     "name": "stdout",
3109     "output_type": "stream",
3110     "text": [
3111      "a=1000010001\n"
3112     ]
3113    }
3114   ],
3115   "source": [
3116    "\"\"\"Use the wavefunction simulator on a channel that implements the mixture protocol.\"\"\"\n",
3117    "circuit = cirq.Circuit(cirq.depolarize(0.5).on(a), cirq.measure(a))\n",
3118    "simulator = cirq.Simulator()\n",
3119    "result = simulator.run(circuit, repetitions=10)\n",
3120    "print(result)"
3121   ]
3122  },
3123  {
3124   "cell_type": "markdown",
3125   "metadata": {
3126    "id": "a13d48d4836f"
3127   },
3128   "source": [
3129    "Because the unitary Kraus operators are applied stochastically, executing the above cell multiple times will produce different outputs."
3130   ]
3131  },
3132  {
3133   "cell_type": "markdown",
3134   "metadata": {
3135    "id": "weWPzaPx8zly"
3136   },
3137   "source": [
3138    "### Adding noise to circuits and simulations"
3139   ]
3140  },
3141  {
3142   "cell_type": "markdown",
3143   "metadata": {
3144    "id": "X-dT_CLu0fH9"
3145   },
3146   "source": [
3147    "To add noise to circuits or during simulations, we provide the notion of a `NoiseModel`.  A `NoiseModel` may add noise operation by operation, or it may add noise moment by moment, or it may add noise across a list of moments.\n",
3148    "\n",
3149    "For example we can define a noise model that add a single qubit depolarizing for every qubit in each moment.  "
3150   ]
3151  },
3152  {
3153   "cell_type": "code",
3154   "execution_count": 61,
3155   "metadata": {
3156    "id": "PfRP7K598wNQ"
3157   },
3158   "outputs": [
3159    {
3160     "name": "stdout",
3161     "output_type": "stream",
3162     "text": [
3163      "Circuit with no noise:\n",
3164      "a: ───H───@───M───\n",
3165      "          │   │\n",
3166      "b: ───────X───M───\n",
3167      "\n",
3168      "Circuit with noise:\n",
3169      "a: ───H───D(0.2)[cirq.VirtualTag()]───@───D(0.2)[cirq.VirtualTag()]───M───D(0.2)[cirq.VirtualTag()]───\n",
3170      "                                      │                               │\n",
3171      "b: ───────D(0.2)[cirq.VirtualTag()]───X───D(0.2)[cirq.VirtualTag()]───M───D(0.2)[cirq.VirtualTag()]───\n"
3172     ]
3173    }
3174   ],
3175   "source": [
3176    "\"\"\"Adding noise to a circuit.\"\"\"\n",
3177    "# Get a noiseless circuit.\n",
3178    "noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.2))\n",
3179    "circuit = cirq.Circuit(cirq.H(a), cirq.CNOT(a, b), cirq.measure(a, b))\n",
3180    "print('Circuit with no noise:\\n{}\\n'.format(circuit))\n",
3181    "\n",
3182    "# Add noise to the circuit.\n",
3183    "system_qubits = sorted(circuit.all_qubits())\n",
3184    "noisy_circuit = cirq.Circuit()\n",
3185    "for moment in circuit:\n",
3186    "    noisy_circuit.append(noise.noisy_moment(moment, system_qubits))\n",
3187    "print('Circuit with noise:\\n{}'.format(noisy_circuit))"
3188   ]
3189  },
3190  {
3191   "cell_type": "markdown",
3192   "metadata": {
3193    "id": "e4946d8f236f"
3194   },
3195   "source": [
3196    "We can also pass a noise model into the `cirq.DensityMatrixSimulator` and execute a noisy circuit in this manner."
3197   ]
3198  },
3199  {
3200   "cell_type": "code",
3201   "execution_count": 62,
3202   "metadata": {
3203    "id": "uzxaFCGIz2aQ"
3204   },
3205   "outputs": [
3206    {
3207     "name": "stdout",
3208     "output_type": "stream",
3209     "text": [
3210      "After step 0 state was\n",
3211      "[[0.4333333 +0.j 0.        +0.j 0.31777775+0.j 0.        +0.j]\n",
3212      " [0.        +0.j 0.06666666+0.j 0.        +0.j 0.04888888+0.j]\n",
3213      " [0.31777775+0.j 0.        +0.j 0.4333333 +0.j 0.        +0.j]\n",
3214      " [0.        +0.j 0.04888888+0.j 0.        +0.j 0.06666666+0.j]]\n",
3215      "\n",
3216      "After step 1 state was\n",
3217      "[[0.34859255+0.j 0.        +0.j 0.        +0.j 0.17089382+0.j]\n",
3218      " [0.        +0.j 0.15140739+0.j 0.02629136+0.j 0.        +0.j]\n",
3219      " [0.        +0.j 0.02629136+0.j 0.15140739+0.j 0.        +0.j]\n",
3220      " [0.17089382+0.j 0.        +0.j 0.        +0.j 0.34859255+0.j]]\n",
3221      "\n",
3222      "After step 2 state was\n",
3223      "[[0.01777777+0.j 0.        +0.j 0.        +0.j 0.        +0.j]\n",
3224      " [0.        +0.j 0.11555553+0.j 0.        +0.j 0.        +0.j]\n",
3225      " [0.        +0.j 0.        +0.j 0.11555554+0.j 0.        +0.j]\n",
3226      " [0.        +0.j 0.        +0.j 0.        +0.j 0.75111103+0.j]]\n",
3227      "\n"
3228     ]
3229    }
3230   ],
3231   "source": [
3232    "\"\"\"Perform noisy simulation by defining a density matrix simulator with a noise model.\"\"\"\n",
3233    "# Define a noise model.\n",
3234    "noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.2))\n",
3235    "\n",
3236    "# Pass this noise model into the simulator.\n",
3237    "simulator = cirq.DensityMatrixSimulator(noise=noise)\n",
3238    "\n",
3239    "# Get a circuit to simulate.\n",
3240    "circuit = cirq.Circuit(cirq.H(a), cirq.CNOT(a, b), cirq.measure(a, b))\n",
3241    "\n",
3242    "# Simulate the circuit in steps.\n",
3243    "for i, step in enumerate(simulator.simulate_moment_steps(circuit)):\n",
3244    "    print('After step {} state was\\n{}\\n'.format(i, step.density_matrix()))"
3245   ]
3246  },
3247  {
3248   "cell_type": "markdown",
3249   "metadata": {
3250    "id": "6308948de99a"
3251   },
3252   "source": [
3253    "## Devices"
3254   ]
3255  },
3256  {
3257   "cell_type": "markdown",
3258   "metadata": {
3259    "id": "PvJCA3e0QsuI"
3260   },
3261   "source": [
3262    "NISQ algorithms work in a regime where every gate counts.  A key philosophy behind Cirq is that we believe the details of the hardware, the performance characteristics, as well as device constraints, will be key to getting the most out of NISQ algorithms.  Towards this end these hardware features are contained in the `Device` class.\n",
3263    "\n",
3264    "For example, here is Google's Bristleconde device which we printed out at the start of this notebook."
3265   ]
3266  },
3267  {
3268   "cell_type": "code",
3269   "execution_count": 63,
3270   "metadata": {
3271    "id": "BmzxGpDB9jJ4"
3272   },
3273   "outputs": [
3274    {
3275     "name": "stdout",
3276     "output_type": "stream",
3277     "text": [
3278      "                                             (0, 5)────(0, 6)\n",
3279      "                                             │         │\n",
3280      "                                             │         │\n",
3281      "                                    (1, 4)───(1, 5)────(1, 6)────(1, 7)\n",
3282      "                                    │        │         │         │\n",
3283      "                                    │        │         │         │\n",
3284      "                           (2, 3)───(2, 4)───(2, 5)────(2, 6)────(2, 7)───(2, 8)\n",
3285      "                           │        │        │         │         │        │\n",
3286      "                           │        │        │         │         │        │\n",
3287      "                  (3, 2)───(3, 3)───(3, 4)───(3, 5)────(3, 6)────(3, 7)───(3, 8)───(3, 9)\n",
3288      "                  │        │        │        │         │         │        │        │\n",
3289      "                  │        │        │        │         │         │        │        │\n",
3290      "         (4, 1)───(4, 2)───(4, 3)───(4, 4)───(4, 5)────(4, 6)────(4, 7)───(4, 8)───(4, 9)───(4, 10)\n",
3291      "         │        │        │        │        │         │         │        │        │        │\n",
3292      "         │        │        │        │        │         │         │        │        │        │\n",
3293      "(5, 0)───(5, 1)───(5, 2)───(5, 3)───(5, 4)───(5, 5)────(5, 6)────(5, 7)───(5, 8)───(5, 9)───(5, 10)───(5, 11)\n",
3294      "         │        │        │        │        │         │         │        │        │        │\n",
3295      "         │        │        │        │        │         │         │        │        │        │\n",
3296      "         (6, 1)───(6, 2)───(6, 3)───(6, 4)───(6, 5)────(6, 6)────(6, 7)───(6, 8)───(6, 9)───(6, 10)\n",
3297      "                  │        │        │        │         │         │        │        │\n",
3298      "                  │        │        │        │         │         │        │        │\n",
3299      "                  (7, 2)───(7, 3)───(7, 4)───(7, 5)────(7, 6)────(7, 7)───(7, 8)───(7, 9)\n",
3300      "                           │        │        │         │         │        │\n",
3301      "                           │        │        │         │         │        │\n",
3302      "                           (8, 3)───(8, 4)───(8, 5)────(8, 6)────(8, 7)───(8, 8)\n",
3303      "                                    │        │         │         │\n",
3304      "                                    │        │         │         │\n",
3305      "                                    (9, 4)───(9, 5)────(9, 6)────(9, 7)\n",
3306      "                                             │         │\n",
3307      "                                             │         │\n",
3308      "                                             (10, 5)───(10, 6)\n"
3309     ]
3310    }
3311   ],
3312   "source": [
3313    "print(cirq_google.Bristlecone)"
3314   ]
3315  },
3316  {
3317   "cell_type": "markdown",
3318   "metadata": {
3319    "id": "GGejgRf0AGni"
3320   },
3321   "source": [
3322    "In a future version, we intend for each `Device` to define a noise model.\n",
3323    "\n",
3324    "`Device`s also contain more information about the timing of the device.  For example here we can calculate the duration of an `X` on the `Bristlecone` device."
3325   ]
3326  },
3327  {
3328   "cell_type": "code",
3329   "execution_count": 64,
3330   "metadata": {
3331    "id": "HAwdWkprAPXN"
3332   },
3333   "outputs": [
3334    {
3335     "name": "stdout",
3336     "output_type": "stream",
3337     "text": [
3338      "20 ns\n"
3339     ]
3340    }
3341   ],
3342   "source": [
3343    "\"\"\"Get the duration of an operation.\"\"\"\n",
3344    "brissy = cirq_google.Bristlecone\n",
3345    "op = cirq.X.on(cirq.GridQubit(5, 5))\n",
3346    "print(brissy.duration_of(op))"
3347   ]
3348  },
3349  {
3350   "cell_type": "markdown",
3351   "metadata": {
3352    "id": "IxnyURhnAdph"
3353   },
3354   "source": [
3355    "Another property of devices is that they can be used to enforce constraints from the hardware, both checking that these constraints are satisfied, but also enforcing the constraints on the device.  For example, on the `Bristlecone` device, a two-qubit gate has the property that one cannot simultaneously perform a pair of two-qubit gates that act on adjacent qubits. So for example if we create such a `Circuit` and validate it using the device, we will see an error."
3356   ]
3357  },
3358  {
3359   "cell_type": "code",
3360   "execution_count": 65,
3361   "metadata": {
3362    "id": "r5F4FUtmA5kW"
3363   },
3364   "outputs": [
3365    {
3366     "name": "stdout",
3367     "output_type": "stream",
3368     "text": [
3369      "(5, 5): ───@───\n",
3370      "           │\n",
3371      "(5, 6): ───@───\n",
3372      "\n",
3373      "(6, 6): ───@───\n",
3374      "           │\n",
3375      "(6, 7): ───@───\n",
3376      "error, as expected: \n",
3377      "Adjacent Exp11 operations:   ╷ 5 6 7\n",
3378      "╶─┼───────\n",
3379      "5 │ @─@\n",
3380      "  │\n",
3381      "6 │   @─@\n",
3382      "  │.\n"
3383     ]
3384    }
3385   ],
3386   "source": [
3387    "\"\"\"Validate operations on a device.\"\"\"\n",
3388    "# Get adjacent qubits on the Bristlecone device.\n",
3389    "q55 = cirq.GridQubit(5, 5)\n",
3390    "q56 = cirq.GridQubit(5, 6)\n",
3391    "q66 = cirq.GridQubit(6, 6)\n",
3392    "q67 = cirq.GridQubit(6, 7)\n",
3393    "\n",
3394    "# Define operations on adjacent qubits.\n",
3395    "ops = [cirq.CZ(q55, q56), cirq.CZ(q66, q67)]\n",
3396    "circuit = cirq.Circuit(ops)\n",
3397    "print(circuit)\n",
3398    "\n",
3399    "try: \n",
3400    "  cirq_google.Bristlecone.validate_circuit(circuit)\n",
3401    "except ValueError as ex:\n",
3402    "  print(f\"error, as expected: \\n{ex}\")"
3403   ]
3404  },
3405  {
3406   "cell_type": "markdown",
3407   "metadata": {
3408    "id": "XkNPbeFDBTL4"
3409   },
3410   "source": [
3411    "But more interestingly we could have passed the device into the `Circuit` and it will perform the creation of the circuit (using the insertion semantics as described above) such that the device cannot violate the constraints."
3412   ]
3413  },
3414  {
3415   "cell_type": "code",
3416   "execution_count": 66,
3417   "metadata": {
3418    "id": "5BOBUIEIBeQ5"
3419   },
3420   "outputs": [
3421    {
3422     "name": "stdout",
3423     "output_type": "stream",
3424     "text": [
3425      "(5, 5): ───@───────\n",
3426      "           │\n",
3427      "(5, 6): ───@───────\n",
3428      "\n",
3429      "(6, 6): ───────@───\n",
3430      "               │\n",
3431      "(6, 7): ───────@───\n"
3432     ]
3433    }
3434   ],
3435   "source": [
3436    "\"\"\"Create a circuit for a particular device.\"\"\"\n",
3437    "# Same adjacent operations as above.\n",
3438    "ops = [cirq.CZ(q55, q56), cirq.CZ(q66, q67)]\n",
3439    "\n",
3440    "# Create a circuit on the Bristlecone device.\n",
3441    "circuit = cirq.Circuit(device=cirq_google.Bristlecone)\n",
3442    "\n",
3443    "\n",
3444    "# When we append operations now, they are put into different moments.\n",
3445    "circuit.append(ops)\n",
3446    "print(circuit)"
3447   ]
3448  },
3449  {
3450   "cell_type": "markdown",
3451   "metadata": {
3452    "id": "lyFcloaARXg4"
3453   },
3454   "source": [
3455    "### Exercise: Make a Device\n",
3456    "\n",
3457    "Construct a device that acts on a square sized lattice, and only allows Hadamard, CZ, and measurement gates."
3458   ]
3459  },
3460  {
3461   "cell_type": "code",
3462   "execution_count": 67,
3463   "metadata": {
3464    "cellView": "form",
3465    "id": "zDE-19I_a3on"
3466   },
3467   "outputs": [],
3468   "source": [
3469    "#@title Attempt the solution here"
3470   ]
3471  },
3472  {
3473   "cell_type": "code",
3474   "execution_count": 68,
3475   "metadata": {
3476    "cellView": "form",
3477    "id": "DuOcTG3XZfmb"
3478   },
3479   "outputs": [],
3480   "source": [
3481    "#@title Expand to view the solution\n",
3482    "class SquareDevice(cirq.Device):\n",
3483    "    \"\"\"A Square Grid Device.\n",
3484    "    \n",
3485    "    The device that only allows \n",
3486    "        1) Grid Qubits from (0, 0) to (grid_size - 1, grid_size - 1)\n",
3487    "        2) H, CZ and MeasurementGate gates.\n",
3488    "    \"\"\"\n",
3489    "    def __init__(self, grid_size):\n",
3490    "        self.qubits = []\n",
3491    "        for i in range(grid_size):\n",
3492    "            for j in range(grid_size):\n",
3493    "                self.qubits.append(cirq.GridQubit(i, j))\n",
3494    "\n",
3495    "    def validate_operation(self, operation: 'cirq.Operation') -> None:\n",
3496    "        if not isinstance(operation, cirq.GateOperation):\n",
3497    "            raise ValueError(f\"Unsupported operation {operation}\")\n",
3498    "        if not (operation.gate in [cirq.H, cirq.CZ] or isinstance(operation.gate, cirq.MeasurementGate)):\n",
3499    "            raise ValueError(f\"Unsupported gate {operation.gate}\")\n",
3500    "        for qubit in operation.qubits:\n",
3501    "            if qubit not in self.qubits:\n",
3502    "                raise ValueError(f\"Qubit {qubit} not on device\")"
3503   ]
3504  },
3505  {
3506   "cell_type": "markdown",
3507   "metadata": {
3508    "id": "ed20ea519cc9"
3509   },
3510   "source": [
3511    "## Compiling / Optimizing"
3512   ]
3513  },
3514  {
3515   "cell_type": "markdown",
3516   "metadata": {
3517    "id": "J9ia4eatUQ_x"
3518   },
3519   "source": [
3520    "Cirq's philosophy for what are often called compilation steps is slightly non-traditional.  In particular we believe that NISQ devices perform so few gates that many compiliations will be one or a few passes. A useful class of optimization code for this is the `PointOptimizer`. For example, here is a `PointOptimizer` that recognizes that a `X` gate followed by a `Z` gate is equivalent to a `Y` gate"
3521   ]
3522  },
3523  {
3524   "cell_type": "code",
3525   "execution_count": 69,
3526   "metadata": {
3527    "id": "l7eFMVe1GEe2"
3528   },
3529   "outputs": [
3530    {
3531     "name": "stdout",
3532     "output_type": "stream",
3533     "text": [
3534      "Before optimizing:\n",
3535      "a: ───X───Z───@───X───\n",
3536      "              │\n",
3537      "b: ───────────@───────\n",
3538      "\n",
3539      "After optimizing:\n",
3540      "a: ───Y───────@───X───\n",
3541      "              │\n",
3542      "b: ───────────@───────\n"
3543     ]
3544    }
3545   ],
3546   "source": [
3547    "\"\"\"Example of defining a custom cirq.PointOptimizer.\"\"\"\n",
3548    "class XZOptimizer(cirq.PointOptimizer):\n",
3549    "    \"\"\"Replaces an X followed by a Z with a Y.\"\"\"\n",
3550    "    \n",
3551    "    def optimization_at(self, circuit, index, op):\n",
3552    "        # Is the gate an X gate?\n",
3553    "        if isinstance(op, cirq.GateOperation) and (op.gate == cirq.X):\n",
3554    "            next_op_index = circuit.next_moment_operating_on(op.qubits, index + 1)\n",
3555    "            qubit = op.qubits[0]\n",
3556    "            if next_op_index is not None:\n",
3557    "                next_op = circuit.operation_at(qubit, next_op_index)\n",
3558    "                if isinstance(next_op, cirq.GateOperation) and  (next_op.gate == cirq.Z):\n",
3559    "                    new_op = cirq.Y.on(qubit)\n",
3560    "                    return cirq.PointOptimizationSummary(\n",
3561    "                        clear_span = next_op_index - index + 1,\n",
3562    "                        clear_qubits=op.qubits, \n",
3563    "                        new_operations=[new_op])\n",
3564    "        \n",
3565    "opt = XZOptimizer()\n",
3566    "circuit = cirq.Circuit(cirq.X(a), cirq.Z(a), cirq.CZ(a, b), cirq.X(a))\n",
3567    "print(\"Before optimizing:\\n{}\\n\". format(circuit))\n",
3568    "opt.optimize_circuit(circuit)\n",
3569    "print(\"After optimizing:\\n{}\".format(circuit))"
3570   ]
3571  },
3572  {
3573   "cell_type": "markdown",
3574   "metadata": {
3575    "id": "--aUfkiaUb3S"
3576   },
3577   "source": [
3578    "### Exercise: Simplify flipped CNOTs\n",
3579    "\n",
3580    "Write an PointOptimizer that performs (greedily) the simplification that\n",
3581    "\n",
3582    "```\n",
3583    "a: ───H───@───H───\n",
3584    "          │\n",
3585    "b: ───H───X───H───\n",
3586    "```\n",
3587    "is equal to\n",
3588    "\n",
3589    "\n",
3590    "```\n",
3591    "a: ───X───\n",
3592    "      │\n",
3593    "b: ───@───\n",
3594    "```\n"
3595   ]
3596  },
3597  {
3598   "cell_type": "code",
3599   "execution_count": 70,
3600   "metadata": {
3601    "cellView": "form",
3602    "id": "S0PThmctKFxl"
3603   },
3604   "outputs": [],
3605   "source": [
3606    "#@title Attempt the solution here\n",
3607    "\n",
3608    "\"\"\"Test your optimizer on this circuit.\"\"\"\n",
3609    "circuit = cirq.Circuit(\n",
3610    "    cirq.H.on_each(a, b, c), \n",
3611    "    cirq.CNOT(a, b), \n",
3612    "    cirq.H.on_each(a, b), \n",
3613    "    cirq.CZ(a, b)\n",
3614    ")\n",
3615    "# Instantiate your optimizer\n",
3616    "# my_opt = \n",
3617    "\n",
3618    "# And check that it worked.\n",
3619    "# print(my_opt.optimizer_circuit(circuit))"
3620   ]
3621  },
3622  {
3623   "cell_type": "code",
3624   "execution_count": 71,
3625   "metadata": {
3626    "cellView": "form",
3627    "id": "O8pnDlAngS80"
3628   },
3629   "outputs": [
3630    {
3631     "name": "stdout",
3632     "output_type": "stream",
3633     "text": [
3634      "Before optimizing:\n",
3635      "a: ───H───@───H───@───\n",
3636      "          │       │\n",
3637      "b: ───H───X───H───@───\n",
3638      "\n",
3639      "c: ───H───────────────\n",
3640      "\n",
3641      "After optimizing:\n",
3642      "a: ───X───────────@───\n",
3643      "      │           │\n",
3644      "b: ───@───────────@───\n",
3645      "\n",
3646      "c: ───H───────────────\n"
3647     ]
3648    }
3649   ],
3650   "source": [
3651    "#@title Expand to view the solution\n",
3652    "class CXOptimizer(cirq.PointOptimizer):\n",
3653    "    \"\"\"Replaces a CX surrounded by Hadamards\n",
3654    "\n",
3655    "        Note: This implementation does not generalize for all situations. It is\n",
3656    "        a simplified version which works for the trivial case where Hs, CX, Hs\n",
3657    "        are present in consecutive moments, as given in the sample input.\n",
3658    "    \"\"\"\n",
3659    "    \n",
3660    "    def optimization_at(self, circuit, index, op):\n",
3661    "        if isinstance(op, cirq.GateOperation) and (op.gate == cirq.H):\n",
3662    "            q0, = op.qubits\n",
3663    "            next_op = circuit.operation_at(q0, index + 1)\n",
3664    "            if isinstance(next_op, cirq.GateOperation) and next_op.gate == cirq.CX:\n",
3665    "                qubits = circuit.operation_at(q0, index + 1).qubits\n",
3666    "                if all(\n",
3667    "                    circuit.operation_at(q, idx).gate == cirq.H\n",
3668    "                    for idx in [index, index + 2]\n",
3669    "                    for q in qubits\n",
3670    "                ):\n",
3671    "                    return cirq.PointOptimizationSummary(\n",
3672    "                        clear_span = 3,\n",
3673    "                        clear_qubits = qubits,\n",
3674    "                        new_operations = [cirq.CX(qubits[1], qubits[0])]\n",
3675    "                    )\n",
3676    "        \n",
3677    "opt = CXOptimizer()\n",
3678    "circuit = cirq.Circuit(\n",
3679    "    cirq.H.on_each(a, b, c), \n",
3680    "    cirq.CNOT(a, b), \n",
3681    "    cirq.H.on_each(a, b), \n",
3682    "    cirq.CZ(a, b)\n",
3683    ")\n",
3684    "print(\"Before optimizing:\\n{}\\n\". format(circuit))\n",
3685    "opt.optimize_circuit(circuit)\n",
3686    "print(\"After optimizing:\\n{}\".format(circuit))"
3687   ]
3688  },
3689  {
3690   "cell_type": "markdown",
3691   "metadata": {
3692    "id": "82c692df49dd"
3693   },
3694   "source": [
3695    "## Google's Xmon Gates"
3696   ]
3697  },
3698  {
3699   "cell_type": "markdown",
3700   "metadata": {
3701    "id": "gM1ZW7TstvK9"
3702   },
3703   "source": [
3704    "We built Cirq at Google because we thought that it was important that hardware details flow up through the level of abstractions in a framework for NISQ algorithms.  And we also built it because Google has a class of superconducting qubit devices where we want to explore NISQ algorithms.  \n",
3705    "\n",
3706    "What sort of gates does the xmon architecture support?  At the hardware level the basic gate set is rotations about the Pauli $Z$ axis\n",
3707    "\n",
3708    "$$\n",
3709    "\\exp(-iZt) = \\left[ \n",
3710    "\\begin{matrix}\n",
3711    " e^{it} & 0 \\\\\n",
3712    " 0 & e^{-it}\n",
3713    "\\end{matrix}\n",
3714    "\\right]\n",
3715    "$$\n",
3716    "\n",
3717    "Rotations about any axis in the Pauli $X$ and $Y$ plane:\n",
3718    "\n",
3719    "$$\n",
3720    "\\exp(-i(\\cos \\theta X + \\sin \\theta Y) t) = \n",
3721    "\\left[\n",
3722    "\\begin{matrix}\n",
3723    "\\cos t & -i\\sin t e^{-i \\theta} \\\\\n",
3724    "-i\\sin t e^{i \\theta} & \\cos t\n",
3725    "\\end{matrix}\n",
3726    "\\right]\n",
3727    "$$\n",
3728    "\n",
3729    "The two qubit gate is a phase about the $|11\\rangle$ state:\n",
3730    "\n",
3731    "$$\n",
3732    "\\exp(-it |11\\rangle \\langle 11|) =\n",
3733    "\\left[ \n",
3734    "\\begin{matrix}\n",
3735    "1 & 0 & 0 & 0 \\\\\n",
3736    "0 & 1 & 0 & 0 \\\\\n",
3737    "0 & 0 & 1 & 0 \\\\\n",
3738    "0 & 0 & 0 & \\exp(-it)\n",
3739    "\\end{matrix}\n",
3740    "\\right]\n",
3741    "$$\n",
3742    "\n",
3743    "And finally measurements in the computational basis.\n",
3744    "\n",
3745    "Many of the common gates in Cirq are directly accessible on this hardware.  To check whether the gate you are using is in the xmon gate set, one can use the `is_supported_operation` as shown below."
3746   ]
3747  },
3748  {
3749   "cell_type": "code",
3750   "execution_count": 72,
3751   "metadata": {
3752    "id": "feb179abdf97"
3753   },
3754   "outputs": [
3755    {
3756     "data": {
3757      "text/plain": [
3758       "True"
3759      ]
3760     },
3761     "execution_count": 72,
3762     "metadata": {},
3763     "output_type": "execute_result"
3764    }
3765   ],
3766   "source": [
3767    "\"\"\"Check if an operation is supported by the XMON gate set.\"\"\"\n",
3768    "# Get the XMON gate set.\n",
3769    "xmon = cirq_google.XMON\n",
3770    "\n",
3771    "# Check if X is supported.\n",
3772    "xmon.is_supported_operation(cirq.X.on(cirq.NamedQubit(\"a\")))"
3773   ]
3774  },
3775  {
3776   "cell_type": "markdown",
3777   "metadata": {
3778    "id": "d6031d18fecd"
3779   },
3780   "source": [
3781    "Thus, `cirq.X` is supported by the xmon gate set. As mentioned above, `cirq.CNOT` is not supported, so the following code block should return `False`."
3782   ]
3783  },
3784  {
3785   "cell_type": "code",
3786   "execution_count": 73,
3787   "metadata": {
3788    "id": "d168c7619994"
3789   },
3790   "outputs": [
3791    {
3792     "data": {
3793      "text/plain": [
3794       "False"
3795      ]
3796     },
3797     "execution_count": 73,
3798     "metadata": {},
3799     "output_type": "execute_result"
3800    }
3801   ],
3802   "source": [
3803    "\"\"\"Check if CNOT is supported.\"\"\"\n",
3804    "xmon.is_supported_operation(cirq.CNOT.on(cirq.NamedQubit('a'), cirq.NamedQubit('b')))"
3805   ]
3806  },
3807  {
3808   "cell_type": "markdown",
3809   "metadata": {
3810    "id": "4FEVSq1T2n2J"
3811   },
3812   "source": [
3813    "When a gate is not a native xmon gate, Cirq can often convert it to an xmon native gate."
3814   ]
3815  },
3816  {
3817   "cell_type": "code",
3818   "execution_count": 74,
3819   "metadata": {
3820    "id": "AdqDGjqL2lI2"
3821   },
3822   "outputs": [
3823    {
3824     "name": "stdout",
3825     "output_type": "stream",
3826     "text": [
3827      "a: ───Z^0.75────X^0.5────S^-1───Y^-0.5───@───S^-1───Y^0.5───Y^0.5─────Z^-0.75───\n",
3828      "                                         │\n",
3829      "b: ───X^-0.25───Y^-0.5───────────────────@───S^-1───Y^0.5───X^-0.25─────────────\n"
3830     ]
3831    }
3832   ],
3833   "source": [
3834    "\"\"\"Convert a gate to xmon gates.\"\"\"\n",
3835    "# Get a converter.\n",
3836    "converter = cirq_google.ConvertToXmonGates()\n",
3837    "\n",
3838    "# Do the conversion.\n",
3839    "converted = converter.convert(cirq.CNOT.on(cirq.NamedQubit(\"a\"), cirq.NamedQubit(\"b\")))\n",
3840    "print(cirq.Circuit(converted))"
3841   ]
3842  },
3843  {
3844   "cell_type": "markdown",
3845   "metadata": {
3846    "id": "iR8zA_uY4HRZ"
3847   },
3848   "source": [
3849    "This isn't very optimized because what it has done is first rely on the decompose of `CNOT` and then decomposed each of these into native xmon gates.  There are many tricks that one can use to simplify xmon gates.  To apply many of these one can use the `cirq_google.optimize_from_xmon` method:"
3850   ]
3851  },
3852  {
3853   "cell_type": "code",
3854   "execution_count": 75,
3855   "metadata": {
3856    "id": "ePc0hrEU2_yy"
3857   },
3858   "outputs": [
3859    {
3860     "name": "stdout",
3861     "output_type": "stream",
3862     "text": [
3863      "a: ───PhXZ(a=0.375,x=1,z=0)────@───PhXZ(a=0.375,x=1,z=0)─────\n",
3864      "                               │\n",
3865      "b: ───PhXZ(a=-0.5,x=0.5,z=0)───@───PhXZ(a=-0.5,x=0.5,z=-1)───\n"
3866     ]
3867    }
3868   ],
3869   "source": [
3870    "\"\"\"Optimize a circuit for the xmon gate set.\"\"\"\n",
3871    "circuit = cirq.Circuit(\n",
3872    "    cirq.CNOT.on(cirq.NamedQubit(\"a\"), cirq.NamedQubit(\"b\"))\n",
3873    ")\n",
3874    "print(cirq_google.optimized_for_xmon(circuit))"
3875   ]
3876  },
3877  {
3878   "cell_type": "markdown",
3879   "metadata": {
3880    "id": "lImnJ5Co4Y1n"
3881   },
3882   "source": [
3883    "Because xmon gates can be executed on Google hardware, they will need to be transmitted as machine code to the quantum computer.  This means that they have a serialized form.  We use protobuffers as the serialization.  To see what this form looks like we can do the following."
3884   ]
3885  },
3886  {
3887   "cell_type": "code",
3888   "execution_count": 76,
3889   "metadata": {
3890    "id": "od6ofvow4EoD"
3891   },
3892   "outputs": [
3893    {
3894     "data": {
3895      "text/plain": [
3896       "gate {\n",
3897       "  id: \"xy\"\n",
3898       "}\n",
3899       "args {\n",
3900       "  key: \"axis_half_turns\"\n",
3901       "  value {\n",
3902       "    arg_value {\n",
3903       "      float_value: 0.0\n",
3904       "    }\n",
3905       "  }\n",
3906       "}\n",
3907       "args {\n",
3908       "  key: \"half_turns\"\n",
3909       "  value {\n",
3910       "    arg_value {\n",
3911       "      float_value: 1.0\n",
3912       "    }\n",
3913       "  }\n",
3914       "}\n",
3915       "qubits {\n",
3916       "  id: \"5_5\"\n",
3917       "}"
3918      ]
3919     },
3920     "execution_count": 76,
3921     "metadata": {},
3922     "output_type": "execute_result"
3923    }
3924   ],
3925   "source": [
3926    "\"\"\"Serialize an operation.\"\"\"\n",
3927    "xmon.serialize_op(cirq.X.on(cirq.GridQubit(5, 5)))"
3928   ]
3929  },
3930  {
3931   "cell_type": "markdown",
3932   "metadata": {
3933    "id": "b13526b78348"
3934   },
3935   "source": [
3936    "## Other interesting things in Cirq"
3937   ]
3938  },
3939  {
3940   "cell_type": "markdown",
3941   "metadata": {
3942    "id": "tMC-nLE474nH"
3943   },
3944   "source": [
3945    "**Experiments**. The `cirq.experiments` package can perform and plot the results of some basic experiments for understanding how well a system is performing.\n"
3946   ]
3947  },
3948  {
3949   "cell_type": "code",
3950   "execution_count": 77,
3951   "metadata": {
3952    "id": "Ih8YgwX19h2-"
3953   },
3954   "outputs": [
3955    {
3956     "name": "stderr",
3957     "output_type": "stream",
3958     "text": [
3959      "/Users/bacon/code/github/Cirq/cirq-core/cirq/experiments/qubit_characterizations.py:98: UserWarning: Matplotlib is currently using module://ipykernel.pylab.backend_inline, which is a non-GUI backend, so cannot show the figure.\n",
3960      "  fig.show()\n"
3961     ]
3962    },
3963    {
3964     "data": {
3965      "image/png": "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\n",
3966      "text/plain": [
3967       "<Figure size 576x576 with 1 Axes>"
3968      ]
3969     },
3970     "metadata": {},
3971     "output_type": "display_data"
3972    }
3973   ],
3974   "source": [
3975    "result = cirq.experiments.rabi_oscillations(\n",
3976    "    sampler=cirq.Simulator(),  # In case of Google QCS or other hardware providers, sampler could point at real hardware.\n",
3977    "    qubit=cirq.LineQubit(0),\n",
3978    "    num_points=200,\n",
3979    "    repetitions=1000,\n",
3980    ")\n",
3981    "result.plot();"
3982   ]
3983  },
3984  {
3985   "cell_type": "markdown",
3986   "metadata": {
3987    "id": "38c8tWcX90Zn"
3988   },
3989   "source": [
3990    "**Testing**. The `cirq.testing` package has useful debugging and testing methods like `cirq.testing.assert_implements_consistent_protocols` and `cirq.testing.assert_allclose_up_to_global_phase`.\n"
3991   ]
3992  },
3993  {
3994   "cell_type": "code",
3995   "execution_count": 78,
3996   "metadata": {
3997    "id": "j7FoZGKv90qe"
3998   },
3999   "outputs": [],
4000   "source": [
4001    "class InconsistentXGate(cirq.SingleQubitGate):\n",
4002    "\n",
4003    "    def _decompose_(self, qubits):\n",
4004    "        yield cirq.H(qubits[0])\n",
4005    "        yield cirq.Z(qubits[0])\n",
4006    "        yield cirq.H(qubits[0])\n",
4007    "\n",
4008    "    def _unitary_(self):\n",
4009    "        return np.array([[0, -1j], [1j, 0]])  # Oops! Y instead of X!\n",
4010    "\n",
4011    "# cirq.testing.assert_decompose_is_consistent_with_unitary(InconsistentXGate())"
4012   ]
4013  },
4014  {
4015   "cell_type": "markdown",
4016   "metadata": {
4017    "id": "iYqy0qwU9sZy"
4018   },
4019   "source": [
4020    "**Export**. You can export a circuit as Qasm."
4021   ]
4022  },
4023  {
4024   "cell_type": "code",
4025   "execution_count": 79,
4026   "metadata": {
4027    "id": "qH7xB-vZ-Jsn"
4028   },
4029   "outputs": [
4030    {
4031     "name": "stdout",
4032     "output_type": "stream",
4033     "text": [
4034      "// Generated from Cirq v0.11.0.dev\n",
4035      "\n",
4036      "OPENQASM 2.0;\n",
4037      "include \"qelib1.inc\";\n",
4038      "\n",
4039      "\n",
4040      "// Qubits: [0, 1, 2]\n",
4041      "qreg q[3];\n",
4042      "\n",
4043      "\n",
4044      "h q[0];\n",
4045      "h q[2];\n",
4046      "cx q[0],q[1];\n",
4047      "\n",
4048      "// Gate: CCZ\n",
4049      "h q[2];\n",
4050      "ccx q[0],q[1],q[2];\n",
4051      "h q[2];\n",
4052      "\n"
4053     ]
4054    }
4055   ],
4056   "source": [
4057    "\"\"\"Export a circuit to Qasm.\"\"\"\n",
4058    "a, b, c = cirq.LineQubit.range(3)\n",
4059    "circuit = cirq.Circuit(cirq.H(a), cirq.H(c), cirq.CNOT(a, b), cirq.CCZ(a, b, c))\n",
4060    "print(circuit.to_qasm())"
4061   ]
4062  },
4063  {
4064   "cell_type": "markdown",
4065   "metadata": {
4066    "id": "35b3a411ffae"
4067   },
4068   "source": [
4069    "You can also export a circuit as QUIL:"
4070   ]
4071  },
4072  {
4073   "cell_type": "code",
4074   "execution_count": 80,
4075   "metadata": {
4076    "id": "951a57e8e0fd"
4077   },
4078   "outputs": [
4079    {
4080     "name": "stdout",
4081     "output_type": "stream",
4082     "text": [
4083      "# Created using Cirq.\n",
4084      "\n",
4085      "H 0\n",
4086      "H 2\n",
4087      "CNOT 0 1\n",
4088      "H 2\n",
4089      "CCNOT 0 1 2\n",
4090      "H 2\n",
4091      "\n"
4092     ]
4093    }
4094   ],
4095   "source": [
4096    "\"\"\"Export a circuit to QUIL.\"\"\"\n",
4097    "print(circuit.to_quil())"
4098   ]
4099  },
4100  {
4101   "cell_type": "markdown",
4102   "metadata": {
4103    "id": "QlgFtRQs-TfQ"
4104   },
4105   "source": [
4106    "You can also turn a circuit into a link to the drag-and-drop web simulation Quirk (though somewhat inconveniently)."
4107   ]
4108  },
4109  {
4110   "cell_type": "code",
4111   "execution_count": 81,
4112   "metadata": {
4113    "id": "Ydst5b0S9IGE"
4114   },
4115   "outputs": [
4116    {
4117     "name": "stdout",
4118     "output_type": "stream",
4119     "text": [
4120      "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"
4121     ]
4122    }
4123   ],
4124   "source": [
4125    "\"\"\"Export a circuit to a Quirk URL.\"\"\"\n",
4126    "from cirq.contrib.quirk.export_to_quirk import circuit_to_quirk_url\n",
4127    "print(circuit_to_quirk_url(circuit))"
4128   ]
4129  }
4130 ],
4131 "metadata": {
4132  "colab": {
4133   "collapsed_sections": [],
4134   "name": "intro.ipynb",
4135   "toc_visible": true
4136  },
4137  "kernelspec": {
4138   "display_name": "Python 3",
4139   "name": "python3"
4140  }
4141 },
4142 "nbformat": 4,
4143 "nbformat_minor": 0
4144}
4145