{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decoding Shor's 9-qubit code"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this experiment, we decode Shor's nine-qubit quantum error correcting code which protects a single qubit from all types of errors by using ``mdopt``. Here, we demonstrate direct-error input decoding, which means that the decoder takes a Pauli error as input and outputs the most likely logical operator. This pipeline is sufficient for threshold computation. In reality, the decoder could be shown a syndrome measurement, from which possible error patterns would be sampled. After each run, the algorithm yields a probability distribution over the Pauli operators (I, X, Z, Y) to apply to the encoded logical qubit. Hereafter, we assume an independent noise model as well as perfect syndrome measurements. In this experiment, we do not truncate the tensor network thus perform exact maximum likelihood decoding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import qecstruct as qec\n",
    "import qecsim.paulitools as pt\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "\n",
    "from mdopt.mps.utils import create_custom_product_state\n",
    "from mdopt.optimiser.utils import (\n",
    "    SWAP,\n",
    "    COPY_LEFT,\n",
    "    XOR_BULK,\n",
    "    XOR_LEFT,\n",
    "    XOR_RIGHT,\n",
    ")\n",
    "from examples.decoding.decoding import (\n",
    "    css_code_checks,\n",
    "    css_code_logicals,\n",
    "    css_code_logicals_sites,\n",
    "    css_code_constraint_sites,\n",
    ")\n",
    "from examples.decoding.decoding import (\n",
    "    apply_constraints,\n",
    "    apply_bitflip_bias,\n",
    ")\n",
    "from examples.decoding.decoding import (\n",
    "    pauli_to_mps,\n",
    "    decode_css,\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us first import the code from `qecstruct` and take a look at it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X stabilizers:\n",
      "[0, 1, 2, 3, 4, 5]\n",
      "[3, 4, 5, 6, 7, 8]\n",
      "Z stabilizers:\n",
      "[0, 1]\n",
      "[1, 2]\n",
      "[3, 4]\n",
      "[4, 5]\n",
      "[6, 7]\n",
      "[7, 8]\n",
      "\n",
      "The X logical:  [0, 1, 2]\n",
      "\n",
      "The Z logical:  [0, 3, 6]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "code = qec.shor_code()\n",
    "print(code)\n",
    "print(\"The X logical: \", code.x_logicals_binary())\n",
    "print(\"The Z logical: \", code.z_logicals_binary())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This quantum error correcting code is defined on $9$ physical qubits and has $2$ logical operators because it encodes $1$ logical qubit. This means we will need $9*2 + 2 = 20$ sites in our MPS."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_logicals = code.num_x_logicals() + code.num_z_logicals()\n",
    "num_sites = 2 * len(code) + num_logicals\n",
    "\n",
    "assert num_sites == 20\n",
    "assert num_logicals == 2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let us define the initial state. First of all we will check that no error implies no correction. This means starting from the all-zero state followed by decoding will return all-zero state for the logical operators (the final logical operator will thus be identity operator). Thus, we start from the all-zero state for the error and the $|+\\rangle$ state for the logicals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "error_state = \"0\" * (num_sites - num_logicals)\n",
    "logicals_state = \"+\" * num_logicals\n",
    "state_string = logicals_state + error_state\n",
    "error_mps = create_custom_product_state(string=state_string)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we get the sites where the checks will be applied. We will need to construct MPOs using this data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X checks:\n",
      "[2, 4, 6, 8, 10, 12]\n",
      "[8, 10, 12, 14, 16, 18]\n",
      "Z checks:\n",
      "[3, 5]\n",
      "[5, 7]\n",
      "[9, 11]\n",
      "[11, 13]\n",
      "[15, 17]\n",
      "[17, 19]\n"
     ]
    }
   ],
   "source": [
    "checks_x, checks_z = css_code_checks(code)\n",
    "print(\"X checks:\")\n",
    "for check in checks_x:\n",
    "    print(check)\n",
    "print(\"Z checks:\")\n",
    "for check in checks_z:\n",
    "    print(check)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These lists mention only the sites where we will apply the XOR constraints. However, the MPOs will also consist of other tensors, such as SWAPs (tensors' legs crossings) and boundary XOR constraints. In what follows we define the list of these auxiliary tensors and the corresponding sites where they reside."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "constraints_tensors = [XOR_LEFT, XOR_BULK, SWAP, XOR_RIGHT]\n",
    "logicals_tensors = [COPY_LEFT, XOR_BULK, SWAP, XOR_RIGHT]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Full X-check lists of sites:\n",
      "[[2], [4, 6, 8, 10], [3, 5, 7, 9, 11], [12]]\n",
      "[[8], [10, 12, 14, 16], [9, 11, 13, 15, 17], [18]]\n",
      "Full Z-check lists of sites:\n",
      "[[3], [], [4], [5]]\n",
      "[[5], [], [6], [7]]\n",
      "[[9], [], [10], [11]]\n",
      "[[11], [], [12], [13]]\n",
      "[[15], [], [16], [17]]\n",
      "[[17], [], [18], [19]]\n"
     ]
    }
   ],
   "source": [
    "constraint_sites = css_code_constraint_sites(code)\n",
    "print(\"Full X-check lists of sites:\")\n",
    "for string in constraint_sites[0]:\n",
    "    print(string)\n",
    "print(\"Full Z-check lists of sites:\")\n",
    "for string in constraint_sites[1]:\n",
    "    print(string)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us now again take a look at the logical operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2]\n",
      "\n",
      "[0, 3, 6]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(code.x_logicals_binary())\n",
    "print(code.z_logicals_binary())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to again translate them to our MPO language by changing the indices since we add the logical sites at the beginning of the MPS."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2, 4, 6]]\n",
      "[[3, 9, 15]]\n"
     ]
    }
   ],
   "source": [
    "print(css_code_logicals(code)[0])\n",
    "print(css_code_logicals(code)[1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now goes the same operation of adding sites where auxiliary tensors should be placed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0], [2, 4], [1, 3, 5], [6]]]\n",
      "[[[1], [3, 9], [2, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14], [15]]]\n"
     ]
    }
   ],
   "source": [
    "logicals_sites = css_code_logicals_sites(code)\n",
    "print(css_code_logicals_sites(code)[0])\n",
    "print(css_code_logicals_sites(code)[1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the fun part, MPS-MPO contraction. But first, we apply the bias channel to our error state. This is done to bias our output towards the received input. This is done by distributing the amplitude around the initial basis product state to other basis product states in the descending order by Hamming distance."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, the tensor network we are going to build is going to look as follows:\n",
    "<img src=\"shor-decoder.png\" alt=\"Tensor-network error-based decoder for the Shor's 9-qubit code.\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "renormalise = True\n",
    "sites_to_bias = list(range(num_logicals, num_sites))\n",
    "error_mps = apply_bitflip_bias(\n",
    "    mps=error_mps,\n",
    "    sites_to_bias=sites_to_bias,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2/2 [00:00<00:00, 299.00it/s]\n",
      "100%|██████████| 6/6 [00:00<00:00, 1443.99it/s]\n",
      "100%|██████████| 1/1 [00:00<00:00, 353.00it/s]\n",
      "100%|██████████| 1/1 [00:00<00:00, 285.31it/s]\n"
     ]
    }
   ],
   "source": [
    "for i in [0, 1]:\n",
    "    error_mps = apply_constraints(\n",
    "        error_mps,\n",
    "        constraint_sites[i],\n",
    "        constraints_tensors,\n",
    "        renormalise=renormalise,\n",
    "        strategy=\"Optimised\",\n",
    "    )\n",
    "for i in [0, 1]:\n",
    "    error_mps = apply_constraints(\n",
    "        error_mps,\n",
    "        logicals_sites[i],\n",
    "        logicals_tensors,\n",
    "        renormalise=renormalise,\n",
    "        strategy=\"Optimised\",\n",
    "    )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we marginalise over the message bits to get the probability distribution over the four possibilities of a logical operator: $I$, $X$, $Z$, $Y$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.61225663 0.06778069 0.28807136 0.03189132]\n"
     ]
    }
   ],
   "source": [
    "sites_to_marginalise = list(range(num_logicals, len(error_state) + num_logicals))\n",
    "logical = error_mps.marginal(sites_to_marginalise=sites_to_marginalise).dense(\n",
    "    flatten=True, renormalise=True, norm=1\n",
    ")\n",
    "print(logical)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which indeed tells us that most likely we do not need to apply any operator!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now put all of this into a function. We'll need this to run the decoder over a bunch of single- and multiqubit errors."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now generate all possible one-, two- and three-qubit errors using `qecsim`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "one_qubit_paulis = pt.ipauli(n_qubits=len(code), min_weight=1, max_weight=1)\n",
    "two_qubit_paulis = pt.ipauli(n_qubits=len(code), min_weight=2, max_weight=2)\n",
    "three_qubit_paulis = pt.ipauli(n_qubits=len(code), min_weight=3, max_weight=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0it [00:00, ?it/s]/Users/aleksandrberezutskii/mdopt/mdopt/mps/canonical.py:1031: RuntimeWarning: invalid value encountered in true_divide\n",
      "  self.tensors[self.orth_centre] /= orth_centre_norm\n",
      "27it [00:00, 167.62it/s]\n"
     ]
    }
   ],
   "source": [
    "one_qubit_outputs = [\n",
    "    decode_css(\n",
    "        code,\n",
    "        error,\n",
    "        bias_type=\"Bitflip\",\n",
    "        renormalise=renormalise,\n",
    "        silent=True,\n",
    "        bias_prob=0,\n",
    "    )\n",
    "    for error in tqdm(one_qubit_paulis)\n",
    "]\n",
    "one_qubit_corrections_distribution = [output[0] for output in one_qubit_outputs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "324it [00:02, 136.81it/s]\n"
     ]
    }
   ],
   "source": [
    "two_qubit_outputs = [\n",
    "    decode_css(\n",
    "        code,\n",
    "        error,\n",
    "        bias_type=\"Bitflip\",\n",
    "        renormalise=renormalise,\n",
    "        silent=True,\n",
    "        bias_prob=1e-2,\n",
    "    )\n",
    "    for error in tqdm(two_qubit_paulis)\n",
    "]\n",
    "two_qubit_corrections_distribution = [output[0] for output in two_qubit_outputs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2268it [00:19, 117.83it/s]\n"
     ]
    }
   ],
   "source": [
    "three_qubit_outputs = [\n",
    "    decode_css(\n",
    "        code,\n",
    "        error,\n",
    "        bias_type=\"Bitflip\",\n",
    "        renormalise=renormalise,\n",
    "        silent=True,\n",
    "        bias_prob=1e-2,\n",
    "    )\n",
    "    for error in tqdm(three_qubit_paulis)\n",
    "]\n",
    "three_qubit_corrections_distribution = [output[0] for output in three_qubit_outputs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def map_distribution_to_pauli(distribution):\n",
    "    mapping = {0: \"I\", 1: \"X\", 2: \"Z\", 3: \"Y\"}\n",
    "    result = []\n",
    "\n",
    "    for array in distribution:\n",
    "        max_index = np.argmax(array)\n",
    "        result.append(mapping[max_index])\n",
    "\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(map_distribution_to_pauli(one_qubit_corrections_distribution))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGdCAYAAAA44ojeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAW2UlEQVR4nO3dfWyV9f3/8VcBqaK0pCoUYr3bdOCmzuDEOrd4QwR0bkS2DMcWMUQXByTaOCfOwVyWwAyZZgZlS1RmAmMz2TBixsIwwBYrKIuZM2rUoGCwgBJaYLEg9PvHL5786u3A1vOhPh7Jldjr+vQ672M48Mx1rtPWdHV1dQUAoCD9qj0AAMB7CRQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKM6DaAxyKAwcOZMuWLRk8eHBqamqqPQ4A8D/o6urKrl27MmLEiPTr99HXSA7LQNmyZUuampqqPQYAcAg2b96cE0444SPXHJaBMnjw4CT/7wnW1dVVeRoA4H/R0dGRpqamyr/jH+WwDJR339apq6sTKABwmPlfbs9wkywAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUZ0C1ByjRybc+Vu0RDtqr866o9ggA0GNcQQEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKc1CBMnfu3HzlK1/J4MGDM3To0EycODEvvvhitzVvv/12pk+fnmOPPTbHHHNMJk2alK1bt3Zbs2nTplxxxRUZNGhQhg4dmh//+Md55513PvmzAQD6hIMKlDVr1mT69Ol58skns3Llyuzbty+XXXZZ9uzZU1lz00035dFHH83DDz+cNWvWZMuWLbnqqqsqx/fv358rrrgie/fuzRNPPJHf//73WbRoUWbPnt1zzwoAOKzVdHV1dR3qN2/fvj1Dhw7NmjVr8vWvfz3t7e05/vjjs2TJknz7299OkrzwwgsZNWpUWltbc/755+evf/1rvvGNb2TLli0ZNmxYkmThwoX5yU9+ku3bt2fgwIEf+7gdHR2pr69Pe3t76urqDnX8D3XyrY/1+Dl726vzrqj2CADwkQ7m3+9PdA9Ke3t7kqShoSFJsmHDhuzbty9jx46trBk5cmROPPHEtLa2JklaW1tz5plnVuIkScaNG5eOjo4899xzH/g4nZ2d6ejo6LYBAH3XIQfKgQMHcuONN+arX/1qvvSlLyVJ2traMnDgwAwZMqTb2mHDhqWtra2y5v+Pk3ePv3vsg8ydOzf19fWVramp6VDHBgAOA4ccKNOnT89//vOfLF26tCfn+UCzZs1Ke3t7Zdu8eXOvPyYAUD0DDuWbZsyYkeXLl2ft2rU54YQTKvsbGxuzd+/e7Ny5s9tVlK1bt6axsbGyZv369d3O9+6nfN5d8161tbWpra09lFEBgMPQQV1B6erqyowZM/KXv/wljz/+eE455ZRux0ePHp0jjjgiq1atqux78cUXs2nTpjQ3NydJmpub8+yzz2bbtm2VNStXrkxdXV3OOOOMT/JcAIA+4qCuoEyfPj1LlizJI488ksGDB1fuGamvr89RRx2V+vr6TJs2LS0tLWloaEhdXV1mzpyZ5ubmnH/++UmSyy67LGeccUZ+8IMf5M4770xbW1tuv/32TJ8+3VUSACDJQQbKfffdlyS56KKLuu1/8MEHM3Xq1CTJXXfdlX79+mXSpEnp7OzMuHHjcu+991bW9u/fP8uXL88NN9yQ5ubmHH300bnmmmvyi1/84pM9EwCgz/hEPwelWvwclPfzc1AAKN2n9nNQAAB6g0ABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiHHSgrF27NldeeWVGjBiRmpqaLFu2rNvxqVOnpqampts2fvz4bmt27NiRKVOmpK6uLkOGDMm0adOye/fuT/REAIC+46ADZc+ePTn77LOzYMGCD10zfvz4vPHGG5XtD3/4Q7fjU6ZMyXPPPZeVK1dm+fLlWbt2ba6//vqDnx4A6JMGHOw3TJgwIRMmTPjINbW1tWlsbPzAY88//3xWrFiRp556Kueee26S5J577snll1+e+fPnZ8SIEQc7EgDQx/TKPSirV6/O0KFD84UvfCE33HBD3nrrrcqx1tbWDBkypBInSTJ27Nj069cv69at+8DzdXZ2pqOjo9sGAPRdPR4o48ePz0MPPZRVq1blV7/6VdasWZMJEyZk//79SZK2trYMHTq02/cMGDAgDQ0NaWtr+8Bzzp07N/X19ZWtqampp8cGAApy0G/xfJzJkydX/vvMM8/MWWedlc997nNZvXp1Lr300kM656xZs9LS0lL5uqOjQ6QAQB/W6x8zPvXUU3Pcccfl5ZdfTpI0NjZm27Zt3da888472bFjx4fet1JbW5u6urpuGwDQd/V6oLz++ut56623Mnz48CRJc3Nzdu7cmQ0bNlTWPP744zlw4EDGjBnT2+MAAIeBg36LZ/fu3ZWrIUmycePGPPPMM2loaEhDQ0PuuOOOTJo0KY2NjXnllVdyyy235POf/3zGjRuXJBk1alTGjx+f6667LgsXLsy+ffsyY8aMTJ482Sd4AIAkh3AF5emnn84555yTc845J0nS0tKSc845J7Nnz07//v3z73//O9/85jdz+umnZ9q0aRk9enT+8Y9/pLa2tnKOxYsXZ+TIkbn00ktz+eWX58ILL8zvfve7nntWAMBh7aCvoFx00UXp6ur60ON/+9vfPvYcDQ0NWbJkycE+NADwGeF38QAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEOOlDWrl2bK6+8MiNGjEhNTU2WLVvW7XhXV1dmz56d4cOH56ijjsrYsWPz0ksvdVuzY8eOTJkyJXV1dRkyZEimTZuW3bt3f6InAgD0HQcdKHv27MnZZ5+dBQsWfODxO++8M7/5zW+ycOHCrFu3LkcffXTGjRuXt99+u7JmypQpee6557Jy5cosX748a9euzfXXX3/ozwIA6FMGHOw3TJgwIRMmTPjAY11dXbn77rtz++2351vf+laS5KGHHsqwYcOybNmyTJ48Oc8//3xWrFiRp556Kueee26S5J577snll1+e+fPnZ8SIEZ/g6QAAfUGP3oOycePGtLW1ZezYsZV99fX1GTNmTFpbW5Mkra2tGTJkSCVOkmTs2LHp169f1q1b94Hn7ezsTEdHR7cNAOi7ejRQ2trakiTDhg3rtn/YsGGVY21tbRk6dGi34wMGDEhDQ0NlzXvNnTs39fX1la2pqaknxwYACnNYfIpn1qxZaW9vr2ybN2+u9kgAQC/q0UBpbGxMkmzdurXb/q1bt1aONTY2Ztu2bd2Ov/POO9mxY0dlzXvV1tamrq6u2wYA9F09GiinnHJKGhsbs2rVqsq+jo6OrFu3Ls3NzUmS5ubm7Ny5Mxs2bKisefzxx3PgwIGMGTOmJ8cBAA5TB/0pnt27d+fll1+ufL1x48Y888wzaWhoyIknnpgbb7wxv/zlL3PaaafllFNOyc9+9rOMGDEiEydOTJKMGjUq48ePz3XXXZeFCxdm3759mTFjRiZPnuwTPABAkkMIlKeffjoXX3xx5euWlpYkyTXXXJNFixbllltuyZ49e3L99ddn586dufDCC7NixYoceeSRle9ZvHhxZsyYkUsvvTT9+vXLpEmT8pvf/KYHng4A0BfUdHV1dVV7iIPV0dGR+vr6tLe398r9KCff+liPn7O3vTrvimqPAAAf6WD+/T4sPsUDAHy2CBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAijOg2gMAQF928q2PVXuEQ/LqvCuq+viuoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHF6PFB+/vOfp6ampts2cuTIyvG3334706dPz7HHHptjjjkmkyZNytatW3t6DADgMNYrV1C++MUv5o033qhs//znPyvHbrrppjz66KN5+OGHs2bNmmzZsiVXXXVVb4wBABymBvTKSQcMSGNj4/v2t7e35/7778+SJUtyySWXJEkefPDBjBo1Kk8++WTOP//83hgHADjM9MoVlJdeeikjRozIqaeemilTpmTTpk1Jkg0bNmTfvn0ZO3ZsZe3IkSNz4oknprW19UPP19nZmY6Ojm4bANB39XigjBkzJosWLcqKFSty3333ZePGjfna176WXbt2pa2tLQMHDsyQIUO6fc+wYcPS1tb2oeecO3du6uvrK1tTU1NPjw0AFKTH3+KZMGFC5b/POuusjBkzJieddFL+9Kc/5aijjjqkc86aNSstLS2Vrzs6OkQKAPRhvf4x4yFDhuT000/Pyy+/nMbGxuzduzc7d+7stmbr1q0feM/Ku2pra1NXV9dtAwD6rl4PlN27d+eVV17J8OHDM3r06BxxxBFZtWpV5fiLL76YTZs2pbm5ubdHAQAOEz3+Fs/NN9+cK6+8MieddFK2bNmSOXPmpH///rn66qtTX1+fadOmpaWlJQ0NDamrq8vMmTPT3NzsEzwAQEWPB8rrr7+eq6++Om+99VaOP/74XHjhhXnyySdz/PHHJ0nuuuuu9OvXL5MmTUpnZ2fGjRuXe++9t6fHAAAOYz0eKEuXLv3I40ceeWQWLFiQBQsW9PRDAwB9hN/FAwAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFESgAQHEECgBQHIECABRHoAAAxREoAEBxBAoAUByBAgAUR6AAAMURKABAcQQKAFAcgQIAFEegAADFGVDtAQDe6+RbH6v2CAft1XlXVHsE6FNcQQEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOAIFACiOQAEAiiNQAIDiCBQAoDhVDZQFCxbk5JNPzpFHHpkxY8Zk/fr11RwHAChE1QLlj3/8Y1paWjJnzpz861//ytlnn51x48Zl27Zt1RoJAChE1QLl17/+da677rpce+21OeOMM7Jw4cIMGjQoDzzwQLVGAgAKMaAaD7p3795s2LAhs2bNquzr169fxo4dm9bW1vet7+zsTGdnZ+Xr9vb2JElHR0evzHeg87+9ct7e1Fv/L6AavAbpSw7HP89J7/yZfvecXV1dH7u2KoHy5ptvZv/+/Rk2bFi3/cOGDcsLL7zwvvVz587NHXfc8b79TU1NvTbj4ab+7mpPAJ9tXoP0Nb35Z3rXrl2pr6//yDVVCZSDNWvWrLS0tFS+PnDgQHbs2JFjjz02NTU1PfpYHR0daWpqyubNm1NXV9ej5wY+ntcgVF9vvQ67urqya9eujBgx4mPXViVQjjvuuPTv3z9bt27ttn/r1q1pbGx83/ra2trU1tZ22zdkyJDeHDF1dXX+coQq8hqE6uuN1+HHXTl5V1Vukh04cGBGjx6dVatWVfYdOHAgq1atSnNzczVGAgAKUrW3eFpaWnLNNdfk3HPPzXnnnZe77747e/bsybXXXlutkQCAQlQtUL773e9m+/btmT17dtra2vLlL385K1aseN+Ns5+22trazJkz531vKQGfDq9BqL4SXoc1Xf/LZ30AAD5FfhcPAFAcgQIAFEegAADFESgAQHEEyntMnTo1EydOrPYY8JmyevXq1NTUfOh28cUXV3tE6NP279+fCy64IFdddVW3/e3t7WlqaspPf/rTT30mgQJU3QUXXJA33njjfdtvf/vb1NTU5Ec/+lG1R4Q+rX///lm0aFFWrFiRxYsXV/bPnDkzDQ0NmTNnzqc+02Hxu3iAvm3gwIHv+zUXzz//fG6++ebcdttt+c53vlOlyeCz4/TTT8+8efMyc+bMXHLJJVm/fn2WLl2ap556KgMHDvzU5/FzUN5j6tSp2blzZ5YtW1btUeAza+fOnTnvvPMycuTIPPLIIz3+S0GBD9bV1ZVLLrkk/fv3z7PPPpuZM2fm9ttvr8osrqAARTlw4EC+973vZcCAAVm8eLE4gU9RTU1N7rvvvowaNSpnnnlmbr311qrN4h4UoCi33XZbWltb88gjj2Tw4MHVHgc+cx544IEMGjQoGzduzOuvv161OQQKUIylS5dm/vz5Wbp0aU477bRqjwOfOU888UTuuuuuLF++POedd16mTZuWat0JIlCAIjzzzDOZNm1a5s2bl3HjxlV7HPjM+e9//5upU6fmhhtuyMUXX5z7778/69evz8KFC6syj0ABqu7NN9/MxIkTc9FFF+X73/9+2traum3bt2+v9ojQ582aNStdXV2ZN29ekuTkk0/O/Pnzc8stt+TVV1/91OdxkyxQdY899lhee+21vPbaaxk+fPj7jp900klV+QsSPivWrFmTBQsWZPXq1Rk0aFBl/w9/+MP8+c9/zrRp0/L3v//9U71p3ceMAYDieIsHACiOQAEAiiNQAIDiCBQAoDgCBQAojkABAIojUACA4ggUAKA4AgUAKI5AAQCKI1AAgOIIFACgOP8HgU4qYSGdeAsAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(map_distribution_to_pauli(two_qubit_corrections_distribution))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(map_distribution_to_pauli(three_qubit_corrections_distribution))\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now check by hand that some of the decoder's nontrivial outputs are indeed correct. First of all, from all one-qubit errors we get the Identity operator which corresponds to the fact that Shor's code corrects all one-qubit errors. However, Shor's code can also correct some two-qubit errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "one_qubit_paulis = list(pt.ipauli(n_qubits=len(code), min_weight=1, max_weight=1))\n",
    "two_qubit_paulis = list(pt.ipauli(n_qubits=len(code), min_weight=2, max_weight=2))\n",
    "three_qubit_paulis = list(pt.ipauli(n_qubits=len(code), min_weight=3, max_weight=3))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at the first 20 errors which result in the Identity logical operator as the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "XXIIIIIII\n",
      "XZIIIIIII\n",
      "XYIIIIIII\n",
      "ZXIIIIIII\n",
      "YXIIIIIII\n",
      "YYIIIIIII\n",
      "XIXIIIIII\n",
      "XIZIIIIII\n",
      "XIYIIIIII\n",
      "ZIXIIIIII\n",
      "YIXIIIIII\n",
      "YIYIIIIII\n",
      "XIIZIIIII\n",
      "ZIIXIIIII\n"
     ]
    }
   ],
   "source": [
    "limit = 20\n",
    "for i, correction in enumerate(\n",
    "    map_distribution_to_pauli(two_qubit_corrections_distribution)\n",
    "):\n",
    "    if correction == \"I\":\n",
    "        print(two_qubit_paulis[i])\n",
    "    if i > limit:\n",
    "        break"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now want to dive a bit more into what is happening inside the decoder to be able to better understand the results, even though the current setup is already sufficient for calculating thresholds. For example, the first error $(X_0 X_1)$ from the list above would trigger the first $X$ parity check in the case of measuring it. This can be seen from the actual tensor network we are building (see the image below). However, in the current setup the stabilisers are being set to $0$, which is the result of the fact that the $\\text{XOR}$ tensors we use project out the inputs of odd (i.e., equal to $1$) parity. After applying the logical-operator MPOs and performing marginalization, the process yields a marginal distribution over codewords, each reflecting different parities of the logical operators.\n",
    "\n",
    "<img src=\"shor-decoder.png\" alt=\"Tensor-network error-based decoder for the Shor's 9-qubit code.\"/>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now take a look at the errors which result in the $X$ logical operator as the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "XIIXIIIII\n",
      "XIIYIIIII\n",
      "YIIXIIIII\n",
      "XIIIXIIII\n",
      "XIIIYIIII\n",
      "YIIIXIIII\n",
      "XIIIIXIII\n",
      "XIIIIYIII\n",
      "YIIIIXIII\n",
      "XIIIIIXII\n",
      "XIIIIIYII\n",
      "YIIIIIXII\n",
      "XIIIIIIXI\n",
      "XIIIIIIYI\n",
      "YIIIIIIXI\n",
      "XIIIIIIIX\n",
      "XIIIIIIIY\n",
      "YIIIIIIIX\n",
      "IXIXIIIII\n",
      "IXIYIIIII\n",
      "IYIXIIIII\n",
      "IXIIXIIII\n",
      "IXIIYIIII\n",
      "IYIIXIIII\n",
      "IXIIIXIII\n",
      "IXIIIYIII\n",
      "IYIIIXIII\n",
      "IXIIIIXII\n",
      "IXIIIIYII\n",
      "IYIIIIXII\n",
      "IXIIIIIXI\n",
      "IXIIIIIYI\n",
      "IYIIIIIXI\n",
      "IXIIIIIIX\n",
      "IXIIIIIIY\n",
      "IYIIIIIIX\n",
      "IIXXIIIII\n",
      "IIXYIIIII\n",
      "IIYXIIIII\n",
      "IIXIXIIII\n",
      "IIXIYIIII\n",
      "IIYIXIIII\n",
      "IIXIIXIII\n",
      "IIXIIYIII\n",
      "IIYIIXIII\n",
      "IIXIIIXII\n",
      "IIXIIIYII\n",
      "IIYIIIXII\n",
      "IIXIIIIXI\n",
      "IIXIIIIYI\n",
      "IIYIIIIXI\n",
      "IIXIIIIIX\n",
      "IIXIIIIIY\n",
      "IIYIIIIIX\n",
      "IIIXIIXII\n",
      "IIIXIIYII\n",
      "IIIYIIXII\n",
      "IIIXIIIXI\n",
      "IIIXIIIYI\n",
      "IIIYIIIXI\n",
      "IIIXIIIIX\n",
      "IIIXIIIIY\n",
      "IIIYIIIIX\n",
      "IIIIXIXII\n",
      "IIIIXIYII\n",
      "IIIIYIXII\n",
      "IIIIXIIXI\n",
      "IIIIXIIYI\n",
      "IIIIYIIXI\n",
      "IIIIXIIIX\n",
      "IIIIXIIIY\n",
      "IIIIYIIIX\n",
      "IIIIIXXII\n",
      "IIIIIXYII\n",
      "IIIIIYXII\n",
      "IIIIIXIXI\n",
      "IIIIIXIYI\n",
      "IIIIIYIXI\n",
      "IIIIIXIIX\n",
      "IIIIIXIIY\n",
      "IIIIIYIIX\n"
     ]
    }
   ],
   "source": [
    "for i, correction in enumerate(\n",
    "    map_distribution_to_pauli(two_qubit_corrections_distribution)\n",
    "):\n",
    "    if correction == \"X\":\n",
    "        print(two_qubit_paulis[i])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly to the previous case, the first error $(X_0 X_3)$ from the list above would trigger the first $X$ parity check which in its turn would trigger the $\\text{XOR}$ tensor corresponding to the $X$ logical-operator MPO therefore the $X$ logical as the most likely output."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mdopt-ZdbamFdU-py3.10",
   "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.10.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}