{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decoding classical LDPC codes"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this experiment, we decode a classical linear error correcting code -- Low Density Parity Check (LDPC) code.\n",
    "First, we build a Matrix Product State containing the superposition of all codewords of a code instance.\n",
    "Then, we demostrate simple decoding of a classical LDPC code using Dephasing DMRG --\n",
    "our own built-in DMRG-like optimisation algorithm to solve the main component problem --\n",
    "the problem of finding a computational basis state cotributing the most to a given state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib\n",
    "from tqdm import tqdm\n",
    "import qecstruct as qec\n",
    "from scipy.stats import sem\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import Normalize\n",
    "from matplotlib.ticker import FormatStrFormatter\n",
    "from mdopt.optimiser.utils import (\n",
    "    ConstraintString,\n",
    "    IDENTITY,\n",
    "    SWAP,\n",
    "    XOR_BULK,\n",
    "    XOR_LEFT,\n",
    "    XOR_RIGHT,\n",
    ")\n",
    "from examples.decoding.decoding import (\n",
    "    linear_code_parity_matrix_dense,\n",
    "    linear_code_constraint_sites,\n",
    "    linear_code_prepare_message,\n",
    "    linear_code_codewords,\n",
    "    linear_code_checks,\n",
    ")\n",
    "from examples.decoding.decoding import (\n",
    "    apply_bitflip_bias,\n",
    "    apply_constraints,\n",
    "    decode_message,\n",
    ")\n",
    "from mdopt.mps.utils import (\n",
    "    create_simple_product_state,\n",
    "    create_custom_product_state,\n",
    ")\n",
    "from mdopt.utils.utils import mpo_to_matrix"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us first fix a random seed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "SEED = 123"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we're going to define the parameters of a classical LDPC code. Since our first experiment will be getting out all of the codewords, we start with a small code so that we can do a dense-form simulation to check against the MPS-MPO evolution simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "NUM_BITS, NUM_CHECKS = 12, 9\n",
    "CHECK_DEGREE, BIT_DEGREE = 4, 3\n",
    "if NUM_BITS / NUM_CHECKS != CHECK_DEGREE / BIT_DEGREE:\n",
    "    raise ValueError(\"The Tanner graph of the code must be bipartite.\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let us construct the code object from ``qecstruct`` and prepare the initial MPS state as well as its dense-form vis-à-vis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "example_code = qec.random_regular_code(\n",
    "    NUM_BITS, NUM_CHECKS, BIT_DEGREE, CHECK_DEGREE, qec.Rng(SEED)\n",
    ")\n",
    "\n",
    "state = create_simple_product_state(NUM_BITS, which=\"+\")\n",
    "state_dense = state.dense(flatten=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we translate the error correcting code to the MPS-MPO language. This means we get the sites where the parity checks will be applied. We will construct MPOs using this data. These lists mention not only the sites where we will apply the XOR constraints but also other tensors, such as SWAPs (a.k.a. tensors' legs' crossings) as well as the boundary XOR constraints. In what follows we define the list of these auxiliary tensors and the corresponding sites where they should reside."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[[0], [6, 10], [1, 2, 3, 4, 5, 7, 8, 9], [11]],\n",
       " [[2], [4, 8], [3, 5, 6, 7, 9], [10]],\n",
       " [[1], [6, 9], [2, 3, 4, 5, 7, 8], [10]],\n",
       " [[0], [4, 7], [1, 2, 3, 5, 6], [8]],\n",
       " [[2], [4, 6], [3, 5], [7]],\n",
       " [[3], [5, 7], [4, 6], [8]],\n",
       " [[0], [2, 3], [1, 4, 5, 6, 7, 8], [9]],\n",
       " [[1], [5, 9], [2, 3, 4, 6, 7, 8, 10], [11]],\n",
       " [[1], [3, 5], [2, 4, 6, 7, 8, 9, 10], [11]]]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code_constraint_sites = linear_code_constraint_sites(example_code)\n",
    "tensors = [XOR_LEFT, XOR_BULK, SWAP, XOR_RIGHT]\n",
    "code_constraint_sites"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, we are ready to check the codewords! We will do this by explicitly constructing the MPS containing equal superposition of all codewords, densifying it and finally checking all the non-zero elements. This MPS will be prepared by applying constraint MPOs to a all-plus state while renormalising it after each contraction so that the norm isn't being lost. We start with the MPS-MPO contraction:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 9/9 [00:00<00:00, 72.00it/s]\n"
     ]
    }
   ],
   "source": [
    "state = apply_constraints(\n",
    "    state,\n",
    "    code_constraint_sites,\n",
    "    tensors,\n",
    "    renormalise=True,\n",
    "    silent=False,\n",
    "    strategy=\"Naive\",\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and continue by the dense-form simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 9/9 [00:01<00:00,  4.66it/s]\n"
     ]
    }
   ],
   "source": [
    "# Preparing the codeword superposition state in the dense form.\n",
    "for j in tqdm(range(NUM_CHECKS)):\n",
    "    # Preparing the MPO.\n",
    "    constraint_string = ConstraintString(tensors, code_constraint_sites[j])\n",
    "    constraint_mpo = constraint_string.mpo()\n",
    "\n",
    "    # Finding the starting site of the MPS to build a correct dense-form operator.\n",
    "    START_SITE = min(constraint_string.flat())\n",
    "\n",
    "    # Preparing the dense-form operator.\n",
    "    identities_l = [IDENTITY for _ in range(START_SITE)]\n",
    "    identities_r = [\n",
    "        IDENTITY for _ in range(NUM_BITS - len(constraint_mpo) - START_SITE)\n",
    "    ]\n",
    "    full_mpo = identities_l + constraint_mpo + identities_r\n",
    "    mpo_dense = mpo_to_matrix(full_mpo, interlace=False, group=True)\n",
    "\n",
    "    # Doing the contraction in dense form.\n",
    "    state_dense = mpo_dense @ state_dense"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are ready to check that the two objects represent the same thing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Codewords from the generator matrix:\n",
      "[   0   58  407  429 3666 3688 4037 4095]\n",
      "Codewords from the dense-form simulation:\n",
      "[   0   58  407  429 3666 3688 4037 4095]\n",
      "Codewords from the MPS-form simulation:\n",
      "[   0   58  407  429 3666 3688 4037 4095]\n",
      "\n",
      "All lists of codewords match: True\n"
     ]
    }
   ],
   "source": [
    "# Tolerance under which we round tensor elements to zero.\n",
    "TOL = 1e-12\n",
    "mps_dense = state.dense(flatten=True)\n",
    "mps_dense[np.abs(mps_dense) < TOL] = 0\n",
    "\n",
    "# Retreiving codewords.\n",
    "cwords = linear_code_codewords(example_code)\n",
    "cwords_to_compare_mps = np.flatnonzero(mps_dense)\n",
    "cwords_to_compare_dense = np.flatnonzero(state_dense)\n",
    "\n",
    "print()\n",
    "print(\"Codewords from the generator matrix:\")\n",
    "print(cwords)\n",
    "print(\"Codewords from the dense-form simulation:\")\n",
    "print(cwords_to_compare_mps)\n",
    "print(\"Codewords from the MPS-form simulation:\")\n",
    "print(cwords_to_compare_dense)\n",
    "print(\"\")\n",
    "print(\n",
    "    \"All lists of codewords match:\",\n",
    "    np.logical_and(\n",
    "        np.array_equal(cwords, cwords_to_compare_mps),\n",
    "        np.array_equal(cwords_to_compare_mps, cwords_to_compare_dense),\n",
    "    ),\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have checked that we are able to prepare the codeword state, let's try and do the decoding. The setup is as follows: we receive a message (which might contain errors) and need to find what was the initial message. In order to do this, we first apply a bitflip bias to our MPS, which biases the state towards the received message by redistributing the amplitudes according to the Hamming distance from the message. Then, we apply the parity checks and solve the main component problem. Let's see how this works in practice. Note, that the final overlap quantity received from the algorithm can be either $0$ or $1$ (the anticipated outcome) because in the end we need a basis product state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Retreiving a perturbed codeword:\n",
      "\n",
      "The initial codeword is   00001011111000010001\n",
      "The perturbed codeword is 00000011111010000100\n",
      "\n",
      "Applying constraints:\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 15/15 [00:13<00:00,  1.08it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Decoding:\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1/1 [00:00<00:00,  7.76it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "The overlap of the density MPO main component and the initial codeword state:  1.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"\")\n",
    "print(\"Retreiving a perturbed codeword:\")\n",
    "print(\"\")\n",
    "\n",
    "# Defining the parameters of a classical LDPC code.\n",
    "NUM_BITS, NUM_CHECKS = 20, 15\n",
    "CHECK_DEGREE, BIT_DEGREE = 4, 3\n",
    "if NUM_BITS / NUM_CHECKS != CHECK_DEGREE / BIT_DEGREE:\n",
    "    raise ValueError(\"The Tanner graph of the code must be bipartite.\")\n",
    "\n",
    "# Defining the bias channel parameter and the error rate.\n",
    "ERROR_RATE = 0.15\n",
    "PROB_BIAS = ERROR_RATE\n",
    "\n",
    "# Maximum bond dimension and spectra cut for contractor/DMRG.\n",
    "CHI_MAX_CONTRACTOR = 1e4\n",
    "CHI_MAX_DMRG = 1e4\n",
    "CUT = 1e-12\n",
    "# Number of DMRG sweeps.\n",
    "NUM_DMRG_RUNS = 1\n",
    "\n",
    "# Constructing the code as a qecstruct object.\n",
    "example_code = qec.random_regular_code(\n",
    "    NUM_BITS, NUM_CHECKS, BIT_DEGREE, CHECK_DEGREE, qec.Rng(SEED)\n",
    ")\n",
    "\n",
    "# Getting the sites where each string of constraints should be applied.\n",
    "code_constraint_sites = linear_code_constraint_sites(example_code)\n",
    "\n",
    "# Building an initial and a perturbed codeword.\n",
    "INITIAL_CODEWORD, PERTURBED_CODEWORD = linear_code_prepare_message(\n",
    "    example_code, ERROR_RATE, error_model=qec.BinarySymmetricChannel, seed=SEED\n",
    ")\n",
    "print(\"The initial codeword is  \", INITIAL_CODEWORD)\n",
    "print(\"The perturbed codeword is\", PERTURBED_CODEWORD)\n",
    "print(\"\")\n",
    "\n",
    "# Building the corresponding matrix product states.\n",
    "initial_codeword_state = create_custom_product_state(\n",
    "    INITIAL_CODEWORD, form=\"Right-canonical\"\n",
    ")\n",
    "perturbed_codeword_state = create_custom_product_state(\n",
    "    PERTURBED_CODEWORD, form=\"Right-canonical\"\n",
    ")\n",
    "\n",
    "# Applying the bitflip bias to the perturbed codeword state.\n",
    "perturbed_codeword_state = apply_bitflip_bias(\n",
    "    mps=perturbed_codeword_state,\n",
    "    sites_to_bias=\"All\",\n",
    "    prob_bias_list=PROB_BIAS,\n",
    ")\n",
    "\n",
    "print(\"Applying constraints:\")\n",
    "print(\"\")\n",
    "# Applying the parity constraints defined by the code.\n",
    "perturbed_codeword_state = apply_constraints(\n",
    "    perturbed_codeword_state,\n",
    "    code_constraint_sites,\n",
    "    tensors,\n",
    "    chi_max=CHI_MAX_CONTRACTOR,\n",
    "    renormalise=True,\n",
    "    strategy=\"Optimised\",\n",
    "    silent=False,\n",
    ")\n",
    "\n",
    "print(\"\")\n",
    "print(\"Decoding:\")\n",
    "print(\"\")\n",
    "# Decoding the perturbed codeword.\n",
    "dmrg_container, success = decode_message(\n",
    "    message=perturbed_codeword_state,\n",
    "    codeword=initial_codeword_state,\n",
    "    num_runs=NUM_DMRG_RUNS,\n",
    "    chi_max_dmrg=CHI_MAX_DMRG,\n",
    "    cut=CUT,\n",
    "    silent=False,\n",
    ")\n",
    "print(\"\")\n",
    "print(\n",
    "    \"The overlap of the density MPO main component and the initial codeword state: \",\n",
    "    success,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us now take a look at how the bond dimensions and entropies behave throughout the decoding process while applying the parity checks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [01:27<00:00,  1.14it/s]\n"
     ]
    }
   ],
   "source": [
    "NUM_BITS = 16\n",
    "CHI_MAX_CONTRACTOR = 1e4\n",
    "CHI_MAX_DMRG = CHI_MAX_CONTRACTOR\n",
    "ERROR_RATE = 0.15\n",
    "PROB_BIAS = ERROR_RATE\n",
    "CUT = 1e-16\n",
    "NUM_DMRG_RUNS = 1\n",
    "NUM_EXPERIMENTS = 100\n",
    "\n",
    "SEED = 123\n",
    "seed_seq = np.random.SeedSequence(SEED)\n",
    "\n",
    "CHECK_DEGREE, BIT_DEGREE = 4, 3\n",
    "NUM_CHECKS = int(BIT_DEGREE * NUM_BITS / CHECK_DEGREE)\n",
    "if NUM_BITS / NUM_CHECKS != CHECK_DEGREE / BIT_DEGREE:\n",
    "    raise ValueError(\"The Tanner graph of the code must be bipartite.\")\n",
    "\n",
    "entropies = np.zeros((NUM_EXPERIMENTS, NUM_CHECKS, NUM_BITS - 1))\n",
    "bond_dimensions = np.zeros((NUM_EXPERIMENTS, NUM_CHECKS, NUM_BITS - 1))\n",
    "\n",
    "for l in tqdm(range(NUM_EXPERIMENTS)):\n",
    "    new_seed = seed_seq.spawn(1)[0]\n",
    "    rng = np.random.default_rng(new_seed)\n",
    "    random_integer = rng.integers(1, 10**8 + 1)\n",
    "    SEED = random_integer\n",
    "\n",
    "    code = qec.random_regular_code(\n",
    "        NUM_BITS, NUM_CHECKS, BIT_DEGREE, CHECK_DEGREE, qec.Rng(SEED)\n",
    "    )\n",
    "    code_constraint_sites = linear_code_constraint_sites(code)\n",
    "\n",
    "    INITIAL_CODEWORD, PERTURBED_CODEWORD = linear_code_prepare_message(\n",
    "        code, ERROR_RATE, error_model=qec.BinarySymmetricChannel, seed=SEED\n",
    "    )\n",
    "    tensors = [XOR_LEFT, XOR_BULK, SWAP, XOR_RIGHT]\n",
    "\n",
    "    initial_codeword_state = create_custom_product_state(\n",
    "        INITIAL_CODEWORD, form=\"Right-canonical\"\n",
    "    )\n",
    "    perturbed_codeword_state = create_custom_product_state(\n",
    "        PERTURBED_CODEWORD, form=\"Right-canonical\"\n",
    "    )\n",
    "\n",
    "    perturbed_codeword_state = apply_bitflip_bias(\n",
    "        mps=perturbed_codeword_state,\n",
    "        sites_to_bias=\"All\",\n",
    "        prob_bias_list=PROB_BIAS,\n",
    "    )\n",
    "    perturbed_codeword_state, entrs, bons = apply_constraints(\n",
    "        perturbed_codeword_state,\n",
    "        code_constraint_sites,\n",
    "        tensors,\n",
    "        chi_max=CHI_MAX_CONTRACTOR,\n",
    "        renormalise=True,\n",
    "        strategy=\"Naive\",\n",
    "        silent=True,\n",
    "        return_entropies_and_bond_dims=True,\n",
    "    )\n",
    "\n",
    "    entropies[l] = np.array(entrs)\n",
    "    bond_dimensions[l] = np.array(bons)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Here we average over all the experiments and plot the results.\n",
    "\n",
    "entropies = np.mean(entropies, axis=0)\n",
    "bond_dimensions = np.mean(bond_dimensions, axis=0)\n",
    "\n",
    "plt.figure(figsize=(4, 3))\n",
    "plt.imshow(entropies, cmap=\"viridis\")\n",
    "plt.colorbar(label=\"Entropy\")\n",
    "plt.xlabel(\"Site number\")\n",
    "plt.ylabel(\"Time ←\")\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(4, 3))\n",
    "plt.imshow(bond_dimensions, cmap=\"viridis\")\n",
    "plt.colorbar(label=\"Bond dimension\")\n",
    "plt.ylabel(\"Time ←\")\n",
    "plt.xlabel(\"Site number\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nice, we do see how entanglement grows during the evolution and declines towards the end!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us now try to take a look at how the truncation affects the threshold for this family of codes. By definition, the threshold is the crossover error rate at which the code transitions from being unable to correct errors to being able to correct errors reliably. In simpler words, what we expect to see is how the logical error rate vs physical error rate curve will move up with more truncation. We will do this for a small 24-bit code for the sake of simplicity. Note, the following cell will take a while to run!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 18%|█▊        | 2/11 [1:41:05<7:34:21, 3029.03s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ** On entry to DLASCL parameter number  4 had an illegal value\n",
      " ** On entry to DLASCL parameter number  4 had an illegal value\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 82%|████████▏ | 9/11 [8:18:30<1:52:25, 3372.65s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ** On entry to DLASCL parameter number  4 had an illegal value\n",
      " ** On entry to DLASCL parameter number  4 had an illegal value\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 11/11 [10:13:50<00:00, 3348.25s/it]\n",
      "100%|██████████| 11/11 [3:12:01<00:00, 1047.43s/it] \n",
      "100%|██████████| 11/11 [1:09:27<00:00, 378.89s/it]\n",
      "100%|██████████| 11/11 [24:51<00:00, 135.61s/it]\n",
      "100%|██████████| 11/11 [22:51<00:00, 124.65s/it]\n"
     ]
    }
   ],
   "source": [
    "NUM_BITS = 24\n",
    "NUM_EXPERIMENTS = 1000\n",
    "\n",
    "SEED = 123\n",
    "seed_seq = np.random.SeedSequence(SEED)\n",
    "initial_codewords = {}\n",
    "perturbed_codewords = {}\n",
    "codes = {}\n",
    "\n",
    "max_bond_dims = [128, 64, 32, 16, 8]\n",
    "error_rates = np.linspace(0.1, 0.3, 11)\n",
    "failures_statistics = {}\n",
    "\n",
    "for ERROR_RATE in error_rates:\n",
    "    initial_codewords[NUM_BITS, ERROR_RATE] = []\n",
    "    perturbed_codewords[NUM_BITS, ERROR_RATE] = []\n",
    "    codes[NUM_BITS, ERROR_RATE] = []\n",
    "\n",
    "    for l in range(NUM_EXPERIMENTS):\n",
    "        rng = np.random.default_rng(seed_seq.spawn(1)[0])\n",
    "        random_integer = rng.integers(1, 10**8 + 1)\n",
    "        SEED = random_integer\n",
    "        CHECK_DEGREE, BIT_DEGREE = 4, 3\n",
    "        NUM_CHECKS = int(BIT_DEGREE * NUM_BITS / CHECK_DEGREE)\n",
    "        if NUM_BITS / NUM_CHECKS != CHECK_DEGREE / BIT_DEGREE:\n",
    "            raise ValueError(\"The Tanner graph of the code must be bipartite.\")\n",
    "\n",
    "        code = qec.random_regular_code(\n",
    "            NUM_BITS, NUM_CHECKS, BIT_DEGREE, CHECK_DEGREE, qec.Rng(SEED)\n",
    "        )\n",
    "        INITIAL_CODEWORD, PERTURBED_CODEWORD = linear_code_prepare_message(\n",
    "            code, ERROR_RATE, error_model=qec.BinarySymmetricChannel, seed=SEED\n",
    "        )\n",
    "        initial_codewords[NUM_BITS, ERROR_RATE].append(INITIAL_CODEWORD)\n",
    "        perturbed_codewords[NUM_BITS, ERROR_RATE].append(PERTURBED_CODEWORD)\n",
    "        codes[NUM_BITS, ERROR_RATE].append(code)\n",
    "\n",
    "for CHI_MAX in max_bond_dims:\n",
    "    for ERROR_RATE in tqdm(error_rates):\n",
    "        failures = []\n",
    "\n",
    "        for l in range(NUM_EXPERIMENTS):\n",
    "            PROB_BIAS = ERROR_RATE\n",
    "\n",
    "            code = codes[NUM_BITS, ERROR_RATE][l]\n",
    "            code_constraint_sites = linear_code_constraint_sites(code)\n",
    "\n",
    "            INITIAL_CODEWORD = initial_codewords[NUM_BITS, ERROR_RATE][l]\n",
    "            PERTURBED_CODEWORD = perturbed_codewords[NUM_BITS, ERROR_RATE][l]\n",
    "\n",
    "            tensors = [XOR_LEFT, XOR_BULK, SWAP, XOR_RIGHT]\n",
    "\n",
    "            initial_codeword_state = create_custom_product_state(\n",
    "                INITIAL_CODEWORD, form=\"Right-canonical\"\n",
    "            )\n",
    "            perturbed_codeword_state = create_custom_product_state(\n",
    "                PERTURBED_CODEWORD, form=\"Right-canonical\"\n",
    "            )\n",
    "\n",
    "            perturbed_codeword_state = apply_bitflip_bias(\n",
    "                mps=perturbed_codeword_state,\n",
    "                sites_to_bias=\"All\",\n",
    "                prob_bias_list=PROB_BIAS,\n",
    "            )\n",
    "\n",
    "            perturbed_codeword_state = apply_constraints(\n",
    "                perturbed_codeword_state,\n",
    "                code_constraint_sites,\n",
    "                tensors,\n",
    "                chi_max=CHI_MAX,\n",
    "                renormalise=True,\n",
    "                strategy=\"Optimised\",\n",
    "                silent=True,\n",
    "            )\n",
    "\n",
    "            dmrg_container, success = decode_message(\n",
    "                message=perturbed_codeword_state,\n",
    "                codeword=initial_codeword_state,\n",
    "                num_runs=1,\n",
    "                chi_max_dmrg=CHI_MAX,\n",
    "                silent=True,\n",
    "            )\n",
    "            failures.append(1 - success)\n",
    "\n",
    "        failures_statistics[NUM_BITS, CHI_MAX, ERROR_RATE] = failures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "failure_rates = {}\n",
    "error_bars = {}\n",
    "\n",
    "for CHI_MAX in max_bond_dims:\n",
    "    for ERROR_RATE in error_rates:\n",
    "        failure_rates[NUM_BITS, CHI_MAX, ERROR_RATE] = np.mean(\n",
    "            failures_statistics[NUM_BITS, CHI_MAX, ERROR_RATE]\n",
    "        )\n",
    "        error_bars[NUM_BITS, CHI_MAX, ERROR_RATE] = sem(\n",
    "            failures_statistics[NUM_BITS, CHI_MAX, ERROR_RATE]\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(5, 4))\n",
    "\n",
    "green_cmap = matplotlib.colormaps[\"viridis_r\"]\n",
    "norm = Normalize(vmin=0, vmax=len(max_bond_dims) - 1)\n",
    "\n",
    "for index, CHI_MAX in enumerate(max_bond_dims):\n",
    "    plt.errorbar(\n",
    "        error_rates,\n",
    "        [failure_rates[NUM_BITS, CHI_MAX, ERROR_RATE] for ERROR_RATE in error_rates],\n",
    "        yerr=[error_bars[NUM_BITS, CHI_MAX, ERROR_RATE] for ERROR_RATE in error_rates],\n",
    "        fmt=\"o--\",\n",
    "        label=f\"System size: {NUM_BITS}, max bond dim: {CHI_MAX}\",\n",
    "        linewidth=3,\n",
    "        color=green_cmap(norm(index)),\n",
    "    )\n",
    "\n",
    "plt.xticks(np.arange(0.1, 0.35, 0.05), [f\"{x:.2f}\" for x in np.arange(0.1, 0.35, 0.05)])\n",
    "plt.legend(fontsize=7)\n",
    "plt.xlabel(\"Error rate\")\n",
    "plt.ylabel(\"Failure rate\")\n",
    "plt.grid()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see what we expect: the decoder is able to correct more errors with less truncation. This is a good sign that the decoder is working as expected."
   ]
  }
 ],
 "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
}