quantum-madness.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Playing with Cirq**\n",
    "\n",
    "Check if ```cirq``` is installed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                             (0, 5)───(0, 6)\n",
      "                                             │        │\n",
      "                                             │        │\n",
      "                                    (1, 4)───(1, 5)───(1, 6)───(1, 7)\n",
      "                                    │        │        │        │\n",
      "                                    │        │        │        │\n",
      "                           (2, 3)───(2, 4)───(2, 5)───(2, 6)───(2, 7)───(2, 8)\n",
      "                           │        │        │        │        │        │\n",
      "                           │        │        │        │        │        │\n",
      "                  (3, 2)───(3, 3)───(3, 4)───(3, 5)───(3, 6)───(3, 7)───(3, 8)───(3, 9)\n",
      "                  │        │        │        │        │        │        │        │\n",
      "                  │        │        │        │        │        │        │        │\n",
      "         (4, 1)───(4, 2)───(4, 3)───(4, 4)───(4, 5)───(4, 6)───(4, 7)───(4, 8)───(4, 9)\n",
      "         │        │        │        │        │        │        │        │\n",
      "         │        │        │        │        │        │        │        │\n",
      "(5, 0)───(5, 1)───(5, 2)───(5, 3)───(5, 4)───(5, 5)───(5, 6)───(5, 7)───(5, 8)\n",
      "         │        │        │        │        │        │        │\n",
      "         │        │        │        │        │        │        │\n",
      "         (6, 1)───(6, 2)───(6, 3)───(6, 4)───(6, 5)───(6, 6)───(6, 7)\n",
      "                  │        │        │        │        │\n",
      "                  │        │        │        │        │\n",
      "                  (7, 2)───(7, 3)───(7, 4)───(7, 5)───(7, 6)\n",
      "                           │        │        │\n",
      "                           │        │        │\n",
      "                           (8, 3)───(8, 4)───(8, 5)\n",
      "                                    │\n",
      "                                    │\n",
      "                                    (9, 4)\n"
     ]
    }
   ],
   "source": [
    "!python -c 'import cirq_google; print(cirq_google.Sycamore)'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It works!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Hello Qubit**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circuit: \n",
      "(0, 0): ───X^0.5───M('m')───\n",
      "Results: \n",
      "m=00111001110000111010\n"
     ]
    }
   ],
   "source": [
    "import cirq\n",
    "\n",
    "# pick a qubit\n",
    "qubit = cirq.GridQubit(0, 0)\n",
    "\n",
    "# create a circuit that applies a square root of NOT gate & measures the qubit\n",
    "circuit = cirq.Circuit(cirq.X(qubit) ** 0.5, cirq.measure(qubit, key='m'))\n",
    "print(\"Circuit: \")\n",
    "print(circuit)\n",
    "\n",
    "# simulate the circuit several times\n",
    "simulator = cirq.Simulator()\n",
    "result = simulator.run(circuit, repetitions=20)\n",
    "print(\"Results: \")\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Qubits**\n",
    "\n",
    "To create a quantum circuit, first we must define a set of qubits/quantum registers to act on. \n",
    "\n",
    "We can define qubits by 3 ways:\n",
    "- ```cirq.NamedQubit```: by an abstract name\n",
    "- ```cirq.LineQubit```: by number in a linear array\n",
    "- ```cirq.GridQubit```: by 2 numbers in a rectangular lattice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# named qubits for abstract algorithms & algorithms unmapped onto hardware\n",
    "q0 = cirq.NamedQubit('source')\n",
    "q1 = cirq.NamedQubit('target')\n",
    "\n",
    "# create line qubits individually\n",
    "q3 = cirq.LineQubit(3)\n",
    "\n",
    "# create line qubits in a range like LineQubit(0), LineQubit(1), LineQubit(2)\n",
    "q0, q1, q2 = cirq.LineQubit.range(3)\n",
    "\n",
    "# create grid qubits individually\n",
    "q4_5 = cirq.GridQubit(4, 5)\n",
    "\n",
    "# create grid qubits in bulk in a square (16) from (0,0) to (3,3)\n",
    "qubits = cirq.GridQubit.square(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Gates & Operations**\n",
    "\n",
    "Now we will create operations using qubits to be used in the circuit. \n",
    "- ```Gate``` is an effect that can be applied to a set of qubits.\n",
    "- ```Operation``` is a gate applied to a set of qubits.\n",
    "\n",
    "```cirq.H``` is a quantum Hadamard (fundamental quantum gate) which is a ```Gate``` object. ```cirq.H(cirq.LineQubit(1))``` is an ```Operation``` object which is the Hadamard gate applied to a specific qubit (line qubit number 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example gates\n",
    "cnot_gate = cirq.CNOT\n",
    "pauli_z = cirq.Z\n",
    "\n",
    "# use exponentiation to get square root gates\n",
    "sqrt_x_gate = cirq.X**0.5\n",
    "\n",
    "# some gates can also take parameters\n",
    "sqrt_sqrt_y = cirq.YPowGate(exponent=0.25)\n",
    "\n",
    "# create two qubits at once, in a line.\n",
    "q0, q1 = cirq.LineQubit.range(2)\n",
    "\n",
    "# example operations\n",
    "z_op = cirq.Z(q0)\n",
    "not_op = cirq.CNOT(q0, q1)\n",
    "sqrt_iswap_op = cirq.SQRT_ISWAP(q0, q1)\n",
    "\n",
    "# use the gates you specified earlier.\n",
    "cnot_op = cnot_gate(q0, q1)\n",
    "pauli_z_op = pauli_z(q0)\n",
    "sqrt_x_op = sqrt_x_gate(q0)\n",
    "sqrt_sqrt_y_op = sqrt_sqrt_y(q0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Cirqcuits & Moments**\n",
    "\n",
    "Now we are ready to construct a quantum circuit. A ```Circuit``` is a collection of ```Moments``` (collection of ```Operations``` that act during same abstract time slice). Each ```Operation``` must be applied to a disjoint set of qubits compared to each of the other ```Operations``` in the ```Moment``` (which can be thought of as a vertical slice of a quantum circuit diagram).\n",
    "\n",
    "Out of the several different ways circuits can be constructed, Cirq by default attempts to slide operation into earliest possible ```Moment``` when inserted. \n",
    "\n",
    "Append each operation one-by-one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ───H───\n",
      "\n",
      "1: ───H───\n",
      "\n",
      "2: ───H───\n"
     ]
    }
   ],
   "source": [
    "circuit = cirq.Circuit()\n",
    "qubits = cirq.LineQubit.range(3)\n",
    "circuit.append(cirq.H(qubits[0]))\n",
    "circuit.append(cirq.H(qubits[1]))\n",
    "circuit.append(cirq.H(qubits[2]))\n",
    "print(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Append some iterable of operations using a preconstructed list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ───H───\n",
      "\n",
      "1: ───H───\n",
      "\n",
      "2: ───H───\n"
     ]
    }
   ],
   "source": [
    "circuit = cirq.Circuit()\n",
    "ops = [cirq.H(q) for q in cirq.LineQubit.range(3)]\n",
    "circuit.append(ops)\n",
    "print(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A generator that yields operation can also be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ───H───\n",
      "\n",
      "1: ───H───\n",
      "\n",
      "2: ───H───\n",
      "0: ───H───\n",
      "\n",
      "1: ───H───\n",
      "\n",
      "2: ───H───\n"
     ]
    }
   ],
   "source": [
    "# append with generator\n",
    "circuit = cirq.Circuit()\n",
    "circuit.append(cirq.H(q) for q in cirq.LineQubit.range(3))\n",
    "print(circuit)\n",
    "\n",
    "# initialize with generator\n",
    "print(cirq.Circuit(cirq.H(q) for q in cirq.LineQubit.range(3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All of the Hadamard gates are pushed as far left as possible, and put into the same Moment since none overlap.\n",
    "\n",
    "Operations applied to same qubits will be put in sequential, insertion-ordered moments. \n",
    "\n",
    "As shown below, the two-qubit gates overlap & are placed in consecutive moments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ───×───────────\n",
      "      │\n",
      "1: ───×───×───────\n",
      "          │\n",
      "2: ───────×───×───\n",
      "              │\n",
      "3: ───────────×───\n"
     ]
    }
   ],
   "source": [
    "print(cirq.Circuit(cirq.SWAP(q, q + 1) for q in cirq.LineQubit.range(3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To construct a circuit without Cirq automatically shifting operations all the way to the left, create the circuit moment-by-moment or use a different ```InsertStrategy```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ───H───────────\n",
      "\n",
      "1: ───────H───────\n",
      "\n",
      "2: ───────────H───\n"
     ]
    }
   ],
   "source": [
    "# creates each gate in a separate moment by passing an iterable of Moments instead of Operations.\n",
    "print(cirq.Circuit(cirq.Moment([cirq.H(q)]) for q in cirq.LineQubit.range(3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Circuits & Devices**\n",
    "\n",
    "There are often constraints on circuits that are able to be run on the hardware. ```Device``` objects specify these constraints and are used to ensure absence of any illegal operations in circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Qubit pair is not valid on device: (cirq.GridQubit(5, 6), cirq.GridQubit(4, 5)).\n"
     ]
    }
   ],
   "source": [
    "import cirq_google\n",
    "\n",
    "# create some qubits.\n",
    "q0 = cirq.GridQubit(5, 6)\n",
    "q1 = cirq.GridQubit(5, 5)\n",
    "q2 = cirq.GridQubit(4, 5)\n",
    "\n",
    "# create operations using the Sycamore gate for both adjacent and non-adjacent qubit pairs.\n",
    "adjacent_op = cirq_google.SYC(q0, q1)\n",
    "nonadjacent_op = cirq_google.SYC(q0, q2)\n",
    "\n",
    "# circuit for the Sycamore device raises no issues.\n",
    "working_circuit = cirq.Circuit()\n",
    "working_circuit.append(adjacent_op)\n",
    "valid = cirq_google.Sycamore.validate_circuit(working_circuit)\n",
    "\n",
    "# circuit using invalid operations.\n",
    "bad_circuit = cirq.Circuit()\n",
    "bad_circuit.append(nonadjacent_op)\n",
    "try:\n",
    "    cirq_google.Sycamore.validate_circuit(bad_circuit)\n",
    "except ValueError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Simulation**\n",
    "\n",
    "```Simulator``` can be used to compute results of application of a quantum circuit. Using ```cirq.Simulator()``` initialize a simulator that can calculate the results of circuits upto 20 qubits.\n",
    "\n",
    "- ```simulate()```: A simulator can directly access & view resulting wave function during a simulation which can be used for debugging, learning & understanding functioning of circuits.\n",
    "\n",
    "-  ```run()```: Running the simulator as a sampler returns bit strings as output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simulating a 2-qubit \"Bell State\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Simulate the circuit: \n",
      "measurements: (no measurements)\n",
      "\n",
      "qubits: (cirq.LineQubit(0), cirq.LineQubit(1))\n",
      "output vector: 0.707|00⟩ + 0.707|11⟩\n",
      "\n",
      "phase:\n",
      "output vector: |⟩\n"
     ]
    }
   ],
   "source": [
    "#  Bell State: 1/sqrt(2) * ( |00⟩ + |11⟩ )\n",
    "bell_circuit = cirq.Circuit()\n",
    "q0, q1 = cirq.LineQubit.range(2)\n",
    "bell_circuit.append(cirq.H(q0))\n",
    "bell_circuit.append(cirq.CNOT(q0, q1))\n",
    "\n",
    "# initialize simulator\n",
    "s = cirq.Simulator()\n",
    "\n",
    "print('Simulate the circuit: ')\n",
    "results = s.simulate(bell_circuit)\n",
    "print(results)\n",
    "\n",
    "# add measurement at end for sampling\n",
    "bell_circuit.append(cirq.measure(q0, q1, key='result'))\n",
    "\n",
    "# sample circuit\n",
    "samples = s.run(bell_circuit, repetitions=1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Visualizing Results**\n",
    "\n",
    "Display Histogram of sample distribution of measurements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "cirq.plot_state_histogram(samples, plt.subplot())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As visible some qubit states are empty which can be problematic when working with more qubits. To graph sparse sampled data, first get the Counts from your results with its histogram() function, and pass that to cirq.plot_state_histogram. By collecting the results into counts, all the qubit states that were never seen are ignored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({0: 507, 3: 493})\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAXSElEQVR4nO3de7RdZX3u8e8DQUDkKpFCEow9ckS0VTEFrNjihSp4AU9VvNQiRXP06NFqbUWPVbTtGTiO9VZ7qFis4aiowxtUsZgilKKCJAhBxJZIYZAIJCIgl3oBf+eP+e7pYrP3zkrI2ivJ/n7GWGPP+c53zvnba++xnjXfOddcqSokSQLYbtwFSJK2HIaCJKlnKEiSeoaCJKlnKEiSeoaCJKlnKGirleSCJK8cdx2jlOTOJL8+7jo0dxgK2iySXJfkP9uL2E1JPp7kIbO4/1ckuWgDfR6T5GtJfpzktiQrkxzdlh2RZM1G7rOSPPIB1Hy/9ZOcnOQTE/NV9ZCqunYD29no2qXpGAranJ5bVQ8BHg88AXjreMu5n38ElgO/BjwMeD3wk7FWtBVIsv24a9DsMRS02VXVTcC5dOEAQJLDknyzvUO/IskRA8tekeTaJHck+Y8kL2vt93nXnGRxe3c9b3B/SR4N/B3wpHakctvkmpLsDTwC+GhV/bw9vlFVFyXZBfgqsF9b/84k+yU5JMm3Ws03Jvlwkge17V3YNn1F639ca39OksvbOt9M8psP5LkcPJpIcnSS77XnaW2SN89Q+45JPpDkh+3xgSQ7Dmz3z9rv9MMkr5y0n48nOTXJOUnuAp6a5NlJvpPkJ0luSHLyFH+XE9qyW5O8OslvJVnVnosPP5DnQbOoqnz4eMAP4DrgGW16IXAl8ME2vwC4BTia7o3IkW1+PrAL3bv1R7W++wKPadMnA58Y2MdioIB5bf4C4JVt+hXARTPUF+Aa4MvAscA+k5YfAayZ1PZE4DBgXtv31cAfDywv4JED808A1gGHAtsDx7fnZcdparrP+tP8zn0f4EbgKW16T+DgGWp/N3Ax3RHRfOCbwF+0Zc8CbgIeAzwY+MSk/XwcuB14cvt77dT28Rtt/jeBm4FjJ/1d/q71/T3gp8CX2v4XtOfld8f9f+pjww+PFLQ5fSnJHcANdC8C72ztfwCcU1XnVNUvq2o5sIIuJAB+CTw2yc5VdWNVXbW5C6vu1eupdC/Sfw3cmOTCJAfMsM7Kqrq4qu6pquuAjwC/O8NulgIfqapLqureqloG/IwuWKZzWXsnfVs7wjlphr6/AA5KsltV3VpVl83Q92XAu6tqXVWtB94FvLwtexHwD1V1VVXdTRdEk51V3ZHUL6vqp1V1QVVd2eZXAWdy/+fiL1rfrwF3AWe2/a8F/pUuNLWFMxS0OR1bVbvSvas8ENi7tT8ceOGkF7/DgX2r6i7gOODVdC/UX0ly4CiKq6o1VfW6qvovraa7gDOm65/kvyb5cjtx/hPgfw/8TlN5OPAnk37PRcB+M6xzcFXtMfEATpmh7+/TBen1Sf4lyZNm6LsfcP3A/PUDdexHF9wTBqenbEtyaJLzk6xPcjvd32vyc3HzwPR/TjE/axceaNMZCtrsqupf6IYg3tuabgD+3+CLX1XtUlWntP7nVtWRdENH3wc+2ta7i254Y8KvzbTbjazxBuBvgcfOsP6prZ4Dqmo34G10w1DTuQH4q0m/54Or6syNqW2Gmi+tqmPohmS+BHx2htp/SBdSE/ZvbdANQy0cWLZoqt1Nmv8UcDawqKp2pxsqmum50FbKUNCofAA4Msnj6Masn5vkmUm2T7JTu4xyYZJ9khzTTpj+DLiTbjgJ4HLgd5Lsn2R3Zr6a6WZg4cSJ4MmS7JnkXUkemWS7duL5j+jG3SfWf2jbz4Rd6c533NmOXl4zxT4HP0PwUeDV7V11kuzSTtDuOkPdQ0nyoCQvS7J7Vf2i1TXxPE1V+5nA25PMb7/rO+j+DtCFyQlJHp3kwcCfD1HCrsCPq+qnSQ4BXvpAfydtmQwFjUQbxz4DeEd7V34M3Tvt9XTvqP+U7v9vO+BNdO9if0w3Tv2ato3lwGeAVcBKupPE0/k6cBVwU5IfTbH853QnRP+Z7gX1u3Qh9Iq2r+/TvZBe24Z+9gPeTPfidwfdC/5nJm3zZGBZ6/+iqloBvAr4MHArsHpi+5vJy4Hr2lDWq+nOG0xX+1/SnbdZRXfS/7LWRlV9FfgQcH6rcSIYfzbDvv8H8O52zugd/OooRduYdOffJM1V6S7p/S7dVVL3jLsejZdHCtIclOT57bMMewLvAf7RQBAYCtJc9d/pLhv+AXAv9z9fojnK4SNJUs8jBUlSb96Gu2y59t5771q8ePG4y5CkrcrKlSt/VFXzp1q2VYfC4sWLWbFixbjLkKStSpLrp1vm8JEkqWcoSJJ6hoIkqWcoSJJ6hoIkqWcoSJJ6hoIkqWcoSJJ6Iw2FJNcluTLJ5UlWtLa9kixPck37uWdrT5IPJVmdZFWSg0dZmyTp/mbjE81PrarBLz05CTivqk5JclKbfwtwFHBAexxK91WIh46qqMUnfWVUm9Y24LpTnj3uEqSxGMfw0THAsja9DDh2oP2M6lwM7JFk3zHUJ0lz1qhDoYCvJVmZZGlr26eqbmzTNwH7tOkFdF/TOGFNa5MkzZJRDx8dXlVrkzwMWJ7k+4MLq6qSbNQXOrRwWQqw//77b75KJUmjPVKoqrXt5zrgi8AhwM0Tw0Lt57rWfS2waGD1ha1t8jZPq6olVbVk/vwp7/wqSdpEIztSSLILsF1V3dGmfw94N3A2cDxwSvt5VlvlbOB1ST5Nd4L59oFhJmnO8WIIzWRUF0OMcvhoH+CLSSb286mq+qcklwKfTXIicD3wotb/HOBoYDVwN3DCCGuTJE1hZKFQVdcCj5ui/Rbg6VO0F/DaUdUjSdowP9EsSeoZCpKknqEgSeoZCpKknqEgSeoZCpKknqEgSeoZCpKknqEgSeoZCpKknqEgSeoZCpKknqEgSeoZCpKknqEgSeoZCpKknqEgSeoZCpKknqEgSeoZCpKknqEgSeoZCpKknqEgSeoZCpKknqEgSeoZCpKknqEgSeoZCpKknqEgSeoZCpKknqEgSeoZCpKk3shDIcn2Sb6T5Mtt/hFJLkmyOslnkjyote/Y5le35YtHXZsk6b5m40jhDcDVA/PvAd5fVY8EbgVObO0nAre29ve3fpKkWTTSUEiyEHg28PdtPsDTgM+1LsuAY9v0MW2etvzprb8kaZaM+kjhA8CfAb9s8w8Fbquqe9r8GmBBm14A3ADQlt/e+t9HkqVJViRZsX79+hGWLklzz8hCIclzgHVVtXJzbreqTquqJVW1ZP78+Ztz05I0580b4bafDDwvydHATsBuwAeBPZLMa0cDC4G1rf9aYBGwJsk8YHfglhHWJ0maZGRHClX11qpaWFWLgRcDX6+qlwHnAy9o3Y4HzmrTZ7d52vKvV1WNqj5J0v2N43MKbwHelGQ13TmD01v76cBDW/ubgJPGUJskzWmjHD7qVdUFwAVt+lrgkCn6/BR44WzUI0mamp9oliT1DAVJUs9QkCT1DAVJUs9QkCT1DAVJUs9QkCT1DAVJUs9QkCT1DAVJUs9QkCT1DAVJUs9QkCT1DAVJUs9QkCT1DAVJUs9QkCT1DAVJUs9QkCT1DAVJUs9QkCT1NhgKSV44TJskaes3zJHCW4dskyRt5eZNtyDJUcDRwIIkHxpYtBtwz6gLkyTNvmlDAfghsAJ4HrByoP0O4I2jLEqSNB7ThkJVXQFckeRTVfWLWaxJkjQmMx0pTDgkycnAw1v/AFVVvz7KwiRJs2+YUDidbrhoJXDvaMuRJI3TMKFwe1V9deSVSJLGbphQOD/J/wG+APxsorGqLhtZVZKksRgmFA5tP5cMtBXwtM1fjiRpnDYYClX11NkoRJI0fhsMhSTvmKq9qt69gfV2Ai4Edmz7+VxVvTPJI4BPAw+lO3n98qr6eZIdgTOAJwK3AMdV1XUb8btIkh6gYW5zcdfA417gKGDxEOv9DHhaVT0OeDzwrCSHAe8B3l9VjwRuBU5s/U8Ebm3t72/9JEmzaJjho78enE/yXuDcIdYr4M42u0N7TJyLeGlrXwacDJwKHNOmAT4HfDhJ2nYkSbNgU26d/WBg4TAdk2yf5HJgHbAc+AFwW1VN3DtpDbCgTS8AbgBoy2+nG2KavM2lSVYkWbF+/fpNKF+SNJ1hzilcSfcOH2B7YD4w4/mECVV1L/D4JHsAXwQO3LQy77PN04DTAJYsWeJRhCRtRsNckvqcgel7gJsH3ukPpapuS3I+8CRgjyTz2jYWAmtbt7XAImBNknnA7nQnnCVJs2SDw0dVdT2wB/Bc4PnAQcNsOMn8doRAkp2BI4GrgfOBF7RuxwNntemz2zxt+dc9nyBJs2uYb157A/BJ4GHt8ckk/3OIbe9L92noVcClwPKq+jLwFuBNSVbTnTM4vfU/HXhoa38TcNLG/jKSpAdmmOGjE4FDq+ougCTvAb4F/M1MK1XVKuAJU7RfCxwyRftPAb/mU5LGaJirj8J97456b2uTJG1jhjlS+AfgkiRfbPPH8qshH0nSNmSYD6+9L8kFwOGt6YSq+s5Iq5IkjcUwn1M4DLhq4lbZSXZLcmhVXTLy6iRJs2qYcwqn8qvbVdCmTx1NOZKkcRrqRPPg5wWq6pcMdy5CkrSVGSYUrk3y+iQ7tMcbgGtHXZgkafYNEwqvBn6b7jYUa+i+iW3pKIuSJI3HMFcfrQNePAu1SJLGbFNunS1J2kYZCpKk3jA3xHvEMG2SpK3fMEcKn5+i7XObuxBJ0vhNe6I5yYHAY4Ddk/y3gUW7ATuNujBJ0uyb6eqjR9F969oedF+wM+EO4FUjrEmSNCbThkJVnQWcleRJVfWtWaxJkjQmMw0f/Q1Qbfolk5dX1etHWJckaQxmGj5aMWtVSJK2CDMNHy2bzUIkSeM3zPcpnE8bRhpUVU8bSUWSpLEZ5hbYbx6Y3gn4feCe0ZQjSRqnYW6It3JS0zeSfHtE9UiSxmiY4aO9Bma3A54I7D6yiiRJYzPM8NFKunMKoRs2+g/gxFEWJUkaj2GGj7z5nSTNEcPcJfWFSXZt029P8oUkB4++NEnSbBvmLql/XlV3JDkceAZwOnDqaMuSJI3DMKFwb/v5bOC0qvoK8KDRlSRJGpdhQmFtko8AxwHnJNlxyPUkSVuZYV7cXwScCzyzqm4D9gL+dJRFSZLGY4OhUFV3A+uAw1vTPcA1oyxKkjQew1x99E7gLcBbW9MOwCdGWZQkaTyGGT56PvA84C6AqvohsOuGVkqyKMn5Sb6X5Kokb2jteyVZnuSa9nPP1p4kH0qyOskqL3uVpNk3TCj8vKqKX33hzi5Dbvse4E+q6iDgMOC1SQ4CTgLOq6oDgPPaPMBRwAHtsRQve5WkWTdMKHy2XX20R5JXAf8MfHRDK1XVjVV1WZu+A7gaWAAcA0x8V8My4Ng2fQxwRnUubvvbd2N+GUnSAzPjbS6SBPgMcCDwE+BRwDuqavnG7CTJYuAJwCXAPlV1Y1t0E7BPm14A3DCw2prWduNAG0mW0h1JsP/++29MGZKkDZgxFKqqkpxTVb8BbFQQTEjyEODzwB9X1U+6nLnP9u/3BT4bqOk04DSAJUuWbNS6kqSZDTN8dFmS39qUjSfZgS4QPllVX2jNN08MC7Wf61r7WmDRwOoLW5skaZYMEwqHAt9K8oN2VdCVSVZtaKU29HQ6cHVVvW9g0dnA8W36eOCsgfY/bFchHQbcPjDMJEmaBcN8n8IzN3HbTwZeDlyZ5PLW9jbgFLqT1ycC19N9YhrgHOBoYDVwN3DCJu5XkrSJhvk+hes3ZcNVdRHdF/NM5elT9C/gtZuyL0nS5uGN7SRJPUNBktQzFCRJPUNBktQzFCRJPUNBktQzFCRJPUNBktQzFCRJPUNBktQzFCRJPUNBktQzFCRJPUNBktQzFCRJPUNBktQzFCRJPUNBktQzFCRJPUNBktQzFCRJPUNBktQzFCRJPUNBktQzFCRJPUNBktQzFCRJPUNBktQzFCRJPUNBktQzFCRJPUNBktQbWSgk+ViSdUm+O9C2V5LlSa5pP/ds7UnyoSSrk6xKcvCo6pIkTW+URwofB541qe0k4LyqOgA4r80DHAUc0B5LgVNHWJckaRojC4WquhD48aTmY4BlbXoZcOxA+xnVuRjYI8m+o6pNkjS12T6nsE9V3dimbwL2adMLgBsG+q1pbfeTZGmSFUlWrF+/fnSVStIcNLYTzVVVQG3CeqdV1ZKqWjJ//vwRVCZJc9dsh8LNE8NC7ee61r4WWDTQb2FrkyTNotkOhbOB49v08cBZA+1/2K5COgy4fWCYSZI0S+aNasNJzgSOAPZOsgZ4J3AK8NkkJwLXAy9q3c8BjgZWA3cDJ4yqLknS9EYWClX1kmkWPX2KvgW8dlS1SJKG4yeaJUk9Q0GS1DMUJEk9Q0GS1DMUJEk9Q0GS1DMUJEk9Q0GS1DMUJEk9Q0GS1DMUJEk9Q0GS1DMUJEk9Q0GS1DMUJEk9Q0GS1DMUJEk9Q0GS1DMUJEk9Q0GS1DMUJEk9Q0GS1DMUJEk9Q0GS1DMUJEk9Q0GS1DMUJEk9Q0GS1DMUJEk9Q0GS1DMUJEk9Q0GS1NuiQiHJs5L8W5LVSU4adz2SNNdsMaGQZHvgb4GjgIOAlyQ5aLxVSdLcssWEAnAIsLqqrq2qnwOfBo4Zc02SNKfMG3cBAxYANwzMrwEOndwpyVJgaZu9M8m/zUJtc8HewI/GXcSWIu8ZdwWagv+jAx7g/+jDp1uwJYXCUKrqNOC0cdexrUmyoqqWjLsOaTr+j86OLWn4aC2waGB+YWuTJM2SLSkULgUOSPKIJA8CXgycPeaaJGlO2WKGj6rqniSvA84Ftgc+VlVXjbmsucQhOW3p/B+dBamqcdcgSdpCbEnDR5KkMTMUJEk9Q2GO89Yi2tIl2SnJt5NckeSqJO8ad03bMs8pzGHt1iL/DhxJ92HBS4GXVNX3xlqYNCBJgF2q6s4kOwAXAW+oqovHXNo2ySOFuc1bi2iLV5072+wO7eG72RExFOa2qW4tsmBMtUjTSrJ9ksuBdcDyqrpkzCVtswwFSVu8qrq3qh5Pd6eDQ5I8dswlbbMMhbnNW4toq1JVtwHnA88acynbLENhbvPWItriJZmfZI82vTPdhRHfH2tR27At5jYXmn3eWkRbiX2BZe1que2Az1bVl8dc0zbLS1IlST2HjyRJPUNBktQzFCRJPUNBktQzFCRJPUNBmkGSVyT58DTLvtl+Lk7y0o3c7ts2Zz9pczEUpE1UVb/dJhcDGxUKwLAv9oaCZpWhoDklyf9K8u9JLkpyZpI3t/YLkixp03snuW5gtUVt+TVJ3jmwrYk7d54CPCXJ5UneOGl/+ya5sC37bpKnJDkF2Lm1fbL1+1KSle37Apa2tqn6/UH7boHLk3ykfaBL2mz8RLPmjCRPpLuVx+Pp/vcvA1YOseohwGOBu4FLk3ylqlYMLD8JeHNVPWeKdV8KnFtVf9VewB9cVf+a5HXtBm8T/qiqftxu43Bpks9X1UmD/ZI8GjgOeHJV/SLJ/wVeBpwx9JMgbYChoLnkKcAXq+pugCTD3udpeVXd0tb5AnA4sGLmVXqXAh9rXw7zpaq6fJp+r0/y/Da9CDgAuGVSn6cDT6QLDYCd6W4lLW02hoLUuYdfDafuNGnZ5HvBDH1vmKq6MMnvAM8GPp7kfVV1n3f2SY4AngE8qaruTnLBFDUABFhWVW8ddv/SxvKcguaSC4Fjk+ycZFfguQPLrqN7Fw7wgknrHZlkrza0cyzwjUnL7wB2nWqHSR4O3FxVHwX+Hji4LfpFO3oA2B24tQXCgcBhA5sY7Hce8IIkD2vb3qttX9psDAXNGVV1GfAZ4Argq3RDOxPeC7wmyXeAvSet+m3g88Aq4POTzifQ2u9tXyz/xknLjgCuaNs9Dvhgaz8NWNVOIP8TMC/J1XQnrQe/e7jv1747++3A15KsApbT3UFU2my8S6rmrCQnA3dW1XvHXYu0pfBIQZLU80hBktTzSEGS1DMUJEk9Q0GS1DMUJEk9Q0GS1Pv/0aH5VDQItGIAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# histogram counts from result data structure\n",
    "counts = samples.histogram(key='result')\n",
    "print(counts)\n",
    "\n",
    "# graph histogram counts instead of results\n",
    "cirq.plot_state_histogram(counts, plt.subplot())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Using Parameter Sweeps**\n",
    "\n",
    "For variational algorithms which vary parameters within circuit to optimize a cost function, Cirq circuits allow for gates to have symbols as free parameters within a circuit. For parameters, Cirq uses ```sympy``` to add ```sympy.Symbol``` as parameters to gates & opertions. \n",
    "\n",
    "After completion of circuit, possible values of each of these parameters can be filled with ```Sweep```.\n",
    "- ```cirq.Points```: A list of manually specified values for one specific symbol as a sequence of floats.\n",
    "\n",
    "- ```cirq.Linspace```: A linear sweep from a starting value to an ending value.\n",
    "\n",
    "- ```cirq.ListSweep```: A list of manually specified values for several different symbols, specified as a list of dictionaries.\n",
    "\n",
    "- ```cirq.Zip``` and ```cirq.Product```: Sweeps can be combined list-wise by zipping them together or through their Cartesian product.\n",
    "\n",
    "A Parametrized circuit & sweep together can be run using simulator or other sampler by changing ```run()``` to ```run_sweep()``` & adding sweep as a parameter.\n",
    "\n",
    "An example of sweeping an exponent of a X gate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAtG0lEQVR4nO3de5zcdX3v8dd7NwNsELJBYo8shAQPF0Ekq1vlgA8LaA0XgS1eAoXWCy3Haxv05NFQONykJUgVrGItWCgoQhBwGwo0eICe9oRG2bgbYtBo5BIYVBCy3LLAJvmcP36/Ib9M5jfznd35zfXzfDzmkZnf/Gbmk5nZ+f5+38vnIzPDOedc5+pqdADOOecayxsC55zrcN4QOOdch/OGwDnnOpw3BM451+GmNTqAau255542Z86cRofhnHMtZdWqVb8zs1ml7mu5hmDOnDkMDw83OgznnGspkh5Pu8+7hpxzrsN5Q+Cccx3OGwLnnOtw3hA451yH84bAOec6XGazhiRdC3wQeNrM3lbifgFfA44HNgEfN7OfZBWPc1M1NJLnwmVrGRufKLvf9FwXO+e6Gds0wV69PSyafyCD/X11itK56imr7KOS3gu8BNyQ0hAcD3yeqCF4N/A1M3t3pecdGBgwnz7q6im0Aahk5vQcF5x4iDcKriEkrTKzgVL3ZXZGYGb/IWlOmV1OJmokDFgpqVfSm83s11nF5FyooZE8ly9fR35sHAG1OFzauGmCRbeuBvDGwDWVRi4o6wOeSNx+Mt62Q0Mg6SzgLIDZs2fXJTjXedJ+/Gt5zjyxxVi4dJSFS0df3+ZnCq7RWmJlsZldDVwNUddQg8NxbaZU1089v2R+puAarZGzhvLAPonbe8fbnKuboZE859y+Zsr9/1M1scX44i2rmbv4To5cch9DI/6n4OonqCGQ9B5Jn4ivz5I0twavvQz4U0UOB5738QFXb5cvX8f4xJZGhwHAFjMMyI+Nc/bSUeZ4o+DqpGLXkKQLgAHgQOA6IAd8FziywuNuAo4C9pT0JHBB/FjM7FvAXUQzhtYTTR/9xGT/E85VKzkeUK3enhyjF3yg7PM+NTbOjJ4cr23ewqaJrVW/RqFrKj82zjm3rwG828hlJ2SM4I+AfuAnAGb2lKTdKj3IzE6rcL8Bnw0J0rlaOm9oDTeu3DCpcYCeXDcXnnRI6v2D/X07/GAPjeRZ9P3VTGyd3MjD+MQWLl++zhsCl5mQhuA1MzNJBiBp14xjci4zQyP5qhuBbomtZpNeHFbYfyprEZ6axJmLc6FCGoJbJP0j0Cvpz4FPAtdkG5Zz2bh8+bqqGoGeXDeXnnLolI/GS50pHLnkvuCuqS6JuYvv9JXKLhMVB4vN7O+AW4HbiMYJzjezr2cdmHO1NjSSD/7hFdDX21OTRiDNovkH0pPrDto3OZB8zu1rfADZ1VTQOgIz+yHww4xjca7miheJhejr7WHF4mMyjQu2dRlVu4LZxwxcrYXMGjoFuAx4E9GBkojGenfPODbnpqSwRqAwPTTkR7Yn182i+QdmG1hCssuomplMPmbgailkHcGXgZPMbIaZ7W5mu3kj4FrBRXesDVojMHN6ri5dQZUM9vexYvExQWcuXZJ3D7maCeka+q2Z/SzzSJyroaGRPBs3VZ6hU69uoGrs1dtT8axgixlnLx1l+PHnuGTw0DpF5tpVSEMwLGkpMAS8WthoZrdnFZRzk1VN94qgrt1AoRbNP3C7Lq00Bnx35Qa+u3IDfT6byE1BSEOwO9HK3+RSSgO8IXBNpXhMoBKjOVfrTmbdga9AdlNRsSEwM0/94FpCtXmD+np7MoxmagqDyNWc4fhsIjdZFQeLJe0t6QeSno4vt0naux7BOVeNambS1Ht20GQVBpCvXDAvaBDZZxO5yQiZNXQdUabQveLLHfE255rG0EieLqX/VIrmmR00GYP9fZx++OyKjcFeTXyW45pXxZrFkkbNbF6lbfXiNYtdsZCxAQGPLjmhfkFlZGgkv111s1J84NiVUq5mccgZwbOSzpDUHV/OAJ6tbYjOTV7I2EC7HCkP9vdVHNvwNBSuWiENwSeBjwK/Iaon/GG8doBrIpUGUltlPCBUSI6iwsCxcyFCZg09DpxUh1icq9rQSL5sjp527CYpzlGUxgeOXaiWKF7vXJq0tNICrlgwr60agKTC9NK5i+9MbQTbpTvMZa+Rxeudm5JyaaWbdbFYraX92DfrqmnXnLwhcC2pMFMoTTMvFqultPECIzpb8gFjFyJkQdnvSfonSXfHtw+WdGb2oTmXrlxm0XYbHC5nsL+PS0859PWGL7nOID82ztlLR5mz+E6OXHKfNwouVcgZwT8Dy4kWkwH8AliYUTzOVVQps2irLRabqsLq477enh3GCwq3fUqpKyekIdjTzG4BtgKY2WYgPKGLczVWblpkX29PRzUCSZVmCfmUUpcmpCF4WdIbiQ8uJB0OPJ9pVM6lqFR3uFO6hEoJmSWUHxv3biK3g5CG4AtEuYbeImkFcAPw+Uyjcq6ESgPEvT25jj0bgPBG0LuJXLGKuYYAJE0DDiQai1pnZmFJ0jPguYY6z9BIvmJu/p5cd8eNDZTSf/E9QZXZCtpxwZ0rrVyuoZDi9bsAnwHeQ9Q99J+SvmVmr9Q2TOe2qSYPP3TeAHGaC048pKriPF7QxkFY19ANwCHA14FvxNe/k2VQrrMVuoBCG4FOHiAuVjydNIQPIruQFBNvM7ODE7fvl/RwVgE5V02lsU5aMxAqJP1EMc9L1NlCzgh+Es8UAkDSuwHvpHeZCf1R6pa8S6iManINeV6izpbaEEhaI+kh4J3AA5Iek/Qo8F9AyQEH52oh5Ecp1y2+8tHDvBEoo1T6iVJ/8H5W5cp1DX2wblE4R/gA8czpOS448RBvBCpIpqt+amycGT05Xn5tM1u3bOswEvChd/b5e9nhUhuCuA7BlEg6Fvga0A1828yWFN0/G7ge6I33WWxmd031dV3rCSk36VNEq1cYLwA4csl9O0zBNeD+nz/TgMhcM8ks+6ikbuAq4DjgYOA0SQcX7XYecIuZ9QOnAt/MKh7X3CoNELdiwflmkzb24quNXZaFad4FrDezRwAk3QycDCRnHBmwe3x9BvBUhvG4JlZugLivt4cVi4+pYzTtaa/entRut0Km0oVLR32RWQcKOiOIU1F/ML68KfC5+4AnErefjLclXQicIelJ4C5SUldIOkvSsKThZ57x09h2VG6A2Kc21kalWseeqbRzhdQj+CjwY+AjREXsfyTpwzV6/dOAfzazvYHjge9I2iEmM7vazAbMbGDWrFk1emnXTBbNP3C7XPpJPrWxNqpZbOaLzDpLyBnBucDvm9nHzOxPibp8/nfA4/LAPonbe8fbks4EbgEws/8CdgH2DHhu12YG+/s4/fDZOzQGPrWxtpK1CyrxM7HOEdIQdJnZ04nbzwY+7kFgf0lzJe1ENBi8rGifDcD7ACS9lagh8L6fDnXJ4KFcsWAefb09CB8gzlK5M7CCGT25usTiGi9ksPjfJC0HbopvLwDurvQgM9ss6XNE1c26gWvNbK2ki4FhM1sGfBG4RtLZRF2UH7eQdKiubRRnFvU1AvUx2N/HwqWjZfcZG59gzuI7ffC4A1RsCMxskaRTiLKPAlxtZj8IefJ4TcBdRdvOT1x/GDgyPFzXToZG8iz6/momtm5r+zdummDRrasBz4aZtb4ys4iSPENp+wsZLL7MzG43sy/Elx9Iuqwewbn2dvnydds1AgUTW8wHKuug0iyiJB88bm8hff1/WGLbcbUOxHWecoORPlCZvWpTVvtn0r5Su4YkfZqoIM1+cfK5gt2AFVkH5tpXIadQucEgnzJaH4UUFCEpPvwzaV/lxgi+RzQofCmwOLH9RTN7LtOoXNsK+cHJdcunjNZZoe//i7esZkuJ+RoivCayaz3lks49DzxPtOjLuZqolFPIZw01TuE9L26oBZx++Gz/TNpYlrmGnNuB5xRqbsWpq/fyqaMdwRsCV1flEp/5YGRzSKaudp0hszTUzpXiOYWcaz7lZg29COkTO8xs97T7nCtIVh3rlthiRk+ui/GJrdvt5zmFmlfhM/SuovZVbrB4NwBJXwJ+DXyHeNwIeHNdonMtrXiGUGE2yvjEVnJd4g27TGNs04T/uDSx84bWcOPKDdulqF64dJSL7ljrg/ptJGSM4CQzOyxx+x8krQbOT3uAc1B+htDEVsMMHl1yQp2jcqGGRvLbNQJJGzdNeNqJNhIyRvCypNMldUvqknQ68HLWgbnWV2nwd2x8woufNLFKi/487UT7CGkI/pioIM1v48tH4m3OlRUy+Os/JM0rZBaXz/RqDxUbAjN7zMxONrM9zWyWmQ2a2WN1iM21uJCkZv5D0rxCGnKf6dUeQrKPHiDpXkk/jW+/XdJ52YfmWl1IUjP/IWlelRpyn+nVPkK6hq4BzgEmAMzsIaJqY85VVCiNeOWCeTv8qPgPSXNLNuQCentyzJye8+pxbUiVCoJJetDMfl/SiJn1x9tGzWxePQIsNjAwYMPDw414aVel4vnnRx80i/t//ozPR29hpdaFeAWz1iBplZkNlLovZPro7yS9hXhxmaQPE60rcK6k4vKTEM0/v21V3o8iW1jauhCvYNb6QrqGPgv8I3CQpDywEPhUlkG51lX4sUg2AgU+3bC1lVsX4p9tayt7RiCpG/iMmb1f0q5Al5m9WJ/QXCuqlGbaZwm1rkqfnX+2ravsGYGZbSEuWm9mL3sj4Cqp9GPgs4RaV6XPzj/b1hXSNTQiaZmkP5F0SuGSeWSuJZX7MfBZQq2t3HRS/2xbW8hg8S7As0CyYogBt2cSkWtpRx80q2R+Gq881vqSRWt81lB7qTh9tNn49NHmVaoecaHM4SWDhzYuMJcpT1PdGqY0fVTSdZSoS2Bmn6xBbK6NlBooNuD+nz/TmIBc5oobf59K2ppCxgj+FbgzvtwL7A68lGVQrjWlDRT7bJL2Varx96mkrafiGYGZ3Za8Lekm4P9lFpFrWWn1iH02Sfvyxr89TKZm8f7Am2odiGt9pWaV+GyS9pbWyHvj31pCxgiKaxf/BvirzCJyLaVU7hmfTdIZhkbyvPzq5h22e+PfekK6hnarRyCu9aTlnokK1Hd7I9DGSs0QK9gl18Xw48/5TKIWElKP4Mg4vQSSzpD0VUn7hjy5pGMlrZO0XtLilH0+KulhSWslfa+68F0jee6ZzlXus9+4aYLvrtxAfmwcY9tMIi9L2rxCxgj+Adgk6TDgi8CvgBsqPSjOU3QVcBxwMHCapIOL9tmfqNbBkWZ2CFFCO9ciPPdM56r2s/UDg+YW0hBstmjV2cnAN8zsKiCku+hdwHoze8TMXgNujp8j6c+Bq8xsI4CZPR0eums0zz3TuSbz2fqBQfMKaQhelHQOcAZwp6QuIBfwuD7gicTtJ+NtSQcAB0haIWmlpGNLPZGksyQNSxp+5hlfnNQsPPdM5wqpR13MDwyaV0hDsAB4FTjTzH4D7A1cXqPXn0Y0HfUo4DTgGkm9xTuZ2dVmNmBmA7NmzarRS7ta2Hnatq9Ql6J/vYxh+yuuR60K+/uBQXMLmTX0G+CridsbCBgjAPLAPonbe8fbkp4EfmRmE8Cjkn5B1DA8GPD8rkFKVSAD2HlatzcAHWSwv+/1z3poJM/CpaOp+/r3ormFzBo6XNKDkl6S9JqkLZKeD3juB4H9Jc2VtBNRwftlRfsMEZ0NIGlPoq6iR6r5D7j68gpkrpTB/r7Xzw6K9fbkuHz5OuYuvpMjl9zns4eaUEjX0DeIum1+CfQAfwZ8s9KDzGwz8DlgOfAz4BYzWyvpYkknxbstB56V9DBwP7DIzJ6t/r/h6sUrkLk0pcYNcl3i5dc2+1TSJhdSjwAzWy+pO65Ydp2kEaJpn5UedxdwV9G28xPXDfhCfHEtwCuQuTTJegVPjY0zoyfHC69MsHXr9vsVzhy9q6h5hDQEm+KunVFJXwZ+zeRyFLkWlTYmUMwHBF1h3KDQhbg1pdyJnzk2l5Af9D+J9/sc8DLRAPCHsgzKNY+hkTyLvr+6YiMwc3rOBwTd6yp1IfqZY3MJmTX0uKQe4M1mdlEdYnJN5PLl65hIO6yL9fbkGDn/A3WKyLWCckf8fubYfEJmDZ0IjAL/Ft+eJ6l49o9rUyGn8M9XOFtwnSftiL9b8jPHJhTSNXQhUbqIMQAzGwXmZhaRayohp/B+mu+KpdWm+MpHD/NGoAmFNAQTZla8bqC1Kt67SVs0/0ByXenrRv0035WSXHksfLV5swuZNbRW0h8D3XG20L8AHsg2LNcsCn+4yVlDXYKthheecWUlVx675hbSEHweOJco39BNRIvAvpRlUK65+B+0c+0tZNbQJqKG4Nzsw3HOOVdvITWLB4C/BuYk9zezt2cXlmsGhXrEXm7QTVWp2tbetdg8QrqGbgQWAWuArRX2dW3ivKE13Lhyw+uzAgo5YgD/w3VVSatt7d+p5hEya+gZM1tmZo+a2eOFS+aRuYYYGskz76J7+G6iESjw7KJuMry2dfMLOSO4QNK3gXuJBowBMLPbM4vKNUTxkVspniPGVctrWze/kIbgE8BBROUpC11DBnhD0GYq5YcBXzzmqrdXbw/5Mj/2/p1qvJCuod+Py0R+zMw+EV8+mXlkru4qHZkJfPGYq1q5+sYiGivwgjWNFdIQPCDp4MwjcQ3XOz2Xep+A0w+f7YN6rmrl6hsXT0bwxqAxQhqCw4lqEayT9JCkNZIeyjowV19DI3leemVzyftmTs9xxYJ5XDJ4aJ2jcu1isL+PFYuP4coF89gl5ezAB44bJ2SM4NjMo3ANl5Zu2lNMu1ryUqfNKageQT0CcY0zNJJPHczzFNOulrzUaXPykpMdrjBlNI3/YbpaqvR9yo+NM2fxnfRffI+PF9SRNwQdrtypuqeYdrVWbgZR0sZNEyy6dbU3BnUSUqHsspBtrjWVO1X3/PGu1orrFPT25EgrdzGxxXzwuE5Czgj+sMS242odiGuMtFP1vt4ebwRcJgoziK5YMI9XN2+lXElsHzyuj9SGQNKnJa0BDoynjRYujwI+fbRNpJUU9C4hlzVfyd48ys0a+h5wN3ApsDix/UUzey7TqFzdFI76Pd20q7dKR/u5bvkBSZ2U6xoyM3sM+CzwYuKCpD2yD83Vg9cccI1S7mh/eq6LN+w8jbOXjnr6iToo1xB8L/53FTAc/7sqcdu1uMLU0fzYOIYv83f1ldYtecbhszHExk0T/r2sk9SGwMw+GP8718z2i/8tXParX4guK6X6aH2Zv6uX4hlEfb09XHrKodz/82f8e1lnISkmkHQK8B6iHFH/aWZDWQblslduNbHP1HD1Mtjft0NX5NlLR0vu69/L7ISsI/gm8CmiUpU/BT4l6aqsA3PZ8dXErpmlff/8e5mdkDOCY4C3mkWFRiVdD6zNNCqXiWQB8TQ+ddQ12qL5B+5QKc+/l9kKWVC2HpiduL1PvK0iScfG6avXS1pcZr8PSTJJAyHP66qXHBgux1cTu2aw87RtP01d2jZG4APG2Si3oOwOScuA3YCfSfp3SfcDP4u3lSWpG7iKaBXywcBppQrcSNoN+EvgR5P7L7gQIYt3fDWxa7TCActYIuttYeVxfmycs5eOct5Qeremm5xyXUN/N8Xnfhew3sweAZB0M3Ay8HDRfl8CLgMWTfH1XBmVzgR88Y5rBpUOWAy4ceUGBvbdww9aaii1ITCz/zvF5+4DnkjcfhJ4d3IHSe8A9jGzOyWlNgSSzgLOApg9e3babi7F0Egesa0sYCm77jTN/7Bcw4XMDDKiBsO/r7UTMmvoRUkvxJdXJG2R9MJUX1hSF/BV4IuV9jWzq81swMwGZs2aNdWX7jiXL19XthEAL0DjmkPozCCfSlpbFRsCM9vNzHY3s92BHuBDwDcDnjtPNLBcsHe8rWA34G3Av0t6jKg28jIfMK69kD8an5rnmkFovQIDTz1RQ1UVprHIEDA/YPcHgf0lzZW0E3AqsCzxXM+b2Z5mNsfM5gArgZPMzNNX1FilH3mfmueaRfFq455c+k+Up56onYrrCOJVxQVdwADwSqXHmdlmSZ8DlgPdwLVmtlbSxcCwmS0r/wxuKpLJ5Gb05Mh1i4kt2zqICmMGfZ5ozjWZ4tXG5da/FKaV+vd3ahSvE0vfQboucXMz8BhwjZk9nWFcqQYGBmx42E8ayilMwSuefdGlaCqe//i7VjR38Z0lx7oEPLrkhHqH03IkrTKzkl3vFc8IzOwTtQ/JZSltCt5W29YN5I2AazV79faUPCvw8a2pC+ka+vty95vZX9QuHFcL5QaH/VTataqjD5rFjSs3bHdWkOsSm17bzNzFd3o9jSkIGSzeBXgH8Mv4Mg/YiW21CVyTqXSE5FPvXKsZGslz26r8Dl1DW8HrFtRASEPwduAoM/u6mX0deB8wz8yuN7Prsw3PTcbRB81CZe73U2nXatK6O7ds3b5p8LoFkxPSEMwEdk/cfkO8zTWhtCOnAp8q6lpRNWexfsZbvZA01EuAkTjhnID3AhdmGZSbvHK5Wny2kGtVaQPFafu66oTMGrpO0t1syxP0V2b2m2zDcpOVdjQkYMXiY+objHM1UqpGQSl+xjs5QaUq4x/+f8k4FlcDPsXOtaPCWWylwkpeT2Nyqkox4ZpfqVwtfpTk2sFgfx8rFh9DX8pBjdfTmLxyhWnm1jMQNzVDI3mOXHIfZy8dZedpXcycnkNEfxx+lOTaSamDHRFNH/VEdJNTrmvoVuCdku41s/fVKyBXveKUEmPjE/TkurliwTxvAFzbKe4mStbaKKwlSO7nKivXNdQl6a+BAyR9ofhSrwBdZaVmCvl8atfOkt1ExVOl/btfvXINwanAFqKzht1KXFyDFbqD0gbPQqfbOdeq0mbJ+VqC6pQrVbkOuEzSQ2Z2dx1jcgHSMowmKd7PT5Fdu0qbJdcl+Xe/CiGzhh6Q9FVJw/HlK5JmZB6ZK6tSkW/YVtvVuXaVVtFsi5nnHapCSENwLfAi8NH48gJwXdlHuMyFnvr6KbJrZ4WKZt3aMbuWjxWEC2kI3mJmF5jZI/HlImC/rANz5YUuEPOFZK7dDfb3sTWlwJaPk4UJaQjGJb2ncEPSkYC/uw00NJLn5Vc3V9zPF5K5TpF2wFMYJ3PlhZSqPAy4ASiMC2wEPmZmD2UcW0mdXqqy0iCx1yJ2nWhoJM/ZS0dLZt3t7cmx687TeGpsvKOL10y1VOVq4DBJu8e3X6hxfK4Knl3UuR0N9vexcOloyfvGxicYG58AfMFZmuBcQ2b2gjcCjVNpzUAhu6h/uV2nSstBVMwHkXfkSedaQKE7qNzAlw8Ku06XNpW0FJ9Nt72gNNSusSqtGRD4oLDreMkcRIXxgE2vbWbjpokd9vUDp+1VPCOQtErSZyV5ecoGqXT0Ynh/p3OwLQfRFQvm8fKrpRsBn023o5CuoQXAXsCDkm6WNF8qsXrDZaZ3eq7s/aF9o851gqGRPIu+v/r1AeJiu+S8R7xYxXfEzNab2bnAAcD3iFYaPy7pIkl7ZB1gpxsayfPSK+lrBvzoxrntXb58HRNb06fFb9w04eknigQ1jZLeDnwFuBy4DfgIUaqJ+7ILzUH5L7UXnXFuRyEDwT5zaHsVB4slrQLGgH8CFpvZq/FdP4pXGbsMeTF656qTlpG0WH5s3DOUxkLOCD5iZu8zs+8lGgEAzOyUjOJyRN1CXSnDMT7rwbnSFs0/kFxX2DCmdxFFQhqCP5PUW7ghaaakS7ILycG2tQNbSqQA8XEB59IN9vdx+UcOo7en/CQL8C6igpCG4DgzGyvcMLONwPEhTy7pWEnrJK2XtLjE/V+Q9LCkhyTdK2nf4MjbXNragW7JxwWcq2Cwv4/RCz7AY0tO4LElJ3Dlgnmp+/risrCGoFvSzoUbknqAncvsX9ivG7gKOA44GDhN0sFFu40AA2b2duBW4Muhgbe7tC/nVjNvBJyr0mB/X+o06xkBZw7tLqQhuBG4V9KZks4EfghcH/C4dwHr4xoGrwE3AycndzCz+81sU3xzJbB3eOjtLW0MwMcGnJuctLGDl1/b3PHjBCHrCC4D/gZ4a3z5kpmFHLn3AU8kbj8Zb0tzJlCyNrKkswqlMp955pmAl259Rx80i+KvrI8NODd5g/19vGGXHSdKTmyxjh8nCMo1FBevz6yAvaQzgAHgD1Je/2rgaojqEWQVR7MYGslz26r8drnVBXzonX3eLeTcFIyVSDkBPk4QkmvoFEm/lPS8pBckvSgpJB11HtgncXvveFvx878fOBc4qXh6aqcqNVBswP0/74yzIeey4l2upYWMEXyZ6Ed6hpntbma7mdnuAY97ENhf0lxJOwGnAsuSO0jqB/4xfv6nqw2+HQ2N5FMXw3T6UYtzU1UqVbV3uYZ1Df3WzH5W7ROb2WZJnwOWA93AtWa2VtLFwLCZLSNKWfEG4PtxHrsNZnZSta/VLs4bWsONKzek3t/pRy3OTVUyVXV+bJxuabu1BJ3a9RrSEAxLWgoMAa933ZjZ7ZUeaGZ3AXcVbTs/cf39wZG2maGR/HZ5048+aBY3rtxQsuYq+FGLc7VS+LFP1v7u9BKWIcXrryux2czsk9mEVF47FK8vVYC+UHQ+zZUL5nXkF9S5LKSVfVX8h9iORe6nWrz+E7UPqbOlDQan6evtaasvpHONljbeVjgu7rQzhJBZQwfE6R9+Gt9+u6Tzsg+tfVUz6OtlKJ2rvZDxtk7KQxQya+ga4BxgAsDMHiKaAeQmKXTQV8Dph8/uiCMS5+op9OCqkKq63YU0BNPN7MdF29JLZrmKSk1hKzZzeo4rFszjksFD6xSVc51jsL+PmRVKwBacvXSU84bWZBxRY4U0BL+T9BbibmxJHwZ+nWlUbW6wv49LTzm0bJrc6TtN8zMB5zJ0wYmHVDwgg+iH78aVG9r6zCCkIfgs0aKvgyTlgYXAp7MMqhMM9vex687pY/W+eMy5bBUOyLpTij8lGbT1eEHIrKFHgPdL2hXoMrMXsw+rPRWvHShXTs8XjzmXvVJrCtK0c2nLkJrF5xfdBsDMLs4oprZUvHagXCPgM4Wcq5/i1cbltOuU0pCuoZcTly1EhWbmZBhT2xkayfPFW1ZXPOIAnynkXCMM9vexYvExPLbkBM44fPYOKeAL2nVKaUjX0FeStyX9HVH+IBegXO3hgm6JrWZtuZrRuVZzyeChDOy7BwuXjpa8vx3H70LOCIpNxyuJBUurPZy01YxHl5zAisXHeCPgXBMoV9rSiFJUtNMsopCVxWvi4vIPSVoLrAOuzDyyFjc0kk/NZ1LMB4adaz7l1vsUUlC0S2MQkn30g4nrm4nSUvuCsjJKJZVL41lFnWtOlQaRC+MF7XAWH9I19GLiMg7sLmmPwiXT6FpUpe6gwkBUX28Pl55yaFt8kZxrR4P9fWUP1NolBUXIGcFPiEpObiT6DesFCtVTDNgvk8haWLnBpD4fEHaupVSaJbRw6SgLl4629N92yBnBD4ETzWxPM3sjUVfRPWY218y8EUgojAukzQ/qllr2i+JcpwqdJdTK4wYhDcHhcaUxAMzsbuCI7EJqTYVxgXKDw1vMWvaL4lynqmYyx/jEFi5ctjbDaLIR0hA8Jek8SXPiy7nAU1kH1mpCpolC+y5Ica5dhWQLThobn2i5g72QhuA0YBbwA+D2+PppWQbVSqqZJlrQjgtSnGtXheR0aesKSmm1g72QlcXPAX8paVcze7kOMbWMaqaJJvm6Aeday2B/3+tje+cNreHGlRvKlpdttQR1IQvKjpD0MPCz+PZhkr6ZeWQt4KI71lbdCPi6Aeda2yWDh3LFgnkVzxBaqaBNSNfQFcB84FkAM1sNvDfLoJrd0EieeRfdw8ZNExX37e3JMXN6DuHrBpxrF4UkdVcumJc6ftBKBW1C1hFgZk9o++IN1R0Gt5FquoP6entYsfiYOkTlnGuEwkFdWoK6QkGbZj/4CzkjeELSEYBJykn6X8TdRJ2kMCi8cOmop45wzr2uXII6iMYL+i++p6nPDEIagk8RlavsA/LAvPh2xwhZI5DkXUDOdZZF8w9MrWEAsHHTBItuXd20jUHZriFJ3cDXzOz0OsXTVAqlJUMbgJ5ctzcAznWgwf4+hh9/ruxsookt1rTdRGXPCMxsC7CvpJ3qFE/TqPYsYOb0nDcCznWwwmyicpq1m0hWpnIWgKQbgLcCy4jKVQJgZl/NNrTSBgYGbHh4OPPX6b84bFYQRDODRi/4QMYROedaQTULTLsEW60+ySglrTKzgVL3hcwa+lV86QJ2q2VgzWJoJM+Fy9YyNh798E/PdbFpYmvQY3ty3Vx40iFZhuecayGL5h/Iou+vZmJr+YNsiBoBiM4Uzl46yvDjz3HJ4KEZR7ij1IZA0nfM7E+AMTP7Wh1jqpviBqAgtBFo5bSzzrlsFH4PSv22lGPAd1du4M6Hfs0FJx5S19+V1K6heDXx+4G7gaNg+0HxOPVE+SeXjgW+BnQD3zazJUX37wzcALyTaMHaAjN7rNxzTqZrKDnoKyi7NDyEDwo750JUm4esnKl2I5XrGio3WPwt4F7gIGBV0aXiL3E84+gq4DjgYOA0SQcX7XYmsNHM/jvRCubLKj1vtYoHfafaCPjUUOdcqEXzDyTXVW5iabhkN1Kt09mnNgRm9vdm9lbgWjPbLy5EM7eKgjTvAtab2SNm9hpwM3By0T4nA9fH128F3qeiJcxTFZoeupKeXDdXLpjHisXHeCPgnAsy2N/H5R85jN6eXE2ft9bp7EOyj356ks/dBzyRuP0k8O60fcxss6TngTcCv0vuJOks4CyA2bNnVxVELVI+d0t+FuCcm5Rk5tK0ccnJqGU6+6BcQ41mZlcDV0M0RlDNY/fq7ZlSH52PBzjnaiXZKMDUGoZaprMPSTExWXmiovcFe8fbSu4jaRowgzjLaa2EVhcScMbhs7kyTi/r2UKdc1kb7O9j9IIPcOWCeVV1H9U6l1mWZwQPAvtLmkv0g38q8MdF+ywDPgb8F/Bh4D6rtMKtSoUf8VKzhtJG4f2H3zlXT4UzhXJnCFkuPqu4snhKTy4dD1xJNH30WjP7G0kXA8NmtkzSLsB3gH7gOeBUM3uk3HPWa2Wxc861k6muLJ40M7sLuKto2/mJ668AH8kyBuecc+VlOUbgnHOuBXhD4JxzHc4bAuec63DeEDjnXIfLdNZQFiQ9Azw+yYfvSdGq5SbhcVXH46pes8bmcVVnKnHta2azSt3Rcg3BVEgaTps+1UgeV3U8ruo1a2weV3Wyisu7hpxzrsN5Q+Cccx2u0xqCqxsdQAqPqzoeV/WaNTaPqzqZxNVRYwTOOed21GlnBM4554p4Q+Cccx2ubRoCScdKWidpvaTFJe7fWdLS+P4fSZqTuO+cePs6SfPrHNcXJD0s6SFJ90raN3HfFkmj8WVZneP6uKRnEq//Z4n7Pibpl/HlY3WO64pETL+QNJa4L8v361pJT0v6acr9kvT3cdwPSXpH4r5M3q+AmE6PY1kj6QFJhyXueyzePiqp5ul8A2I7StLzic/r/MR9Zb8DGce1KBHTT+Pv1B7xfZm8Z5L2kXR//DuwVtJfltgn2++XmbX8hSjN9a+A/YCdgNXAwUX7fAb4Vnz9VGBpfP3geP+dgbnx83TXMa6jgenx9U8X4opvv9TA9+vjwDdKPHYP4JH435nx9Zn1iqto/88TpTfP9P2Kn/u9wDuAn6bcfzxwN1GNo8OBH9Xh/aoU0xGF1wKOK8QU334M2LOB79dRwL9O9TtQ67iK9j2RqEZKpu8Z8GbgHfH13YBflPh7zPT71S5nBO8C1pvZI2b2GnAzcHLRPicD18fXbwXeJ0nx9pvN7FUzexRYHz9fXeIys/vNbFN8cyVRJbeshbxfaeYDPzSz58xsI/BD4NgGxXUacFONXrssM/sPopoZaU4GbrDISqBX0pvJ8P2qFJOZPRC/JtTvu1V47UrvV5qpfDdrHVddvl9m9msz+0l8/UXgZ0T13JMy/X61S0PQBzyRuP0kO76Rr+9jZpuB54E3Bj42y7iSziRq9Qt2kTQsaaWkwRrFVE1cH4pPQ2+VVCg72hTvV9yFNhe4L7E5q/crRFrsWb5f1Sj+bhlwj6RVks5qQDwA/0PSakl3Szok3tYU75ek6UQ/qLclNmf+ninqsu4HflR0V6bfr5YoXt8JJJ0BDAB/kNi8r5nlJe0H3CdpjZn9qk4h3QHcZGavSvqfRGdTx9TptUOcCtxqZlsS2xr5fjUtSUcTNQTvSWx+T/xevQn4oaSfx0fL9fITos/rJUWVDIeA/ev4+pWcCKwws+TZQ6bvmaQ3EDU8C83shVo9b4h2OSPIA/skbu8dbyu5j6RpwAzg2cDHZhkXkt4PnAucZGavFrabWT7+9xHg34mOFOoSl5k9m4jl28A7Qx+bZVwJp1J02p7h+xUiLfYs36+KJL2d6PM72cyeLWxPvFdPAz+gdt2hQczsBTN7Kb5+F5CTtCcNfr8Syn2/av6eScoRNQI3mtntJXbJ9vtV64GPRlyIzmweIeoqKAwwHVK0z2fZfrD4lvj6IWw/WPwItRssDomrn2hwbP+i7TOBnePrewK/pEaDZoFxvTlx/Y+AlbZtcOrROL6Z8fU96hVXvN9BRAN3qsf7lXiNOaQPfp7A9oN5P876/QqIaTbRmNcRRdt3BXZLXH8AOLaW71VAbP+t8PkR/aBuiN+7oO9AVnHF988gGkfYtR7vWfz/vgG4ssw+mX6/avrBN/JCNKr+C6If1XPjbRcTHWUD7AJ8P/7D+DGwX+Kx58aPWwccV+e4/g/wW2A0viyLtx8BrIn/ENYAZ9Y5rkuBtfHr3w8clHjsJ+P3cT3wiXrGFd++EFhS9Lis36+bgF8DE0T9sGcCnwI+Fd8v4Ko47jXAQNbvV0BM3wY2Jr5bw/H2/eL3aXX8GZ9by/cqMLbPJb5fK0k0VqW+A/WKK97n40QTSJKPy+w9I+qyM+ChxGd1fD2/X55iwjnnOly7jBE455ybJG8InHOuw3lD4JxzHc4bAuec63DeEDjnXIfzhsC5FJJ6JX2mzP0PBDzHS7WNyrna84bAuXS9RFlrtxOvTMfMjqh3QM5lwXMNOZduCfAWSaNEC5BeIVqgdRBwgKSXzOwNcY6YfyFa2ZkDzjOzf0k+UZwpcimwO9Hf3afN7D/r9j9xrgxfUOZcijgT5L+a2dskHQXcCbzNonTlJBqCaUQ1JV6I8+WsJEoZYol9vgjsYmZ/I6k73v/FhvzHnCviZwTOhftxoREoIuBvJb0X2EqUBvj3gN8k9nkQuDZOLjZkZqNZB+tcKB8jcC7cyynbTwdmAe80s3lEuaN2Se5gUbri9xJlhvxnSX+aYZzOVcUbAufSvUhUOrCSGcDTZjYR5/7ft3iHuJDOb83sGqJkcO8o3se5RvGuIedSmNmzklbEhc7HiY70S7kRuEPSGmAY+HmJfY4CFkmaAF4C/IzANQ0fLHbOuQ7nXUPOOdfhvCFwzrkO5w2Bc851OG8InHOuw3lD4JxzHc4bAuec63DeEDjnXIf7/45zSgjZb6ERAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import sympy\n",
    "\n",
    "# perform X gate with variable exponent\n",
    "q = cirq.GridQubit(1, 1)\n",
    "circuit = cirq.Circuit(cirq.X(q) ** sympy.Symbol('t'), cirq.measure(q, key='m'))\n",
    "\n",
    "# sweep exponent from zero (off) to one (on) and back to two (off)\n",
    "param_sweep = cirq.Linspace('t', start=0, stop=2, length=200)\n",
    "\n",
    "# simulate the sweep\n",
    "s = cirq.Simulator()\n",
    "trials = s.run_sweep(circuit, param_sweep, repetitions=1000)\n",
    "\n",
    "# plot results\n",
    "x_data = [trial.params['t'] for trial in trials]\n",
    "y_data = [trial.histogram(key='m')[1] / 1000.0 for trial in trials]\n",
    "plt.scatter('t', 'p', data={'t': x_data, 'p': y_data})\n",
    "plt.xlabel(\"trials\")\n",
    "plt.ylabel(\"frequency of qubit measured to be one\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Unitary Matrices & decompositions**\n",
    "\n",
    "Many quantum operations have unitary matrix representations. This matrix can be accessed by applying ```cirq.unitary```(operation) to that ```operation```. This can be applied to gates, operations, and circuits that support this protocol and will return the unitary matrix that represents the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unitary of the X gate\n",
      "[[0.+0.j 1.+0.j]\n",
      " [1.+0.j 0.+0.j]]\n",
      "Unitary of SWAP operator on two qubits.\n",
      "[[1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 1.+0.j 0.+0.j]\n",
      " [0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 0.+0.j 1.+0.j]]\n",
      "unitary of a sample circuit\n",
      "[[0.+0.j 0.+0.j 1.+0.j 0.+0.j]\n",
      " [1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
      " [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n",
      " [0.+0.j 1.+0.j 0.+0.j 0.+0.j]]\n"
     ]
    }
   ],
   "source": [
    "print('Unitary of the X gate')\n",
    "print(cirq.unitary(cirq.X))\n",
    "\n",
    "print('Unitary of SWAP operator on two qubits.')\n",
    "q0, q1 = cirq.LineQubit.range(2)\n",
    "print(cirq.unitary(cirq.SWAP(q0, q1)))\n",
    "\n",
    "print('unitary of a sample circuit')\n",
    "print(cirq.unitary(cirq.Circuit(cirq.X(q0), cirq.SWAP(q0, q1))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Decompositions**\n",
    "\n",
    "A lot of gates can be decomposed into an equivalent circuit with simpler operations and gates, this process is called Decomposition & can be accomplished with ```cirq.decompose``` protocol.\n",
    "\n",
    "A Hadamard H gate can be decomposed into X and Y gates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(cirq.Y**0.5).on(cirq.LineQubit(0)), cirq.XPowGate(global_shift=-0.25).on(cirq.LineQubit(0))]\n"
     ]
    }
   ],
   "source": [
    "print(cirq.decompose(cirq.H(cirq.LineQubit(0))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The 3-qubit Toffoli gate equivalent to a controlled-controlled-X gate is another example. Many devices do not support three qubit gates so they have to be decomposed into one and two qubit gates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ───T────────────────@─────────────────────────────────@─────────────────────────────@────────────────────────────@───────────────────────────────────────\n",
      "                       │                                 │                             │                            │\n",
      "1: ───T───────Y^-0.5───@───Y^0.5────@───T^-1────Y^-0.5───@────────Y^0.5───@───Y^-0.5───@──────Y^0.5────@───Y^-0.5───@──────Y^0.5────@───────────────────────\n",
      "                                    │                                     │                            │                            │\n",
      "2: ───Y^0.5───X────────T───Y^-0.5───@───Y^0.5───T────────Y^-0.5───────────@───Y^0.5────T^-1───Y^-0.5───@───Y^0.5────T^-1───Y^-0.5───@───Y^0.5───Y^0.5───X───\n"
     ]
    }
   ],
   "source": [
    "q0, q1, q2 = cirq.LineQubit.range(3)\n",
    "print(cirq.Circuit(cirq.decompose(cirq.TOFFOLI(q0, q1, q2))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Transformers**\n",
    "\n",
    "A transformer can take a circuit and modify (combining or modifying operations to make it more efficient and shorter), though a transformer can, in theory, do any sort of circuit manipulation.\n",
    "\n",
    "The ```cirq.merge_single_qubit_gates_to_phxz``` transformer takes consecutive single-qubit operations and merges them into a single ```PhasedXZ``` operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1): ───X^0.25───Y^0.25───T───\n",
      "(1, 1): ───PhXZ(a=0.304,x=0.333,z=0.142)───\n"
     ]
    }
   ],
   "source": [
    "q = cirq.GridQubit(1, 1)\n",
    "c = cirq.Circuit(cirq.X(q) ** 0.25, cirq.Y(q) ** 0.25, cirq.Z(q) ** 0.25)\n",
    "print(c)\n",
    "c = cirq.merge_single_qubit_gates_to_phxz(c)\n",
    "print(c)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.13 ('python_ai')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "a5af77f05d3bdf18f34d2227fcd1c3aa7be868e46f5c9d85f13e352356a74cc6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}