solutions_tutorial_III_shallow_circuits.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solutions Tutorial 3: Shallow Circuits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### After going through this 1 hour tutorial you will:\n",
    "\n",
    "- know what a universal quantum gate set is\n",
    "- be able to decompose quantum gates using universal gate sets\n",
    "- know how to manually initialize quantum states\n",
    "- know [pyQuil](https://github.com/rigetticomputing/pyquil)'s quantum algorithm library [Grove](https://github.com/rigetticomputing/grove)\n",
    "- understand how to simulate Hamiltonians on universal quantum computers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As always, we first need to make sure that pyQuil is installed and 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": [
    "!pip install pyquil"
   ]
  },
  {
   "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. Universal quantum gate set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most near-term quantum computers have a limited set of quantum gates which can be implemented on the hardware level. For example, Rigetti implements only two single-qubit and one two-qubit gate on the QPU. More specifically, these are $RZ(\\theta)$, $RX(\\frac{k\\pi}{2})$, and a controlled $Z$ ($CZ$) defined as:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\newcommand{\\ket}[1]{\\left|{#1}\\right\\rangle}\n",
    "\\newcommand{\\bra}[1]{\\left\\langle{#1}\\right|}$$\n",
    "$$R_Z(\\theta) = \\begin{bmatrix}\n",
    "    e^{-i\\frac{\\theta}{2}} & 0 \\\\\n",
    "    0 & e^{i\\frac{\\theta}{2}}\n",
    "    \\end{bmatrix}$$\n",
    "    \n",
    "$$R_X(\\frac{k\\pi}{2}) = \\begin{bmatrix}\n",
    "    \\cos\\frac{k\\pi}{4} & -i\\sin\\frac{k\\pi}{4} \\\\\n",
    "    -i\\sin\\frac{k\\pi}{4} & \\cos\\frac{k\\pi}{4}\n",
    "    \\end{bmatrix}$$\n",
    "    \n",
    "$$CZ = \\begin{bmatrix}\n",
    "    1 & 0 & 0 & 0 \\\\\n",
    "    0 & 1 & 0 & 0 \\\\\n",
    "    0 & 0 & 1 & 0 \\\\\n",
    "    0 & 0 & 0 & -1 \\\\\n",
    "    \\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At first, this set of quantum gates might seem very small. Especially considering that we just learned in Lecture II that there are infinitely many quantum gates (since the only requirement is unitarity)! However, there is a very important theorem at the core of quantum theory:\n",
    "\n",
    "###### The Solovay-Kitaev theorem\n",
    "Let $G$ be a universal quantum set consisting of quantum gates from SU(2) and\n",
    "let $\\epsilon > 0$ be a desired accuracy. Then there is a constant $b$ such that for any single-qubit\n",
    "gate $W \\in$ $SU(2)$ there exists a finite gate sequence $\\tilde{G}$ of gates from the set $G$ of length\n",
    "$\\mathcal{O}(\\log^b (\\frac{1}{\\epsilon}))$ such that $d(W, \\tilde{G}) < \\epsilon$. In their proof, Dawson and Nielsen (2005) show that $b \\approx 3.97$.\n",
    "\n",
    "In other words, using a universal quantum gate set we can approximate any circuit containing $m$ CNOTs and single qubit unitaries to an accuracy $\\epsilon$ with $\\mathcal{O}(m \\log^b (\\frac{m}{\\epsilon}))$ gates. That's a polylogarithmic increase in size compared to the original circuit which is very acceptable for almost all applications.\n",
    "\n",
    "And of course Rigetti's set of three quantum gates is universal. **Hence, any quantum circuit can be constructed from this universal set of quantum gates!**\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Lecture II on quantum gates and notation we've been discussing the four Pauli gates I, X, Y and Z as well as the Hadamard gate. For the next exercises, we've manually implemented these four gates as matrices using `numpy.matrix`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "pauli_I = np.matrix([[1, 0],[0, 1]])\n",
    "print(f'Identity gate matrix: \\n {pauli_I} \\n')\n",
    "pauli_X = np.matrix([[0, 1],[1, 0]])\n",
    "print(f'Pauli X gate matrix: \\n {pauli_X} \\n')\n",
    "pauli_Y = np.matrix([[0, -1j],[1j, 0]])\n",
    "print(f'Pauli Y gate matrix: \\n {pauli_Y} \\n')\n",
    "pauli_Z = np.matrix([[1, 0],[0, -1]])\n",
    "print(f'Pauli Z gate matrix: \\n {pauli_Z} \\n')\n",
    "hadamard = np.matrix([[0.707, 0.707],[0.707, -0.707]])\n",
    "print(f'Hadamard gate matrix: \\n {hadamard} \\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise 1.0\n",
    "For which value of $\\theta$ does $RZ(\\theta)$ represent the Pauli Z gate?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cmath\n",
    "\n",
    "# manual definition of Rigetti's parametrized RZ gate. no need to modify.\n",
    "rz = lambda theta: np.matrix([[cmath.exp(-1j*theta/2), 0],[0, cmath.exp(1j*theta/2)]])\n",
    "\n",
    "theta = cmath.pi # TODO: find the right value for theta\n",
    "\n",
    "print(f'RZ with theta={theta} results in the following matrix: \\n\\n {1j*rz(theta)} \\n')\n",
    "print(f'Subtracting RZ with theta = {theta} from pauli_Z results in: \\n\\n {np.round(1j*rz(theta)-pauli_Z)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise 1.1\n",
    "For which integer value of $k$ does $RX(\\phi)$ with $\\phi=\\frac{k\\pi}{2}$ represent the Pauli X gate?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# manual definition of Rigetti's parametrized RX gate. no need to modify.\n",
    "rx = lambda phi: np.matrix([[cmath.cos(phi/2), -1j*cmath.sin(phi/2)],[-1j*cmath.sin(phi/2), cmath.cos(phi/2)]])\n",
    "\n",
    "k = 2 # TODO: find the right value for k (must be an integer)\n",
    "\n",
    "phi = k*cmath.pi/2 # do NOT modify (this is Rigetti's RX parametrization)\n",
    "print(f'RX with k={k} results in the following matrix: \\n\\n {1j*rx(phi)}\\n')\n",
    "print(f'Subtracting RX with k = {k} from pauli_X results in: \\n\\n {np.round(1j*rx(phi)-pauli_X)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 2. Quantum gate decomposition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To fully grasp the implications of the Solovay-Kitaev theorem you will manually decompose several gates in this section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise 2.0\n",
    "Use the definitions of Rigetti's $RZ(\\theta)$ and $RX(\\frac{k\\pi}{2})$ gates above to find a combination (product) of gates that implements the Hadamard (H) on Rigetti's QPU! As a recap here is the matrix representation of the Hadamard gate:\n",
    "$$H = \\frac{1}{\\sqrt{2}} \\begin{bmatrix}\n",
    "    1 & 1 \\\\\n",
    "    1 & -1\n",
    "    \\end{bmatrix}  \\approx  \\begin{bmatrix}\n",
    "    0.707 & 0.707 \\\\\n",
    "    0.707 & -0.707\n",
    "    \\end{bmatrix}$$\n",
    "\n",
    "<a title=\"Try multiplying the resulting matrix with the imaginary number i (remember that global phase doesn't matter) in order to get the correct result.\">Hint.</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: play with these two values (theta and k)\n",
    "theta = cmath.pi/2\n",
    "k = 1 # must be an integer\n",
    "\n",
    "# the angle for the RX gate is fixed to integer multiple of pi/2\n",
    "phi = k*cmath.pi/2\n",
    "\n",
    "# TODO: make different products (use 2, 3 or 4 gates)\n",
    "gate_product = rz(theta)*rx(phi)*rz(theta)*1j\n",
    "print(f'The sequence of gates yields the matrix: \\n \\n {gate_product} \\n')\n",
    "print(f'Subtracting this sequence of gates from the Hadamard yields: \\n \\n {np.round(gate_product-hadamard)}')"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 2.1:\n",
    "[This paper by Garcia-Escartin and Chamorro-Posada](https://arxiv.org/pdf/1110.2998.pdf) is a great resource to understand the equivalence of a lot of different circuits. Among other useful things, they show that the following circuit involving a controlled-Z (CZ) gate is equivalent to a single CNOT operation:\n",
    "\n",
    "<img src=\"attachment:image.png\" width=\"300\">\n",
    "\n",
    "Use your decomposed Hadamard gate from the previous exercise to implement a $CNOT$ (up to an unimportant global phase) using a $CZ$ gate and parametrized RX and RZ gates in pyQuil!\n",
    "\n",
    "**NOTE: Don't use the definitions of `rz` and `rx` from the previous exercises but rather use pyQuil's parametrized RX and RZ gates.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# from pyquil.api import CompilerConnection, get_devices\n",
    "from pyquil.quil import Program\n",
    "from pyquil.gates import RX, RZ, CZ, X\n",
    "from pyquil.api import QVMConnection\n",
    "%matplotlib inline\n",
    "\n",
    "# leaving the control qubit OFF (0)\n",
    "p = Program()\n",
    "\n",
    "# TODO: create a circuit with RX, RZ and CZ that equals a single CNOT gate\n",
    "p.inst(RZ(theta)(1), RX(phi)(1), RZ(theta)(1), CZ(0,1), RZ(theta)(1), RX(phi)(1), RZ(theta)(1))\n",
    "\n",
    "# establish connection to QVM and get wavefunction\n",
    "qvm = QVMConnection()\n",
    "wavefunction = qvm.wavefunction(p)\n",
    "print(f'With control qubit OFF the resulting wavefunction is: {wavefunction}')\n",
    "wavefunction.plot()\n",
    "\n",
    "\n",
    "# turning the control qubit ON (1)\n",
    "p = Program().inst(X(0))\n",
    "\n",
    "# TODO: create a circuit with RX, RZ and CZ that equals a single CNOT gate\n",
    "p.inst(RZ(theta)(1), RX(phi)(1), RZ(theta)(1), CZ(0,1), RZ(theta)(1), RX(phi)(1), RZ(theta)(1))\n",
    "\n",
    "# establish connection to QVM and get wavefunction\n",
    "qvm = QVMConnection()\n",
    "wavefunction = qvm.wavefunction(p)\n",
    "print(f'With control qubit ON the resulting wavefunction is: {wavefunction}')\n",
    "wavefunction.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 3. Quantum state preparation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The goal of quantum state preparation is the ability to generate quantum states with arbitrary amplitude distributions. Formally speaking, given a complex non-zero amplitude vector $\\mathbf{a} \\in \\mathbb{C}^N$ with components $a_i$ find an algorithm that takes the initial state $\\ket{0}^{\\otimes \\log_2 N}$ and outputs the following state:\n",
    "$$\\ket{\\Psi} = \\sum^{N-1}_{i=0} \\frac{a_i}{\\mid \\mathbf{a} \\mid} \\ket{i}$$\n",
    "where $\\ket{i}$ stands for $i$ in its binary representation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 3.0:\n",
    "Design and implement a quantum circuit that initializes the following quantum state:\n",
    "\n",
    "$$ \\ket{\\Psi} = \\frac{-i}{2} \\, \\ket{00} - \\frac{i}{2} \\, \\ket{01} + \\frac{i}{2} \\, \\ket{10} + \\frac{i}{2} \\,\\ket{11} $$\n",
    "\n",
    "<a title=\"Use pyQuil's wavefunction functionality to print the prepared quantum state.\">Hint.</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyquil.api import QVMConnection\n",
    "from pyquil.gates import CNOT, H, Z, Y\n",
    "from pyquil.quil import Program\n",
    "\n",
    "qvm = QVMConnection()\n",
    "p = Program()\n",
    "\n",
    "# TODO: initialize the quantum state with quantum gates\n",
    "p.inst(H(0), H(1), Y(1))\n",
    "\n",
    "print(qvm.wavefunction(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 3.1:\n",
    "Built a quantum circuit with a conditional measurement to construct the following quantum state:\n",
    "\n",
    "$$ \\ket{\\Psi} = -\\frac{1}{2} \\,|001> -  \\, \\frac{1}{2} \\,|011> + \\, \\frac{1}{2} \\,|101> + \\, \\frac{1}{2} \\,|111> $$\n",
    "\n",
    "<a title=\"Look at the if_then() function to access the shared memory in order to perform a conditional measurement.\">Hint.</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyquil.api import QVMConnection\n",
    "from pyquil.gates import CNOT, H, Z, CCNOT, X, CZ, I\n",
    "from pyquil.quil import Program\n",
    "\n",
    "qvm = QVMConnection()\n",
    "p = Program()\n",
    "\n",
    "# TODO: initialize the quantum state with quantum gates\n",
    "then_branch = Program()\n",
    "else_branch = Program(X(0))\n",
    "\n",
    "p.inst(H(0), H(1), H(2)).inst(CZ(0,2)).inst(X(0)).measure(0,0)\n",
    "p.if_then(0, then_branch, else_branch).inst(Z(0),Z(2))\n",
    "\n",
    "print(qvm.wavefunction(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 4. Rigetti's Grove algorithms library"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is several algorithms for quantum state preparation in the literature. For example, see [1](https://arxiv.org/pdf/1706.02721.pdf), [2](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.73.012307), [3](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.87.067901), [4](https://arxiv.org/abs/quant-ph/0208112) and [5](https://link.springer.com/article/10.1023/A:1021695125245). You should definitely read them at some point since they offer great insight into the difficulties involved with quantum state preparation. As you will see, each of these algorithms comes with it tradeoffs and you will eventually figure out which one fits your needs. Also keep in mind that near-term quantum computers limit the number of quantum gate operations you can perform due to decoherence (also called **quantum circuit depth**). Most of the above algorithms will have extensive resource requirements to ensure generality which will probably force you to do manual state preparation in order to ensure maximum efficiency."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point, we need to install [Grove](https://github.com/rigetticomputing/grove) - a Python library with plenty of quantum algorithms implemented in [pyQuil](https://github.com/rigetticomputing/pyquil). I highly recommend you to check out the Grove documentation since it is a great resource to learn about the individual quantum algorithms and their implementations!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install git+https://github.com/rigetticomputing/grove"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 4.0:\n",
    "Use Grove's arbitrary state generation algorithm to generate circuits for the quantum states in Exercises 3.0 and 3.1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Use Grove to generate circuits\n",
    "from grove.alpha.arbitrary_state.arbitrary_state import create_arbitrary_state\n",
    "\n",
    "# generating circuit for quantum state from exercise 3.0\n",
    "amplitude_vector = [-1j/2, -1j/2, 1j/2, 1j/2]\n",
    "p = create_arbitrary_state(amplitude_vector)\n",
    "print(f'Generated wavefunction for exercise 3.0: \\n{qvm.wavefunction(p)} \\n')\n",
    "print(f'Quantum circuit used to generate the state: \\n{p}')\n",
    "\n",
    "\n",
    "# generating circuit for quantum state from exercise 3.1\n",
    "amplitude_vector = [0, -1/2, 0, -1/2, 0, 1/2, 0, 1/2]\n",
    "p = create_arbitrary_state(amplitude_vector)\n",
    "print(f'Generated wavefunction for exercise 3.1: \\n{qvm.wavefunction(p)} \\n')\n",
    "print(f'Quantum circuit used to generate the state: \\n{p}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 4.1:\n",
    "Print the generated circuits in Exercise 4.0 and compare them with the circuits that you designed by hand in section 3. Were you doing better or worse in terms of quantum circuit depth?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 5. Quantum simulation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Errors in quantum computations are major hurdles for the development of a universal fault-tolerant quantum computer. There is a whole research field dedicated to what we call **quantum error correction**. The various types of error propagate differently through CNOT gates. In the following section we will analyze this in more detail and use it to our advantage to simulate simple local Hamiltonians."
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbcAAAD5CAYAAACksntDAAAABHNCSVQICAgIfAhkiAAAFzxJREFUeF7t3Y1y3bgNgNG44/d/5XQ5CWMZ5r9AEiC/zuy0ligKOKCIqxtn+/H7v//84j8IIIBAp8DHx0fnFQy3InDDtv8/K9jEgQACfgRobH5qlYr0hvrR3FKV5xgCCCCAgGuBT9fREzwCCGwXuOErru3IigHc8NYWuHhzU1w0TIUAAgggYEOA5majDkSBAAIIIKAoQHNTxGQqBBBAAAEbAjQ3G3UgCgQQQAABRQGamyImUyGAAAII2BCgudmoA1EggMAhAuG3EW/5jUTLJaO5Wa4OsSGAgEsB/nrE/rLR3PbXgAgQQOAQAd7Y7BSS5manFkSCAAIIIKAkQHNTgmQaBBC4WyC8tfF1pJ01QHOzUwsiQQABBBBQEqC5KUEyDQII3CsQ39r4Mzc7a4DmZqcWRIIAAgggoCRAc1OCZBoEELhTgD9rs1l3mpvNuhAVAgg4EKCx2S3SZ/yO+Pbf8nl+V367hd3lSmQI2BGgsdmpRSqSf29u/EFoiodjCCCAQJsAe2ib06pRfC35V5q3tVVLjvsg4F8g99YW9pHwD41uf41pbokasDATKBxCAIF/AvLDMHuGvcVBc3vURC5Ye+UiIgQQ8CDAXrK/SjS3TA34JJaB4TACCCQFaGhJlm0HaW7b6LkxAggggMAsAZqbkOXT16ylxrwIIIDAOgGaW8GaryYLOJxCAAEEDAvQ3AwXh9AQQMC+QO6vBdiP/OwIaW6J+vLVZAKFQwgggIAjAZpbpVh8NVkB4jQCCCBgUIDmlikKb28ZGA4jgAACDgRobg1F4u2tAYkhCCCAgCGBT0OxEMoFAqkPCie9JZ+e3wVLtCvFVL27JmDwNAGaW4E2bLos3gJQ46maYTzvtcmdnl9jma8d5nXdnl4wvpZsrHBtA2uc5qphwazHrXf8bszeeHvH786P+7cJ9KzxthkZpSFAc6so8qmsApQ5/eaBf3NtJhz1w29ifHOteiJM+FqAPeI14ZQJljW3Ez61sim1rUENJ4052qLtH6URm8Yc/ZFzBQL3CExtbrGhPR/kUpMrnbunJL4z1dy0NefSUtWMSXMurfyYB4FTBKb8QsnzoU29sscm9jxn+UHnF0tOWe7kgUBeoLYHpfay/Gz2z9TytZ9BOcKP/07/jkPeFk9ileaLY1ONo3RdOZ15Z2sNe96d/cws668VuZX1cHp+PfXy+jxQw19dv+TVsyasjVV7c5OLprYhxabWe501QOJBAAG7AnJ/mRWpvE9t/5sVB/N+Cag0txsKm3rDZCGtEQjr6+TN4vT81qySr7vI/ajn/rl11jvnc3xuzp64GNsvoNLc+m/75wqvDYPN6GfFex/+nzPYPnJ6frb169H11Gek2aSuiftA7d5WG10qp7q0nxGvm5ss7AoweU/JPSsGr81Y+vAzAqcI1PaCkOes/SAayvlLMcVz8ppT6mEpj1fNrVTEliTl9bWC1z4BxfPhv2tztcRXGrPqHqUYbjon18ppuZ+en3a9al6zn/9SPs975+KMx3fGWcrhhHOvmpsEmFmo5yLJ3SceD2NXNB+ZPz8jgMBcgVyzCHfN7QszIirF8bxfrdHR5GZU58+cw3+Ju7W4GqG3NLbUfWbEuPIBSuXEMQRuFcg9z+GZ3PFc9t6zND6X26211sh7uLlp3HzWHLVPS1r3ZUFqSTIPAnmB8JylnrVdTS0VSz7672dizKlGl8uzdW7GfRcY+loyVdxUsUrYco7c9c9xuTGl+3g+5y1fWVMteysOp+fXU69ZFjKG3H2srAkZb8/PIYdUfvHYCTn2eGiPPfLNTSKlFpAcM/Izi++72gyPGXOO1DpcMyOWGXOO5mfpuvDMpp7b4GXBTCuGUj6p/C3VyHosQ29u1pOaGR8LbqYucyOQ/9dDaTUUi8Yht9TeEo7Nyjt1P4s2ozGpvLlZxJ8VU4SePf9oQXdfp+miOZeWi2ZMmnNp5bd7ntSGG5xusMrlmTLZXScP9+9ubhrQco4bFq6HxaAVo0Y9NebQykfOoxGbxhwyLu8/y30h5HOjUyrnlI33es+Ov7u5zQ7I8vwssPbqpB7Q1qvfXNt6j7fj3sT45tq3cVu9PvVsWXQKca6IK3WPlJHVelqI65o/c9NclKmFZ6GY1mKITq0PpTfX0/NbtZ7k+vC2DmY5pdYX+1i79jXNrZ0kPVI+gOlRHE0JyM3qaSnPpa63fkzmcFp+M/3lcyUtZ97by9zB5Omk2eC8GIzE2f215NvFx2IeKRPXIHCeAHtBe03lvivt2me6Z2R3c7uHJp2pXGTpURxFAIGSgNycea5KWn/OSSNpWJ/hrhFLm5vXYniN+66lTLZeBOTzJDdtq3nIuHfEKa0sxLTDoeWeQ81NArfc6IQijOTdYsMYBG4V8PZMWYhXxnDC3jpj/Q81NxlIDTd3XhZJzmvh51zsFmIjBgS8CXh9nrzG7W19aMY73NxaG1NcFK3jNZN7zrX7/rPyYl4EvAjIBsEzOV45aSdtx2c+58pXfxUgAEfUHK4sgle6U/Lw6k/cvgXk/uDxebIW83P/DasjGFuLceeqfdXcQuBPzOcCPgFZPpA7C8W9EThF4IS9wUotZIOzEpeFOF43t2cSpUUrG0VprAaMvJ/GnMyBAAL9AjyL/WajV/D29iU3/Gduo/g9181ugK2xWImjNV7GIWBFQDY2niX9ykhTaa5/Rx8zmm5uWoSy+C3zskBalBiDQLvAyHPYPvu8kR7ehrzazqvar1+umtuOhsOimbn8mBsBBBCYI7Ckucmm1NMwesZqEcl4teZlHgRuEng+Rzue45usQ65PY/YwJ29uvUXjobrtsSZfBBBA4LvAkjc3bfTSpxLNxsanTe3KMd+NAjxH66qO9Ze1m+YWilZ6gwtNTaOxlRrnuiXKnRBAwIIA+4GFKozFoPr33GQIMxZGbHCymYV7a35q0ZxLuvAzAjcInPIMecvDW7yzngXV5tbazOS4kWKMXFNDlHHVxnMeAQTOFwj7woz95ny5vRm6+VpyLxN3RwCBWwVobD4rr/rmdsoiOCUPn0uSqBFAAIH3Ary5/TXkK8n3i4kZEEAAASsC/5rb7W8rMf/bHawsTOJAAAEE3gh8spl/8WHxZilxLQIIIGBHgK8l7dSCSBBAwJAAvyVpqBgDodDcBtC4BAEEEEDAtgDNzXZ9iA4BBBBAYECA5jaAxiUIIIAAArYFaG6260N0CCCAAAIDAjS3ATQuQQCBswX4e6/+60tz819DMkAAgQkC/NWgCagLp6S5LcTmVggggAACawRobmucuQsCCCCAwEIBmttCbG6FAAI+BPhK0kedSlGq/r8ClG7EOQQQOFOAX744s67es+LNzXsFiR8BBBBA4IcAze0HCQcQQKAmwNd2NSHb52+oH19L2l6DRIeAWYEbNkiz+ARWFeDNrUrEAAQQQAABbwI0N28VI14EEEAAgaoAza1KxAAEEEAAAW8CNDdvFSNeBBBAAIGqAM2tSsQABBBAAAFvAjQ3bxUjXgQQQACBqgDNrUrEAAQQQAABbwI0N28VI14EEEAAgaoAza1KxAAEEEAAAW8CNDdvFSNeBBBAAIGqAM2tSsQABBBAAAFvAjQ3bxUjXgQQQACBqgDNrUrEAAQQQAABbwI0N28VI14EEEAAgaoAza1KxAAEEEAAAW8CNDdvFSNeBBBAAIGqAM2tSsQABBBAAAFvAjQ3bxUjXgQQQACBqgDNrUrEAAQQQAABbwI0N28VI14EEEAAgaoAza1KxAAEEEAAAW8CNDdvFSNeBBBAAIGqAM2tSsQABBBAAAFvAjQ3bxUjXgQQQACBqgDNrUrEAAQQQAABbwI0N28VI14EEEAAgaoAza1KxAAEEEAAAW8CNDdvFSNeBBBAAIGqAM2tSsQABBBAAAFvAjQ3bxUjXgQQQACBqgDNrUrEAAQQQAABbwI0N28VI14EEEAAgaoAza1KxAAEEEAAAW8CNDdvFSNeBBBAAIGqAM2tSsQABBBAAAFvAjQ3bxUjXgQQQACBqgDNrUrEAAQQQAABbwI0N28VI14EEEAAgaoAza1KxAAEEEAAAW8CNDdvFSNeBBBAAIGqAM2tSsQABBBAAAFvAjQ3bxUjXgQQQACBqgDNrUrEAAQQQAABbwI0N28VI14EEEAAgaoAza1KxAAEEEAAAW8CNDdvFSNeBBBAAIGqAM2tSsQABBBAAAFvAjQ3bxUjXgQQQACBqgDNrUrEAAQQQAABbwI0N28VI14EEEAAgaoAza1KxAAEEEAAAW8CNDdvFSNeBBBAAIGqAM2tSsQABBBAAAFvAjQ3bxUjXgQQQACBqgDNrUrEAAQQQAABbwI0N28VI14EEEAAgaoAza1KxAAEEEAAAW8CNDdvFSNeBBBAAIGqAM2tSsQABBBAAAFvAjQ3bxUjXgQQQACBqgDNrUrEAAQQQAABbwI0N28VI14EEEAAgarAZ3UEAxBAAIGEwMfHR+IohzwI/P7920OYr2Lkze0VHxcjcKcAjc133W+oH83N9xolegQQQACBhABfSyZQOIQAAu0CN3zF1a5hf+QNb22hCry52V+LRIgAAggg0ClAc+sEYzgCCCCAgH0Bmpv9GhEhAggggECnAM2tE4zhCCCAAAL2BWhu9mtEhAgggAACnQI0t04whiOAAAIlgfDbiLf8RmLJYfc5mtvuCnB/BBA4ToC/HrG/pDS3/TUgAgQQOESANzY7haS52akFkSCAAAIIKAnQ3JQgmQYBBO4WCG9tfB1pZw3Q3OzUgkgQQAABBJQEaG5KkEyDAAL3CsS3Nv7Mzc4aoLnZqQWRIIAAAggoCdDclCCZBgEE7hTgz9ps1v0zvkbf/gehz68TbrewuVSJCgF7AjQ2ezWJEf17c+O7YrtFIjIEELAnQGOzV5NnRHwt+VeDtzXbC5XoELAuwAuCrQrR3BL1YJEmUDiEAAL/BHJvbeFDcviHPWT/YqG5PWrA29v+BUkECHgQkHsFzcxe1WhumZqwWDMwHEYAgaqAbH7VCxigLkBzUydlQgQQuFGAhmar6jQ3UQ8WqK0FSjQIIIDAiMDnyEW3XJP7Q+Nb8tfMM/c1rzzu8cOFzOHp9jznMTfNNcBcCKwUoLmt1L7sXqVNP0cRr7HeCHK5hbhz57zklqsNxxHwJEBzS1SrtEElhnNICNTeVlrOW20EtdjlYpBNOlxvNTcZOz+3CYR6yjq3XcmomQI0t4ouC7cC9Djdu/HnZo4bhaVGcHJuuTpwHAHPAvxCSaZ6fBLLwGQOP99GtOzCPM9Gl7n19MMn5zYdjxsgsEmA5tYA//zU3jD8uiHPzX9G8jsb3Mm5zagVcyJgRYDmZqUSTuOYvflHlh0N7uTcnC43wkagWYDmVqDS+nqtcAvXp1Zt/jsa3Mm5uV50xoLnWx1jBXmEQ3NrrA2L+DvU6s1/ZYM7ObfG5c6wDgE+BHdgLRxKc6tgs3B/Au3a/Fc0uJNz+1lJjmgI8MFXQ1F/jmXNLSwA74vAe/yay+fkpn9ybpprgLn+CLBebK6Eqc0tNrRnUyg1udI5m3z3RWWlwc/4BZOTc7tvpZLx7QJT/hL3c5NIfaqJTex5zsrGkloQIU7L8aVinnksVdOZ91s598m5rXTkXgjsFlBtbrIB5DaK2CzCeG+NI8a8u3A77i/ruyOG5z3lOnoTz8m5vXG58Vq5FnL7mHcbmaf3fGT8as1NQtUWxHNjkhuWDJKfEUAAAQ0BuU+1zFm75uYPvC1+u8aoNDdZ/Fpj25Xsm/t6e8N8k2vp2hNrG/M9ObdSTU8+J/emWbnK+7CWZkm3zzv1F0pqYXhdAHIh1/Lk/DwBr2uoReTk3FryHx0Tns/4z+gcwf6Nv0YMo7Fz3R+B129ucqN/syCsFyXkJvO1HjPxIXCLQM+z2bpPlca13u85rjTf6jpZimVG7h//Tfo7TtybbKq4PXPI63uufWLEeUav74FduVClT0+cjEVglcCK5y6XS8szMiu+cO/U3Dtjyjnt2i9b4pk15vWb2zOwVKFnBR7mbVlEM+/P3AggsEeg9uyv3oueCs975+KMx3fGuady6+463NxyRZsR+sp71eIPi9FSPLV4OY/ASQK1Z29Vs6jFEc1jPLnxNLl5q3PrL5SMphUWzKpFXIoxt2BL13AOAQTGBErP2449oWcPqsVXym1Mi6uG3txShegpdGCXc5SuL507uYSW8tb+hBnm08rv7Vwn5zbr+ZDP76z7pPaKeC+t9dMb+5vcnzHLebTXYW9ep413+eZmpQi7Hq4d+Z+c68m57VgrmveUDWB3Y9PMLbfuQs65vDXvf/pcQ29up6OU8mPRlXTWnzu5Hifn1rJSUvnnGkLLfJpjtOKI86Ry1Yw3NdeOe6bimHVM5c1Nq9Czkpwx7405B8eTH4iTc5vxDMyaM9QhVYuTn7lUbjmHWe6nzdvd3FKLrhdFzpEqbO+cjL9X4OT1c3JuqRUr94YwJhjc4JDLM2WSsuPYd4Hu5nYz4O2LLG4wVhw04zg5Ny/PbKqeNzQ1WZ9UzikbeR0/fxfgz9wGVkRq8Q1MwyUIIPBXILV5W3zOQpwr4gr3kCba916Rx84Fzptbo75caI2XHTfMyhtOrIfmA3pybpYXYurZ0qyr5dxLsaUMUlalOW4+193cUuA9gLI4b+fruTdjEUDAlkBqP2BP+KpRsJAe0sxWRe1E093c7IS+JxK50PZEsfeu0WDXQzbjrS2Knpzb3lXz8+5y/fBs/TSS6zL+LO3yV957Zmlz81oQr3HPXNa7msDMxiY3ktV1X5HbzDXRM/dq257YvIzFsFypoeY28gnrhEKM5F3m9312dYNbufmfnNvuVSf3gmDt4dmSca92TDntjmm1Qc/9hpqbvEENOHeeBS0l/f28qgmsbGyxCifnZmWledgDnlYW4pUx5PZXKzXeFcdwc5PAuQR2bEq5WDg+R2B2E9i5hk7Obc5qKM/qdSP2Gne5GmefffX33MKDH4ueK35rE7TOfEoes5zjWtBsRM81tdP/5NxmrYfUvHKP2FnTVHyejj333hB3sMXzewVfNbcw1RPUymaktUjlw6g176nzxLUQ3EbXgjS38sCenNuK9Wi1rj25W1mLMWYaXLl6r5vbc/pS8U9Y3GVKzj4fuvC/Y81l7eO43PFwvrSWdko/m9wzRxmTx9xkDrN+tlrbWfnOnFc2uJn38ja3anPzlnxrvDyMrVLfxz3dSpt9vMqT88m5jVU7f1VL7fNXc6ZHIFh7eo56cusdS3PLiPFAZmAGD5/8wJ2c22C5s5dhlaUZPhFM2a9+8g3/tuTPqc48wsN4Zl3Jao3Ac9P1+ix5eBvq/SZhTfX33mVJc5OfKqwvchnv3hJxdwQQQACBXoElza03KMYjgIB/gRPe2jxVgbe379WiuRVWr/U3zELonEIAAQSuFnD1CyW1rwvl+ZHmJOe4enWQPAIKAiPPocJtr5wiWLOH/Sn91OamhTw6T7xu5OEauebKp4mkEThYYHTvOZjETWqqza11IchxtUZSO6+lLePSmpd5EEDAr8Cq/cevkM3IVZubzRSJCgEEdgic0hTCh15PuXiKdea6VG1up6CeksfMhcPcCNwiwH7gs9L8tuTfuvGVpM8FTNQIIIBASuBfc7v900nM/3aH1CLhGAIIIOBN4JPN/KtkWHhbvsSLAAIIpAX4WjLtwlEEEEAAAccCNDfHxSN0BBCYJ+DttyTnSficmebms25EjQACCCBQEKC5FXA4hQACCCDgU4Dm5rNuRI0AAgggUBCguRVwOIUAAggg4FOA5uazbkSNAAITBfiXOkzEXTQ1zW0RNLdBAAFfAvy9V1/1ktHS3KQIPyOAAAIIuBegubkvIQkggAACCEgBmpsU4WcEELhegK8k/S8B1f/LG/8cZIAAAr0C/PJFrxjjVwjw5rZCmXsggAACCCwVoLkt5eZmCJwhwNd2vut4Q/3+DwS+SskPJ0oaAAAAAElFTkSuQmCCAA=="
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example: Bit flip errors\n",
    "\n",
    "A bit flip error is a undesired spontaneous flip of a qubit and equivalent to the application of an X gate. Consider the following **error-free circuit**:\n",
    "\n",
    "<img src=\"attachment:image.png\" width=\"200\">\n",
    "\n",
    "With an initial state of $\\ket{00}$ we would also expect an output of $\\ket{00}$ since two CNOTs are equal to the identity operation."
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkcAAAD5CAYAAAAtHJHbAAAABHNCSVQICAgIfAhkiAAAG2JJREFUeF7t3YtynTqyANB4yv//y5lhEmIsS7wkgR5rqk7dygYk9eoWtNlO7sfv//3vl/8RIECAAIGHBD4+Ph6ayTSlBWZpGT5LwxmPwOwCbvz1KmCWG3M9wfdHtj/ez0HOCpb8zbAP/5OD5FoCBAg8KbDcmD1cnxQ3F4E5Bbw5mjPvoibQtcC2QZrhp9iuk7WzeLnbwWnw0Ew/mHhz1GABWhIBAgQIECDwnoA3R+/Zm3kCAT8Z10nyTD/B1hE0KgECewLeHO3pOEaAAAECBAhMJ6A5mi7lAiZAgAABAgT2BDRHezqOESBAgAABAtMJaI6mS7mACRAgQKBFAf9URTtZ0Ry1kwsrIUCAAIHJBfwljjYKQHPURh6sggABAgQmFvA3MNtKvuaorXxYDQECBAgQIPCygObo5QSYngABAgTmFpjl/19ZT1nWHPWULWslQIAAAQIEqgtojqoTm4AAAQIECMQF1rdGfuco7vPWp5qjt+TNS4AAAQIECDQpoDlqMi0WRYAAAQKjC/hdo3YzrDlqNzdWRoAAAQKDCmiM2k7s5/o95+z/8NT2+97ZLdouWasjQIBA3wIao/bz9+/NkV8Gaz9ZVkiAAAEC4wl4/raXU1+r/c2Jt0XtFacVESBAYDSB1Fuj5Rm0/KdRaiPjmqNIHhRnBMVHBAgQIJAtEP4g7nmTTVplAM3RhjUs2iriBiVAgAABAgkBz6EEzMMfa44S4Lr5BIyPCRAgQKCogIaoKGeRwTRHRRgNQoAAAQIECIwioDkKMqmDH6W0xUGAAAECBO4JaI523Hy1toPjEAECBAgQGFTgc9C4hEVgKoESjfzRW9O7cxyNO1WiBEtgI5D6a/2Q3hfw5iiSAzfzCIqPmhbIrdnc65vGsTgCBAhcFPDm6ABMZ38A5HAzArEGZ+9tT+z8vWC256fGvTrm3nyOESBA4C0Bb44S8m7yCRgfDyFQur6X8UqPOQS0IAgQ6FJAc3Qibamfkk9c6hQCrwo80bA8MceriCYnQGA6AV+rTZfydwOONZoers/nJOfr4m0O5a5c7uyNcpY9jBTLdw/rnmWNmqOdTC83fgW8A3Ty0JHhetyD9iToi6dpjMri2xtlPXsbzT2v3Yz5Wu1kbo5uYieHmeq0xeyK29Xzp8LMCDZ1A76Sm2V6jVFGEoJLr9b61fPLrdRINQWu7sGaazH2dwHN0UFFpB4sB5dNfzhn0+dcOz18JQCNUTnYnPrOubZcBEYqJeD5Ukqy/DiPNUcj/OTjxnSuAEs4lRjj3GrnOCvnJqwxKlcjJeq6xBjlIjISgTEFqjZHa0O03czrZzHOvWOx833WnkDJG3fJsdqTamNFV4xzGqw2on13FVesj1ZacqyjuRwnMKNAlV/I3m7c2A11bYK2x1re7Ms6W17fjIUr5usCd+p4rfvYPr6+AlcQGFPg6Pkw4v45irn3TBdtjkKsVEGsN+nl/Ds37DfR1zW/uYZW5w7zX2KdvEso7o+RMl7zmdrH+6M6uhWwN/qvh5wcpq5N7b3+tfqPoFhzFCb/6Ia6bZC2jEfX9U8uAgLtC2iM2s+RFdYVCJ9ptWYL5/EMrCV9bdwizdEMye3tDde1Mmj7bD9dlctPqo63xhqjct61R7I3ygqHz7Iro6eamqtjbs9PjXllXc69J1CkObo39a/uvlJb43RD+pnxqzeAnyP4pAUBjVH5LNgb5U1LjnglP3ealdg16zPkaO6WG6VYXCXz8vZY2c1RmNwnwMI5Q8Raa0j91B3O788EWhZI1bHGqOWsWVtpgaPnyDJfrWfJGks4/t6a7M/SFbA/XlZztJfI/Wn/HA2vDwslHGN7fuzc9fjyf2PHw/Fy/vzUHDlrHOnasFZGiq2lWGrvmxqxzl4bs8d/taaOvN7cA9u5U+tcP39znVfNezw/qzkKA66ZrG2hpOZZP1/OXf5LnReu258JECBAYGyBVLOxRP3ks2JvHdsMHDVKmqS69Xr7H4E8m+ASyz/TGMXmqbHGJzdRLCafESghkKrjGnumxHqNQSBHIFXXyz5I7YWc+Y6uvTrn3vmp2I7W4Pi+wO3maH/Yd48eddylVqcoS0kahwABAuUFlnt07D79VlMUW8vZqNc1xxqlVJxnx3beT4FbX6vFEhxL2M/pvj4Jx0hdvz0vdc7ePD0f6y3eMKel7DmUkkzvv/IzPDdiD/VhbzxfeynzHurlaPcsMcTiWz8bIcYjg9rHh3xzFKLFiig8586fFeB3tRoeNca8k+uRrjnaD0fHR7J4KpYadVxjzKc8as6z1G+shhevFsxKrWEvnlj8Nc1HHPvWm6MRIc7GpOjOSjmvRYFt/a43aTXdYqas6Y5AqpZLNSR31lT7miW2WNzLZzXjjs1ZO9Ynxy/y5qhWAnLwa61pTU7t8Z8sgpJzlXQpOVbJGEcY68g2Z++N4FMjhiPzK3OWHOvKvC2fG6vZxWkGq1ScMZOWc9jS2i43RyWwwzFmKN6Wkl57LSXyWWKM2nH2Nv6679i+l7kS9iXGeE+gzszhM2WZZUanWMwxmzpZGGvUy83RWOFfi0aRnfeKbdKzV+dce3aO2c7ba4xS3uq9TpWkvM/MlnPtmfF7PCdWpy06Let8Yl2xOWJGPeb6yTVP8ztHJQszVnxPJq2XuVansxuTa53M7jVGdWY06pGAvXEkdO54eG9xD/njFquvks/AZZbRradpjs5ttfRZ4SZMn+lIKBBuoq1leCy81p/zBM42Rkse1Hie9Z2rw/q3N84rhvUaWp4fadwzw31dukEaV+7Xr8tfq+UWoIIeuZzE1pLA2cZob83hft071zECTwmEdZn7XHpq3W/ME9qEdm+sqYc5LzdHPQRVc41hodWcy9gE7gqUaIzuzu06AjUFwoe7e/KxdmgUGh6PMN8ZjzZHvSak13XPV84iXgTuNkbhDXTVVP/qqhWBsBZTNdvKelvaQ6FVaNma2dvrudUchchnghghEXfiPmPjHAKlBO42RqXmNw4BAnGBFp4f4RpGeC7HtfM/vdUchdMeAaeOh4kKx23hz6m1t7A2ayCwFSjRGKX2pH2g1t4WCGswVatvrzOcP1x3eNyf2xS43RydLcwSN+wSdGfXW2IuYxB4WqCVffZ03OabQyBsMNzP7+c9tAtt74881pVZf5V/QV5hU8BhInrlGyWOXv2tOy2Q2nvpK/aPbPf1/pmOEqgvENZ3j/fi1tYc7vHFuLU11q+s/Rluvzlah11A1/+2U8U+219Ke0fDTdneCq1odoFtjda+udkPs1eb+EcSqH2/6N0q681RGPwednhj3Ts3HPfOn8P57ozhGgItC6jxlrNjbSUEwhqv/dwoseZex/D26Hvmst8c1SyEVjZCK+uoaW3sPgSWG9j6X60Vhw+k7Tx7x2qtx7gEFgH34fJ1EJra31/GRd8clU9dmRHDAjgzqiI5o+Sc2gJX6nB77tWavzvPGv/V+Wq7Gb9/gZx6biX6JYbW98ayviv7vxXb2uto+s1RGPwbCWy9sEMjfyZAgAABAgTyBB55cxQ2NVcajje62nC9ecSuJnBf4MpeuT+Lryxy7FxbXmCEt0blVeqNuH3O9vC2q57E18hdvDnaPiDONC421hOlYw4CBAgQIDCmQBfNUUi/1yCVbIye+qk9jM+fCRAgQMAbzSdrwPPuu3Y3zdGSuL03SEtTVKIx2mu8nixUcxEgQIBAvwKeJf3mbll51d85qlEca4MUNkNLMCU735Jj9V0iVk+AAIFnBUa5//YWR2/rrVmVRZujs81QeN6dhNy55ggyXNfR+Y4TIECAAIGUwPJMqfGsSs3n83IC3XytVi5kIxEgQIAAgfoCGqP6xrVmKPrmaJRCGCWOWkVjXAIECBAgMLKAN0d/s+srtZHLXGwECBAgQOC8wL/maPa3JWv8szucLx1nEiBAgACBMQU+NQNfiWUxZpGLigABAgQIXBHwtdoVLecSIECAAIEDAX9L7QCog8Oaow6SZIkECBAgQIDAcwKao+eszUSAAAECBAh0IKA56iBJlkiAAAECBAg8J6A5es7aTAQIECBAgEAHApqjDpJkiQQIECDQh4B/M6+PPB2tUnN0JOQ4AQIECBC4IOCfhbmA1eipmqNGE2NZBAgQIECAwDsCmqN33M1KgAABAgQINCqgOWo0MZZFgAABAv0J+Eqtv5zFVvwZ+9BnBAiUEfDLmWUc11E8eMp6vj2a/fF2BsyfEtAcpWR8ToBAcwIeps2lxIIIDCmgORoyrYIiMLaAN0j95nfJnSa37/z1u/rzK9ccnbdyJgECBAgUENDcFkA0RFUBzVFVXoPPKODGP2PWxUyAwEgC/rbaSNkUCwECBAgQIJAtoDnKJjQAAQIECBAgMJKA5mikbIqFAAECBAgQyBbQHGUTGoAAAQIECBAYSUBzNFI2xUKAAAECBAhkC2iOsgkNQIAAAQIECIwkoDkaKZtiIUCAAAECBLIFNEfZhAYgQIAAAQIERhLQHI2UTbEQIECAAAEC2QKao2xCAxAgQIAAAQIjCWiORsqmWAgQIECAAIFsAc1RNqEBCBAgQIAAgZEENEcjZVMsBAgQIECAQLaA5iib0AAECBAgQIDASAKao5GyKRYCBAgQIEAgW0BzlE1oAAIECBAgQGAkAc3RSNkUCwECBAgQIJAtoDnKJjQAAQIECBAgMJKA5mikbIqFAAECBAgQyBbQHGUTGoAAAQIECBAYSUBzNFI2xUKAAAECBAhkC2iOsgkNQIAAAQIECIwkoDkaKZtiIUCAAAECBLIFNEfZhAYgQIAAAQIERhLQHI2UTbEQIECAAAEC2QKao2xCAxAgQIAAAQIjCWiORsqmWAgQIECAAIFsAc1RNqEBCBAgQIAAgZEENEcjZVMsBAgQIECAQLaA5iib0AAECBAgQIDASAKao5GyKRYCBAgQIEAgW0BzlE1oAAIECBAgQGAkAc3RSNkUCwECBAgQIJAtoDnKJjQAAQIECBAgMJKA5mikbIqFAAECBAgQyBbQHGUTGoAAAQIECBAYSUBzNFI2xUKAAAECBAhkC2iOsgkNQIAAAQIECIwkoDkaKZtiIUCAAAECBLIFNEfZhAYgQIAAAQIERhLQHI2UTbEQIECAAAEC2QKao2xCAxAgQIAAAQIjCWiORsqmWAgQIECAAIFsAc1RNqEBCBAgQIAAgZEENEcjZVMsBAgQIECAQLaA5iib0AAECBAgQIDASAKao5GyKRYCBAgQIEAgW0BzlE1oAAIECBAgQGAkAc3RSNkUCwECBAgQIJAtoDnKJjQAAQIECBAgMJKA5mikbIqFAAECBAgQyBbQHGUTGoAAAQIECBAYSUBzNFI2xUKAAAECBAhkC2iOsgkNQIAAAQIECIwkoDkaKZtiIUCAAAECBLIFNEfZhAYgQIAAAQIERhLQHI2UTbEQIECAAAEC2QKao2xCAxAgQIAAAQIjCWiORsqmWAgQIECAAIFsAc1RNqEBCBAgQIAAgZEENEcjZVMsBAgQIECAQLbAZ/YIBiBAgAABAhcEPj4+Lpzt1JYEfv/+3dJyqq3Fm6NqtAYmQIAAgVBAYxSK9PXnWfKnOeqrLq2WAAECBAgQqCzga7XKwIYnQIAAgbjALF/RxKPv79NZ3hotmfHmqL/6tGICBAgQIECgooDmqCKuoQkQIECAAIH+BDRH/eXMigkQIECAAIGKApqjiriGJkCAAAECBPoT0Bz1lzMrJkCAAAECBCoKaI4q4hqaAAECBAicFVj+NthMfyPsrMsb52mO3lA3JwECBAgQiAj45w0iKC98pDl6Ad2UBAgQIEBgK+CNUVv1oDlqKx9WQ4AAAQIECLwsoDl6OQGmJ0CAAIG5BZa3Rr5Oa6sGNEdt5cNqCBAgQIAAgZcFNEcvJ8D0BAgQIDCvwPrWyO8ctVUDmqO28mE1BAgQIECAwMsCmqOXE2B6AgQIEJhTwO8atZv3z/VV3uy/DLZ9pTm7RbvlamUECBAYQ0Bj1HYe/7058n1n24myOgIECBAYQ0Bj1H4efa32N0feFrVfrFZIgACBEQW8nGgvq5qjSE4UagTFRwQIECCQLZB6a7T8gL785/mTTVxkAM3RhtHboyI1ZRACBAgQSAiEzxnNUALq5Y81R4kEKNgEjI8JECBAoJpA2DxVm8jAuwKao10eBwkQIECAQF0BDVFd3zuja44CNUV6p4xcQ4AAAQIExhH4HCeU8pGkfnGu/Ezjj5j6mjL8XHM6fi2I8LtAuAfWo+Hn9obKIfCcgOboOevpZgpv7mcA1ms8CM5oOadXAXuj18xZ9ywCmqNIppcH852bV2SoKT/a2sWanDPHNUlTls7wQZ+p/RUhtXfsjXHKZMllLM/jRNhvJJqjg9wp3gOgzeGjG//ZkdabxTKeB8FZNee1LGBvtJwdayPwU8AvZP80+f8nuvkETOLjbRNTym4ZZ9soJab2MYGmBeyNptNjcQSiApqjKMv3D7c/9Z04fbpTar/d0SBNV1LDBGxvDJNKgUwmoDmaLOGlw61981/Xq0EqnTnj1RawN2oLG59APQHN0Y5tqa+Hdqbo+tBTN/8VSYPUdblMtXh7Y6p03wrWNxK32B67SHN0klohf4d6+ua/zq5BOlmwTntNwN54jb67if0A3m7KNEcHuVG8P4HeuvmvK9Eg/cyJT9oQsDfayEMvq/BDd7uZeqw5Woqg90Loff0ly1DTWFLTWCMJ2BsjZbNuLGqlrm/O6FWbo7Uh2jYVe03S3rGcIF1bTqCVBtHbo3I5NVIZAXujjKNRCLQgUOUfgdzeJGKd8doEbY+1cmOJJWVZZ8vri6255mexnNacz9gEehGwN3rJlHUS2Bco2hyFDUTqRrE2G8v5vTUe65r3Wcc8Gub37SjDOnp7PeafV8DemDf328jDOkg9A0fQCmMdIaZtDMWaoxDqqCi2D7btgo6uGy0B4iFAgACB9gXCZ9yZFR9dM/MP22f83jynSHMUFsCIDU5vb7hqFdWIua1lZdy5BOyNsfIdPtdqRRfOo45qSV8bt+ovZB8tpdciCIv5KE7H6wn0WkP1RIxM4I+AvXG9EpZ7+/rf9au/3HPsS6zh7tpd9yWQ/eYobBRyiqL1xCyxhfG2vmbrI0CAAIF9gSv39bPPuL3zzs63PW9vvP3o6hxtbT2lo/z434C/10GvBhtL8JUxwuuvXLuFWMe5e/0V1CeLNfS5sk7nEiBAoHWBJ+7ZKYMz99da61vmjo395ppSTtvPn3zWnllPzXOy3xxtFxdLds3FnymkmvMbmwABAgT6Ejh6bjz9HNvqbedOrXOmBuXNyrrdHKUSVyOYJ+c6Wv9SvC2t52i9jhMgQIDAr8P79lNN0dnnx7qe1PmapLpV/eovZN8NbSmapwp5b42pot27xjECBAgQeFZg7179xvPkyvPraH17sT2rPNZst94cxZJxJdkLYTjG3vV7x8ZKx/doWoq79E8py3il4is51sj1JLY6AvbGNdfw3n/t6mtnp+Yqde+5tpqfz70r12/XHMZVugavrGvUc7t8c9RKMt7aYG/EP1Osb/ias18Be6PN3IUNxLrKEfKVimGJORV3m1lqd1W33hy1G079lSm8+sZXZpCPK1rOnUlg5r0Riz3VUDxdE6XWsY4Ti/WJmN6a94nYljmKvDkqleyngi4xz4wxL26jb4gStWGMOQXsjffzvuQgloeR79ex2FIO72eonxVcbo5ihXc13HCMWHKvjun8eQXUz7y5F/m+wEx7I3yuLDJL/DMYpOKMmexXjKOrwOXmaGa62Qttvcm04tDKOmbeE2L/I2BvvFsJsXvBDE1RqB6LOWYTXufPPwX8ztFPk8NPYgV4eJETCBAgQKC4QOzh3+I9elnnE+ta5ghNasz9RCzFi+XCgN4cncQKi+3kZcOd1spPyGs+Rt+gwxXQwAHZG88nN3Zfdk/483VimI2YVXiOP38JXG6OcgsvTFDueJJJgAABAvMJxJ4lnidfdbBYhB6h2XxVcz7iy83R+aHHPDMstjGj3I/q7Z+QvTXaz4+j7wnYG8/Yhw959+W0e2gT2qWvnPvIo81Rr0npdd01S/uth4DGqGZWjV1CwN4ooZgew/04bXP2CMNjqVvNUdiJHk8zxr+PcyfuMza9nvP0Q0Bj1GulzLdue6NOzsOH+uLcw305XHcdnfSoMae315RebRtHbjVH4dKPkFPHFXUo2d+fn3oIaIz6q43ZV2xvzF4B3+Nv4XkXriH1bJa5jH8hO0ROYXqopWTG+bz2Q0ANjVMrs0Vib5TLePggP/sMKreCeyOF6743iqueFsj6d46W4lwTnyqAXgr4CH6UOI7ivHt8rYWSjcy2pvjfzYzr3hawN/IzED5f3A/um26f28soiy3Pn55ZzdEy3BZ1tIdZuCF/8vlkK7DWwuJ2txZCc5tWjY0gYG/cz+II94TW7mMapON6zG6OYg/H2LQjFHgsLp/9FNg+CJajYe7XK1KfL8dbu5n8jNInBK4L2BvXzVxRRyBskOrM0u+oRZujfhn2V+5Bve+TOrp122uE1us5pyR9PpqAvXEuo+F9wz3inNudsxZrvl9ymqNEFYWbMnGaj08K2HQnoZw2nYC9cS7lnM45XTlrMfWsi4sV+av88aHH+NSGHCOPoiBAoC+B7UO71/twD29jtrYapa898khzFIK3Xujhevu6pVgtAQIECBAgkCPwSHOUs0DXEiBAgMBcAn5AfTbf3h799NYc/TT590nrb7h2lu4QAQIEhhBwHx4ijd0F0dUvZB/9NBEev7OpwjG6y6gFEyBAYBCBO/fwQUJ/PIzF2vPvi71qc1QK+u4463V3Ntidax6vZhMSIECAQJMCd59bTQYz4aKKNkdniyE876gROTpeKm/hukqNaxwCBAgQmE/gqWfXfLL1Iy7aHNVfrhkIECBAYHSBUZqK5QfunmLpaa2190DR5mgU2FHiqF08xidAgACBtIBnSdqm9SP+ttrfDPlKrfVStT4CBAgQIPCMwL/maPYOd41/dodnys4sBAgQIECgXYFPzcBXcli0W6hWRoAAAQIEnhLwtdpT0uYhQIAAAQIEuhDQHHWRJoskQIAAgV4Eevtbar24PrlOzdGT2uYiQIAAAQIEmhfQHDWfIgskQIAAAQIEnhTQHD2pbS4CBAgQIECgeQHNUfMpskACBAgQIEDgSQHN0ZPa5iJAgACBoQX8g8JjpFdzNEYeRUGAAAECjQj4N/MaSUTGMjRHGXguJUCAAAECBMYT0ByNl1MRESBAgAABAhkCmqMMPJcSIECAAIGtgK/UxqiHzzHCEAUBAgQI9Cbgl5d7y9g86/XmaJ5ci5QAAQIECBA4IaA5OoHkFAIECBAoI+BrpzKOb40yS/7+C9VrEv7O/nq1AAAAAElFTkSuQmCCAA=="
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's assume a bit flip error on $q_0$ occurs between the two CNOT gates. The circuit with bit flip error then reads:\n",
    "\n",
    "<img src=\"attachment:image.png\" width=\"200\">\n",
    "\n",
    "With an initial state of $\\ket{00}$ we will know get an output of $\\ket{11}$ which means **the bit flip error propagated downwards through the second CNOT gate**!"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the sake of completeness, let's also check the case when a bit flip error on $q_1$ (rather than $q_0$) occurs between the two CNOT gates. The circuit then looks like:\n",
    "\n",
    "<img src=\"attachment:image.png\" width=\"200\">\n",
    "\n",
    "With an initial state of $\\ket{00}$ we will know get an output of $\\ket{01}$ which implies that a bit flip error does not travel upwards through a CNOT. Hence, we conclude that a bit flip error only propagates downwards through CNOT gates."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 5.0:\n",
    "Phase flip errors propagate upwards through CNOT gates. Verify this statement with pen & paper and/or with pyQuil by implementing a short circuit that:\n",
    "\n",
    "- initializes an equal superposition over all 2-qubit strings,\n",
    "- applies a phase (Z) gate to one of the qubits,\n",
    "- applies a CNOT gate to the two qubits,\n",
    "- observe how the phase flip propagates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyquil.api import QVMConnection\n",
    "from pyquil.gates import CNOT, H, Z\n",
    "from pyquil.quil import Program\n",
    "\n",
    "qvm = QVMConnection()\n",
    "\n",
    "for i in range(2):\n",
    "    p = Program()\n",
    "    p.inst(H(0), H(1))\n",
    "    p.inst(Z(i))\n",
    "    p.inst(CNOT(0,1))\n",
    "\n",
    "    print(f'Acting Z on qubit {i} yields: \\n{qvm.wavefunction(p)}\\n\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The resulting quantum states are **product states** and can be separated into two components:\n",
    "\n",
    "In the case of where we apply $Z$ to qubit 0 we get:\n",
    "\n",
    "$$\\frac{1}{2}\\,\\ket{00} - \\frac{1}{2}\\,\\ket{01} + \\frac{1}{2}\\,\\ket{10} - \\frac{1}{2}\\,\\ket{11} = \\frac{1}{\\sqrt{2}} (\\ket{0} + \\ket{1}) \\otimes \\frac{1}{\\sqrt{2}} (\\ket{0} - \\ket{1})$$\n",
    "\n",
    "From this it becomes evident that the phase shift of $-1$ was only applied to qubit 0 (the latter - remember the reverse qubit ordering!).\n",
    "\n",
    "However, in the case of where we apply $Z$ to qubit 1 we get:\n",
    "\n",
    "$$\\frac{1}{2}\\,\\ket{00} - \\frac{1}{2}\\,\\ket{01} - \\frac{1}{2}\\,\\ket{10} + \\frac{1}{2}\\,\\ket{11} = \\frac{1}{\\sqrt{2}} (\\ket{0} - \\ket{1}) \\otimes \\frac{1}{\\sqrt{2}} (\\ket{0} - \\ket{1})$$\n",
    "\n",
    "which clearly shows that the phase shift was applied to both qubits! Hence, the phase shift ($Z$) error propagated upwards through the CNOT gate!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 5.1:\n",
    "We can exploit the fact that phase flip errors propagate upwards to simulate local Hamiltonians with many-body interactions such as:\n",
    "\n",
    "$$ H = \\pi \\big( Z_0 \\otimes Z_1 \\otimes Z_2 \\big) $$\n",
    "\n",
    "Implement a quantum circuit with at least three qubits in pyQuil that simulates the Hamiltonian above. <a title=\"Check out pages 209-211 in Nielsen & Chuang.\">Hint.</a>"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We simply build a CNOT ladder as shown here:\n",
    "\n",
    "<img src=\"attachment:image.png\" width=\"200\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: simulate the Hamiltonian above\n",
    "from pyquil.gates import CNOT, RZ\n",
    "\n",
    "p = Program([CNOT(0,2), CNOT(1,2), RZ(cmath.pi)(2) ,CNOT(1,2), CNOT(0,2)])\n",
    "\n",
    "print(qvm.wavefunction(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 6. Bonus exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bonus Exercise 6.0:\n",
    "Find a Toffoli decomposition with the lowest T count possible (small number of $T$ gates) by using [Nielsen & Chuang](http://www-reynal.ensea.fr/docs/iq/QC10th.pdf) or other resources. Implement the following two circuits with pyQuil:\n",
    "\n",
    "- single Toffoli gate\n",
    "- decomposed Toffoli\n",
    "\n",
    "Using the three different input states: $\\ket{000},\n",
    "\\ket{010},\n",
    "\\ket{001},\n",
    "\\ket{011}$"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the following decomposition of the Toffoli gate:\n",
    "\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyquil.gates import CCNOT\n",
    "from pyquil.gates import H, T, X, CNOT\n",
    "%matplotlib inline\n",
    "\n",
    "initial_states = [Program().inst(X(0)), Program().inst(X(1)), Program().inst(X(2)), Program().inst(X(0), X(1)), Program().inst(X(0), X(1), X(2))]\n",
    "\n",
    "for initial_state in initial_states:\n",
    "    # single Toffoli\n",
    "    original_toffoli = Program().inst(CCNOT(0,1,2))\n",
    "    print(f\"Original Toffoli result:\")\n",
    "    qvm.wavefunction(initial_state + original_toffoli).plot()\n",
    "    \n",
    "    # decomposed Toffoli\n",
    "    t_dagger = np.array([[1, 0], [ 0, cmath.exp(-1j*cmath.pi/4)]])\n",
    "    decomposed_toffoli = Program().defgate(\"T_dagger\", t_dagger) # register T_dagger\n",
    "    decomposed_toffoli.inst(H(2), CNOT(1,2), (\"T_dagger\", 2), CNOT(0,2), T(2))\n",
    "    decomposed_toffoli.inst(CNOT(1,2), (\"T_dagger\", 2), CNOT(0,2), T(1), T(2), H(2))\n",
    "    decomposed_toffoli.inst(CNOT(0,1), T(0), (\"T_dagger\", 1), CNOT(0,1))\n",
    "    print(f\"Decomposed Toffoli result:\")\n",
    "    qvm.wavefunction(initial_state + decomposed_toffoli).plot()"
   ]
  }
 ],
 "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
}