{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decoding 3-qubit repetition code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this experiment, we decode the 3-qubit repetition code 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. After each run, the algorithm yields a probability distribution over the Pauli operators (I, X, Z, Y) to apply to the encoded logical qubit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import qecsim.paulitools as pt\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import colormaps\n",
    "from matplotlib.colors import LogNorm, Normalize\n",
    "from matplotlib.ticker import FuncFormatter, FormatStrFormatter\n",
    "from tqdm import tqdm\n",
    "from scipy.stats import sem\n",
    "\n",
    "from mdopt.utils.utils import mpo_to_matrix\n",
    "from mdopt.contractor.contractor import mps_mpo_contract\n",
    "from mdopt.mps.utils import (\n",
    "    inner_product,\n",
    "    create_custom_product_state,\n",
    "    create_simple_product_state,\n",
    ")\n",
    "from mdopt.optimiser.utils import (\n",
    "    apply_constraints,\n",
    "    ConstraintString,\n",
    "    SWAP,\n",
    "    COPY_LEFT,\n",
    "    XOR_BULK,\n",
    "    XOR_LEFT,\n",
    "    XOR_RIGHT,\n",
    "    IDENTITY,\n",
    ")\n",
    "\n",
    "from examples.decoding.decoding import (\n",
    "    custom_code_checks,\n",
    "    custom_code_logicals,\n",
    "    custom_code_logicals_sites,\n",
    "    custom_code_constraint_sites,\n",
    "    apply_bitflip_bias,\n",
    "    apply_depolarising_bias,\n",
    "    pauli_to_mps,\n",
    "    decode_custom,\n",
    "    css_code_stabilisers,\n",
    "    multiply_pauli_strings,\n",
    "    map_distribution_to_pauli,\n",
    "    generate_pauli_error_string,\n",
    ")\n",
    "from examples.decoding.visualisation import plot_parity_check_mpo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us first define the code. Here, we won't be using `qecstruct` as in the other examples because it lacks the machinery we need. Instead, we define the code as a list of stabilizers and logical operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "stabilizer_generators = [\n",
    "    \"XXI\",\n",
    "    \"IXX\",\n",
    "]\n",
    "x_logical_operators = [\n",
    "    \"XXX\",\n",
    "]\n",
    "z_logical_operators = [\n",
    "    \"ZZZ\",\n",
    "]\n",
    "logical_operators = x_logical_operators + z_logical_operators\n",
    "num_qubits = len(stabilizer_generators[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us first take a look at the code in terms of the MPS sites where the checks will be applied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stabilizer generators:\n",
      "[2, 4]\n",
      "[4, 6]\n"
     ]
    }
   ],
   "source": [
    "checks = custom_code_checks(stabilizer_generators, logical_operators)\n",
    "\n",
    "print(\"Stabilizer generators:\")\n",
    "for check in checks:\n",
    "    print(check)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now transform this into lists of sites where all the logical constraints are applied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MPS constraint sites:\n",
      "[[2], [], [3], [4]]\n",
      "[[4], [], [5], [6]]\n"
     ]
    }
   ],
   "source": [
    "constraint_sites = custom_code_constraint_sites(\n",
    "    stabilizer_generators, logical_operators\n",
    ")\n",
    "\n",
    "print(\"MPS constraint sites:\")\n",
    "for string in constraint_sites:\n",
    "    print(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logical operators:\n",
      "[[2, 4, 6]]\n",
      "[[3, 5, 7]]\n"
     ]
    }
   ],
   "source": [
    "logicals = custom_code_logicals(x_logical_operators, z_logical_operators)\n",
    "\n",
    "print(\"Logical operators:\")\n",
    "print(logicals[0])\n",
    "print(logicals[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MPS logical constraint sites:\n",
      "[[[0], [2, 4], [1, 3, 5], [6]]]\n",
      "[[[1], [3, 5], [2, 4, 6], [7]]]\n"
     ]
    }
   ],
   "source": [
    "logicals_sites = custom_code_logicals_sites(x_logical_operators, z_logical_operators)\n",
    "\n",
    "print(\"MPS logical constraint sites:\")\n",
    "print(logicals_sites[0])\n",
    "print(logicals_sites[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This quantum error correcting code is defined on $3$ physical qubits and has $2$ logical operators because it encodes $1$ logical qubit. This means we will need $3*2 + 2 = 8$ sites in our MPS."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_logicals = len(x_logical_operators) + len(z_logical_operators)\n",
    "num_sites = 2 * len(stabilizer_generators[0]) + num_logicals\n",
    "\n",
    "assert num_sites == 8\n",
    "assert num_logicals == 2"
   ]
  },
  {
   "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 the 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": 8,
   "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(\n",
    "    string=state_string, tolerance=1e-17, form=\"Left-canonical\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The lists of sites in the previous cells identify the sites where we will apply the XOR constraints. However, the MPOs will also consist of other tensors, such as SWAPs (a.k.a. the tensors' legs crossings) and boundary XOR constraints. In what follows, we define the list of these auxiliary tensors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "constraints_tensors = [XOR_LEFT, XOR_BULK, SWAP, XOR_RIGHT]\n",
    "logicals_tensors = [COPY_LEFT, XOR_BULK, SWAP, XOR_RIGHT]"
   ]
  },
  {
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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",
    "    prob_bias_list=0.01,\n",
    "    sites_to_bias=sites_to_bias,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1/1 [00:00<00:00, 49.01it/s]\n",
      "100%|██████████| 1/1 [00:00<00:00, 267.02it/s]\n",
      "100%|██████████| 2/2 [00:00<00:00, 90.99it/s]\n"
     ]
    }
   ],
   "source": [
    "entropies, bond_dims = [], []\n",
    "\n",
    "# for the X and the Z logicals\n",
    "for i in [0, 1]:\n",
    "    error_mps, entrps, bnd_dims = apply_constraints(\n",
    "        error_mps,\n",
    "        logicals_sites[i],\n",
    "        logicals_tensors,\n",
    "        cut=1e-17,\n",
    "        chi_max=1e4,\n",
    "        renormalise=renormalise,\n",
    "        strategy=\"Naive\",\n",
    "        return_entropies_and_bond_dims=True,\n",
    "    )\n",
    "    entropies += entrps\n",
    "    bond_dims += bnd_dims\n",
    "\n",
    "# for the stabilizer checks\n",
    "error_mps, entrps, bnd_dims = apply_constraints(\n",
    "    error_mps,\n",
    "    constraint_sites,\n",
    "    constraints_tensors,\n",
    "    cut=1e-17,\n",
    "    chi_max=1e4,\n",
    "    renormalise=renormalise,\n",
    "    strategy=\"Naive\",\n",
    "    return_entropies_and_bond_dims=True,\n",
    ")\n",
    "entropies += entrps\n",
    "bond_dims += bnd_dims"
   ]
  },
  {
   "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": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "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()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(4, 3))\n",
    "plt.imshow(bond_dims, cmap=\"viridis\", norm=LogNorm(vmin=2**1, vmax=2**10))\n",
    "cbar = plt.colorbar(\n",
    "    label=\"Bond dimension\",\n",
    "    format=FuncFormatter(lambda x, pos: f\"$2^{{{int(np.log2(x))}}}$\"),\n",
    "    ticks=[2**i for i in range(1, 11, 3)],\n",
    ")\n",
    "plt.ylabel(\"Time ←\")\n",
    "plt.xlabel(\"Site number\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now take a look at how the truncation error behaves for different bond dimension cutoffs. First, let's look at the bond dimensions appearing in the MPS if we do not impose any truncation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 8, 8, 8, 4, 2]\n"
     ]
    }
   ],
   "source": [
    "print(error_mps.bond_dimensions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4/4 [00:00<00:00, 314.39it/s]\n"
     ]
    }
   ],
   "source": [
    "bond_dims = [np.inf, 16, 8, 4]\n",
    "inv_bond_dims = [1 / bd for bd in bond_dims]\n",
    "errors = []\n",
    "for chi in tqdm(bond_dims):\n",
    "    errors.append(\n",
    "        np.linalg.norm(\n",
    "            error_mps.compress(\n",
    "                chi_max=chi, renormalise=True, return_truncation_errors=True\n",
    "            )[1]\n",
    "        )\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(4, 3))\n",
    "plt.plot(inv_bond_dims, errors, marker=\"o\", label=\"Truncation Error\")\n",
    "plt.xlabel(\"Inverse Max Bond Dimension\")\n",
    "plt.ylabel(\"Truncation Error\")\n",
    "plt.grid(True)\n",
    "plt.yscale(\"log\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "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": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "sites_to_marginalise = list(range(num_logicals, len(error_state) + num_logicals))\n",
    "logical_mps = error_mps.marginal(\n",
    "    sites_to_marginalise=sites_to_marginalise,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7.72235375e-01 2.26750465e-01 7.83965408e-04 2.30194740e-04]\n"
     ]
    }
   ],
   "source": [
    "logicals = logical_mps.dense(flatten=True, renormalise=True, norm=1)\n",
    "print(logicals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the record, we're hunting for the most likely logical operator to be the identity operator. So that's it, we see the biggest probability assigned to the identity operator. Let's see how the probabilities of the four operators change as we change the bond dimension cutoff."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4/4 [00:00<00:00, 147.54it/s]\n"
     ]
    }
   ],
   "source": [
    "strategy = \"Optimised\"\n",
    "logical_values = [[] for _ in range(4)]\n",
    "\n",
    "for max_bond_dim in tqdm(bond_dims):\n",
    "    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(\n",
    "        string=state_string, tolerance=1e-17, form=\"Right-canonical\"\n",
    "    )\n",
    "\n",
    "    error_mps = apply_bitflip_bias(\n",
    "        mps=error_mps,\n",
    "        prob_bias_list=0.1,\n",
    "        sites_to_bias=sites_to_bias,\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=strategy,\n",
    "            chi_max=max_bond_dim,\n",
    "            silent=True,\n",
    "            cut=1e-17,\n",
    "        )\n",
    "    error_mps = apply_constraints(\n",
    "        error_mps,\n",
    "        constraint_sites,\n",
    "        constraints_tensors,\n",
    "        renormalise=renormalise,\n",
    "        strategy=strategy,\n",
    "        chi_max=max_bond_dim,\n",
    "        silent=True,\n",
    "        cut=1e-17,\n",
    "    )\n",
    "\n",
    "    sites_to_marginalise = list(range(num_logicals, len(error_state) + num_logicals))\n",
    "    logical = error_mps.marginal(\n",
    "        sites_to_marginalise=sites_to_marginalise,\n",
    "    ).dense(flatten=True, renormalise=True, norm=1)\n",
    "\n",
    "    for i in range(4):\n",
    "        logical_values[i].append(logical[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(4, 3))\n",
    "plt.plot(inv_bond_dims, logical_values[0], marker=\"o\", label=f\"Pr(I)\")\n",
    "plt.xlabel(\"Inverse Max Bond Dimension\")\n",
    "plt.ylabel(\"Logical Value\")\n",
    "plt.title(\"Logical Values vs Bond Dimension (Optimised)\")\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(4, 3))\n",
    "plt.plot(inv_bond_dims, logical_values[1], marker=\"o\", label=f\"Pr(X)\")\n",
    "plt.plot(inv_bond_dims, logical_values[2], marker=\"o\", label=f\"Pr(Z)\")\n",
    "plt.plot(inv_bond_dims, logical_values[3], marker=\"o\", label=f\"Pr(Y)\")\n",
    "plt.xlabel(\"Inverse Max Bond Dimension\")\n",
    "plt.ylabel(\"Logical Value\")\n",
    "plt.title(\"Logical Values vs Bond Dimension (Optimised)\")\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because this system is a small one, we can compute the failure probability exactly. Here, we are talking about the bitflip channel which is parametrised by probability $p$. Then, the failure probability is equal to the probability of 2- or 3-qubit error occurence. The probability of 2-qubit error is $3p^2(1-p)$ and the probability of 3-qubit error is $p^3$. The total failure probability is the sum of these two probabilities: $3p^2 - 2p^3$. Our Monte-Carlo simulations should yield exactly the same result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing CHI_MAX = inf\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 23/23 [11:47<00:00, 30.75s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing CHI_MAX = 16\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 23/23 [11:36<00:00, 30.29s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing CHI_MAX = 8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 23/23 [11:37<00:00, 30.34s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing CHI_MAX = 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 23/23 [11:29<00:00, 29.98s/it]\n"
     ]
    }
   ],
   "source": [
    "NUM_EXPERIMENTS = 10000\n",
    "SEED = 123\n",
    "NUM_QUBITS = 3\n",
    "error_rates = np.linspace(0.01, 0.50, 23)\n",
    "max_bond_dims = [np.inf, 16, 8, 4]\n",
    "\n",
    "# Initialize seed sequence\n",
    "seed_seq = np.random.SeedSequence(SEED)\n",
    "\n",
    "# Generate errors\n",
    "errors = {}\n",
    "for ERROR_RATE in error_rates:\n",
    "    errors[ERROR_RATE] = []\n",
    "    for _ in range(NUM_EXPERIMENTS):\n",
    "        rng = np.random.default_rng(seed_seq.spawn(1)[0])\n",
    "\n",
    "        error = generate_pauli_error_string(\n",
    "            num_qubits=NUM_QUBITS,\n",
    "            error_rate=ERROR_RATE,\n",
    "            rng=rng,\n",
    "            error_model=\"Bitflip\",\n",
    "        )\n",
    "        errors[ERROR_RATE].append(error)\n",
    "\n",
    "# Decode and gather statistics\n",
    "failures_statistics = {}\n",
    "for CHI_MAX in max_bond_dims:\n",
    "    print(f\"Processing CHI_MAX = {CHI_MAX}\")\n",
    "    for ERROR_RATE in tqdm(error_rates):\n",
    "        failures = []\n",
    "\n",
    "        for error in errors[ERROR_RATE]:\n",
    "            _, success = decode_custom(\n",
    "                stabilizers=stabilizer_generators,\n",
    "                x_logicals=x_logical_operators,\n",
    "                z_logicals=z_logical_operators,\n",
    "                error=error,\n",
    "                chi_max=CHI_MAX,\n",
    "                bias_type=\"Bitflip\",\n",
    "                bias_prob=0.1,\n",
    "                cut=1e-17,\n",
    "                tolerance=1e-17,\n",
    "                renormalise=True,\n",
    "                silent=True,\n",
    "                contraction_strategy=\"Naive\",\n",
    "            )\n",
    "            failures.append(1 - success)\n",
    "\n",
    "        failures_statistics[CHI_MAX, ERROR_RATE] = failures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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[CHI_MAX, ERROR_RATE] = np.mean(\n",
    "            failures_statistics[CHI_MAX, ERROR_RATE]\n",
    "        )\n",
    "        error_bars[CHI_MAX, ERROR_RATE] = sem(failures_statistics[CHI_MAX, ERROR_RATE])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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 = colormaps[\"viridis_r\"]\n",
    "norm = Normalize(vmin=0, vmax=len(max_bond_dims) - 1)\n",
    "f = lambda p: 3 * p**2 - 2 * p**3\n",
    "\n",
    "for index, CHI_MAX in enumerate(max_bond_dims):\n",
    "    plt.errorbar(\n",
    "        error_rates,\n",
    "        [failure_rates[CHI_MAX, ERROR_RATE] for ERROR_RATE in error_rates],\n",
    "        yerr=[error_bars[CHI_MAX, ERROR_RATE] for ERROR_RATE in error_rates],\n",
    "        fmt=\"o--\",\n",
    "        label=f\"Max bond dim: {CHI_MAX}\",\n",
    "        linewidth=3,\n",
    "        color=green_cmap(norm(index)),\n",
    "    )\n",
    "\n",
    "plt.plot(\n",
    "    error_rates,\n",
    "    [f(error_rate) for error_rate in error_rates],\n",
    "    label=\"f(x) = 3x^2 - 2x^3\",\n",
    "    color=\"red\",\n",
    "    linewidth=2,\n",
    ")\n",
    "\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": [
    "This is perfect, we see that the Monte Carlo simulation results are in perfect agreement with the analytical expression apart from bond dimension 4 which is just too agressive of a truncation."
   ]
  }
 ],
 "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}