diff --git a/examples/decoding/quantum_surface.ipynb b/examples/decoding/quantum_surface.ipynb index 39c0351f..367cd26b 100644 --- a/examples/decoding/quantum_surface.ipynb +++ b/examples/decoding/quantum_surface.ipynb @@ -8,72 +8,1010 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "In this experiment, we’ll use ``mdopt`` to decode the Surface Code. Hereafter, we assume an independent noise model as well as perfect syndrome measurements. We will create a Surface Code instance via the Hypergraph Product of two repetition codes. This example will be less pedagogical than the one with the Shor's code because we have already packaged all subroutines in a function. For a detailed overview of these subroutines the user is invited to read the Shor Code example as well as consult the appropriate code." + "In this experiment, we decode the Surface 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. We will create a Surface Code instance via the Hypergraph Product of two repetition codes since this construction yields a 2D lattice with stabilizers suitable for the Surface Code's structure." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import qecstruct as qc\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.mps.utils import marginalise, create_custom_product_state\n", + "from mdopt.contractor.contractor import mps_mpo_contract\n", + "from mdopt.optimiser.utils import (\n", + " SWAP,\n", + " COPY_LEFT,\n", + " XOR_BULK,\n", + " XOR_LEFT,\n", + " XOR_RIGHT,\n", + ")\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", + " apply_constraints,\n", + " apply_bitflip_bias,\n", + " apply_depolarising_bias,\n", + " pauli_to_mps,\n", + " decode_css,\n", + " css_code_stabilisers,\n", + " multiply_pauli_strings,\n", + " generate_pauli_error_string,\n", + ")\n", + "from examples.decoding.visualisation import plot_parity_check_mpo\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us first import the code from `qecstruct` and take a look at it. Here, we will be looking at a 3x3 system." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X stabilizers:\n", + "[0, 1, 9]\n", + "[1, 2, 10]\n", + "[3, 4, 9, 11]\n", + "[4, 5, 10, 12]\n", + "[6, 7, 11]\n", + "[7, 8, 12]\n", + "Z stabilizers:\n", + "[0, 3, 9]\n", + "[1, 4, 9, 10]\n", + "[2, 5, 10]\n", + "[3, 6, 11]\n", + "[4, 7, 11, 12]\n", + "[5, 8, 12]\n", + "\n", + "The X logical: [2, 5, 8]\n", + "\n", + "The Z logical: [0, 1, 2]\n", + "\n" + ] + } + ], + "source": [ + "LATTICE_SIZE = 3\n", + "rep_code = qc.repetition_code(LATTICE_SIZE)\n", + "code = qc.hypergraph_product(rep_code, rep_code)\n", + "print(code)\n", + "print(\"The X logical: \", code.x_logicals_binary())\n", + "print(\"The Z logical: \", code.z_logicals_binary())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This quantum error correcting code is defined on $2 * L * (L-1) + 1 = 13$ (where $L$ is the lattice size and an extra qubit handles the boundary conditions) physical qubits and has $2$ logical operators because it encodes $1$ logical qubit. This means we will need $13*2 + 2 = 28$ 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 == 28\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": 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)" + ] + }, + { + "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, 20]\n", + "[4, 6, 22]\n", + "[8, 10, 20, 24]\n", + "[10, 12, 22, 26]\n", + "[14, 16, 24]\n", + "[16, 18, 26]\n", + "Z checks:\n", + "[3, 9, 21]\n", + "[5, 11, 21, 23]\n", + "[7, 13, 23]\n", + "[9, 15, 25]\n", + "[11, 17, 25, 27]\n", + "[13, 19, 27]\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)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These lists display 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 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], [3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], [20]]\n", + "[[4], [6], [5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21], [22]]\n", + "[[8], [10, 20], [9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23], [24]]\n", + "[[10], [12, 22], [11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25], [26]]\n", + "[[14], [16], [15, 17, 18, 19, 20, 21, 22, 23], [24]]\n", + "[[16], [18], [17, 19, 20, 21, 22, 23, 24, 25], [26]]\n", + "Full Z-check lists of sites:\n", + "[[3], [9], [4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], [21]]\n", + "[[5], [11, 21], [6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 22], [23]]\n", + "[[7], [13], [8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22], [23]]\n", + "[[9], [15], [10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], [25]]\n", + "[[11], [17, 25], [12, 13, 14, 15, 16, 18, 19, 20, 21, 22, 23, 24, 26], [27]]\n", + "[[13], [19], [14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26], [27]]\n" + ] + } + ], + "source": [ + "constraints_sites = css_code_constraint_sites(code)\n", + "print(\"Full X-check lists of sites:\")\n", + "for string in constraints_sites[0]:\n", + " print(string)\n", + "print(\"Full Z-check lists of sites:\")\n", + "for string in constraints_sites[1]:\n", + " print(string)" + ] + }, + { + "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": [ + "[2, 5, 8]\n", + "\n", + "[0, 1, 2]\n", + "\n" + ] + } + ], + "source": [ + "print(code.x_logicals_binary())\n", + "print(code.z_logicals_binary())" + ] + }, + { + "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": [ + "[[6, 12, 18]]\n", + "[[3, 5, 7]]\n" + ] + } + ], + "source": [ + "print(css_code_logicals(code)[0])\n", + "print(css_code_logicals(code)[1])" + ] + }, + { + "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], [6, 12], [1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17], [18]]]\n", + "[[[1], [3, 5], [2, 4, 6], [7]]]\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])" + ] + }, + { + "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": 11, + "metadata": {}, + "outputs": [], + "source": [ + "renormalise = True\n", + "result_to_explicit = False\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.05,\n", + " sites_to_bias=sites_to_bias,\n", + " renormalise=renormalise,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1/1 [00:00<00:00, 148.59it/s]\n", + "100%|██████████| 1/1 [00:00<00:00, 55.13it/s]\n", + "100%|██████████| 6/6 [00:00<00:00, 68.00it/s]\n", + "100%|██████████| 6/6 [00:52<00:00, 8.79s/it]\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", + " renormalise=renormalise,\n", + " result_to_explicit=result_to_explicit,\n", + " strategy=\"Optimised\",\n", + " return_entropies_and_bond_dims=True,\n", + " )\n", + " entropies += entrps\n", + " bond_dims += bnd_dims\n", + "\n", + "# for the X and the Z checks\n", + "for i in [0, 1]:\n", + " error_mps, entrps, bnd_dims = apply_constraints(\n", + " error_mps,\n", + " constraints_sites[i],\n", + " constraints_tensors,\n", + " renormalise=renormalise,\n", + " result_to_explicit=result_to_explicit,\n", + " strategy=\"Optimised\",\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": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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(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()\n" + ] + }, + { + "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": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2, 4, 8, 16, 32, 64, 64, 64, 128, 256, 512, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 512, 512, 256, 128, 64, 32, 16, 8, 2]\n" + ] + } + ], + "source": [ + "print(error_mps.bond_dimensions)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 11/11 [01:36<00:00, 8.75s/it]\n" + ] + } + ], + "source": [ + "bond_dims = [np.inf, 1024, 512, 256, 128, 64, 32, 16, 8, 4, 2]\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": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.88597714 0.05528634 0.05528675 0.00344977]\n" + ] + } + ], + "source": [ + "sites_to_marginalise = list(range(num_logicals, len(error_state) + num_logicals))\n", + "logical = marginalise(mps=error_mps, sites_to_marginalise=sites_to_marginalise).dense(\n", + " flatten=True, renormalise=True, norm=1\n", + ")\n", + "print(logical)" + ] + }, + { + "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%|██████████| 11/11 [02:32<00:00, 13.91s/it]\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(string=state_string)\n", + "\n", + " error_mps = apply_depolarising_bias(\n", + " mps=error_mps,\n", + " prob_bias_list=0.1,\n", + " sites_to_bias=sites_to_bias,\n", + " renormalise=renormalise,\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", + " result_to_explicit=result_to_explicit,\n", + " strategy=strategy,\n", + " chi_max=max_bond_dim,\n", + " silent=True,\n", + " )\n", + " for i in [0, 1]:\n", + " error_mps = apply_constraints(\n", + " error_mps,\n", + " constraints_sites[i],\n", + " constraints_tensors,\n", + " renormalise=renormalise,\n", + " result_to_explicit=result_to_explicit,\n", + " strategy=strategy,\n", + " chi_max=max_bond_dim,\n", + " silent=True,\n", + " )\n", + "\n", + " sites_to_marginalise = list(range(num_logicals, len(error_state) + num_logicals))\n", + " logical = marginalise(\n", + " mps=error_mps, 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": [ + "
" + ] + }, + "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": [ + "
" + ] + }, + "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": [ + "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. For this, we first generate all possible one-qubit errors and first 100 two-qubit errors using `qecsim`." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, "outputs": [], "source": [ - "import numpy as np\n", - "from tqdm import tqdm\n", - "import qecstruct as qc\n", - "import qecsim.paulitools as pt\n", + "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))[:99]" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 39/39 [03:17<00:00, 5.07s/it]\n" + ] + } + ], + "source": [ + "one_qubit_outputs = [\n", + " decode_css(code, error, bias_type=\"Bitflip\", renormalise=renormalise, silent=True)\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": 24, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 99/99 [24:30<00:00, 14.85s/it]\n" + ] + } + ], + "source": [ + "two_qubit_outputs = [\n", + " decode_css(code, error, bias_type=\"Bitflip\", renormalise=renormalise, silent=True)\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": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def map_distribution_to_pauli(distribution):\n", + " mapping = {0: \"I\", 1: \"X\", 2: \"Z\", 3: \"Y\"}\n", + " result = []\n", "\n", - "import matplotlib\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib.colors import Normalize\n", - "from matplotlib.ticker import FormatStrFormatter\n", + " for array in distribution:\n", + " max_index = np.argmax(array)\n", + " result.append(mapping[max_index])\n", "\n", - "from mdopt.mps.utils import marginalise, create_custom_product_state\n", - "from mdopt.contractor.contractor import mps_mpo_contract\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", - " apply_constraints,\n", - " apply_bitflip_bias,\n", - ")\n", - "from examples.decoding.decoding import (\n", - " decode_css,\n", - " pauli_to_mps,\n", - " css_code_checks,\n", - " css_code_logicals,\n", - " css_code_logicals_sites,\n", - " css_code_constraint_sites,\n", - " generate_pauli_error_string,\n", - ")" + " return result" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(map_distribution_to_pauli(one_qubit_corrections_distribution))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(map_distribution_to_pauli(two_qubit_corrections_distribution))\n", + "plt.show()" + ] + }, + { + "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 the surface code of distance $d$ (equal to 3 in our case) corrects errors on up to $ \\lfloor \\frac{d-1}{2} \\rfloor $ qubits. However, some of the two-qubit errors can be corrected as well. Let's check some of them. For this, 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": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CHI_MAX = 256\n" + "XZIIIIIIIIIII\n", + "ZXIIIIIIIIIII\n", + "ZZIIIIIIIIIII\n", + "ZYIIIIIIIIIII\n", + "XIZIIIIIIIIII\n", + "ZIXIIIIIIIIII\n", + "ZIZIIIIIIIIII\n", + "ZIYIIIIIIIIII\n", + "YIZIIIIIIIIII\n", + "XIIXIIIIIIIII\n", + "XIIZIIIIIIIII\n", + "XIIYIIIIIIIII\n", + "ZIIXIIIIIIIII\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" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To be able to track which parity check is triggered by which error, let's plot the tensor network we are building." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ { - "name": "stderr", + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_parity_check_mpo(code)" + ] + }, + { + "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. For example, the first error $(X_0 Z_1)$ from the list above would trigger the first $X$ parity check (parity check index 2) as well as the second $Z$ parity check (index 9). 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." + ] + }, + { + "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": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", "output_type": "stream", "text": [ - "100%|██████████| 10/10 [57:52<00:00, 347.25s/it]\n" + "YZIIIIIIIIIII\n", + "ZIIZIIIIIIIII\n", + "ZIIYIIIIIIIII\n", + "YIIZIIIIIIIII\n", + "ZIIIXIIIIIIII\n", + "ZIIIZIIIIIIII\n", + "ZIIIYIIIIIIII\n", + "ZIIIIIXIIIIII\n", + "ZIIIIIZIIIIII\n", + "ZIIIIIYIIIIII\n", + "YIIIIIXIIIIII\n", + "YIIIIIYIIIIII\n", + "ZIIIIIIZIIIII\n", + "ZIIIIIIYIIIII\n", + "YIIIIIIZIIIII\n", + "YIIIIIIYIIIII\n", + "YIIIIIIIXIIII\n", + "YIIIIIIIYIIII\n", + "YIIIIIIIIXIII\n", + "YIIIIIIIIIXII\n", + "YIIIIIIIIIIXI\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])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similarly to the previous case, the first error $(Y_0 Z_1)$ 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." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, let's take a look at how the MPO order optimisation looks visually and test the truncation effects." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "LATTICE_SIZE = 3\n", + "rep_code = qc.repetition_code(LATTICE_SIZE)\n", + "surface_code = qc.hypergraph_product(rep_code, rep_code)\n", + "\n", + "mpo_matrix_full_unoptimised = plot_parity_check_mpo(\n", + " surface_code, optimise_order=False, return_matrix=True, plot_type=\"X\"\n", + ")\n", + "\n", + "mpo_matrix_xpart = plot_parity_check_mpo(\n", + " surface_code, optimise_order=False, return_matrix=True, plot_type=\"X\"\n", + ")\n", + "\n", + "mpo_matrix_zpart = plot_parity_check_mpo(\n", + " surface_code, optimise_order=False, return_matrix=True, plot_type=\"Z\"\n", + ")\n", + "\n", + "mpo_matrix_full = plot_parity_check_mpo(\n", + " surface_code, optimise_order=True, return_matrix=True, plot_type=\"both\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ { "name": "stdout", "output_type": "stream", @@ -85,7 +1023,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 10/10 [18:21<00:00, 110.14s/it]\n" + "100%|██████████| 11/11 [1:07:20<00:00, 367.31s/it]\n" ] }, { @@ -99,7 +1037,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 10/10 [05:50<00:00, 35.08s/it]\n" + "100%|██████████| 11/11 [22:24<00:00, 122.24s/it]\n" ] }, { @@ -113,7 +1051,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 10/10 [02:01<00:00, 12.17s/it]\n" + "100%|██████████| 11/11 [07:02<00:00, 38.41s/it]\n" ] }, { @@ -127,7 +1065,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 10/10 [00:26<00:00, 2.62s/it]\n" + "100%|██████████| 11/11 [01:50<00:00, 10.05s/it]\n" ] }, { @@ -141,54 +1079,74 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 10/10 [00:19<00:00, 1.98s/it]\n" + "100%|██████████| 11/11 [01:20<00:00, 7.30s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CHI_MAX = 4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 27%|██▋ | 3/11 [00:16<00:45, 5.73s/it]/Users/aleksandrberezutskii/mdopt/mdopt/mps/canonical.py:274: RuntimeWarning: invalid value encountered in divide\n", + " dense /= np.linalg.norm(dense, ord=norm)\n", + "100%|██████████| 11/11 [01:10<00:00, 6.41s/it]\n" ] } ], "source": [ - "LATTICE_SIZE = 3\n", - "NUM_EXPERIMENTS = 50\n", + "NUM_QUBITS = 2 * (LATTICE_SIZE - 1) * LATTICE_SIZE\n", + "NUM_EXPERIMENTS = 200\n", "\n", "SEED = 123\n", "seed_seq = np.random.SeedSequence(SEED)\n", + "errors = {}\n", "\n", - "max_bond_dims = [256, 128, 64, 32, 16, 8]\n", - "error_rates = np.linspace(1e-2, 0.2, 10)\n", + "max_bond_dims = [128, 64, 32, 16, 8, 4]\n", + "error_rates = np.linspace(0.05, 0.40, 11)\n", "failures_statistics = {}\n", "\n", + "rep_code = qc.repetition_code(LATTICE_SIZE)\n", + "surface_code = qc.hypergraph_product(rep_code, rep_code)\n", + "\n", + "for ERROR_RATE in error_rates:\n", + " errors[LATTICE_SIZE, ERROR_RATE] = []\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", + "\n", + " error = generate_pauli_error_string(\n", + " len(surface_code),\n", + " ERROR_RATE,\n", + " seed=SEED,\n", + " error_model=\"Bit Flip\",\n", + " )\n", + " errors[LATTICE_SIZE, ERROR_RATE].append(error)\n", + "\n", "for CHI_MAX in max_bond_dims:\n", " print(f\"CHI_MAX = {CHI_MAX}\")\n", " for ERROR_RATE in tqdm(error_rates):\n", " failures = []\n", "\n", " for l in 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", - " rep_code = qc.repetition_code(LATTICE_SIZE)\n", - " surface_code = qc.hypergraph_product(rep_code, rep_code)\n", - "\n", - " error = generate_pauli_error_string(\n", - " len(surface_code),\n", - " ERROR_RATE,\n", - " seed=SEED,\n", - " error_model=\"Depolarising\",\n", - " )\n", - " error = pauli_to_mps(error)\n", - "\n", + " error = errors[LATTICE_SIZE, ERROR_RATE][l]\n", " _, success = decode_css(\n", " code=surface_code,\n", " error=error,\n", " chi_max=CHI_MAX,\n", - " bias_type=\"Depolarising\",\n", - " bias_prob=ERROR_RATE,\n", + " multiply_by_stabiliser=True,\n", + " bias_type=\"Bit Flip\",\n", + " bias_prob=0.05,\n", " renormalise=True,\n", " silent=True,\n", " contraction_strategy=\"Optimised\",\n", " )\n", - "\n", " failures.append(1 - success)\n", "\n", " failures_statistics[LATTICE_SIZE, CHI_MAX, ERROR_RATE] = failures" @@ -196,7 +1154,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -208,21 +1166,19 @@ " failure_rates[LATTICE_SIZE, CHI_MAX, ERROR_RATE] = np.mean(\n", " failures_statistics[LATTICE_SIZE, CHI_MAX, ERROR_RATE]\n", " )\n", - " error_bars[LATTICE_SIZE, CHI_MAX, ERROR_RATE] = (\n", - " np.std(failures_statistics[LATTICE_SIZE, CHI_MAX, ERROR_RATE])\n", - " * 1.96 # Standart error of the mean with 95% confidence interval\n", - " / NUM_EXPERIMENTS\n", + " error_bars[LATTICE_SIZE, CHI_MAX, ERROR_RATE] = sem(\n", + " failures_statistics[LATTICE_SIZE, CHI_MAX, ERROR_RATE]\n", " )" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 34, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -234,7 +1190,7 @@ "source": [ "plt.figure(figsize=(5, 4))\n", "\n", - "green_cmap = matplotlib.colormaps[\"viridis_r\"]\n", + "green_cmap = 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", @@ -262,16 +1218,16 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "Great, so, we see the convergence in bond dimension (given bitflip noise, we converege to optimal decoding at the bon dimension equal to $2^6$ where $6$ is the maximum number of leg crossings encountered while applying MPOs, thus the curves with bond dimensions $2^6$ and $2^7$ are identically the same). Besides, we see how the curve moves to the right as we increase the bond dimension cutoff which is expected behaviour." + ] } ], "metadata": { "kernelspec": { - "display_name": "mdopt-ZdbamFdU-py3.11", + "display_name": "mdopt-ZdbamFdU-py3.10", "language": "python", "name": "python3" }, @@ -286,12 +1242,6 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.13" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "64c06a7280c9749d5771a76ca6109d7df6b2615ddb3b9b0828f83fb315c7f8a2" - } } }, "nbformat": 4,