solutions_tutorial_II_quantum_gates.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solutions Tutorial 2: Quantum Gates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### After going through this 1 hour tutorial you will:\n",
    "\n",
    "- understand pyQuil's wavefunction functionality\n",
    "- be able to visualize quantum states on the Bloch sphere\n",
    "- understand quantum gates on the Bloch sphere\n",
    "- be able to use pyQuil to create shallow circuits\n",
    "- know how to use quantum gate identities to simplify circuits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we need to install [QuTiP](http://qutip.org/) which is a Python toolbox for quantum physicists. We will use it to plot quantum states on the Bloch sphere. If you haven't work with or heard of QuTiP yet then you should definitely check it out (not now though). We also install Cython and pyQuil to be on the safe side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install cython numpy qutip\n",
    "!pip install pyquil"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we need to make sure that we set up our API key & user ID in order to be able to use Rigetti's servers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "API_KEY = 'YOUR API KEY GOES HERE'\n",
    "USER_ID = 'YOUR USER ID GOES HERE'\n",
    "\n",
    "PYQUIL_CONFIG = f\"\"\"\n",
    "[Rigetti Forest]\n",
    "url: https://api.rigetti.com/qvm\n",
    "key: {API_KEY}\n",
    "user_id: {USER_ID}\n",
    "\"\"\"\n",
    "\n",
    "with open(os.path.expanduser('~/.pyquil_config'), 'w') as f:\n",
    "    f.write(PYQUIL_CONFIG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 1. The Bloch sphere"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the [standard quantum computing literature](https://www.google.ca/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=0ahUKEwifzcXS743cAhXs6YMKHX9WCXkQFggqMAA&url=http%3A%2F%2Fwww-reynal.ensea.fr%2Fdocs%2Fiq%2FQC10th.pdf&usg=AOvVaw2C4NgLeXUf1P_DLxSk85_e) we usually write a single qubit as:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\newcommand{\\ket}[1]{\\left|{#1}\\right\\rangle}\n",
    "\\newcommand{\\bra}[1]{\\left\\langle{#1}\\right|}$$\n",
    "$$\\ket{\\psi} = e^{i\\gamma} \\big( \\, \\alpha \\ket{0} + \\beta \\ket{1}\\,\\big)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We know that the probability of measuring the $\\ket{0}$ state is given by the absolute value of its amplitude squared:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$|e^{i\\gamma}\\alpha|^2 = e^{i\\gamma}\\alpha e^{-i\\gamma}\\alpha^\\dagger = e^{i\\gamma - i\\gamma} \\alpha \\alpha^\\dagger = \\alpha \\alpha^\\dagger$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This leads to the important observation that the global phase of $e^{i\\gamma}$ has no impact on the final probability and thus *global phases can always be ignored since they are immeasurable quantities*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, in order to visualize single-qubit states we need to express the qubit amplitudes in the following form:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\ket{\\psi} = \\cos(\\frac{\\theta}{2}) \\ket{0} + e^{i\\phi}\\sin(\\frac{\\theta}{2}) \\ket{1}$$\n",
    "where\n",
    "$$0 \\leq \\theta \\leq \\pi$$ and $$0 \\leq \\phi < 2\\pi$$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From this expression we can obtain the three Cartesian coordinates:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$x = \\sin(\\theta)\\cos(\\phi)$$\n",
    "$$y = \\sin(\\theta)\\sin(\\phi)$$\n",
    "$$z = \\cos(\\theta)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which can be plotted on the three-dimensional unit 2-sphere, also called Bloch sphere which looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qutip import Bloch\n",
    "\n",
    "# Initialize an empty Bloch sphere\n",
    "bloch_sphere = Bloch()\n",
    "bloch_sphere.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 1.0: \n",
    "If you haven't worked with the Bloch sphere before, read about it briefly (!) on [Wikipedia](https://en.wikipedia.org/wiki/Bloch_sphere) and read page 15 in [Nielsen & Chuang](https://www.google.ca/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=0ahUKEwifzcXS743cAhXs6YMKHX9WCXkQFggqMAA&url=http%3A%2F%2Fwww-reynal.ensea.fr%2Fdocs%2Fiq%2FQC10th.pdf&usg=AOvVaw2C4NgLeXUf1P_DLxSk85_e). What does it mean if a quantum state vector lies on the equator of the sphere?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write answer here:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we define two useful functions related to the Bloch sphere that we will need later on. The first one eliminates the global phase and computes $x, y, z$ from $\\alpha$ and $\\beta$. The second function simply plots a given amplitude vector on the Bloch sphere using the QuTiP library. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cmath\n",
    "import numpy as np\n",
    "\n",
    "def get_vector(alpha, beta):\n",
    "    \"\"\"\n",
    "    Function to compute 3D Cartesian coordinates\n",
    "    from 2D qubit vector.\n",
    "    \"\"\"\n",
    "\n",
    "    # get phases\n",
    "    angle_alpha = cmath.phase(alpha)\n",
    "    angle_beta = cmath.phase(beta)\n",
    "    \n",
    "    # avoiding wrong normalization due to rounding errors\n",
    "    if cmath.isclose(angle_alpha, cmath.pi):\n",
    "        angle_alpha = 0\n",
    "    if cmath.isclose(angle_beta, cmath.pi):\n",
    "        angle_beta = 0\n",
    "\n",
    "    if (angle_beta < 0 and angle_alpha < angle_beta) or (angle_beta > 0 and angle_alpha > angle_beta):\n",
    "            denominator = cmath.exp(1j*angle_beta)\n",
    "    else:\n",
    "            denominator = cmath.exp(1j*angle_alpha)\n",
    "\n",
    "    # eliminate global phase\n",
    "    alpha_new = alpha/denominator\n",
    "    beta_new = beta/denominator\n",
    "\n",
    "    # special case to avoid division by zero\n",
    "    if abs(alpha) == 0 or abs(beta) == 0:\n",
    "        if alpha == 0:\n",
    "            return [0,0,-1]\n",
    "        else:\n",
    "            return [0,0,1]\n",
    "    else:\n",
    "        # compute theta and phi from alpha and beta\n",
    "        theta = 2*cmath.acos(alpha_new)\n",
    "        phi = -1j*cmath.log(beta_new/cmath.sin(theta/2))\n",
    "\n",
    "        # compute the Cartesian coordinates\n",
    "        x = cmath.sin(theta)*cmath.cos(phi)\n",
    "        y = cmath.sin(theta)*cmath.sin(phi)\n",
    "        z = cmath.cos(theta)\n",
    "\n",
    "    return [x.real,y.real,z.real]\n",
    "\n",
    "def plot_quantum_state(sphere, amplitudes):\n",
    "    \"\"\"\n",
    "    Thin function to abstract the plotting on the Bloch sphere.\n",
    "    \"\"\"\n",
    "    bloch_sphere = Bloch()\n",
    "    vec = get_vector(amplitudes[0], amplitudes[1])\n",
    "    bloch_sphere.add_vectors(vec)\n",
    "    bloch_sphere.show()\n",
    "    bloch_sphere.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 2. pyQuil's wavefunction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rigetti initializes all their qubits in the $\\ket{0}$ state. Let's verify this by running a simple pyQuil program and visualizing the resulting quantum state on the Bloch sphere."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 2.0: \n",
    "Read the pyQuil docs and learn how to obtain the wavefunction and its amplitudes to visualize the initial qubit state on the Bloch sphere."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyquil.api import QVMConnection\n",
    "from pyquil.quil import Program\n",
    "\n",
    "# initialize a QVMConnection with Rigetti's server\n",
    "qvm = QVMConnection()\n",
    "\n",
    "# initialize a pyQuil program that measures the initial qubit state\n",
    "p = Program()\n",
    "p.measure(0, 0)\n",
    "\n",
    "# TODO: find out how to get the resulting wavefunction + amplitudes after running the program in the QVM\n",
    "wavefunction = qvm.wavefunction(p)\n",
    "amplitudes = wavefunction.amplitudes\n",
    "\n",
    "# now we can call our custom function to plot the quantum state\n",
    "plot_quantum_state(bloch_sphere, amplitudes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "pyQuil's Wavefunction has a lot of very helpful functionalities like obtaining probabilities from amplitudes, plotting as well as pretty printing them. \n",
    "\n",
    "#### Exercise 2.1:\n",
    "Explore pyQuil's wavefunction functionalities. Plot and pretty print the probabilities!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Try getting the probabilities from a wavefunction object and plot & pretty print the result!\n",
    "\n",
    "print('Plotting the probabilities:')\n",
    "wavefunction.plot()\n",
    "\n",
    "print('Pretty printing the wavefunction: \\n')\n",
    "print(f'{wavefunction.pretty_print()} \\n')\n",
    "\n",
    "print('Pretty printing the probabilities: \\n')\n",
    "print(wavefunction.pretty_print_probabilities())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 3. The Hadamard gate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous tutorial you've already familiarized yourself with a really important quantum gate: the Hadamard gate. In Dirac notation the H gate corresponds to the matrix given by:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$H = \\frac{1}{\\sqrt{2}} \\begin{bmatrix}\n",
    "1 & 1 \\\\\n",
    "1 & -1\n",
    "\\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Hadamard is an essential ingredient to create quantum superposition states. In the following exercises you will further explore it's use cases and intricacies."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 3.0:\n",
    "Import and apply the Hadamard gate one time and observe how the plot of the probability distribution changes! What do you observe?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TODO: import the Hadamard gate\n",
    "from pyquil.gates import H\n",
    "\n",
    "p = Program()\n",
    "# apply the Hadamard gate to qubit 0 once\n",
    "p.inst(H(0))\n",
    "\n",
    "# TODO: get the wavefunction from the QVM \n",
    "# and plot the probability distribution\n",
    "wavefunction = qvm.wavefunction(p)\n",
    "wavefunction.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 3.1:\n",
    "In three different experiments, apply the Hadamard gate two, three, and four times in sequence and observe how the probability distribution changes! What do you observe?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(2, 5):\n",
    "    # TODO: apply the Hadamard gate multiple times\n",
    "    p = Program(H(0) for k in range(i))\n",
    "    \n",
    "    # TODO: get the wavefunction from the QVM \n",
    "    # and plot the probability distribution\n",
    "    wavefunction = qvm.wavefunction(p)\n",
    "    print(f'Probabilities after applying H {i} times:')\n",
    "    wavefunction.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 4. Pauli gates on the Bloch sphere"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 4.0:\n",
    "Explore the action of the Pauli gates (Identity, $X$, $Y$, $Z$) on the Bloch sphere. <a title=\"Try using a H gate first to move the Bloch vector onto the equator and then apply the X, Y or Z gate to observe the rotation. Also try applying an H gate and an S gate to move the initial vector onto the y axis.\">Hint.</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# TODO: import the Pauli gates (Identity, X, Y, Z).\n",
    "from pyquil.gates import I, X, Y, Z\n",
    "\n",
    "def apply_pauli_gates(initial_state, state_name):\n",
    "    \"\"\"\n",
    "    Given a program that initializes an initial state this function\n",
    "    will apply each Pauli gate once and plot the resulting state\n",
    "    on the Bloch sphere.\n",
    "    \"\"\"\n",
    "    \n",
    "    for pauli_gate in [I(0), X(0), Y(0), Z(0)]:\n",
    "        p = Program()\n",
    "        p.inst(pauli_gate)\n",
    "        p = initial_state + p\n",
    "        amplitudes = qvm.wavefunction(p).amplitudes\n",
    "        print(f\"{pauli_gate.name}'s action on the {state_name} state:\")\n",
    "        plot_quantum_state(bloch_sphere, amplitudes)\n",
    "\n",
    "# TODO: try I, X, Y, Z on different initial quantum states!\n",
    "\n",
    "from pyquil.gates import H, S # needed to get initial state to x or y axis\n",
    "\n",
    "# |+z> = |0>\n",
    "apply_pauli_gates(Program(), '|+z>')\n",
    "\n",
    "# |-z> = |1>\n",
    "apply_pauli_gates(Program(X(0)), '|-z>')\n",
    "\n",
    "# |+x> = 0.707 |0> + 0.707 |1>\n",
    "apply_pauli_gates(Program(H(0)), '|+x>')\n",
    "\n",
    "# |-x> = 0.707 |0> - 0.707 |1>\n",
    "apply_pauli_gates(Program(X(0), H(0)), '|-x>')\n",
    "\n",
    "# |+y> = 0.707 |0> + 0.707i |1>\n",
    "apply_pauli_gates(Program(H(0), S(0)), '|+y>')\n",
    "\n",
    "# |-y> = 0.707 |0> - 0.707i |1>\n",
    "apply_pauli_gates(Program(X(0), H(0), S(0)), '|-y>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 4.1:\n",
    "How many degrees around which axis do the Pauli gates rotate the Bloch vector? Make sure to also try other initial states (e.g. Bloch vector on $x$, $-x$, $y$ or $-y$ axis)!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write answer here:\n",
    "\n",
    "- Identity: no rotation\n",
    "- X: 180 degrees around the X axis\n",
    "- Y: 180 degrees around the Y axis\n",
    "- Z: 180 degress around the Z axis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 4.2:\n",
    "pyQuil has many different ways of defining a quantum program. Read the docs and try it below (print the final programs to understand the effect):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Try out different possibilities of chaining instructions\n",
    "\n",
    "# try putting multiple gates into a single .inst() call\n",
    "p = Program()\n",
    "p.inst(H(0), H(1), H(2))\n",
    "print(f'Many gates in one .inst() call:\\n{p} \\n')\n",
    "\n",
    "# chain multiple .inst() call after each other and add a final MEASURE or .measure statement\n",
    "p = Program()\n",
    "p.inst(H(0)).inst(H(1)).inst(H(2)).measure(0,0)\n",
    "print(f'Chained .inst() calls:\\n{p} \\n')\n",
    "\n",
    "# try to mix the two possibilities above\n",
    "p = Program()\n",
    "p.inst(H(0)).inst(H(1), H(2)).measure(0,0)\n",
    "print(f'Mixing the two:\\n{p} \\n')\n",
    "\n",
    "# use a Python generator to populate a Program\n",
    "p = Program()\n",
    "p.inst(H(i) for i in range(3))\n",
    "print(f'With generator:\\n{p} \\n')\n",
    "\n",
    "# define three programs and then ADD them together and print it. What do you observe?\n",
    "p0 = Program().inst(H(0))\n",
    "p1 = Program().inst(H(1))\n",
    "p2 = Program().inst(H(2))\n",
    "p = p0 + p1 + p2\n",
    "print(f'With addition:\\n{p} \\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 4.3:\n",
    "Use the last program from the previous exercise and try calling the `.pop()` function. Print the program again. What do you observe?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Use .pop() on the last program from Ex. 4.4\n",
    "print(f'Before .pop():\\n{p}')\n",
    "p.pop()\n",
    "print(f'After .pop():\\n{p}')\n",
    "\n",
    "# Observation: it pops/deletes the last quantum gate in the Program"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 5. Quantum gate identities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Current quantum computers only allow shallow depth circuits since the qubits decohere too quickly. Thus, it is extremely important to keep your circuits small! In this section you will use pen & paper to learn how to manually simplify quantum circuits.\n",
    "\n",
    "By the way, there is a lot of people (including Rigetti staff) working on automating this task. They are working on developing more efficient and better **quantum compiler**. If you're interested in diving deeper in quantum gate identities than consider tackling Bonus Exercise 7.6!"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfYAAADbCAIAAAAQzCS3AAAAA3NCSVQICAjb4U/gAAATMUlEQVR4Ae2c7ZYjKa5FO2fl+79yXfpSo2EhR5gPESHE7h+zIrEQ0j7yMeWqyZ8/f/78w38RCfz8/ERsq7snJrwb2fUGhiqz2Wio/nOtJq9AIAIBXCmCis562Giofjb6OHKmsutyNhrBJzky7TO0GaqP9JwPFbf4j6qxCAEIQCACgd8ITdDDNQHnV4zrwi1f4fppSfOffxiqxHOXoeIWbzv8ZIMABCDgiAAW70gMSoEABCBgSwCLt+VJNghAAAKOCGDxjsSgFAhAAAK2BLB4W55kgwAEIOCIABbvSAxKgQAEIGBLAIu35Uk2CEAAAo4IYPGOxKAUCEAAArYEsHhbnmSDAAQg4IgAFu9IDEqBAAQgYEsAi7flSTYIQAACjghg8Y7EoBQIQAACtgSweFueZIMABCDgiMBv/n1pu//qOPmtb7s34mg0KAUCENifwN9bvFjk/h3RAQQgAAEI/CUQ5IsaLu9MNAQgAAFNIIjFS2P8cURQ8AABCEAgjsVzkWeaIQABCFQE4li8NMZFXlDwAAEIHE4goMUfrijtQwACEBACoSye72pEVx4gAAEIJAKhLF4U5bsaQcEDBCBwMoHfk5un9wECYx+f+g9YA3l0koH62eKQwMAwpC70PAzk0Ukc8pkpKdotPrxgM2K/tRdR3iIf+FyGqlHcsLf49HnOEDQOQVeYplpdnXTAx/xVWJUkbakCPiZhMQYBrXU1DzrgY+NVWJUkbakCPiYJthjtFn+misGGEhHjCeqhowP9PWEPaPEyTPozXF7iwYoAkK1IkkcIMFSCYv4h7Bc182jIMEDgzIvSAKhyS+VoMCzhpGeAVEC6foxp8WkmqrdNFxSCHyZQiXXIW7rqWpjn9UMgSNfmDxXeY3lG/qImDU0ls/kYkRACAwTSWH6dzJaYgaPZchqBsBZ/7If2kxP81aeeLGaXs7qgdQXvQuC+zgNbvgcy+aqxxSd5vCnkrZ5JwTxv52P1qzoD0ziw5WsZGwUwVJNi2XwXX01h/rHS5uPiZPVsD0CgGp5qbAI0KC1Uncr614e0MTCWr+0PBFSoT6Y3a/GCsoKY1tN/spieB3Sa3JJOf+XcybLZDgEIQMCKwPgXNf9a+H+NW6xcysorOUDC5NWHH14v4OF+nzkOql2cJ3FNbu8q9cXgQ9p8kvCgxZdKaH/PDZQuX6482R5nPUbgagweK4CD4hFgqOY1HbH4Fn+fr8wkAyNignFdknKW0inodYO6YnUTefhLFajDh2rE4tsHyA/cSvX2FoiEwDwBxm+eIRnGCHT/dWs5rIYOXqYtO5k/ImW4Sl4exHMXAZB24SK4hQBD1UKpN6bP4ns1KOOvzFpiqoC8nv63Wu/tUOJtU0laHhIBK41Ww5RhW33Qovy719+FhaHqwnUVPP5FjYkAMrI6W1rJixJz1QPrmxKolM1yb9oLZTshwFBVQnTc4it2VaKBHyXh1/d2ivwac1NA2itn3YTx0jAB8A6jY+MVAYbqikzXeofFd+W1ChZ3nnT5XI9JEqvW9s1TvfeGP32rPPsCofJ5AtUwMFTzSHOGVosfEKDcogWTV/VLVr2ty+O/ZsG7DsKOmV8Ubl6RF4vPWs+3sOPMfK35dV3uKxz/Lv4+74pX5yfMuRgroLnNWakZXprJBie3ux0D28JOG6oWejtZfEs/H2Mq4T/GsAgBCEAgHoERi5+/UHR57vxxWTarPPGGoKujLu26MocPHp7A4Y27IGWo1inVZPEDApRbwg/oOnn8Z0bcLo0GcA1s6SrJYfCBLa9Tocni1x3/QObyw+aB4ziihUAlylFv6a5mu4JbyAeOOXmobmTdzOIrFW8aq17irVIB4ccXCaRp/DqQLTEvtsDRuxBo/UeTu/RT1Tn8kVDl4cdMAJ6Gk1C6vIAtFw3P8pxKevdc5L61Nd3ie8eu1Kx3774oD6wccQ8UfXXLDJUt4SaLtz3y+WwMzfPMb04sbwApDHVuWPFSIwGG6gqUvcVXrK8OfmDdTyUPNMsREIAABDSBVotvvGo5dNXGyjUaVioCDsWtKuTH7QgwVKsla7X4so4rVfT6i/aqiylb4HmewIvizhdPBp8EGCpzXTos/p5+ttT7mPnqV+efr5AM9wSqj14EvcfFqy0EGKobSn3/aDK9ITPNimk6wOd71WdVN3rwEgQgAAFDAn0Wnw4W0xSXlxXDsiZTSW2TedguBEAqKHiwIsBQWZG8ydNt8ZLro7OXmn0MkO3tD2XO9l1ELiVgJe7SIkm+FwGGaoVeHd/FGx7/jJbPnGKIxW0qq09ZqzxuQVFYOwGrYbDK0175XpHjt/jn+2y0bCSfl+YrQx2g1dExurAqRifRW1jZlEClte5CB+h50DFf8+gkekvglXdu8SXQFs3K+Mbnw3VtpPQxbJEiH89i8RACDNVbQlve4ksVvzpsCijjrfpfkdOqtl3yfNWusRGrPI3HEeaZgNUwWOXxzMq2tjdv8aLWjS/LSxJs2z/ZIAABCAQm8KbFl1jFyj8u9vp7b3x5KM8QgAAEwhB42eKTF4sdly6fnuVHCfgKXbZ8jSQAAhCAwAkEbL6Ln/TWbOL/mvrPj0Bvd3bZkh+GN1Z5+BECEIDA7gTGLb60Y02hfLXRcxvD9Fl5pTzxKoZ1CEAAAkcRePmLmqNY0ywEIACBhwmM3+InL92L+vRZ1aJmSQsBCEDgnkCQWzzf0tzLzKsQgMCZBP5a/O6X31z/7l2cOYJ0DQEIrCPwG8YWwzSyTmwyQwACpxEI8kXNabLRLwQgAIEWAlh8CyViIAABCGxJAIvfUjaKhgAEINBCAItvoUQMBCAAgS0JYPFbykbREIAABFoIYPEtlIiBAAQgsCUBLH5L2SgaAhCAQAsBLL6FEjEQgAAEtiSAxW8pG0VDAAIQaCGAxbdQIgYCEIDAlgTGf9Pklu2eVzS/oI3fbGE+9QzVRkPFLd58/knoiwB+5EuPENVsNFTc4kNMnGoi3TI2mkJVvvHCRncu485N0zFUJc5dhopbfKkazxCAAARCEeAWH0rOspldbhllzTw7J8BQORdIl8ctXjNhBQIQgEAQAlh8ECFpAwIQgIAmgMVrJqxAAAIQCEIAiw8iJG1AAAIQ0ASweM2EFQhAAAJBCGDxQYSkDQhAAAKaABavmbACAQhAIAgBLD6IkLQBAQhAQBPA4jUTViAAAQgEIYDFBxGSNiAAAQhoAli8ZsIKBCAAgSAEsPggQtIGBCAAAU0Ai9dMWIEABCAQhAAWH0RI2oAABCCgCWDxmgkrEIAABIIQwOKDCEkbEIAABDQBLF4zYQUCEIBAEAJYfBAhaQMCEICAJoDFayasQAACEAhCAIsPIiRtQAACENAEsHjNhBUIQAACQQhg8UGEpA0IQAACmgAWr5mwAgEIQCAIASw+iJC0AQEIQEATwOI1E1YgAAEIBCGAxQcRkjYgAAEIaAJYvGbCCgQgAIEgBLD4IELSBgQgAAFNAIvXTFiBAAQgEIQAFh9ESNqAAAQgoAlg8ZoJKxCAAASCEMDigwhJGxCAAAQ0gV+9xEoMAj8/PzEame/iz58/80nIkAgwVDIGuwwVt3iRjAcIQAAC0Qhwi4+maO6H21apq9DY5eZVFu/nWTD6KenFSoSG86HiFv/ikHD0EwScvwOfQMAZ1gQ2Gipu8dbiO8u30Sw6I0c5lwQYqks0/l7gFu9PEyqCAAQgYEQAizcCSRoIQAAC/ghg8f40oSIIQAACRgSweCOQpIEABCDgjwAW708TKoIABCBgRACLNwJJGghAAAL+CGDx/jShIghAAAJGBLB4I5CkgQAEIOCPABbvTxMqggAEIGBEAIs3AkkaCEAAAv4IYPH+NKEiCEAAAkYEsHgjkKSBAAQg4I8AFu9PEyqCAAQgYETgN//W491/ddwuv7vZSDXSQAACEGgi8PcWLxbZtIkgCEAAAhDYgUCQL2p2/1PIDqNCjRCAwH4Egli8gOePI4KCBwhAAAJxLJ6LPNMMAQhAoCIQx+KlMS7ygoIHCEDgcAIBLf5wRWkfAhCAgBAIZfF8VyO68gABCEAgEfgNSSF9V4Pdh1Q2WFP6S8VyhRkOJvcr7cS0+FdQHnJo6UHtLWu3Gsijk7QX4CqysfccFqbrGwkagVQZNJmBPDpJdcruP0az+CTYgMy7q+i8/vDvonb+MpwVk5v1/FIV335i1EiANCobzeKl7fTGYAiEhuGDpir2lE/RAR9Pr8KqJGlLFfAxyUaL0mBXXzk47c3bu/ZuBEf3lfuVFnSAvFQ+VGFVkhRZBZR7oz6H+uvWLNKBKsabzmAiikGP9ZV25Y3as+JJv66jzHBdfp+ZA1q8gOb9ICjWPQD5K1vx96+R9wHnuDxDdT8JXa9GtvguEASbEDjzonSDzsrf8xHnuHyJlKEqafQ+x7R4ZqJ3Dt6Nr25tYeSz9fes0ZkuPzCfUYeqF0VMixcKlcyyzgMEVhNY4e+5Zlx+tXaR8oe1+DA3Qc/TxifolTrr/D2fGNjlGaqroRpbN7b4JI83hbzVM6bTFrv4WC1lgkZJY/gZjMPo8kYbi/9/Y/+fuecfq8o+LlYx/HgggTQYZdcB3tJVR2V3hs8Z1DNnGZb9TKoKS4ChGuY2+399EpQVxLSe/pPF9Dxc4vDGdPor5w4XzMYwBGTyw3REI5sSGL/F/2vh/zVuPdB5JQdI2FuMXi/grcaXngvVj3ifxFK+yz4Ws93ik/S2gzNW8KDFl0pof8+l6Pm7ihwrnV2uCCCuKzliFMNQzes4YvEt/j5fmUkGRsQE47ok5SylU2LoFaOLdaKvzhxyqIahjVh8+2F+Zr1Svb0FIiHgmYCft5hnSifX1m3xpVcuGq90RHnKpDyLipysavfthgLtjoL6rQgwVFYkyzx9/6KmV4MyvsVqy/iySpPnlLylhpazltbZUoC3GCuwq/t6RriZU8b2ju1aTXsyP0M1CTBv77P48sh5AULOZYmI53sC1QDMT9T9cbx6AgGGqlK5w+IrdlWiyR/z23vRESn5osyTXYfZDt4wUvpphKEy0aLD4k3OK5M8f2tLQ/P8oWXLMZ6r994w0ipPDDh0MUagGgaGagyj3tVq8QMClFuGBdMVe1jx304J3wMxJzWsFi5jHzsl7X14Y68oDNVHYmOqfUy1YrH7X9SsKOKxnM7FeIyDh4Mqv4ghTYwuPIzHWA0hh2oMhew6wuIr4aV5HiCwOwFme3cFV9c/YvGbXlU2LXv1BPTmx1O+EgPRV0RVAMQqIIY/Nln8gADlFrzVUDBvqRD3dUXiSRCvoxeHpMniX6xv/ujyw2Y+GxlMCFSiRHpL516qBk2g6STPnKLP9blS0Yg0VDPA41t8poPeM1PCXghAYFMCwS2++mDfVCQ/ZcOzRYtnLvJZiwB3F4aqZaiGY5osvneMSs169w53wsbnCSDu88zDn8hQ2UrcZPG2Rz6fjaF5nvnNieUNIIWFVCc3VXV6w6T3pZw5JLpeFDm+Qg0ZwWhv8RVrOen5Bz+VPN87J75OYJ3L4++vi7tRAa0W3/ip6NBVGyvfSLO3SnUo7lsoGs9d4fLB/J2hapyl4bBWiy8PuFJFr79or7qYsgWe5wm8KO588Y9lsHX5PNWByQdu7bGRqw7qsPh7+uGHrwLHj2MEqo/e+6EaO8Lbrtxj1fhAkbzFrqBVbE8YqisUer31N03mnYldplkxTa/6xOqzKi0DK7EJ5DfOsEfL2415jj0nK7rrs/hUgQyZ57GT2lYgOzMnSCd1z2+chFFIylvpKrNEpoCvwVdJPK+XDXquc+vaui1euv04c6VmHwNkOw9bE0DcMfkyt/w2Kd8sOZteSevnoD6n07HhGds1bvFj5z25i4mxov3RegaSW+UZONrVFpnMGyAS46pyw2Jueu86xSpP16EbBQe0eCSfn7+vDHWAtiQdowurYnQSvSXSylH9VlprHXWA5qNjvubRSfSWwCsd/6JmLwqH6zojVsu7aCY/ew8kwFC9JbrlLb5U8S2HLWt4i+nu51ppZ5Vnd57UnwhYDYNVnnNECXuLP0dCOoUABCBwRcDyFn91xv361b27XO/96O6Nv6+QVyEAAQhsSuBNiy9N/B5fjvxq3O0J74/jVQhAAAIxCNhY/Ji3frXsMcSL0o4Vwy4IQAACLxIYt/h7Wy9ffcZzyxNfBMrREIAABPwQ4K9b/WhBJRCAAASMCYzf4p+5m/e267Oq3i6IhwAEIGBCIMgtnm9pTKaBJBCAQDACfy1+98tvrn/3LoLNFu1AAAKvE/gNY4thGnl9JigAAhAIQyDIFzVh9KARCEAAAoYEsHhDmKSCAAQg4IsAFu9LD6qBAAQgYEgAizeESSoIQAACvghg8b70oBoIQAAChgSweEOYpIIABCDgiwAW70sPqoEABCBgSACLN4RJKghAAAK+CGDxvvSgGghAAAKGBLB4Q5ikggAEIOCLwPhvmvTVB9VcEOAXtPGbLS5GY3yZodpoqLjFjw86O7cggB9tIdNeRW40VD8bfRztNQSvV7vRFK5mxZBbEWaohOQuQ8UtXiSL9rDLCEbjHrofhmo7ef8PzVaLlqgnpfwAAAAASUVORK5CYII="
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"attachment:image.png\" width=\"300\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pen & Paper Exercise 5.0\n",
    "Go through the math of the quantum circuit shown above by explicitly multiplying the matrices. What does this circuit reduce to? <a title=\"You have to take the tensor product H x H (numpy.kron) in order to get a 4x4 matrix.\">Hint.</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write your answer here: It reduces to a CNOT with source and target qubit interchanged."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 6. Notation in quantum computing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 6.0:\n",
    "Write a short pyQuil program which implements an $X$ gate on qubit $0$ and an identity gate on qubit $1$. BEFORE you print the wavefunction, write down what qubit string you expect. Then contrast it with the result. Did you expect it? Why or why not? Check out Bonus Exercise 7.5 for explanation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from pyquil.gates import X, I\n",
    "\n",
    "p = Program()\n",
    "\n",
    "# TODO: implement an X gate on qubit 0 and an identity gate on qubit 1\n",
    "p.inst(X(0), I(1))\n",
    "\n",
    "# TODO: print the wavefunction\n",
    "print(qvm.wavefunction(p))\n",
    "\n",
    "# Observation: the qubits are ordered in reverse |q_N,..., q_1, q_0>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 7. Bonus exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bonus Exercise 7.0:\n",
    "pyQuil comes with a lot of already implemented quantum gates. In this exercise it is your goal to manually implement your own single qubit gate. Try to define the following gate manually:\n",
    "$U =  \\begin{bmatrix}\n",
    "e^{i\\frac{2}{3}\\pi} & 0 \\\\\n",
    "0 & e^{-i\\frac{2}{3}\\pi}\n",
    "\\end{bmatrix}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Implement custom single-qubit rotation with pyQuil\n",
    "\n",
    "# implementing u\n",
    "u = np.array([[cmath.exp(1j*(2/3)*cmath.pi), 0], [ 0, cmath.exp(-1j*(2/3)*cmath.pi)]])\n",
    "\n",
    "# define the new gate\n",
    "p = Program().defgate(\"U\", u)\n",
    "\n",
    "# now we can use it in a Program\n",
    "p.inst((\"U\", 0))\n",
    "\n",
    "print(qvm.wavefunction(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bonus Exercise 7.1:\n",
    "There is many more elementary quantum gates than just Pauli gates! Try out the $T$ and $S$ gates and find out which rotations they correspond to. You might want to quickly read up on them in [Nielsen & Chuang](https://www.google.ca/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=0ahUKEwifzcXS743cAhXs6YMKHX9WCXkQFggqMAA&url=http%3A%2F%2Fwww-reynal.ensea.fr%2Fdocs%2Fiq%2FQC10th.pdf&usg=AOvVaw2C4NgLeXUf1P_DLxSk85_e)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: import the T and S gate\n",
    "from pyquil.gates import T, S\n",
    "\n",
    "initial_state = Program().inst(H(0))\n",
    "amplitudes = qvm.wavefunction(initial_state).amplitudes\n",
    "\n",
    "print(\"Initial state (|+>):\")\n",
    "plot_quantum_state(bloch_sphere, amplitudes)\n",
    "\n",
    "# TODO: try T and S on different initial quantum states!\n",
    "\n",
    "# testing the S gate\n",
    "p = Program()\n",
    "p.inst(S(0))\n",
    "p = initial_state + p\n",
    "amplitudes = qvm.wavefunction(p).amplitudes\n",
    "\n",
    "print(\"S gate's action on the |+> state:\")\n",
    "plot_quantum_state(bloch_sphere, amplitudes)\n",
    "\n",
    "# testing the T gate\n",
    "p = Program()\n",
    "p.inst(T(0))\n",
    "p = initial_state + p\n",
    "amplitudes = qvm.wavefunction(p).amplitudes\n",
    "\n",
    "print(\"T gate's action on the |+> state:\")\n",
    "plot_quantum_state(bloch_sphere, amplitudes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bonus Exercise 7.2:\n",
    "What rotations on the Bloch sphere do the T and S gate correspond to?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write answer here:\n",
    "\n",
    "- S gate rotates 90 degrees around the Z axis\n",
    "- T gate rotates 45 degrees around the Z axis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bonus Exercise 7.3:\n",
    "How would you describe the rotation of the Hadamard gate on the Bloch sphere? How many degrees around which axis? Make sure to not just check how it acts on the $\\ket{0}$ or $\\ket{1}$ state! Try for example to prepare the state $$\\ket{\\psi} = \\frac{1}{\\sqrt{2}}\\ket{0} + \\frac{i}{\\sqrt{2}}\\ket{1}$$ (y-axis on Bloch sphere) and then act the H gate on it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write answer here:\n",
    "\n",
    "- The Hadamard gate rotates 180 degrees around the Z+X axis\n",
    "- You can also visualize it as a 90 degree rotation around Y followed by a 180 degree rotation around X "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bonus Exercise 7.4:\n",
    "Read the pyQuil docs and learn about parametric gates. Then try to manually create a parametrized controlled U gate with:\n",
    "\n",
    "$$U =  \\begin{bmatrix}\n",
    "1 & 0 \\\\\n",
    "0 & e^{i\\phi}\n",
    "\\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyquil.parameters import Parameter, quil_exp\n",
    "from pyquil.quilbase import DefGate\n",
    "from pyquil.gates import X\n",
    "# TODO: Manually create a parametric controlled U gate\n",
    "\n",
    "phi = Parameter('phi')\n",
    "u = np.array([[1, 0], [0, quil_exp(1j*phi)]])\n",
    "\n",
    "dg = DefGate('U', u, [phi])\n",
    "U = dg.get_constructor()\n",
    "\n",
    "p = Program()\n",
    "p.inst(dg) # register the new gate\n",
    "\n",
    "p.inst(X(0))\n",
    "p.inst(U(cmath.pi/4)(0)) # use the new gate\n",
    "\n",
    "print(qvm.wavefunction(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bonus Exercise 7.5:\n",
    "Read the paper with the title ['Someone shouts, “$\\ket{01000}$!” Who is excited?'](https://arxiv.org/pdf/1711.02086.pdf) by Rigetti staff member Robert Smith to gain a deeper understanding why we label qubits the reverse way ($\\ket{q_N, ..., q_1, q_0}$ rather than $\\ket{q_0, ..., q_{N-1}, q_N}$)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bonus Pen & Paper Exercise 7.6:\n",
    "Consider the quantum circuit below. Use [this paper](https://arxiv.org/pdf/quant-ph/0307111.pdf) and other sources to simplify and condense the quantum circuit as much as possible."
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This circuit can be reduced to:\n",
    "\n",
    "<img src=\"attachment:image.png\" width=\"200\">\n",
    "\n",
    "by using the following identities:\n",
    "\n",
    "$$XX = \\mathbb{1}$$\n",
    "$$YY = \\mathbb{1}$$\n",
    "$$ZZ = \\mathbb{1}$$\n",
    "$$HXH = Z$$\n",
    "$$HZH = X$$\n",
    "$$HYH = -Y$$\n",
    "$$\\text{Two consecutive CNOTs} = \\mathbb{1}$$\n",
    "$$\\text{CNOT surrounded with Hadamards} = \\text{inverted CNOT}$$"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}