qiskit/advanced/ignis/8_repetition_code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../../../images/qiskit_header.png\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" align=\"middle\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Repetition Codes\n",
    "---\n",
    "\n",
    "* **Last Updated:** June 11, 2019\n",
    "* **Requires:** qiskit-terra 0.8, qiskit-ignis 0.1.2, qiskit-aer 0.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "In quantum error correction we take many noisy qubits (which we call *physical qubits*) and use them to store a smaller number of *logical qubits*. The error correction procedure is designed to detect and correct for the effects of noise. This makes the logical qubits much less noisy and more reliable than the physical ones from which they are built.\n",
    "\n",
    "The repetition code is a simple example of quantum error correction, in which a logical *bit* is stored rather than a logical *qubit*. A given instance of the repetition code is defined by two numbers, which we call $d$ and $T$.\n",
    "\n",
    "The $d$ parameter determines how many physical qubits are used. The actual information about the logical bit is stored in $d$ qubits (which we'll call _code qubits_). The encoding is done in a very simple way: to encode a `0`, all these qubits are set in the state $|0\\rangle$, to encode a `1` they are set to $|1\\rangle$. To readout the value, you can just look at any qubit. To read it out in a way that protects against single qubit errors, you can read out all the qubits and take a majority vote.\n",
    "\n",
    "It is not only at readout that we can extract useful information that will help us correct errors. We can also extract information while the logical bit sits idle, or even while it is involved in computation.\n",
    "\n",
    "Since this is an exercise in quantum error correction, we will do this in a way that would also work for logical *qubits*. Specifically, our method of extracting information about errors must not extract any information regarding the stored logical information. In the quantum case, this is required so that we do not disturb superposition states of the stored qubits.\n",
    "\n",
    "We will extract information over $T$ rounds of _syndrome measurements_. For the repetition code, these are based on the fact that all code qubits should be in the same state (all $|0\\rangle$ or all $|1\\rangle$). Any departure from this is therefore a signature of error. Specifically, we imagine our $d$ code qubits sitting along a line. We will then perform a measurement on each pair of neighboring code qubits. This will tell us whether they are the same or different, without extracting any information on what their values are.\n",
    "\n",
    "The implementation of these measurements requires $d-1$ additional qubits, which we will call _link qubits_ for the repetition code. By pefforming two CNOTs between the pair of code qubits and a corresponding link qubit, the required information (and only the required information) is placed on the link qubit and can then be measured."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           \n",
      "code_qubit_0: |0>──■───────\n",
      "                   │       \n",
      "code_qubit_1: |0>──┼────■──\n",
      "                 ┌─┴─┐┌─┴─┐\n",
      "link_qubit_0: |0>┤ X ├┤ X ├\n",
      "                 └───┘└───┘\n"
     ]
    }
   ],
   "source": [
    "from qiskit import *\n",
    "cq = QuantumRegister(2,'code_qubit')\n",
    "lq = QuantumRegister(1,'link_qubit')\n",
    "qc = QuantumCircuit(cq,lq)\n",
    "qc.cx(cq[0],lq[0])\n",
    "qc.cx(cq[1],lq[0])\n",
    "print(qc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we provide tools for creating and testing repetition codes. The first thing we need to do is import them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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": [
    "## Creating a repetition code\n",
    "\n",
    "The `repetition_code` class creates a code for given values of $d$ and $T$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = 3\n",
    "T = 2\n",
    "code = RepetitionCode(d,T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this we can inspect various properties of the code, such as the names of the qubit registers used for the code and ancilla qubits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'code_qubit', 'link_qubit'}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code.qubit_registers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These registers are also attributes of the `repetition_code` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "QuantumRegister(3, 'code_qubit')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code.code_qubit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also access the quantum circuits that implement the code. Two of these are produced: one for each of the two possible logical bit values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "========= logical 0 =========\n",
      "\n",
      "                      ┌───┐     ┌───┐     ┌─┐         ░ ┌───┐     ┌───┐     ┌─┐»\n",
      "     link_qubit_0: |0>┤ X ├─────┤ X ├─────┤M├────|0>──░─┤ X ├─────┤ X ├─────┤M├»\n",
      "                      └─┬─┘┌───┐└─┬─┘┌───┐└╥┘┌─┐      ░ └─┬─┘┌───┐└─┬─┘┌───┐└╥┘»\n",
      "     link_qubit_1: |0>──┼──┤ X ├──┼──┤ X ├─╫─┤M├─|0>──░───┼──┤ X ├──┼──┤ X ├─╫─»\n",
      "                        │  └─┬─┘  │  └─┬─┘ ║ └╥┘      ░   │  └─┬─┘  │  └─┬─┘ ║ »\n",
      "     code_qubit_0: |0>──■────┼────┼────┼───╫──╫───────░───■────┼────┼────┼───╫─»\n",
      "                             │    │    │   ║  ║       ░        │    │    │   ║ »\n",
      "     code_qubit_1: |0>───────■────■────┼───╫──╫───────░────────■────■────┼───╫─»\n",
      "                                       │   ║  ║       ░                  │   ║ »\n",
      "     code_qubit_2: |0>─────────────────■───╫──╫───────░──────────────────■───╫─»\n",
      "                                           ║  ║       ░                      ║ »\n",
      "round_0_link_bit_0: 0 ═════════════════════╩══╬══════════════════════════════╬═»\n",
      "                                              ║                              ║ »\n",
      "round_0_link_bit_1: 0 ════════════════════════╩══════════════════════════════╬═»\n",
      "                                                                             ║ »\n",
      "round_1_link_bit_0: 0 ═══════════════════════════════════════════════════════╩═»\n",
      "                                                                               »\n",
      "round_1_link_bit_1: 0 ═════════════════════════════════════════════════════════»\n",
      "                                                                               »\n",
      "        code_bit_0: 0 ═════════════════════════════════════════════════════════»\n",
      "                                                                               »\n",
      "        code_bit_1: 0 ═════════════════════════════════════════════════════════»\n",
      "                                                                               »\n",
      "        code_bit_2: 0 ═════════════════════════════════════════════════════════»\n",
      "                                                                               »\n",
      "«                             ░          \n",
      "«      link_qubit_0: ────|0>──░──────────\n",
      "«                    ┌─┐      ░          \n",
      "«      link_qubit_1: ┤M├─|0>──░──────────\n",
      "«                    └╥┘      ░ ┌─┐      \n",
      "«      code_qubit_0: ─╫───────░─┤M├──────\n",
      "«                     ║       ░ └╥┘┌─┐   \n",
      "«      code_qubit_1: ─╫───────░──╫─┤M├───\n",
      "«                     ║       ░  ║ └╥┘┌─┐\n",
      "«      code_qubit_2: ─╫───────░──╫──╫─┤M├\n",
      "«                     ║       ░  ║  ║ └╥┘\n",
      "«round_0_link_bit_0: ═╬══════════╬══╬══╬═\n",
      "«                     ║          ║  ║  ║ \n",
      "«round_0_link_bit_1: ═╬══════════╬══╬══╬═\n",
      "«                     ║          ║  ║  ║ \n",
      "«round_1_link_bit_0: ═╬══════════╬══╬══╬═\n",
      "«                     ║          ║  ║  ║ \n",
      "«round_1_link_bit_1: ═╩══════════╬══╬══╬═\n",
      "«                                ║  ║  ║ \n",
      "«        code_bit_0: ════════════╩══╬══╬═\n",
      "«                                   ║  ║ \n",
      "«        code_bit_1: ═══════════════╩══╬═\n",
      "«                                      ║ \n",
      "«        code_bit_2: ══════════════════╩═\n",
      "«                                        \n",
      "\n",
      "========= logical 1 =========\n",
      "\n",
      "                            ░ ┌───┐     ┌───┐     ┌─┐         ░ ┌───┐     ┌───┐»\n",
      "     link_qubit_0: |0>──────░─┤ X ├─────┤ X ├─────┤M├────|0>──░─┤ X ├─────┤ X ├»\n",
      "                            ░ └─┬─┘┌───┐└─┬─┘┌───┐└╥┘┌─┐      ░ └─┬─┘┌───┐└─┬─┘»\n",
      "     link_qubit_1: |0>──────░───┼──┤ X ├──┼──┤ X ├─╫─┤M├─|0>──░───┼──┤ X ├──┼──»\n",
      "                      ┌───┐ ░   │  └─┬─┘  │  └─┬─┘ ║ └╥┘      ░   │  └─┬─┘  │  »\n",
      "     code_qubit_0: |0>┤ X ├─░───■────┼────┼────┼───╫──╫───────░───■────┼────┼──»\n",
      "                      ├───┤ ░        │    │    │   ║  ║       ░        │    │  »\n",
      "     code_qubit_1: |0>┤ X ├─░────────■────■────┼───╫──╫───────░────────■────■──»\n",
      "                      ├───┤ ░                  │   ║  ║       ░                »\n",
      "     code_qubit_2: |0>┤ X ├─░──────────────────■───╫──╫───────░────────────────»\n",
      "                      └───┘ ░                      ║  ║       ░                »\n",
      "round_0_link_bit_0: 0 ═════════════════════════════╩══╬════════════════════════»\n",
      "                                                      ║                        »\n",
      "round_0_link_bit_1: 0 ════════════════════════════════╩════════════════════════»\n",
      "                                                                               »\n",
      "round_1_link_bit_0: 0 ═════════════════════════════════════════════════════════»\n",
      "                                                                               »\n",
      "round_1_link_bit_1: 0 ═════════════════════════════════════════════════════════»\n",
      "                                                                               »\n",
      "        code_bit_0: 0 ═════════════════════════════════════════════════════════»\n",
      "                                                                               »\n",
      "        code_bit_1: 0 ═════════════════════════════════════════════════════════»\n",
      "                                                                               »\n",
      "        code_bit_2: 0 ═════════════════════════════════════════════════════════»\n",
      "                                                                               »\n",
      "«                         ┌─┐         ░          \n",
      "«      link_qubit_0: ─────┤M├────|0>──░──────────\n",
      "«                    ┌───┐└╥┘┌─┐      ░          \n",
      "«      link_qubit_1: ┤ X ├─╫─┤M├─|0>──░──────────\n",
      "«                    └─┬─┘ ║ └╥┘      ░ ┌─┐      \n",
      "«      code_qubit_0: ──┼───╫──╫───────░─┤M├──────\n",
      "«                      │   ║  ║       ░ └╥┘┌─┐   \n",
      "«      code_qubit_1: ──┼───╫──╫───────░──╫─┤M├───\n",
      "«                      │   ║  ║       ░  ║ └╥┘┌─┐\n",
      "«      code_qubit_2: ──■───╫──╫───────░──╫──╫─┤M├\n",
      "«                          ║  ║       ░  ║  ║ └╥┘\n",
      "«round_0_link_bit_0: ══════╬══╬══════════╬══╬══╬═\n",
      "«                          ║  ║          ║  ║  ║ \n",
      "«round_0_link_bit_1: ══════╬══╬══════════╬══╬══╬═\n",
      "«                          ║  ║          ║  ║  ║ \n",
      "«round_1_link_bit_0: ══════╩══╬══════════╬══╬══╬═\n",
      "«                             ║          ║  ║  ║ \n",
      "«round_1_link_bit_1: ═════════╩══════════╬══╬══╬═\n",
      "«                                        ║  ║  ║ \n",
      "«        code_bit_0: ════════════════════╩══╬══╬═\n",
      "«                                           ║  ║ \n",
      "«        code_bit_1: ═══════════════════════╩══╬═\n",
      "«                                              ║ \n",
      "«        code_bit_2: ══════════════════════════╩═\n",
      "«                                                \n"
     ]
    }
   ],
   "source": [
    "for log in ['0','1']:\n",
    "    print('\\n========= logical',log,'=========\\n')\n",
    "    print( code.circuit[log] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building a custom repetition code\n",
    "\n",
    "You can also implement measurement rounds and logical `X` gates yourself. For example, let's set up a code with no syndrome measurement rounds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_code = RepetitionCode(3,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This does nothing but set up two circuits for the two logical encoded states. There are no syndrome measurement rounds, and no final readout."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "========= logical 0 =========\n",
      "\n",
      "                 \n",
      "link_qubit_0: |0>\n",
      "                 \n",
      "link_qubit_1: |0>\n",
      "                 \n",
      "code_qubit_0: |0>\n",
      "                 \n",
      "code_qubit_1: |0>\n",
      "                 \n",
      "code_qubit_2: |0>\n",
      "                 \n",
      "\n",
      "========= logical 1 =========\n",
      "\n",
      "                       ░ \n",
      "link_qubit_0: |0>──────░─\n",
      "                       ░ \n",
      "link_qubit_1: |0>──────░─\n",
      "                 ┌───┐ ░ \n",
      "code_qubit_0: |0>┤ X ├─░─\n",
      "                 ├───┤ ░ \n",
      "code_qubit_1: |0>┤ X ├─░─\n",
      "                 ├───┤ ░ \n",
      "code_qubit_2: |0>┤ X ├─░─\n",
      "                 └───┘ ░ \n"
     ]
    }
   ],
   "source": [
    "def print_circuits(code):\n",
    "    for log in ['0','1']:\n",
    "        print('\\n========= logical',log,'=========\\n')\n",
    "        print( code.circuit[log] )\n",
    "            \n",
    "print_circuits(empty_code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add a round using the `syndrome_measurement()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "========= logical 0 =========\n",
      "\n",
      "                      ┌───┐     ┌───┐     ┌─┐         ░ \n",
      "     link_qubit_0: |0>┤ X ├─────┤ X ├─────┤M├────|0>──░─\n",
      "                      └─┬─┘┌───┐└─┬─┘┌───┐└╥┘┌─┐      ░ \n",
      "     link_qubit_1: |0>──┼──┤ X ├──┼──┤ X ├─╫─┤M├─|0>──░─\n",
      "                        │  └─┬─┘  │  └─┬─┘ ║ └╥┘      ░ \n",
      "     code_qubit_0: |0>──■────┼────┼────┼───╫──╫───────░─\n",
      "                             │    │    │   ║  ║       ░ \n",
      "     code_qubit_1: |0>───────■────■────┼───╫──╫───────░─\n",
      "                                       │   ║  ║       ░ \n",
      "     code_qubit_2: |0>─────────────────■───╫──╫───────░─\n",
      "                                           ║  ║       ░ \n",
      "round_0_link_bit_0: 0 ═════════════════════╩══╬═════════\n",
      "                                              ║         \n",
      "round_0_link_bit_1: 0 ════════════════════════╩═════════\n",
      "                                                        \n",
      "\n",
      "========= logical 1 =========\n",
      "\n",
      "                            ░ ┌───┐     ┌───┐     ┌─┐         ░ \n",
      "     link_qubit_0: |0>──────░─┤ X ├─────┤ X ├─────┤M├────|0>──░─\n",
      "                            ░ └─┬─┘┌───┐└─┬─┘┌───┐└╥┘┌─┐      ░ \n",
      "     link_qubit_1: |0>──────░───┼──┤ X ├──┼──┤ X ├─╫─┤M├─|0>──░─\n",
      "                      ┌───┐ ░   │  └─┬─┘  │  └─┬─┘ ║ └╥┘      ░ \n",
      "     code_qubit_0: |0>┤ X ├─░───■────┼────┼────┼───╫──╫───────░─\n",
      "                      ├───┤ ░        │    │    │   ║  ║       ░ \n",
      "     code_qubit_1: |0>┤ X ├─░────────■────■────┼───╫──╫───────░─\n",
      "                      ├───┤ ░                  │   ║  ║       ░ \n",
      "     code_qubit_2: |0>┤ X ├─░──────────────────■───╫──╫───────░─\n",
      "                      └───┘ ░                      ║  ║       ░ \n",
      "round_0_link_bit_0: 0 ═════════════════════════════╩══╬═════════\n",
      "                                                      ║         \n",
      "round_0_link_bit_1: 0 ════════════════════════════════╩═════════\n",
      "                                                                \n"
     ]
    }
   ],
   "source": [
    "empty_code.syndrome_measurement()\n",
    "print_circuits(empty_code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A logical `X` operation can be added using the `x()` method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "========= logical 0 =========\n",
      "\n",
      "                      ┌───┐     ┌───┐     ┌─┐         ░       ░ \n",
      "     link_qubit_0: |0>┤ X ├─────┤ X ├─────┤M├────|0>──░───────░─\n",
      "                      └─┬─┘┌───┐└─┬─┘┌───┐└╥┘┌─┐      ░       ░ \n",
      "     link_qubit_1: |0>──┼──┤ X ├──┼──┤ X ├─╫─┤M├─|0>──░───────░─\n",
      "                        │  └─┬─┘  │  └─┬─┘ ║ └╥┘      ░ ┌───┐ ░ \n",
      "     code_qubit_0: |0>──■────┼────┼────┼───╫──╫───────░─┤ X ├─░─\n",
      "                             │    │    │   ║  ║       ░ ├───┤ ░ \n",
      "     code_qubit_1: |0>───────■────■────┼───╫──╫───────░─┤ X ├─░─\n",
      "                                       │   ║  ║       ░ ├───┤ ░ \n",
      "     code_qubit_2: |0>─────────────────■───╫──╫───────░─┤ X ├─░─\n",
      "                                           ║  ║       ░ └───┘ ░ \n",
      "round_0_link_bit_0: 0 ═════════════════════╩══╬═════════════════\n",
      "                                              ║                 \n",
      "round_0_link_bit_1: 0 ════════════════════════╩═════════════════\n",
      "                                                                \n",
      "\n",
      "========= logical 1 =========\n",
      "\n",
      "                            ░ ┌───┐     ┌───┐     ┌─┐         ░       ░ \n",
      "     link_qubit_0: |0>──────░─┤ X ├─────┤ X ├─────┤M├────|0>──░───────░─\n",
      "                            ░ └─┬─┘┌───┐└─┬─┘┌───┐└╥┘┌─┐      ░       ░ \n",
      "     link_qubit_1: |0>──────░───┼──┤ X ├──┼──┤ X ├─╫─┤M├─|0>──░───────░─\n",
      "                      ┌───┐ ░   │  └─┬─┘  │  └─┬─┘ ║ └╥┘      ░ ┌───┐ ░ \n",
      "     code_qubit_0: |0>┤ X ├─░───■────┼────┼────┼───╫──╫───────░─┤ X ├─░─\n",
      "                      ├───┤ ░        │    │    │   ║  ║       ░ ├───┤ ░ \n",
      "     code_qubit_1: |0>┤ X ├─░────────■────■────┼───╫──╫───────░─┤ X ├─░─\n",
      "                      ├───┤ ░                  │   ║  ║       ░ ├───┤ ░ \n",
      "     code_qubit_2: |0>┤ X ├─░──────────────────■───╫──╫───────░─┤ X ├─░─\n",
      "                      └───┘ ░                      ║  ║       ░ └───┘ ░ \n",
      "round_0_link_bit_0: 0 ═════════════════════════════╩══╬═════════════════\n",
      "                                                      ║                 \n",
      "round_0_link_bit_1: 0 ════════════════════════════════╩═════════════════\n",
      "                                                                        \n"
     ]
    }
   ],
   "source": [
    "empty_code.x()\n",
    "print_circuits(empty_code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This also has a `logs` kwarg, which is a list of the circuits for which `X` is applied. This is `['0','1']` by default."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Final readout is then done with the `readout()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "========= logical 0 =========\n",
      "\n",
      "                      ┌───┐     ┌───┐     ┌─┐         ░       ░          \n",
      "     link_qubit_0: |0>┤ X ├─────┤ X ├─────┤M├────|0>──░───────░──────────\n",
      "                      └─┬─┘┌───┐└─┬─┘┌───┐└╥┘┌─┐      ░       ░          \n",
      "     link_qubit_1: |0>──┼──┤ X ├──┼──┤ X ├─╫─┤M├─|0>──░───────░──────────\n",
      "                        │  └─┬─┘  │  └─┬─┘ ║ └╥┘      ░ ┌───┐ ░ ┌─┐      \n",
      "     code_qubit_0: |0>──■────┼────┼────┼───╫──╫───────░─┤ X ├─░─┤M├──────\n",
      "                             │    │    │   ║  ║       ░ ├───┤ ░ └╥┘┌─┐   \n",
      "     code_qubit_1: |0>───────■────■────┼───╫──╫───────░─┤ X ├─░──╫─┤M├───\n",
      "                                       │   ║  ║       ░ ├───┤ ░  ║ └╥┘┌─┐\n",
      "     code_qubit_2: |0>─────────────────■───╫──╫───────░─┤ X ├─░──╫──╫─┤M├\n",
      "                                           ║  ║       ░ └───┘ ░  ║  ║ └╥┘\n",
      "round_0_link_bit_0: 0 ═════════════════════╩══╬══════════════════╬══╬══╬═\n",
      "                                              ║                  ║  ║  ║ \n",
      "round_0_link_bit_1: 0 ════════════════════════╩══════════════════╬══╬══╬═\n",
      "                                                                 ║  ║  ║ \n",
      "        code_bit_0: 0 ═══════════════════════════════════════════╩══╬══╬═\n",
      "                                                                    ║  ║ \n",
      "        code_bit_1: 0 ══════════════════════════════════════════════╩══╬═\n",
      "                                                                       ║ \n",
      "        code_bit_2: 0 ═════════════════════════════════════════════════╩═\n",
      "                                                                         \n",
      "\n",
      "========= logical 1 =========\n",
      "\n",
      "                            ░ ┌───┐     ┌───┐     ┌─┐         ░       ░       »\n",
      "     link_qubit_0: |0>──────░─┤ X ├─────┤ X ├─────┤M├────|0>──░───────░───────»\n",
      "                            ░ └─┬─┘┌───┐└─┬─┘┌───┐└╥┘┌─┐      ░       ░       »\n",
      "     link_qubit_1: |0>──────░───┼──┤ X ├──┼──┤ X ├─╫─┤M├─|0>──░───────░───────»\n",
      "                      ┌───┐ ░   │  └─┬─┘  │  └─┬─┘ ║ └╥┘      ░ ┌───┐ ░ ┌─┐   »\n",
      "     code_qubit_0: |0>┤ X ├─░───■────┼────┼────┼───╫──╫───────░─┤ X ├─░─┤M├───»\n",
      "                      ├───┤ ░        │    │    │   ║  ║       ░ ├───┤ ░ └╥┘┌─┐»\n",
      "     code_qubit_1: |0>┤ X ├─░────────■────■────┼───╫──╫───────░─┤ X ├─░──╫─┤M├»\n",
      "                      ├───┤ ░                  │   ║  ║       ░ ├───┤ ░  ║ └╥┘»\n",
      "     code_qubit_2: |0>┤ X ├─░──────────────────■───╫──╫───────░─┤ X ├─░──╫──╫─»\n",
      "                      └───┘ ░                      ║  ║       ░ └───┘ ░  ║  ║ »\n",
      "round_0_link_bit_0: 0 ═════════════════════════════╩══╬══════════════════╬══╬═»\n",
      "                                                      ║                  ║  ║ »\n",
      "round_0_link_bit_1: 0 ════════════════════════════════╩══════════════════╬══╬═»\n",
      "                                                                         ║  ║ »\n",
      "        code_bit_0: 0 ═══════════════════════════════════════════════════╩══╬═»\n",
      "                                                                            ║ »\n",
      "        code_bit_1: 0 ══════════════════════════════════════════════════════╩═»\n",
      "                                                                              »\n",
      "        code_bit_2: 0 ════════════════════════════════════════════════════════»\n",
      "                                                                              »\n",
      "«                       \n",
      "«      link_qubit_0: ───\n",
      "«                       \n",
      "«      link_qubit_1: ───\n",
      "«                       \n",
      "«      code_qubit_0: ───\n",
      "«                       \n",
      "«      code_qubit_1: ───\n",
      "«                    ┌─┐\n",
      "«      code_qubit_2: ┤M├\n",
      "«                    └╥┘\n",
      "«round_0_link_bit_0: ═╬═\n",
      "«                     ║ \n",
      "«round_0_link_bit_1: ═╬═\n",
      "«                     ║ \n",
      "«        code_bit_0: ═╬═\n",
      "«                     ║ \n",
      "«        code_bit_1: ═╬═\n",
      "«                     ║ \n",
      "«        code_bit_2: ═╩═\n",
      "«                       \n"
     ]
    }
   ],
   "source": [
    "empty_code.readout()\n",
    "print_circuits(empty_code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running a repetition code\n",
    "\n",
    "The code object produces the circuits required for the code. The user can then run them using any method they prefer, allowing full control over compilation, backends, noise models and so on. \n",
    "\n",
    "For example, here we run them without noise on the `qasm_simulator`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "========= logical 0 =========\n",
      "\n",
      "{'000 00 00': 1024}\n",
      "\n",
      "========= logical 1 =========\n",
      "\n",
      "{'111 00 00': 1024}\n"
     ]
    }
   ],
   "source": [
    "circuits = code.get_circuit_list()\n",
    "job = execute( circuits, Aer.get_backend('qasm_simulator') )\n",
    "raw_results = {}\n",
    "for log in ['0','1']:\n",
    "    raw_results[log] = job.result().get_counts(log)\n",
    "    print('\\n========= logical',log,'=========\\n')\n",
    "    print(raw_results[log])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the strings from right to left represent the outputs of the syndrome measurement rounds, followed by the final measurement of the code qubits.\n",
    "\n",
    "These results need to be rewritten in a different form in order to be decoded. To do this we can use the `process_results` method of the code object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0': {'0 0  00 00 00': 1024}, '1': {'1 1  00 00 00': 1024}}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code.process_results( raw_results )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is a dictionary whose keys are bit strings that represent outputs of the circuit, and the values represent the number of shots for which this output occurred.\n",
    "\n",
    "The strings are not the direct output from the circuits. They have been processed to take the form that helps us correct errors. Here's a short guided tour.\n",
    "\n",
    "* The `0 0` to the far left for the logical `0` result, and the `1 1` to the far left of the logical `1`, are the logical readout. Any code qubit could be used for this readout, since they should (without errors) all be equal. So we could have just one result here, for one arbitrarily chosen code qubit. Or we could have $d$, one for each qubit. Instead we have two, from the two qubits at either end of the line. This is because it works best with the decoder (which we'll use later). In the absence of errors, these two values will always be equal.\n",
    "\n",
    "* The following `0000` is the $d-1$ results of the syndrome measurements for the first round.A `0` implies that the corresponding pair of qubits where the same, and `1` implies different. There are $d-1$ results because the line of $d$ code qubits has $d-1$ possible neighboring pairs. In the absence of errors, they will all be `0`.\n",
    "\n",
    "* The `0000` that follows that is the syndrome change between the first and second rounds. It is therefore the bitwise `OR` of the syndrome measurement results from the second round with those from the first. In the absence of errors, they will all be `0`.\n",
    "\n",
    "* Subsequent blocks follow the same formula, though the last requires some comment. This is not measured using the standard method (with a link qubit). Instead it is calculated from the final readout measurement of all code qubits. Again it is presented as a syndrome change, and will be all `0` in the absence of errors. This is the $T+1$-th block of syndrome measurements since, as it is not done in the same way as the others, it is not counted among the $T$ syndrome measurement rounds.\n",
    "\n",
    "**Example 1:** `0 0  0110 0000 0000` would represent a $d=5$, $T=2$ repetition code with encoded `0`. The syndrome shows that (most likely) the middle code qubit was flipped by an error before the first measurement round. This causes it to disagree with both neighboring code qubits for the rest of the circuit. This is shown by the syndrome in the first round, but the blocks for subsequent rounds do not report it as it no longer represents a change. Other sets of errors could also have caused this syndrome, but they would need to be more complex and so presumably less likely.\n",
    "\n",
    "**Example 2:** `0 0  0010 0010 0000` would represent a $d=5$, $T=2$ repetition code with encoded `0`. Here one of the syndrome measurements reported a difference between two code qubits in the first round, leading to a `1`. The next round did not see the same effect, and so resulted in a `0`. However, since this disagreed with the previous result for the same syndrome measurement, and since we track syndrome changes, this change results in another `1`. Subsequent rounds also do not detect anything, but this no longer represents a change and hence results in a `0` in the same position. Most likely the measurement result leading to the first `1` was an error.\n",
    "\n",
    "**Example 3:** `0 1  0000 0001 0000` would represent a $d=5$, $T=2$ repetition code with encoded `1`. A code qubit on the end of the line is flipped before the second round of syndrome measurements. This is detected by only a single syndrome measurement, because it is on the end of the line. For the same reason, it also disturbs one of the logical readouts.\n",
    "\n",
    "Note that in all these examples, a single error causes exactly two characters in the string to change from the value it would have with no errors. This is, in fact, the reason why the logical output consists of both endpoints. It is a property that will be used by the decoder."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see the effects of noise, we need to specify a noise model. For example, let's set up a simple noise model with gate and measurement errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.providers.aer.noise import NoiseModel\n",
    "from qiskit.providers.aer.noise.errors import pauli_error, depolarizing_error\n",
    "\n",
    "def get_noise(p_meas,p_gate):\n",
    "\n",
    "    error_meas = pauli_error([('X',p_meas), ('I', 1 - p_meas)])\n",
    "    error_gate1 = depolarizing_error(p_gate, 1)\n",
    "    error_gate2 = error_gate1.tensor(error_gate1)\n",
    "\n",
    "    noise_model = NoiseModel()\n",
    "    noise_model.add_all_qubit_quantum_error(error_meas, \"measure\")\n",
    "    noise_model.add_all_qubit_quantum_error(error_gate1, [\"u1\", \"u2\", \"u3\"])\n",
    "    noise_model.add_all_qubit_quantum_error(error_gate2, [\"cx\"])\n",
    "        \n",
    "    return noise_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "noise_model = get_noise(0.04,0.04)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can then be run to generate noisy results. Let's make a quick function to do this, and then run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def get_syndrome(code,noise_model,shots=1014):\n",
    "    \n",
    "    circuits = code.get_circuit_list()\n",
    "\n",
    "    job = execute( circuits, Aer.get_backend('qasm_simulator'),noise_model=noise_model, shots=shots )\n",
    "    raw_results = {}\n",
    "    for log in ['0','1']:\n",
    "        raw_results[log] = job.result().get_counts(log)\n",
    "\n",
    "    return code.process_results( raw_results )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0': {'0 0  000000 000101 000110': 1,\n",
       "  '0 0  001000 010010 000010': 1,\n",
       "  '1 0  100000 000100 000010': 1,\n",
       "  '0 0  000000 001000 001110': 1,\n",
       "  '0 0  000100 000100 011000': 1,\n",
       "  '1 0  001000 001000 101100': 1,\n",
       "  '0 0  000100 010110 010010': 1,\n",
       "  '0 0  000100 100100 100000': 2,\n",
       "  '0 0  000000 010000 100000': 5,\n",
       "  '0 0  000010 000000 000010': 2,\n",
       "  '0 1  000000 001110 000011': 1,\n",
       "  '0 1  100000 100000 000001': 1,\n",
       "  '1 0  000000 000001 100001': 2,\n",
       "  '0 0  000100 000100 110000': 1,\n",
       "  '0 0  000010 011010 000000': 1,\n",
       "  '0 0  000001 000000 000010': 2,\n",
       "  '0 0  000100 001000 000000': 5,\n",
       "  '0 1  000000 100001 100000': 1,\n",
       "  '1 0  000010 000010 100000': 1,\n",
       "  '0 0  001000 001010 000100': 1,\n",
       "  '0 0  010100 111000 100000': 1,\n",
       "  '0 0  100010 100010 011000': 1,\n",
       "  '0 0  001000 001000 000011': 1,\n",
       "  '0 0  110000 111000 001000': 1,\n",
       "  '0 0  000000 110100 000100': 1,\n",
       "  '0 0  000000 000010 110010': 1,\n",
       "  '0 1  000011 000011 000001': 1,\n",
       "  '0 0  011001 011010 000000': 1,\n",
       "  '0 0  001000 010011 000101': 1,\n",
       "  '1 0  000000 000000 100011': 2,\n",
       "  '0 1  010000 010000 000001': 1,\n",
       "  '0 0  000000 000000 000101': 2,\n",
       "  '0 0  000000 101100 100011': 1,\n",
       "  '0 0  000010 000110 000100': 2,\n",
       "  '1 0  000000 000000 010000': 1,\n",
       "  '0 0  010101 010101 000000': 1,\n",
       "  '0 0  000100 000100 001100': 2,\n",
       "  '0 0  001010 001010 000000': 1,\n",
       "  '1 0  000001 010001 000011': 1,\n",
       "  '1 0  000000 100000 000000': 4,\n",
       "  '0 0  000100 001110 010010': 1,\n",
       "  '0 0  011000 011010 001110': 1,\n",
       "  '0 0  000100 000000 000100': 1,\n",
       "  '0 0  000000 010000 010000': 14,\n",
       "  '0 0  000000 000011 000000': 5,\n",
       "  '0 0  000000 001100 000110': 1,\n",
       "  '0 0  010000 010000 000000': 10,\n",
       "  '0 0  000000 001100 000000': 4,\n",
       "  '1 0  000000 001000 101000': 1,\n",
       "  '0 0  001000 001000 011000': 1,\n",
       "  '1 0  000100 000100 100000': 1,\n",
       "  '0 0  010000 100001 001110': 1,\n",
       "  '0 0  001000 101000 100000': 2,\n",
       "  '0 0  000000 000101 000101': 1,\n",
       "  '0 0  000000 010001 010001': 3,\n",
       "  '0 0  010010 010011 000001': 2,\n",
       "  '0 1  000000 000000 001101': 1,\n",
       "  '0 0  000001 000001 000110': 1,\n",
       "  '0 0  000100 001000 000110': 1,\n",
       "  '0 1  000000 001000 001001': 1,\n",
       "  '0 0  001001 001001 000000': 2,\n",
       "  '0 0  010100 010100 000000': 1,\n",
       "  '0 0  000000 000000 011110': 1,\n",
       "  '0 0  010100 000100 010000': 1,\n",
       "  '0 0  000100 000100 000000': 29,\n",
       "  '0 0  000000 000100 001000': 6,\n",
       "  '0 0  100000 100000 011000': 1,\n",
       "  '0 0  010000 100011 000000': 1,\n",
       "  '0 0  100000 101000 010000': 1,\n",
       "  '0 1  000000 010010 010011': 1,\n",
       "  '0 0  000000 000100 101100': 1,\n",
       "  '0 0  100001 100011 000111': 1,\n",
       "  '0 0  000100 010101 100001': 1,\n",
       "  '0 0  000000 000100 110100': 1,\n",
       "  '0 0  000000 011000 011000': 1,\n",
       "  '0 0  000000 000100 000100': 19,\n",
       "  '0 0  000001 000010 000000': 5,\n",
       "  '0 0  000000 110110 110000': 1,\n",
       "  '0 0  000000 100010 100010': 1,\n",
       "  '0 0  101100 100100 100000': 1,\n",
       "  '0 0  000000 100100 100100': 3,\n",
       "  '0 0  100001 100101 000100': 1,\n",
       "  '0 1  000000 100110 100001': 1,\n",
       "  '0 0  000000 000000 000011': 13,\n",
       "  '0 0  000001 010001 010000': 1,\n",
       "  '0 0  000001 000101 000100': 3,\n",
       "  '0 0  010000 100001 000001': 1,\n",
       "  '0 0  000010 000010 001100': 1,\n",
       "  '0 0  001000 001001 000001': 1,\n",
       "  '0 0  000000 000100 000111': 1,\n",
       "  '0 0  010000 010010 000010': 1,\n",
       "  '0 0  000010 000010 000000': 20,\n",
       "  '0 0  000000 101000 110000': 1,\n",
       "  '0 0  000000 010000 010011': 2,\n",
       "  '0 0  001100 010100 000000': 1,\n",
       "  '0 0  100000 100010 000100': 1,\n",
       "  '0 0  000100 001101 001001': 1,\n",
       "  '0 0  000000 010011 010011': 1,\n",
       "  '0 0  000000 100000 100110': 1,\n",
       "  '0 0  000000 000110 011000': 1,\n",
       "  '0 0  000001 000010 000110': 1,\n",
       "  '0 1  000000 000001 000011': 1,\n",
       "  '0 0  100000 100110 000000': 1,\n",
       "  '1 0  000000 000011 100000': 1,\n",
       "  '0 0  000000 000101 011101': 1,\n",
       "  '0 0  100000 101001 001001': 1,\n",
       "  '1 0  001000 001000 111011': 1,\n",
       "  '0 0  000000 000010 000100': 4,\n",
       "  '0 0  000000 011000 000000': 4,\n",
       "  '0 0  010000 101101 001110': 1,\n",
       "  '0 0  000000 000101 001001': 1,\n",
       "  '0 0  001000 011000 010000': 1,\n",
       "  '1 0  000010 000000 100100': 1,\n",
       "  '0 0  010000 010000 000110': 2,\n",
       "  '0 0  000000 010000 011100': 1,\n",
       "  '0 0  001000 110000 100110': 1,\n",
       "  '0 0  001000 001010 000010': 1,\n",
       "  '0 0  000000 001000 010000': 6,\n",
       "  '0 0  000000 000011 011011': 1,\n",
       "  '0 0  000000 000010 000001': 1,\n",
       "  '0 1  000000 000010 000000': 1,\n",
       "  '0 0  000000 001000 111000': 1,\n",
       "  '0 0  001000 001000 110000': 1,\n",
       "  '1 1  000000 000000 100001': 1,\n",
       "  '1 0  000000 100000 001100': 1,\n",
       "  '0 0  000001 001001 001000': 1,\n",
       "  '0 0  000100 001100 001000': 1,\n",
       "  '0 0  000000 000110 000000': 8,\n",
       "  '0 1  000000 000100 000101': 1,\n",
       "  '0 0  000001 000001 000000': 29,\n",
       "  '0 0  000000 000000 011011': 1,\n",
       "  '0 0  000000 000000 000000': 417,\n",
       "  '0 0  000000 001000 001000': 22,\n",
       "  '0 0  010000 010100 000100': 1,\n",
       "  '0 0  000000 000000 110000': 16,\n",
       "  '0 0  000001 011001 000000': 1,\n",
       "  '0 0  000001 000001 011000': 1,\n",
       "  '0 0  010000 110000 100000': 2,\n",
       "  '0 0  000000 001000 000100': 2,\n",
       "  '0 1  000000 001111 001000': 1,\n",
       "  '0 0  100000 100001 000010': 1,\n",
       "  '0 1  000001 000001 000001': 1,\n",
       "  '0 0  000010 100010 100000': 1,\n",
       "  '0 0  000010 100110 100100': 1,\n",
       "  '0 0  000000 000110 000110': 1,\n",
       "  '0 0  000000 000001 000001': 17,\n",
       "  '1 0  000000 110000 010000': 2,\n",
       "  '0 0  000000 010100 100100': 1,\n",
       "  '0 0  010000 011000 001000': 1,\n",
       "  '0 1  001000 010000 000001': 1,\n",
       "  '1 1  000000 000000 111001': 1,\n",
       "  '0 1  000000 010000 010111': 1,\n",
       "  '1 0  000000 000000 100000': 12,\n",
       "  '0 0  000010 000010 000110': 3,\n",
       "  '0 1  000100 000101 000000': 1,\n",
       "  '0 0  010000 010010 000100': 2,\n",
       "  '0 0  000000 000010 000010': 15,\n",
       "  '0 0  100000 100100 000100': 1,\n",
       "  '0 0  000000 100000 100000': 23,\n",
       "  '0 0  000000 000011 000011': 1,\n",
       "  '0 0  000000 100001 100001': 1,\n",
       "  '0 0  000000 000000 011000': 11,\n",
       "  '0 0  010000 010001 000001': 1,\n",
       "  '0 0  010001 010011 000010': 1,\n",
       "  '0 0  000100 000100 111100': 1,\n",
       "  '0 0  000000 110000 000000': 3,\n",
       "  '0 0  000000 000100 000010': 1,\n",
       "  '0 0  001000 010000 000000': 5,\n",
       "  '1 0  010000 010000 100000': 1,\n",
       "  '0 0  000010 000010 011000': 1,\n",
       "  '0 1  000000 000001 000000': 2,\n",
       "  '1 0  000010 000100 100000': 1,\n",
       "  '0 0  000100 000000 001000': 1,\n",
       "  '1 0  110000 010001 000001': 1,\n",
       "  '0 0  010000 100000 000000': 4,\n",
       "  '0 0  100000 100000 000000': 20,\n",
       "  '0 0  000010 110010 110000': 1,\n",
       "  '0 0  100001 100001 000110': 1,\n",
       "  '0 0  000001 000001 110000': 1,\n",
       "  '0 0  000000 001001 001010': 1,\n",
       "  '0 0  000010 001010 001000': 1,\n",
       "  '0 1  000000 001001 010000': 1,\n",
       "  '0 1  000000 000001 011110': 1,\n",
       "  '0 0  000000 000000 000110': 10,\n",
       "  '0 0  001000 001000 000000': 20,\n",
       "  '0 0  000000 001000 001011': 1,\n",
       "  '0 0  000000 010010 010100': 1,\n",
       "  '0 0  000000 000001 011001': 1,\n",
       "  '0 0  000000 010100 011000': 1,\n",
       "  '1 0  100000 100000 100000': 1,\n",
       "  '0 0  010000 010000 000011': 1,\n",
       "  '1 0  010000 010101 101001': 1,\n",
       "  '0 0  000000 000001 000010': 5,\n",
       "  '0 1  000000 000000 000001': 15,\n",
       "  '0 0  000010 000100 000000': 4,\n",
       "  '0 0  000000 000000 001100': 9,\n",
       "  '0 0  000000 011001 000001': 2,\n",
       "  '0 0  001000 001100 000100': 2,\n",
       "  '0 0  001100 000100 001000': 1,\n",
       "  '0 0  000000 001000 010110': 1,\n",
       "  '0 0  000001 100001 100000': 1,\n",
       "  '1 0  001000 001000 100000': 1,\n",
       "  '0 0  100010 100010 000000': 1,\n",
       "  '0 0  000001 000001 001100': 1},\n",
       " '1': {'1 0  000000 001100 000001': 1,\n",
       "  '1 1  000000 001000 010000': 3,\n",
       "  '1 1  100000 100000 001100': 1,\n",
       "  '1 1  001001 010001 000000': 1,\n",
       "  '1 1  000000 000000 000000': 451,\n",
       "  '1 1  000010 000110 000100': 2,\n",
       "  '1 0  000000 100000 100111': 1,\n",
       "  '1 1  000000 000011 000011': 1,\n",
       "  '1 1  000000 000000 001111': 1,\n",
       "  '1 1  000000 000000 001100': 12,\n",
       "  '1 1  000000 001100 000000': 6,\n",
       "  '0 1  000000 000100 101000': 1,\n",
       "  '1 1  000000 001110 000010': 2,\n",
       "  '1 1  100000 100000 000011': 1,\n",
       "  '1 1  000101 000100 000001': 1,\n",
       "  '1 1  000000 011001 000001': 1,\n",
       "  '1 1  000000 000010 000100': 2,\n",
       "  '0 1  000000 100000 000000': 8,\n",
       "  '1 1  100001 100001 000000': 2,\n",
       "  '0 1  010000 011000 101000': 1,\n",
       "  '1 1  000000 000100 001011': 1,\n",
       "  '1 1  000101 000101 000000': 2,\n",
       "  '1 1  000101 011101 100100': 1,\n",
       "  '1 1  100100 100100 000000': 1,\n",
       "  '1 1  000100 000000 000100': 1,\n",
       "  '1 1  000000 000110 000000': 2,\n",
       "  '1 1  100000 100000 000000': 10,\n",
       "  '1 1  000000 000001 001101': 2,\n",
       "  '1 1  000001 000001 011000': 1,\n",
       "  '0 1  000000 100100 001000': 1,\n",
       "  '1 1  000000 000100 000010': 1,\n",
       "  '0 1  000010 000110 100010': 1,\n",
       "  '1 1  000001 110001 110000': 1,\n",
       "  '1 1  000010 000010 000000': 20,\n",
       "  '1 0  000000 000000 110001': 1,\n",
       "  '1 1  000000 000011 000000': 4,\n",
       "  '1 1  000000 001000 001011': 2,\n",
       "  '1 1  000001 110001 000000': 1,\n",
       "  '1 0  000000 001000 001001': 1,\n",
       "  '1 0  000000 110000 000001': 1,\n",
       "  '1 0  001000 001110 000001': 1,\n",
       "  '1 1  000000 010000 001000': 1,\n",
       "  '1 1  001000 010000 000000': 4,\n",
       "  '1 1  010000 011000 001000': 1,\n",
       "  '1 1  000000 001101 000001': 1,\n",
       "  '1 1  000000 000000 000110': 11,\n",
       "  '1 1  100000 101000 111011': 1,\n",
       "  '1 1  001000 001000 001100': 2,\n",
       "  '1 1  110000 110000 001100': 1,\n",
       "  '1 1  000000 001000 001000': 22,\n",
       "  '1 1  000001 000001 001111': 1,\n",
       "  '0 1  010000 010000 100000': 2,\n",
       "  '0 1  000000 000000 010000': 1,\n",
       "  '1 1  000000 010000 100011': 1,\n",
       "  '1 1  010010 010010 000000': 1,\n",
       "  '1 1  000000 000001 000010': 7,\n",
       "  '0 1  000000 000010 100010': 1,\n",
       "  '1 1  000000 000000 000011': 10,\n",
       "  '1 1  000100 000100 000000': 15,\n",
       "  '1 1  000000 100000 111110': 1,\n",
       "  '1 1  000000 000101 000101': 1,\n",
       "  '1 1  000000 010100 101000': 1,\n",
       "  '1 1  000001 000000 000010': 2,\n",
       "  '0 1  000000 000000 100000': 17,\n",
       "  '1 1  000100 101000 100110': 1,\n",
       "  '1 1  000001 001010 001011': 1,\n",
       "  '1 1  000000 010110 100000': 1,\n",
       "  '1 1  001000 001100 000111': 1,\n",
       "  '1 1  000001 011001 000000': 1,\n",
       "  '1 1  000100 001000 000000': 2,\n",
       "  '1 1  000000 010000 100000': 9,\n",
       "  '1 0  000000 000010 000101': 1,\n",
       "  '1 1  000010 000010 110000': 1,\n",
       "  '1 1  100000 100001 000001': 1,\n",
       "  '1 1  000000 110000 001100': 1,\n",
       "  '1 1  000001 000010 000000': 4,\n",
       "  '1 1  000001 010010 010000': 1,\n",
       "  '1 1  000000 000001 000001': 16,\n",
       "  '1 1  000000 100000 111000': 1,\n",
       "  '1 1  001001 001001 000000': 2,\n",
       "  '1 1  000001 000101 011100': 1,\n",
       "  '1 1  100010 110100 010000': 1,\n",
       "  '1 1  000000 001010 001100': 1,\n",
       "  '1 1  101000 110000 000000': 1,\n",
       "  '1 1  000000 111100 010100': 1,\n",
       "  '1 0  000000 000000 011001': 1,\n",
       "  '0 1  000000 000000 100110': 2,\n",
       "  '1 1  000100 001100 010000': 1,\n",
       "  '1 1  000000 000000 011000': 18,\n",
       "  '1 1  000000 000010 000010': 17,\n",
       "  '1 1  000000 010000 010000': 16,\n",
       "  '1 1  000010 000101 000001': 1,\n",
       "  '1 1  010000 100010 000010': 1,\n",
       "  '1 0  011000 101001 000000': 1,\n",
       "  '1 1  000000 100000 101100': 1,\n",
       "  '1 1  000100 000101 000001': 1,\n",
       "  '1 1  000010 001010 001000': 1,\n",
       "  '1 0  000010 001011 010000': 1,\n",
       "  '1 1  000001 001001 010000': 1,\n",
       "  '0 1  000001 010001 110000': 1,\n",
       "  '1 1  100000 100000 011000': 1,\n",
       "  '1 0  000000 000000 000001': 17,\n",
       "  '0 1  000000 000001 100001': 1,\n",
       "  '1 1  000000 000000 110011': 1,\n",
       "  '1 1  001000 000000 100000': 1,\n",
       "  '1 1  000000 000100 000100': 23,\n",
       "  '1 1  100000 100100 000100': 1,\n",
       "  '1 1  000000 100000 010000': 1,\n",
       "  '1 1  100000 101000 001000': 2,\n",
       "  '1 1  000000 010000 010011': 1,\n",
       "  '1 1  000000 000111 000001': 1,\n",
       "  '1 1  000000 100000 100000': 22,\n",
       "  '1 1  000001 000010 110000': 1,\n",
       "  '1 0  000001 000010 000001': 1,\n",
       "  '1 1  000100 000100 011000': 1,\n",
       "  '1 1  001000 001100 000100': 2,\n",
       "  '1 1  010000 010100 000100': 1,\n",
       "  '1 1  001000 001000 110000': 1,\n",
       "  '1 1  100011 110101 010000': 1,\n",
       "  '0 0  000000 000001 100000': 1,\n",
       "  '1 1  010000 100000 110000': 1,\n",
       "  '1 1  000000 000010 011010': 2,\n",
       "  '1 0  000010 000011 000000': 1,\n",
       "  '0 1  000100 000100 100000': 2,\n",
       "  '1 1  010000 000000 100000': 1,\n",
       "  '1 0  000010 000010 000001': 3,\n",
       "  '1 0  000000 000100 000101': 1,\n",
       "  '1 1  000000 000101 001010': 1,\n",
       "  '1 0  000000 010000 100001': 1,\n",
       "  '1 1  000100 110100 000000': 1,\n",
       "  '1 1  010000 100000 000000': 3,\n",
       "  '1 1  000000 001010 010010': 1,\n",
       "  '1 1  000000 000110 011110': 1,\n",
       "  '1 1  000000 000000 101000': 1,\n",
       "  '1 1  000100 010100 010000': 1,\n",
       "  '1 1  000000 001000 000100': 1,\n",
       "  '1 0  000100 000100 000001': 3,\n",
       "  '1 1  000000 010010 010010': 1,\n",
       "  '0 1  000000 100001 000001': 1,\n",
       "  '1 1  001000 000000 001000': 1,\n",
       "  '1 0  000100 001101 000100': 1,\n",
       "  '1 1  001000 001000 000000': 16,\n",
       "  '1 1  000000 000000 110000': 14,\n",
       "  '1 1  010000 010000 000000': 11,\n",
       "  '0 1  001000 001000 100000': 1,\n",
       "  '1 1  010000 011000 010000': 2,\n",
       "  '0 1  000000 100000 110000': 1,\n",
       "  '1 1  110000 000010 001110': 1,\n",
       "  '1 1  000000 000010 001110': 2,\n",
       "  '1 1  101000 101000 000000': 2,\n",
       "  '1 1  000001 000010 011000': 1,\n",
       "  '1 1  001000 001010 000010': 1,\n",
       "  '1 1  000001 000111 000000': 2,\n",
       "  '1 1  001001 000001 001000': 1,\n",
       "  '1 1  100000 000000 100000': 1,\n",
       "  '1 0  000000 000001 000000': 2,\n",
       "  '1 1  000000 011001 000010': 1,\n",
       "  '1 1  000000 001001 100001': 1,\n",
       "  '1 0  000001 000001 000001': 1,\n",
       "  '1 1  001010 001010 000000': 1,\n",
       "  '1 0  000100 000111 000010': 1,\n",
       "  '1 1  000000 000001 110001': 2,\n",
       "  '1 0  000000 000100 001001': 2,\n",
       "  '1 1  000000 000100 001000': 5,\n",
       "  '1 0  100000 100001 000000': 1,\n",
       "  '1 1  000000 000000 110110': 1,\n",
       "  '0 1  000001 000001 100000': 1,\n",
       "  '0 1  000000 010000 110000': 1,\n",
       "  '0 1  000000 000100 100100': 1,\n",
       "  '1 1  000100 000101 000100': 1,\n",
       "  '1 1  000000 100100 100100': 1,\n",
       "  '1 1  000000 010001 010001': 1,\n",
       "  '1 1  000110 000000 000000': 1,\n",
       "  '1 1  001000 101000 100000': 1,\n",
       "  '0 1  000000 000000 111000': 1,\n",
       "  '1 0  000100 000101 000000': 1,\n",
       "  '0 1  000100 100100 000000': 1,\n",
       "  '1 1  100001 110001 100000': 1,\n",
       "  '1 1  000001 000001 000000': 22,\n",
       "  '1 1  000000 001010 001010': 3,\n",
       "  '1 1  000100 000100 110000': 2,\n",
       "  '1 1  000000 110000 000000': 3,\n",
       "  '1 1  000000 000000 011011': 1,\n",
       "  '0 1  000000 100010 000010': 1,\n",
       "  '0 1  000000 000000 101100': 1,\n",
       "  '0 1  000000 100010 000100': 1,\n",
       "  '0 1  000000 001000 101000': 1,\n",
       "  '1 1  010100 010100 011000': 1,\n",
       "  '1 1  000100 001000 000011': 1,\n",
       "  '1 0  000000 100000 100001': 1,\n",
       "  '1 1  000011 000111 000100': 1,\n",
       "  '1 1  001000 001000 000110': 2,\n",
       "  '1 1  001000 010000 000110': 1,\n",
       "  '1 1  000000 001001 010001': 1,\n",
       "  '1 1  000000 000110 001010': 1,\n",
       "  '1 1  000000 000111 000100': 1}}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_syndrome(code,noise_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the non-noisy results are the most likely. The rest of the samples are distributed among other possibilities with non-trivial syndromes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decoding a repetition code\n",
    "\n",
    "Noisy results can change the logical value at readout, and so affect our ability to read out the logical qubit. This can be mitigated by looking at the syndrome values. These can tell us whether or not the logical values are most likely to have changed, and so allow us to correct for the errors. The process of analyzing the syndrome to correct for the errors is called 'decoding'. We do this by building a decoding object for our code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "dec = GraphDecoder( RepetitionCode(4,2) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This analyzes the code by seeing how different kinds of error change the output. With this information, along with a decoding algorithm, we can determine what the logical value is most likely to have been.\n",
    "\n",
    "For example, let's use the 'matching' algorithm to decode, which is based on minimum weight perfect matching. This takes specific output strings as input. We'll give it the simple example string `'1 0  001 100 100'`, for a logical `1` that has suffered two errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1 1'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dec.matching('1 0  001 100 100')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output is what the logical part should have been. As you can see, the decoder correctly determined that the readout should have been of a logical `1`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we take many samples, we can determine the probability with which the decoder is incorrect. This should decrease exponentially as the code size is increased, since the configurations of noise that fool the decoder become less likely. The probability of a logical error is calculated using the `logical_prob()` method. This runs matching by default, but other algorithms can be specified by the `algorithm` kwarg."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d = 3 ,log = 0\n",
      "logical error probability for matching      = 0.032470703125\n",
      "logical error probability for lookup table  = 0.0177001953125\n",
      "logical error probability for postselection = 0.00022598870056497175\n",
      "\n",
      "d = 3 ,log = 1\n",
      "logical error probability for matching      = 0.0296630859375\n",
      "logical error probability for lookup table  = 0.019775390625\n",
      "logical error probability for postselection = 0.00044014084507042255\n",
      "\n",
      "\n",
      "d = 4 ,log = 0\n",
      "logical error probability for matching      = 0.018798828125\n",
      "logical error probability for lookup table  = 0.0081787109375\n",
      "logical error probability for postselection = 0.0\n",
      "\n",
      "d = 4 ,log = 1\n",
      "logical error probability for matching      = 0.01904296875\n",
      "logical error probability for lookup table  = 0.0115966796875\n",
      "logical error probability for postselection = 0.0\n",
      "\n",
      "\n",
      "d = 5 ,log = 0\n",
      "logical error probability for matching      = 0.010986328125\n",
      "logical error probability for lookup table  = 0.0035400390625\n",
      "logical error probability for postselection = 0.0\n",
      "\n",
      "d = 5 ,log = 1\n",
      "logical error probability for matching      = 0.010986328125\n",
      "logical error probability for lookup table  = 0.0018310546875\n",
      "logical error probability for postselection = 0.0\n",
      "\n",
      "\n",
      "d = 6 ,log = 0\n",
      "logical error probability for matching      = 0.0047607421875\n",
      "logical error probability for lookup table  = 0.0003662109375\n",
      "logical error probability for postselection = 0.0\n",
      "\n",
      "d = 6 ,log = 1\n",
      "logical error probability for matching      = 0.0048828125\n",
      "logical error probability for lookup table  = 0.0001220703125\n",
      "logical error probability for postselection = 0.0\n",
      "\n",
      "\n",
      "d = 7 ,log = 0\n",
      "logical error probability for matching      = 0.0032958984375\n",
      "logical error probability for lookup table  = 0.0\n",
      "logical error probability for postselection = 0.0\n",
      "\n",
      "d = 7 ,log = 1\n",
      "logical error probability for matching      = 0.0025634765625\n",
      "logical error probability for lookup table  = 0.0\n",
      "logical error probability for postselection = 0.0\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for d in range(3,8):\n",
    "    \n",
    "    code = RepetitionCode(d,2)\n",
    "    \n",
    "    results = get_syndrome(code,noise_model=noise_model,shots=8192)\n",
    "    \n",
    "    dec = GraphDecoder(code)\n",
    "\n",
    "    logical_prob_match = dec.get_logical_prob(results)\n",
    "    logical_prob_lookup = lookuptable_decoding(results,results)\n",
    "    logical_prob_post = postselection_decoding(results)\n",
    "\n",
    "    for log in ['0','1']:\n",
    "        print('d =',d,',log =',log)\n",
    "        print('logical error probability for matching      =',logical_prob_match[log])\n",
    "        print('logical error probability for lookup table  =',logical_prob_lookup[log])\n",
    "        print('logical error probability for postselection =',logical_prob_post[log])\n",
    "        print('')\n",
    "    print('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T01:35:28.117843Z",
     "start_time": "2019-08-22T01:35:28.108586Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td>Qiskit</td><td>None</td></tr><tr><td>Terra</td><td>0.9.0</td></tr><tr><td>Aer</td><td>0.3.0</td></tr><tr><td>Ignis</td><td>0.2.0</td></tr><tr><td>Aqua</td><td>0.5.3</td></tr><tr><td>IBM Q Provider</td><td>0.3.2rc1</td></tr><tr><th>System information</th></tr><tr><td>Python</td><td>3.7.4 (default, Aug 13 2019, 15:17:50) \n",
       "[Clang 4.0.1 (tags/RELEASE_401/final)]</td></tr><tr><td>OS</td><td>Darwin</td></tr><tr><td>CPUs</td><td>4</td></tr><tr><td>Memory (Gb)</td><td>16.0</td></tr><tr><td colspan='2'>Wed Aug 21 21:35:28 2019 EDT</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2019.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import qiskit.tools.jupyter\n",
    "%qiskit_version_table\n",
    "%qiskit_copyright"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.4"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}