lab5_ex1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](resources/qgss-header.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 5: Quantum error correction\n",
    "\n",
    "You can do actual insightful science with IBMQ devices and the knowledge you have about quantum error correction. All you need are a few tools from Qiskit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install -U -r grading_tools/requirements.txt\n",
    "from qiskit import *\n",
    "from IPython.display import clear_output\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using a noise model\n",
    "\n",
    "In this lab we are going to deal with noisy quantum systems, or at least simulations of them. To deal with this in Qiskit, we need to import some things."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.providers.aer.noise import NoiseModel\n",
    "from qiskit.providers.aer.noise.errors import pauli_error, depolarizing_error\n",
    "from qiskit.providers.aer.noise import thermal_relaxation_error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following function is designed to create a noise model which will be good for what we are doing here. It has two types of noise:\n",
    "* Errors on `cx` gates in which an `x`, `y` or `z` is randomly applied to each qubit.\n",
    "* Errors in measurement which simulated a thermal process happening over time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_noise(p_cx=0,T1T2Tm=(1,1,0)):\n",
    "    '''\n",
    "        Returns a noise model specified by the inputs\n",
    "        - p_cx: probability of depolarizing noise on each\n",
    "                qubit during a cx\n",
    "        - T1T2Tm: tuple with (T1,T2,Tm), the T1 and T2 times\n",
    "              and the measurement time\n",
    "    '''\n",
    "    \n",
    "    noise_model = NoiseModel()\n",
    "    \n",
    "    # depolarizing error for cx\n",
    "    error_cx = depolarizing_error(p_cx, 1)\n",
    "    error_cx = error_cx.tensor(error_cx)\n",
    "    noise_model.add_all_qubit_quantum_error(error_cx, [\"cx\"])\n",
    "    \n",
    "    # thermal error for measurement\n",
    "    (T1,T2,Tm) = T1T2Tm\n",
    "    error_meas = thermal_relaxation_error(T1, T2, Tm)\n",
    "    noise_model.add_all_qubit_quantum_error(error_meas, \"measure\")\n",
    "        \n",
    "    return noise_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check it out on a simple four qubit circuit. One qubit has an `x` applied. Two others has a `cx`. One has nothing. Then all are measured."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 539.392x325.08 with 1 Axes>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc = QuantumCircuit(4)\n",
    "qc.x(0)\n",
    "qc.cx(1,2)\n",
    "qc.measure_all()\n",
    "\n",
    "qc.draw(output='mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a simple circuit with a simple output, as we'll see when we run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0001': 8192}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "execute( qc, Aer.get_backend('qasm_simulator'), shots=8192).result().get_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's run it with noise on the `cx` gates only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0011': 392, '0111': 23, '0101': 387, '0001': 7390}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "noise_model = make_noise(p_cx=0.1)\n",
    "\n",
    "execute( qc, Aer.get_backend('qasm_simulator'), noise_model=noise_model, shots=8192).result().get_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The measurement noise depends on three numbers: $T_1$, $T_2$ and $T_m$. The first two describe the timescale for certain noise processes. The last describes how long measurements take. For simplicity we'll set $T_1=T_2=1$ and vary $T_m$. For $T_m=0$, the measurement is too fast to see any noise. The longer it takes, the more noise we'll see."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tm = 0.01 , counts = {'0000': 63, '0001': 8129}\n",
      "Tm = 0.1 , counts = {'0000': 819, '0001': 7373}\n",
      "Tm = 1 , counts = {'0000': 5218, '0001': 2974}\n",
      "Tm = 10 , counts = {'0000': 8192}\n"
     ]
    }
   ],
   "source": [
    "for Tm in (0.01,0.1,1,10):\n",
    "\n",
    "    noise_model = make_noise(p_cx=0, T1T2Tm=(1,1,Tm))\n",
    "\n",
    "    counts = execute( qc, Aer.get_backend('qasm_simulator'), noise_model=noise_model, shots=8192).result().get_counts()\n",
    "    print('Tm =',Tm,', counts =',counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most notable effect of this noise is that it causes `1` values to relax down to `0`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running repetition codes\n",
    "\n",
    "Qiskit has tools to make it easy to set up, run and analyze repetition codes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.ignis.verification.topological_codes import RepetitionCode\n",
    "from qiskit.ignis.verification.topological_codes import GraphDecoder\n",
    "from qiskit.ignis.verification.topological_codes import lookuptable_decoding, postselection_decoding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's one with four repetitions and a single measurement round."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = 4\n",
    "T = 1\n",
    "code = RepetitionCode(d,T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The repetition code object contains a couple of circuits: for encoded logical values of `0` and `1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0': <qiskit.circuit.quantumcircuit.QuantumCircuit at 0x1dbee635e80>,\n",
       " '1': <qiskit.circuit.quantumcircuit.QuantumCircuit at 0x1dbee635940>}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code.circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the one for `0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">                    ┌───┐          ┌───┐             ┌─┐               \n",
       "      link_qubit_0: ┤ X ├──────────┤ X ├─────────────┤M├───────────────\n",
       "                    └─┬─┘┌───┐     └─┬─┘┌───┐        └╥┘┌─┐            \n",
       "      link_qubit_1: ──┼──┤ X ├───────┼──┤ X ├─────────╫─┤M├────────────\n",
       "                      │  └─┬─┘┌───┐  │  └─┬─┘┌───┐    ║ └╥┘┌─┐         \n",
       "      link_qubit_2: ──┼────┼──┤ X ├──┼────┼──┤ X ├────╫──╫─┤M├─────────\n",
       "                      │    │  └─┬─┘  │    │  └─┬─┘┌─┐ ║  ║ └╥┘         \n",
       "      code_qubit_0: ──■────┼────┼────┼────┼────┼──┤M├─╫──╫──╫──────────\n",
       "                           │    │    │    │    │  └╥┘ ║  ║  ║ ┌─┐      \n",
       "      code_qubit_1: ───────■────┼────■────┼────┼───╫──╫──╫──╫─┤M├──────\n",
       "                                │         │    │   ║  ║  ║  ║ └╥┘┌─┐   \n",
       "      code_qubit_2: ────────────■─────────■────┼───╫──╫──╫──╫──╫─┤M├───\n",
       "                                               │   ║  ║  ║  ║  ║ └╥┘┌─┐\n",
       "      code_qubit_3: ───────────────────────────■───╫──╫──╫──╫──╫──╫─┤M├\n",
       "                                                   ║  ║  ║  ║  ║  ║ └╥┘\n",
       "round_0_link_bit_0: ═══════════════════════════════╬══╩══╬══╬══╬══╬══╬═\n",
       "                                                   ║     ║  ║  ║  ║  ║ \n",
       "round_0_link_bit_1: ═══════════════════════════════╬═════╩══╬══╬══╬══╬═\n",
       "                                                   ║        ║  ║  ║  ║ \n",
       "round_0_link_bit_2: ═══════════════════════════════╬════════╩══╬══╬══╬═\n",
       "                                                   ║           ║  ║  ║ \n",
       "        code_bit_0: ═══════════════════════════════╩═══════════╬══╬══╬═\n",
       "                                                               ║  ║  ║ \n",
       "        code_bit_1: ═══════════════════════════════════════════╩══╬══╬═\n",
       "                                                                  ║  ║ \n",
       "        code_bit_2: ══════════════════════════════════════════════╩══╬═\n",
       "                                                                     ║ \n",
       "        code_bit_3: ═════════════════════════════════════════════════╩═\n",
       "                                                                       </pre>"
      ],
      "text/plain": [
       "                    ┌───┐          ┌───┐             ┌─┐               \n",
       "      link_qubit_0: ┤ X ├──────────┤ X ├─────────────┤M├───────────────\n",
       "                    └─┬─┘┌───┐     └─┬─┘┌───┐        └╥┘┌─┐            \n",
       "      link_qubit_1: ──┼──┤ X ├───────┼──┤ X ├─────────╫─┤M├────────────\n",
       "                      │  └─┬─┘┌───┐  │  └─┬─┘┌───┐    ║ └╥┘┌─┐         \n",
       "      link_qubit_2: ──┼────┼──┤ X ├──┼────┼──┤ X ├────╫──╫─┤M├─────────\n",
       "                      │    │  └─┬─┘  │    │  └─┬─┘┌─┐ ║  ║ └╥┘         \n",
       "      code_qubit_0: ──■────┼────┼────┼────┼────┼──┤M├─╫──╫──╫──────────\n",
       "                           │    │    │    │    │  └╥┘ ║  ║  ║ ┌─┐      \n",
       "      code_qubit_1: ───────■────┼────■────┼────┼───╫──╫──╫──╫─┤M├──────\n",
       "                                │         │    │   ║  ║  ║  ║ └╥┘┌─┐   \n",
       "      code_qubit_2: ────────────■─────────■────┼───╫──╫──╫──╫──╫─┤M├───\n",
       "                                               │   ║  ║  ║  ║  ║ └╥┘┌─┐\n",
       "      code_qubit_3: ───────────────────────────■───╫──╫──╫──╫──╫──╫─┤M├\n",
       "                                                   ║  ║  ║  ║  ║  ║ └╥┘\n",
       "round_0_link_bit_0: ═══════════════════════════════╬══╩══╬══╬══╬══╬══╬═\n",
       "                                                   ║     ║  ║  ║  ║  ║ \n",
       "round_0_link_bit_1: ═══════════════════════════════╬═════╩══╬══╬══╬══╬═\n",
       "                                                   ║        ║  ║  ║  ║ \n",
       "round_0_link_bit_2: ═══════════════════════════════╬════════╩══╬══╬══╬═\n",
       "                                                   ║           ║  ║  ║ \n",
       "        code_bit_0: ═══════════════════════════════╩═══════════╬══╬══╬═\n",
       "                                                               ║  ║  ║ \n",
       "        code_bit_1: ═══════════════════════════════════════════╩══╬══╬═\n",
       "                                                                  ║  ║ \n",
       "        code_bit_2: ══════════════════════════════════════════════╩══╬═\n",
       "                                                                     ║ \n",
       "        code_bit_3: ═════════════════════════════════════════════════╩═\n",
       "                                                                       "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code.circuit['0'].draw(output='text')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And for `1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">                         ┌───┐          ┌───┐             ┌─┐               \n",
       "      link_qubit_0: ─────┤ X ├──────────┤ X ├─────────────┤M├───────────────\n",
       "                         └─┬─┘┌───┐     └─┬─┘┌───┐        └╥┘┌─┐            \n",
       "      link_qubit_1: ───────┼──┤ X ├───────┼──┤ X ├─────────╫─┤M├────────────\n",
       "                           │  └─┬─┘┌───┐  │  └─┬─┘┌───┐    ║ └╥┘┌─┐         \n",
       "      link_qubit_2: ───────┼────┼──┤ X ├──┼────┼──┤ X ├────╫──╫─┤M├─────────\n",
       "                    ┌───┐  │    │  └─┬─┘  │    │  └─┬─┘┌─┐ ║  ║ └╥┘         \n",
       "      code_qubit_0: ┤ X ├──■────┼────┼────┼────┼────┼──┤M├─╫──╫──╫──────────\n",
       "                    ├───┤       │    │    │    │    │  └╥┘ ║  ║  ║ ┌─┐      \n",
       "      code_qubit_1: ┤ X ├───────■────┼────■────┼────┼───╫──╫──╫──╫─┤M├──────\n",
       "                    ├───┤            │         │    │   ║  ║  ║  ║ └╥┘┌─┐   \n",
       "      code_qubit_2: ┤ X ├────────────■─────────■────┼───╫──╫──╫──╫──╫─┤M├───\n",
       "                    ├───┤                           │   ║  ║  ║  ║  ║ └╥┘┌─┐\n",
       "      code_qubit_3: ┤ X ├───────────────────────────■───╫──╫──╫──╫──╫──╫─┤M├\n",
       "                    └───┘                               ║  ║  ║  ║  ║  ║ └╥┘\n",
       "round_0_link_bit_0: ════════════════════════════════════╬══╩══╬══╬══╬══╬══╬═\n",
       "                                                        ║     ║  ║  ║  ║  ║ \n",
       "round_0_link_bit_1: ════════════════════════════════════╬═════╩══╬══╬══╬══╬═\n",
       "                                                        ║        ║  ║  ║  ║ \n",
       "round_0_link_bit_2: ════════════════════════════════════╬════════╩══╬══╬══╬═\n",
       "                                                        ║           ║  ║  ║ \n",
       "        code_bit_0: ════════════════════════════════════╩═══════════╬══╬══╬═\n",
       "                                                                    ║  ║  ║ \n",
       "        code_bit_1: ════════════════════════════════════════════════╩══╬══╬═\n",
       "                                                                       ║  ║ \n",
       "        code_bit_2: ═══════════════════════════════════════════════════╩══╬═\n",
       "                                                                          ║ \n",
       "        code_bit_3: ══════════════════════════════════════════════════════╩═\n",
       "                                                                            </pre>"
      ],
      "text/plain": [
       "                         ┌───┐          ┌───┐             ┌─┐               \n",
       "      link_qubit_0: ─────┤ X ├──────────┤ X ├─────────────┤M├───────────────\n",
       "                         └─┬─┘┌───┐     └─┬─┘┌───┐        └╥┘┌─┐            \n",
       "      link_qubit_1: ───────┼──┤ X ├───────┼──┤ X ├─────────╫─┤M├────────────\n",
       "                           │  └─┬─┘┌───┐  │  └─┬─┘┌───┐    ║ └╥┘┌─┐         \n",
       "      link_qubit_2: ───────┼────┼──┤ X ├──┼────┼──┤ X ├────╫──╫─┤M├─────────\n",
       "                    ┌───┐  │    │  └─┬─┘  │    │  └─┬─┘┌─┐ ║  ║ └╥┘         \n",
       "      code_qubit_0: ┤ X ├──■────┼────┼────┼────┼────┼──┤M├─╫──╫──╫──────────\n",
       "                    ├───┤       │    │    │    │    │  └╥┘ ║  ║  ║ ┌─┐      \n",
       "      code_qubit_1: ┤ X ├───────■────┼────■────┼────┼───╫──╫──╫──╫─┤M├──────\n",
       "                    ├───┤            │         │    │   ║  ║  ║  ║ └╥┘┌─┐   \n",
       "      code_qubit_2: ┤ X ├────────────■─────────■────┼───╫──╫──╫──╫──╫─┤M├───\n",
       "                    ├───┤                           │   ║  ║  ║  ║  ║ └╥┘┌─┐\n",
       "      code_qubit_3: ┤ X ├───────────────────────────■───╫──╫──╫──╫──╫──╫─┤M├\n",
       "                    └───┘                               ║  ║  ║  ║  ║  ║ └╥┘\n",
       "round_0_link_bit_0: ════════════════════════════════════╬══╩══╬══╬══╬══╬══╬═\n",
       "                                                        ║     ║  ║  ║  ║  ║ \n",
       "round_0_link_bit_1: ════════════════════════════════════╬═════╩══╬══╬══╬══╬═\n",
       "                                                        ║        ║  ║  ║  ║ \n",
       "round_0_link_bit_2: ════════════════════════════════════╬════════╩══╬══╬══╬═\n",
       "                                                        ║           ║  ║  ║ \n",
       "        code_bit_0: ════════════════════════════════════╩═══════════╬══╬══╬═\n",
       "                                                                    ║  ║  ║ \n",
       "        code_bit_1: ════════════════════════════════════════════════╩══╬══╬═\n",
       "                                                                       ║  ║ \n",
       "        code_bit_2: ═══════════════════════════════════════════════════╩══╬═\n",
       "                                                                          ║ \n",
       "        code_bit_3: ══════════════════════════════════════════════════════╩═\n",
       "                                                                            "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code.circuit['1'].draw(output='text')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can run both circuits at once by first converting them into a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "circuits = code.get_circuit_list()\n",
    "\n",
    "job = execute( circuits, Aer.get_backend('qasm_simulator'), noise_model=noise_model, shots=8192)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once they've run, we can extract the results and convert them into a form that allows us to more easily look at syndrome changes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "raw_results = {}\n",
    "for log in ['0','1']:\n",
    "    raw_results[log] = job.result().get_counts(log)\n",
    "\n",
    "results = code.process_results( raw_results )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's easiest to just package this up into a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_results(code, noise_model, shots=8192):\n",
    "    \n",
    "    circuits = code.get_circuit_list()\n",
    "\n",
    "    job = execute( circuits, Aer.get_backend('qasm_simulator'), noise_model=noise_model, shots=shots)\n",
    "\n",
    "    raw_results = {}\n",
    "    for log in ['0','1']:\n",
    "        raw_results[log] = job.result().get_counts(log)\n",
    "\n",
    "    results = code.process_results( raw_results )\n",
    "    \n",
    "    return results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First let's look at an example without any noise, to keep things simple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0': {'0 0  000 000': 8192}, '1': {'1 1  000 000': 8192}}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "noise_model = make_noise() # noise model with no noise\n",
    "\n",
    "results = get_results(code, noise_model)\n",
    "\n",
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example with some `cx` noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Most common results for a stored 0\n",
      "0 0  000 000 ocurred for 7720 samples.\n",
      "\n",
      "Most common results for a stored 1\n",
      "1 1  000 000 ocurred for 7706 samples.\n"
     ]
    }
   ],
   "source": [
    "noise_model = make_noise(p_cx=0.01)\n",
    "\n",
    "results = get_results(code, noise_model)\n",
    "\n",
    "for log in results:\n",
    "    print('\\nMost common results for a stored',log)\n",
    "    for output in results[log]:\n",
    "        if results[log][output]>100:\n",
    "            print(output,'ocurred for',results[log][output],'samples.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The main thing we need to know is the probability of a logical error. By setting up and using a decoder, we can find out!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0': 0.0, '1': 0.0}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decoder = GraphDecoder(code)\n",
    "\n",
    "decoder.get_logical_prob(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By calculating these value for different sizes of code and noise models, we can learn more about how the noise will affect large circuits. This is important for error correction, but also for the applications that we'll try to run before error correction is possible.\n",
    "\n",
    "Even more importantly, running these codes on real devices allows us to see the effects of real noise. Small-scale quantum error correction experiments like these will allow us to study the devices we have access to, understand what they do and why they do it, and test their abilities.\n",
    "\n",
    "This is the most important exercise that you can try: doing real and insightful experiments on cutting-edge quantum hardware. It's the kind of thing that professional researchers do and write papers about. I know this because I'm one of those researchers.\n",
    "\n",
    "See the following examples:\n",
    "* [\"A repetition code of 15 qubits\", James R. Wootton and Daniel Loss, Phys. Rev. A 97, 052313 (2018)](https://arxiv.org/abs/1709.00990)\n",
    "* [\"Benchmarking near-term devices with quantum error correction\", James R. Wootton, Quantum Science and Technology (2020)](https://arxiv.org/abs/2004.11037)\n",
    "\n",
    "As well as the relevant chapter of the Qiskit textbook: [5.1 Introduction to Quantum Error Correction using Repetition Codes](https://qiskit.org/textbook/ch-quantum-hardware/error-correction-repetition-code.html).\n",
    "\n",
    "By running repetition codes on the IBM quantum devices available to you, looking at the results and figuring out why they look like they do, you could soon know things about them that no-one else does!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transpiling for real devices\n",
    "\n",
    "The first step toward using a real quantum device is to load your IBMQ account and set up the provider."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#from qiskit import IBMQ\n",
    "#IBMQ.save_account('token')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "IBMQ.load_account()\n",
    "\n",
    "provider = IBMQ.get_provider(hub='ibm-q')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can set up a backend object for your device of choice. We'll go for the biggest device on offer: Melbourne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "backend = provider.get_backend('ibmq_16_melbourne')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the Jupyter tools, we can take a closer look."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "200ccf27326d4e8a819b620bbdabc36e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HTML(value=\"<h1 style='color:#ffffff;background-color:#000000;padding-top: 1%;padding-bottom: 1…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<IBMQBackend('ibmq_16_melbourne') from IBMQ(hub='ibm-q', group='open', project='main')>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import qiskit.tools.jupyter\n",
    "%matplotlib inline\n",
    "\n",
    "backend"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This has enough qubits to run a $d=8$ repetition code. Let's set this up and get the circuits to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = 8\n",
    "code = RepetitionCode(8,1)\n",
    "\n",
    "raw_circuits = code.get_circuit_list()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rather than show such a big circuit, let's just look at how many of each type of gate there are. For example, repetition codes should have $2(d-1)$ `cx` gates in, which means 14 in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('measure', 15), ('cx', 14), ('x', 8)])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raw_circuits[1].count_ops()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before running on a real device we need to transpile. This is the process of turing the circuits into ones that the device can actually run. It is usually done automatically before running, but we can also do it ourself using the code below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "circuits = []\n",
    "for qc in raw_circuits:\n",
    "    circuits.append( transpile(qc, backend=backend) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check what this process did to the gates in the circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('cx', 77), ('measure', 15), ('u3', 8), ('barrier', 1)])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuits[1].count_ops()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that this has `u3` gates (which the circuit previously didn't) and the `x` gates have disappeared. The solution to this is simple. The `x` gates have just been described as specific forms of `u3` gates, which is the way that the hardware understands single qubit operations.\n",
    "\n",
    "More concerning is what has happened to the `cx` gates. There are now 74!.\n",
    "\n",
    "This is due to connectivity. If you ask for a combination of `cx` gates that cannot be directly implemented, the transpiler will do some fancy tricks to make a circuit which is effectively the same as the one you want. This comes at the cost of inserting `cx` gates. For more information, see [2.4 More Circuit-Identities](https://qiskit.org/textbook/ch-gates/more-circuit-identities.html).\n",
    "\n",
    "However, here our circuit *is* something that can be directly implemented. The transpiler just didn't realize (and figuring it out is a hard problem). We can solve the problem by telling the transpiler exactly which qubits on the device should be used as the qubits in our code.\n",
    "\n",
    "This is done by setting up an `initial_layout` as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{Qubit(QuantumRegister(8, 'code_qubit'), 0): 6,\n",
       " Qubit(QuantumRegister(8, 'code_qubit'), 1): 4,\n",
       " Qubit(QuantumRegister(8, 'code_qubit'), 2): 2,\n",
       " Qubit(QuantumRegister(8, 'code_qubit'), 3): 0,\n",
       " Qubit(QuantumRegister(8, 'code_qubit'), 4): 13,\n",
       " Qubit(QuantumRegister(8, 'code_qubit'), 5): 11,\n",
       " Qubit(QuantumRegister(8, 'code_qubit'), 6): 9,\n",
       " Qubit(QuantumRegister(8, 'code_qubit'), 7): 7,\n",
       " Qubit(QuantumRegister(7, 'link_qubit'), 0): 5,\n",
       " Qubit(QuantumRegister(7, 'link_qubit'), 1): 3,\n",
       " Qubit(QuantumRegister(7, 'link_qubit'), 2): 1,\n",
       " Qubit(QuantumRegister(7, 'link_qubit'), 3): 14,\n",
       " Qubit(QuantumRegister(7, 'link_qubit'), 4): 12,\n",
       " Qubit(QuantumRegister(7, 'link_qubit'), 5): 10,\n",
       " Qubit(QuantumRegister(7, 'link_qubit'), 6): 8}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_initial_layout(code,line):\n",
    "    initial_layout = {}\n",
    "    for j in range(code.d):\n",
    "        initial_layout[code.code_qubit[j]] = line[2*j]\n",
    "    for j in range(code.d-1):\n",
    "        initial_layout[code.link_qubit[j]] = line[2*j+1]\n",
    "    return initial_layout\n",
    "    \n",
    "line = [6,5,4,3,2,1,0,14,13,12,11,10,9,8,7]\n",
    " \n",
    "initial_layout = get_initial_layout(code,line)\n",
    "\n",
    "initial_layout"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this, let's try transpilation again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('measure', 15), ('cx', 14), ('u3', 8)])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuits = []\n",
    "for qc in raw_circuits:\n",
    "    circuits.append( transpile(qc, backend=backend, initial_layout=initial_layout) )\n",
    "    \n",
    "circuits[1].count_ops()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perfect!\n",
    "\n",
    "Now try for yourself on one of the devices that we've now retired: Tokyo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fd125628f51348c9ab5202df0d4a52d4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HTML(value=\"<h1 style='color:#ffffff;background-color:#000000;padding-top: 1%;padding-bottom: 1…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<FakeTokyo('fake_tokyo') from None()>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x648 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from qiskit.test.mock import FakeTokyo\n",
    "\n",
    "backend = FakeTokyo()\n",
    "\n",
    "backend"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The largest repetition code this can handle is one with $d=10$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('measure', 19), ('cx', 18), ('x', 10)])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = 10\n",
    "code = RepetitionCode(d,1)\n",
    "raw_circuits = code.get_circuit_list()\n",
    "\n",
    "raw_circuits[1].count_ops()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this we need to find a line of 19 qubits across the coupling map."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('cx', 76), ('measure', 19), ('u3', 10), ('barrier', 1)])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]\n",
    "initial_layout = get_initial_layout(code,line)\n",
    "\n",
    "circuits = []\n",
    "for qc in raw_circuits:\n",
    "    circuits.append(transpile(qc, backend=backend, initial_layout=initial_layout) )\n",
    "    \n",
    "circuits[1].count_ops()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clearly, the line chosen in the cell above was not a good example. Find a line such that the transpiled circuit `circuits[1]` has exactly 18 `cx` gates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('measure', 19), ('cx', 18), ('u3', 10)])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line = None\n",
    "# define line variable so the transpiled circuit has exactly 18 CNOTs.\n",
    "### WRITE YOUR CODE BETWEEN THESE LINES - START\n",
    "line = [0,1,2,3,9,4,8,7,6,5,10,15,16,17,11,12,13,18,14,19]\n",
    "\n",
    "### WRITE YOUR CODE BETWEEN THESE LINES - END\n",
    "\n",
    "initial_layout = get_initial_layout(code,line)\n",
    "\n",
    "circuits = []\n",
    "for qc in raw_circuits:\n",
    "    circuits.append(transpile(qc, backend=backend, initial_layout=initial_layout) )\n",
    "    \n",
    "circuits[1].count_ops()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Grade your solution by running the cell below. Provide always the same name and email as the one you wrote during the course sign up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grading...\n",
      "lab5/ex1 - 🎉 Correct\n",
      "🎊 Hurray! You have a new correct answer! Let's submit it.\n",
      "Submitting the answers for lab5...\n",
      "📝 Our records, so far, are:\n",
      "Correct answers: lab1:ex1, lab2:ex1, lab3:ex1, lab4:ex1, lab5:ex1\n"
     ]
    }
   ],
   "source": [
    "name = 'First Last'\n",
    "email = 'first.last@domain.com'\n",
    "\n",
    "from grading_tools import grade\n",
    "grade(answer=circuits[1], name=name, email=email, labid='lab5', exerciseid='ex1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Help us improve our educational tools by submitting your code**<br>\n",
    "If you would like to help us learn how to improve our educational materials and offerings, you can opt in to send us a copy of your Jupyter notebook. By executing the cell below, you consent to sending us the code in your Jupyter notebook. All of the personal information will be anonymized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import display, Javascript;display(Javascript('IPython.notebook.save_checkpoint();'));\n",
    "from grading_tools import send_code;send_code('ex1.ipynb')"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}