Near-Optimal Decoding Algorithm for Color Codes Using Population Annealing

Abstract

The development and use of large-scale quantum computers relies on integrating quantum error-correcting (QEC) schemes into the quantum computing pipeline. A fundamental part of the QEC protocol is the decoding of the syndrome to identify a recovery operation with a high success rate. In this work, we implement a decoder that finds the recovery operation with the highest success probability by mapping the decoding problem to a spin system and using Population Annealing to estimate the free energy of the different error classes. We study the decoder performance on a 4.8.8 color code lattice under different noise models, including code capacity with bit-flip and depolarizing noise, and phenomenological noise, which considers noisy measurements, with performance reaching near-optimal thresholds for bit-flip and depolarizing noise, and the highest reported threshold for phenomenological noise. This decoding algorithm can be applied to a wide variety of stabilizer codes, including surface codes and quantum Low-Density Parity Check (qLDPC) codes.

1. Introduction

The development of quantum computers has experienced rapid progress in recent years. These efforts have materialized in technological and theoretical developments in multiple platforms such as superconducting circuits [1,2,3,4], ion traps [5,6,7,8,9,10], neutral atoms [11,12,13,14,15] or photonic devices [16], while these developments continue to improve the quality of quantum processors, the main challenge towards practical quantum advantage lies in the fragile nature of quantum states. The realization of reliable, universal large-scale quantum computations thus requires the development of fault-tolerant quantum error correction (QEC) protocols capable of detecting and correcting the effects of noise, and unlocking the most powerful capabilities of quantum computation [17,18,19,20]. Stabilizer codes [21] stand as one of the most powerful tools for QEC. These QEC codes encode logical information in non-local degrees of freedom of multi-qubit states, and allow for the detection and correction of errors through the measurement of stabilizer operators (or parity checks). The set of measurement results for the stabilizer operators of a given QEC protocol is called syndrome, and the algorithm that infers a correction from the syndrome is called decoder. Currently, the most prominent families of codes include surface codes [22,23,24], color codes [25,26] and qLDPC codes [27,28,29,30,31,32]. The threshold theorem [33,34,35] states that the logical error rate can be arbitrarily suppressed with fault-tolerant protocols by scaling the size of the code, as long as the physical error rate remains under a critical threshold.

The error threshold of a given protocol has an upper bound given by the properties of the code. This optimal threshold can be obtained by mapping the errors on the QEC protocol into a classical statistical-mechanical model [24,36,37,38]. However, in a practical implementation, the threshold of a protocol is limited by our capacity to decode the information from the syndrome to infer a recovery operation. The problem of decoding requires a classical algorithm that is fast enough to match the rate at which the syndrome is generated, avoiding a backlog problem [20]. In addition, achieving a high threshold necessitates an algorithm with high accuracy. Therefore, there is a trade-off between decoding quality and decoding time, where more accuracy can usually be obtained at the expense of a higher computational cost. The study of this trade-off has encouraged the development of multiple decoding algorithms in recent years [39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54].

Recently, Simulated Annealing (SA) [55] has been tested for the implementation of decoders for the color code [56] and surface code [57]. This approach is used to select a correction by finding the minimum-weight error chain compatible with the error syndrome observed. However, it is known from the mapping of QEC codes to spin systems that the optimal decoding process, also known as maximum-likelihood decoding, can be achieved by estimating free energy values [24,36,37,58,59].

In this work, we implement a modified version of the SA algorithm, known as Population Annealing (PA) [60,61], for the decoding problem. In PA, a resampling step is introduced that helps to avoid local minima and, most importantly, allows for the estimation of the free energies. Therefore, our proposed decoder can be used to find the recovery operation with the maximum success probability, pushing the threshold of the decoder closer to the optimal theoretical thresholds. We test the decoder on a triangular color code with the square-octagon (4.8.8) lattice, reaching a threshold of 10.81% for code capacity noise (errors happen before an ideal round of stabilizer readout) with bit-flip noise, close to the estimated optimal threshold of 10.9% found in Refs. [36,59]. It surpasses the threshold of previous decoders, such as the threshold of 10.36% obtained recently using SA [56], the 10.2% obtained using the more efficient restriction decoder with MWPM [47] or the 9.8% obtained when implementing the restriction decoder using the more scalable union-find algorithm [47], which scales almost-linealy with the number of qubits used for encoding. When applied to the case of code capacity with depolarizing noise, we achieve a threshold of 18.75%. This result is close to the estimated optimal threshold of 18.78% [37] and improves over the previous result of 18.47% obtained using SA [56] or the 17.5% obtained using neural networks [42]. Finally, for the phenomenological noise model, which includes errors in the stabilizer measurements, we achieve a threshold of 3.47%, improving over the 2.9% obtained by SA [56] and the $2.08\%$ using the more efficient graph matching decoder [41], while higher than the $3.3\%$ optimal threshold obtained for the surface code under phenomenological noise [62], the optimal threshold under this noise model was estimated at 4.8% for the hexagonal color code lattice [38,63]. The discrepancy between the thresholds for phenomenological noise could be caused by factors such as boundary conditions or finite-size effects. We leave the analysis of these effects for future work.

The manuscript is structured as follows: In Section 2, we introduce basic concepts related to stabilizer codes, color codes, their mapping to spin systems, and how optimal decoding can be achieved by estimating the free energy associated with a syndrome. In Section 3, we explain the population annealing algorithm and how it can be used to estimate free energies. In Section 4, we explain details of our numerical simulations and present the results of our simulations for different error models, namely bit-flip, depolarizing, and phenomenological noise. Then, in Section 5, we provide insight on how the quality of the decoding behaves with the amount of computational resources used for decoding. We also explain how these results can be used as a guide for finding appropriate values of the hyperparameters that minimize the decoding time. Finally, in Section 6 we conclude with final remarks and ideas for further extensions of this work.

Contributions

The main contributions of the present work are as follows:

• We introduce the first application of Population Annealing (PA) to quantum error correction, a modified simulated annealing algorithm that incorporates resampling steps to avoid local minima and enables free energy estimation for maximum-likelihood decoding. The algorithm is applicable to CSS codes under bit-flip, depolarizing and phenomenological noise models.
• Unlike previous SA-based decoders that minimize error weights (most likely error), our PA decoder finds recovery operations with maximum success probability (most likely error class). This leads to an increase in decoding accuracy with a comparable computational cost.
• We demonstrate significant threshold improvements over existing methods on the triangular color code with the square-octagon lattice: 10.81% for bit-flip noise (vs. 10.36% with SA [56], 10.2% with restriction + MWPM [47]), 18.75% for depolarizing noise (vs. 18.47% with SA [56], 17.5% with neural networks [42]), and 3.47% for phenomenological noise (vs. 2.9% with SA [56], 2.08% with graph matching [41]).
• We provide methods for hyperparameter optimization to balance decoding performance and computational cost, and suggest avenues for further reduction in decoding time.

2. Background

2.1. Color Codes

Stabilizer codes are a family of quantum error correcting (QEC) codes characterized by sets of operators called stabilizers. The stabilizer operators subdivide the Hilbert space of the multiqubit system into orthogonal subspaces. The logical information is encoded into one of these subspaces, called the code space. The code space is usually chosen as the subspace for which all stabilizer operators simultaneously have a $+1$ eigenvalue. Pauli errors on individual qubits anticommute with the stabilizers, and bring the state out of the code space. By measuring stabilizer operators, it is possible to detect, identify and correct errors [21]. The result of the stabilizer measurements is called syndrome.

2D Color codes (from now on referred as color codes) are a family of stabilizer codes that can be defined on planar three-colorable lattices [25]. Each vertex has three incident edges (except for the vertices on the corners of the lattice), and each face can be colored in one of three colors, in a way that any two faces sharing an edge have different colors (see Figure 1). The vertices of the lattice represent data qubits. The colored faces represent stabilizer operators $S_Z={\prod }_{i\in F}{Z}_i$ and $S_X={\prod }_{i\in F}{X}_i$, where $X_i$ and $Z_i$ represent the Pauli operator Z or X applied on qubit i, and F represents the set of qubits that belong to that face. The logical operators $X_L$ and $Z_L$ commute with all stabilizer operators and act on the encoded information. They can be written as a product of Pauli operators on individual qubits; e.g., $X_L={\prod }_{i\in L_X}{X}_i$, where $L_X$ is a subset of qubits that forms the support of the logical $X_L$ operator (see Figure 1). For the triangular color code lattice, both $X_L$ and $Z_L$ can have their support over the same set of qubits. Note that the support of the logical operators is not unique, and can be modified by multiplying stabilizer operators.

The decoding problem consists on the interpretation of the syndrome to infer a recovery operation that brings the state back to the code space and preserves the logical information encoded in the code with a high probability of success. In the following section, we explain how the decoding problem for color codes can be mapped to a spin system.

2.2. Mapping the Code to a Spin System

The first step of the mapping consists of the decomposition of potential error chains $\mathcal{E}$ compatible with a syndrome S. Note that, given an error chain that generates a syndrome S, we can find alternative error chains ${\mathcal{E}}^{\prime }$ compatible with that syndrome by multiplying $\mathcal{E}$ with a product of stabilizer operators and logical operators. In this section, we explain the mapping for an error model where independent bit-flips happen on the data qubits with probability p before a single round of ideal stabilizer measurement. This derivation, as well as the derivation for depolarizing and phenomenological noise, can be found in Ref. [56]. We consider $\mathcal{G}$ to be a complete set of stabilizer generators of the code. For a stabilizer code, an error $\mathcal{E}$ can be decomposed into a product of three components: the set of destabilizers $D\left(S\right)$ (or “pure error”) that corresponds to the syndrome S, a subset of stabilizer generators $G\in \mathcal{G}$ and a logical operator L [64]:

$$\mathcal{E}=D\left(S\right)·G·L.$$

(1)

This expression can be rewritten in terms of binary variables, such that for each qubit i, $e_i$ represents if qubit i belongs to the error configuration $\mathcal{E}$:

$$e_i=D_i\left(S\right)\oplus \left({\displaystyle \underset{k\in Q_i}{⨁}}{g}_k\right)\oplus (L_i·l),$$

(2)

where $D_i\left(S\right)$ represents the action of the destabilizer corresponding to syndrome S on qubit i, $g_k$ is a binary variable that represents if the stabilizer generator k is being applied (if $g_k\in G$ then $g_k=1$), $Q_i$ represents the set of stabilizer generators with support on qubit i, $L_i$ represents the support of the logical operator on qubit i, and l is a binary variable that represents if the logical operator is being applied.

We can explore all error configurations compatible with a syndrome S by changing the terms $g_k$ and l. Notably, changing $\mathcal{E}$ by applying a different subset of stabilizer generators $G^{\prime }\in \mathcal{G}$ leads to alternative error configurations ${\mathcal{E}}^{\prime }$ with an equivalent effect on the encoded information. Thus, when trying to find a correction for an error, we are only concerned about finding the error class L to which it belongs, i.e., if the effect of an error corresponds to a logical operation on the encoded information. Note that this mapping can be applied to any stabilizer code, as long as we can define a destabilizer operator $D\left(S\right)$ for any possible syndrome S.

The second step consists on mapping $\mathcal{E}$ to a spin configuration $\sigma$, where each spin ${\sigma }_k\in \{-1,+1\}$ corresponds to one of the stabilizer generators in $\mathcal{G}$: ${\sigma }_k=1-2g_k$. In this way, inverting the sign of a spin would change the error configuration by the action of a stabilizer operator, leading to an equivalent error chain ${\mathcal{E}}^{\prime }$. Similarly, we can rewrite the binary terms corresponding to the destabilizer and the logical operator in Equation (2) as a coupling $J_i\left(l\right)\in \{-1,+1\}$, with $J_i\left(l\right)=(1-2D_i\left(S\right))(1-2L_i·l)$. This change allows us to rewrite Equation (2) in terms of the spin variables:

$$e_i={\displaystyle \frac{1}{2}}\left(1-J_i\left(l\right){\displaystyle \prod _{k\in Q_i}}{\sigma }_k\right).$$

(3)

Using this expression, the total number of errors can be written as

$${\displaystyle \sum _i^N}{e}_i={\displaystyle \frac{1}{2}}\left(N-{\displaystyle \sum _i^N}{J}_i\left(l\right){\displaystyle \prod _{k\in Q_i}}{\sigma }_k\right),$$

(4)

where N is the total number of qubits. Therefore, by ignoring the constant term, we can write an Ising Hamiltonian for the system as

$$H_l=-{\displaystyle \sum _i^N}{J}_i\left(l\right){\displaystyle \prod _{k\in Q_i}}{\sigma }_k,$$

(5)

which for color codes corresponds to a random three-body Ising model with spins located at plaquette centers. Note that for each error class l we find a Hamiltonian with different couplings $J_i\left(l\right)$ between the spins. By finding the spin configuration that minimizes the Hamiltonian for each value of l, we can then find the error configuration with the minimum number of errors, which is also the most probable error configuration.

A similar mapping can be derived for the depolarizing noise model, where independent Pauli errors occur with equal probability according to the following:

$${\mathcal{E}}_d\left(\rho \right)=(1-p_d)\rho +{\displaystyle \frac{p_d}{3}}(X\rho X+Y\rho Y+Z\rho Z),$$

(6)

where the map ${\mathcal{E}}_d\left(\rho \right)$ represents the effect of depolarizing noise on the state $\rho$ of a qubit. The mapping considers two spins for each plaquette (as each plaquette has X and Z stabilizers), and the resulting model can be interpreted as two random three-body Ising models coupled by a six-body interaction (due to Y errors interacting with three X stabilizers and three Z stabilizers) [37,56]. For this case, we must consider two logical operators, $X_L$ and $Z_L$. This leads to four homology classes: one for the case where no logical error happened, and one for each $X_L$, $Y_L$, and $Z_L$ case. The derivation of this mapping can be found in Refs. [37,56].

The last error model that we consider in this work is phenomenological noise, where independent bit-flips occur on the data qubits with probability p, and stabilizer measurement errors occur with probability q. For this error model, multiple rounds of stabilizer measurement are considered to protect against measurement errors. The couplings for this case result in a 3D random-plaquette gauge model, where we have spatial spins located at the center of each plaquette, and temporal spins located at each qubit position. The details of the mapping for this problem are shown in Refs. [38,56]. In this work, we study the $p=q$ case and for a code of distance d, with d rounds of noisy stabilizer measurement. The model can be generalized to cases with $p\ne q$ [63].

Note that for a realistic scenario, one would need to consider the different faulty gates required for stabilizer measurement in a circuit-level noise model, while some mappings have been studied for this case [65,66], the adaptation of the decoder for this model require some further considerations that are beyond the scope of this work.

2.3. Optimal Decoding

While finding the minimum-weight error chain that accounts for the observed syndrome is a valid criterion for the selection of a correction, it is only an approximation to the optimal decoding scheme. The optimal decoding can be achieved in the following way: Let us consider the probability of an error $\mathcal{E}$ with an associated syndrome S:

$$P\left(\mathcal{E}\right|S)\propto {\displaystyle \prod _{i=1}^N}{(1-p)}^{1-e_i}{p}^{e_i}\propto {\displaystyle \prod _{i=1}^N}{\left({\displaystyle \frac{p}{1-p}}\right)}^{e_i}.$$

(7)

In the following, we consider that any error chain $\mathcal{E}$ can be defined by a spin configuration $\sigma$ and a homology class l, with a set of coefficients $J_i\left(l\right)$ given by the measured syndrome S. Using the expression in Equation (3) and performing a change in variable given by $exp(-2\beta )\equiv p/(1-p)$, we obtain

$$P\left(\mathcal{E}\right|S)=P(\sigma ,l|S)\propto exp\left[{\displaystyle \sum _{i=1}^N}\beta J_i\left(l\right){\displaystyle \prod _{k\in Q_i}}{\sigma }_k\right].$$

(8)

Finally, this probability can be written as

$$P(\sigma ,l|S)\propto exp\left[-\beta H_l\left(\sigma \right)\right],$$

(9)

which is proportional to a Boltzmann factor with energy $H_l\left(\sigma \right)$ at inverse temperature $\beta$.

To obtain the optimal correction, we do not need to find the exact original error, it is enough to perform a correction that belongs to the same homology class as the original error. If this is not the case, then the combination of the original error and the correction introduces a logical error. Thus, the best decoding strategy consists of estimating the most likely homology class. This can be obtained by performing the sum of the probabilities of all possible errors in each homology class:

$$P\left(l\right|S)={\displaystyle \sum _{\sigma }}P(\sigma ,l|S)\propto {\displaystyle \sum _{\sigma }}exp\left[-\beta H_l\left(\sigma \right)\right]={\mathcal{Z}}_l,$$

(10)

where ${\mathcal{Z}}_l$ is the partition function of the Hamiltonian $H_l$ at inverse temperature $\beta$. The most likely homology class can then be obtained by evaluating the value of ${\mathcal{Z}}_{l=0}/{\mathcal{Z}}_{l=1}$, if this value is bigger (smaller) than 1, then the homology class $l=0$ ($l=1$) is the most likely. This result can be related to the free energy F since

$$-\beta F_{l=0}+\beta F_{l=1}=-\beta \Delta F=-log\left({\mathcal{Z}}_{l=1}/{\mathcal{Z}}_{l=0}\right),$$

(11)

where $\Delta F$ is the difference in free energy between the two homology classes. Therefore, by estimating $\Delta F$, we can find the most likely error class, maximizing the success probability of the decoding operation.

This method can also be applied to other error models, like depolarizing noise or phenomenological noise. For depolarizing noise, we consider Pauli errors on the physical qubits occurring with probability $p_d/3$ (see Equation (6)). Using the mapping described in Ref. [56], it can be found that the target inverse temperature for this model is given by

$$\beta =-{\displaystyle \frac{1}{4}}log\left({\displaystyle \frac{p_d/3}{1-p_d}}\right).$$

(12)

To find the optimal recovery operation, one must find the most likely homology class, given by the combinations of the logical operators $X_L$ and $Z_L$. Generally, for a code with k independent logical operators, the optimal decoder should explore the $2^k$ different homology classes for the bit-flip noise case (or $4^k$ for the depolarizing noise case) to find the optimal correction.

3. Population Annealing

Population annealing (PA) [60,61] is an algorithm closely related to the Simulated Annealing (SA) algorithm [55]. Both are sequential Monte Carlo algorithms that start with a set of R replicas ${\sigma }^{\left(i\right)}$, $i=1,\dots ,R$, which in our case of interest are spin configurations. These replicas have an energy associated with a given Hamiltonian and, when their spin values are initialized randomly, they can be considered as samples from a Boltzmann distribution at a temperature $T\to \infty$ or inverse temperature ${\beta }_0=1/T=0$. Given a replica $\sigma$ with energy E, it is possible to propose a change to it (e.g., a single spin flip) that results in the configuration ${\sigma }^{\prime }$ with energy $E^{\prime }$. To transform our replicas from thermal distribution samples with ${\beta }_0=0$ to samples corresponding to ${\beta }_1>{\beta }_0$, we accept or reject these changes with a probability given by the Metropolis–Hastings rule [67]:

$$P_{\mathrm{accept}}\left({\sigma }^{\prime }\right|\sigma )=\left\{\begin{array}{cc}1\hfill & \mathrm{if}{E}^{\prime }\le E\hfill \\ e^{-{\beta }_1(E^{\prime }-E)}\hfill & \mathrm{if}{E}^{\prime }>E.\hfill \end{array}\right.$$

(13)

Eventually, after proposing enough changes, the resulting replicas will approximate the result of sampling from the Boltzmann distribution at inverse temperature ${\beta }_1$. This process can be iterated for increasing inverse temperature values ${\beta }_t$, with $t=1,\dots ,N_T$, until reaching a target temperature ${\beta }_{N_T}$. These steps constitute the simulated annealing algorithm.

In the PA algorithm, when changing the temperature of the system from ${\beta }_t$ to ${\beta }_{t+1}$, a resampling between the replicas is performed by associating a probability proportional to the relative Boltzmann weights between each temperature to each replica:

$${\tau }_i={\displaystyle \frac{e^{-({\beta }_{t+1}-{\beta }_t)E_i}}{Q({\beta }_t,{\beta }_{t+1})}},$$

(14)

with the normalization factor

$$Q({\beta }_t,{\beta }_{t+1})={\displaystyle \sum _{i=1}^R}{e}^{-({\beta }_{t+1}-{\beta }_t)E_i}.$$

(15)

There are different ways of resampling using these probabilities. In this work, we chose to implement the so-called systematic resampling approach, which keeps the number of replicas constant at all times, requires only one randomly generated number for each resampling step, and was found to introduce fewer statistical errors as compared to other resampling methods [68]. To visualize how systematic resampling works, let us consider a line of unit length. Each replica can be positioned in this line with a length equal to its corresponding ${\tau }_i$ value (see Figure 2). This resampling is implemented by generating a random number $U_0\in [0,1/R)$ and selecting R positions given by the values $U_k=U_0+k/R$ with $k=0,\dots ,R-1$. Each of these values will be associated with a replica. The set of replicas associated with the R values $U_k$ will be the new set of resampled replicas. This completes the resampling process.

The resampling step and the acceptance-rejection defined by the Metropolis–Hastings rule are complementary to each other. On the one hand, when applying the SA algorithm alone, the replicas can become stuck in local minima and are less likely to escape as the temperature decreases. This reduces the number of effective replicas, resulting in a less efficient use of the computational resources. This effect is mitigated by resampling the replicas, which introduces a mechanism for these trapped replicas to escape. On the other hand, while the resampling step introduces correlations between replicas that are resampled to the same configuration, this is alleviated by the acceptance-rejection protocol, which uncorrelates the replicas step by step.

However, the most important consequence of introducing this resampling step is that it can be used to estimate the free energy, $\overline{F}\left({\beta }_{N_T}\right)$, at the target temperature ${\beta }_{N_T}$ [61]. This can be obtained as follows:

$$-{\beta }_{N_T}\overline{F}\left({\beta }_{N_T}\right)={\displaystyle \sum _{t=0}^{N_T-1}}lnQ({\beta }_t,{\beta }_{t+1})+ln\mathrm{\Omega },$$

(16)

where $\mathrm{\Omega }$ is the total number of possible configurations. As explained in Section 2.3, estimating the values of the free energies for different homology classes can be used to achieve optimal decoding in QEC codes for different error models. In the following section, we explain and present in detail our simulations of PA as a decoder for the color code.

4. Numerical Results

4.1. Simulation Details

We simulate the decoding process on triangular color code lattices for different code distances d and error rates p around the expected value of the threshold corresponding to each error model. For these decoding simulations, we use $R=1000$ replicas, $N_T=100$ inverse temperature steps following a linear inverse temperature schedule, and $N_S=200$ sweeps over all the spin variables, where a sweep consists of going over each of the spins (stabilizers) of the code always in the same order and accepting or rejecting a change in its value based on Equation (13). We note that these values of the hyperparameters correspond to computational resources $W=R{N}_T{N}_S$ that are far above those required for the correct behavior of the PA decoder, and that the decoder behavior is largely insensitive to the specific choice of R, $N_T$, and $N_S$ as long as W is high enough [69,70]. We use the additional resources to ensure that the decoder finds the optimal correction for all the cases. The optimization of the hyperparameters is further discussed in Section 5. We also note that the PA decoder dedicates most of the computing time on the acceptance or rejection of spin-flip candidates. A non-parallelized version of our code using an AMD Ryzen 9 5950x 3.4 GHz (AMD (Advanced Micro Devices), Santa Clara, CA, USA) requires 7 ns for each candidate. However, our implementation takes advantage of CPU parallelization, which considerably improves the algorithm speed, reducing the time per candidate to approximately $0.5$ ns in our simulations. As an example, for the bit-flip noise model, which has $h=2$ homology classes, and for code distance $d=15$ ($N_{\mathrm{spins}}=63$ spins), the time required for decoding is $R{N}_T{N}_S{N}_{\mathrm{spins}}{t}_{\mathrm{flip}}h=1.8$ s.

With the current implementation, the application of the decoder in a real-time scenario is unfeasible for most quantum computing platforms, where a single round of stabilizer measurements can be of the order of 1 μs in superconducting architectures [71]. However, the computational time could be greatly reduced by paralellization, as the computation for different replicas and homology classes could be performed in parallel. For the particular example above, that parallelization could lead up to a $R·h=2000$ times increase in computational speed if sufficient computational cores are available. This level of parallelization could be possible with dedicated hardware or GPUs [72,73]. We note that these computational resources are intentionally high for such a small code distance, and were chosen to ensure reliable convergence across all code distances and noise models considered in this work. Additional methods to reduce computational time are discussed in Section 6, which together with parallelization could further reduced the execution time of the decoder. Beyond the optimization of the execution time, a real-time implementation of the decoder would require the capability to adquire new syndrome information dynamically by doing, e.g., window decoding [74]. The study of a dynamic implementation of the decoder is left for future work.

From the simulation results, we obtain the probability of a logical error $p_L$ for each value p and d. With these results, we assume a critical scaling ansatz to estimate the corresponding threshold. Using this ansatz, we expect $p_L$ to behave as a linear function around the threshold, given by

$$p_L=A+B{d}^{1/\nu }(p-p_{th}),$$

(17)

where A and B are linear fit parameters, $\nu$ is the critical exponent, and $p_{th}$ is the value of the threshold. For this approximation to be accurate, we perform the fit considering only points close to the threshold. Also, we only consider high enough distances so that finite-size effects do not affect our analysis.

4.2. Bit-Flip Noise

For the bit-flip noise model, we consider independent bit-flip errors on the data qubits and a single round of ideal stabilizer measurement. As explained in Section 2.3, for bit-flip noise we have to estimate the free energies associated with the two different homology classes. We simulate the decoding process under independent bit-flip noise to obtain the logical error probabilities for distances $d=15,17,19,21,23$ for a total of $2·{10}^5$ decoding instances for each code distance and error probability. We show the results of these simulations in Figure 3. Fitting these results to Equation (17) we obtain the following values:

$$\begin{array}{cc}\hfill A& =0.155\pm 0.002,\hfill \\ \hfill B& =0.709\pm 0.127,\hfill \\ \hfill \nu & =1.41\pm 0.12,\hfill \\ \hfill p_{th}& =0.1081\pm 0.0003.\hfill \end{array}$$

(18)

For this case, we find that using the PA decoder to estimate free energies improves the quality of the decoding process as compared to finding the minimum-weight error chain using SA, for which the threshold found in Ref. [56] is $10.359\%$. Additionally, the value that we find for the threshold is close to the optimal threshold of 10.9% estimated in Refs. [36,51].

4.3. Depolarizing Noise

In this model, we consider independent Pauli errors on each data qubit (see Equation (6)) and a single round of ideal stabilizer measurement. For depolarizing noise, we have to estimate the free energies associated with four different homology classes. We simulate the decoding process under depolarizing noise to obtain the logical error probabilities for distances $d=11,13,15,17,19$ for a total of $2·{10}^5$ decoding instances for each code distance and error probability. We show the results of these simulations in Figure 4. Fitting these results to Equation (17), we obtain the following values:

$$\begin{array}{cc}\hfill A& =0.2836\pm 0.0017,\hfill \\ \hfill B& =0.7309\pm 0.1034,\hfill \\ \hfill \nu & =1.338\pm 0.092,\hfill \\ \hfill p_{th}& =0.1875\pm 0.0003.\hfill \end{array}$$

(19)

For this case, we find again that using the PA decoder to estimate free energies improves the quality of the decoding process as compared to finding the minimum-weight error chain, for which the threshold found in Ref. [56] was $18.467\%$. Additionally, the value that we find for the threshold is in close agreement with the 18.9% optimal threshold numerically obtained for the 6.6.6 color code and the value estimated for the 4.8.8 color code of 18.78% in Ref. [37].

4.4. Phenomenological Noise

In this noise model, we consider independent bit-flip errors happening with probability p on data qubits at each round of stabilizer measurements, and incorrect measurement results with probability q. In particular, we assume $p=q$ for all simulations. Since we consider only bit-flip errors, we need to estimate the free energies associated with two different homology classes. We simulate the decoding process under phenomenological noise to obtain the logical error probabilities for distances $d=9,11,13,15$ for a total of $5·{10}^4$ decoding instances for each code distance and error probability. We show the results of these simulations in Figure 5. For the values of p and d used in these simulations, we observe a deviation from a linear fit. Therefore, we perform a fit similar to Equation (17) but including a quadratic term, described by the parameter C, and given by:

$$p_L=A+B{d}^{1/\nu }(p-p_{th})+C{d}^{2/\nu }{(p-p_{th})}^2.$$

(20)

We obtain the following values:

$$\begin{array}{cc}\hfill A& =0.127\pm 0.002,\hfill \\ \hfill B& =1.80\pm 0.16,\hfill \\ \hfill C& =7.07\pm 1.13,\hfill \\ \hfill \nu & =1.12\pm 0.04,\hfill \\ \hfill p_{th}& =0.0347\pm 0.0002.\hfill \end{array}$$

(21)

Once again, we find that using the PA decoder to estimate free energies improves the quality of the decoding process as compared to finding the minimum-weight error chain, for which the threshold found in Ref. [56] with SA was $2.90\%$. Our result sits above the optimal threshold of $3.3\%$ estimated for surface codes [62], while the authors are not aware of any study of the optimal threshold for 4.8.8 color codes under phenomenological noise, it does not match the optimal threshold estimated for the hexagonal color code at 4.8% [38,63]. The reason for this discrepancy deserves further study, but it is beyond the scope of this work.

5. Resource Optimization

The previous results were obtained by using more computational resources than needed to ensure that we obtained high-fidelity threshold values. However, in practice, one would want to reach a compromise between the quality of the solutions and computational resources, i.e., the time required for decoding. In the following, we study the relation between these two quantities. Although we show the analysis applied to the bit-flip noise model, the ideas presented here are directly applicable to the other noise models presented in this work.

The population annealing decoder for the bit-flip noise model works by estimating the free energy of the two possible homology classes and choosing the corresponding correction based on the difference between them, $\beta \Delta F$. However, since population annealing uses a limited amount of computational resources (number of replicas and spin flips), the estimate obtained has an associated variance $\mathrm{Var}(\beta \Delta F)$. We study how this variance increases the probability of logical error in the following way: For a given bit-flip probability and code distance, we simulate several instances with a high number of resources to obtain an estimate of the distribution $P\left(\right|\beta \Delta F\left|\right)$ with sufficiently small error (see Figure 6). We know that some of these instances will correspond to successful corrections, denoted as $P_{\mathrm{s}}\left(\right|\beta \Delta F\left|\right)$, while the rest will correspond to failed corrections, $P_{\mathrm{f}}\left(\right|\beta \Delta F\left|\right)$. As previously explained, in a real implementation of the decoder there will be an error in the estimation of $|\beta \Delta F|$ due to using a finite number of computational resources. The value of $|\beta \Delta F|$ plus this error might result in a negative value. For these cases, the decoder finds the opposed homology class than the one which the optimal decoder would find. Therefore, an error configuration that an optimal decoder would successfully correct, can lead to a logical error with the finite-resource decoder due to the error in the estimation of $|\beta \Delta F|$. We denote the probability of this happening as $P_{\mathrm{s}\to \mathrm{f}}$. Similarly, the error can transform a correction that would otherwise be a failed correction into a successful one, $P_{\mathrm{f}\to \mathrm{s}}$. As a consequence, the logical error probability, $p_L$, is increased by $\Delta p_L$:

$$p_L^{\prime }=p_L+\Delta p_L,$$

(22)

with

$$\Delta p_L=(1-p_L)P_{\mathrm{s}\to \mathrm{f}}-p_L{P}_{\mathrm{f}\to \mathrm{s}},$$

(23)

where $\Delta p_L$ can be obtained by using the estimated distribution $P\left(\right|\beta \Delta F\left|\right)$ and the value of $\mathrm{Var}(\beta \Delta F)$ associated with using a finite number of computational resources. Specifically, the value $P_{\mathrm{s}\to \mathrm{f}}$ ($P_{\mathrm{f}\to \mathrm{s}}$) can be obtained by performing the convolution of $P_s$ ($P_f$) with a normal distribution of mean zero and variance $\mathrm{Var}(\beta \Delta F)$ and calculating the area that corresponds to negative values.

The previous derivation introduces a way to relate the quality of the decoding process with the error in the estimate of $\Delta F$. We have tested this relation on the color code with $d=7,9,11,13$ and $p=10.8\%$. We use the PA decoder for a fixed value of $N_T=30$ temperature steps while changing the value of $R{N}_S$. For each of these values, we estimate the corresponding value of $\mathrm{Var}(\beta \Delta F)$ by simulating 200 decoding instances 100 times each. We can use the obtained value of the variance and the histograms of $P\left(\right|\beta \Delta F\left|\right)$ to obtain the estimated value of $\Delta p_L$. We then simulate $5·{10}^5$ decoding instances for each value of d and $R{N}_S$ to estimate $p_L^{\prime }$ and subtract the estimated value of $p_L$ for those values of d and p. The results obtained from our estimation method and those found from simulations are in close agreement and are shown in Figure 7.

Using this approach, it is possible to set a maximum target value of $\Delta p_L$ and find the corresponding value of $\mathrm{Var}(\beta \Delta F)$. The optimization problem is then transformed into finding the value of the parameters (number of replicas, number of temperature steps, and number of spin flips per temperature) that achieves that variance value. Although one can simplify this three-dimensional problem by fixing two of these parameters while scanning different values of the remaining one (similar to what is shown in Figure 7), a better optimization would require a three-dimensional scan of the parameters.

We conclude this section by noting that a similar analysis can be performed by fixing the distance of the code and considering different values of p. An example of this process is shown in Figure 8 for $d=11$. We can see that, given some computational resources $R{N}_S$, and for decreasing values of p below the threshold, the values of $|\beta \Delta F|$ move away from zero. Thus, it is expected for the value $\Delta p_L$ to decrease given a fixed value of $\mathrm{Var}(\beta \Delta F)$. Moreover, using the histogram analysis, we see that the value $\Delta p_L/p_L$ also decreases with p (see Figure 9), with the case close to the threshold being the most expensive case in terms of computational resources. This insight can be useful for reducing the decoding times in codes with error probabilities far from the threshold.

6. Conclusions and Outlook

In this work, we have shown an implementation of the population annealing algorithm as a color code decoder. This algorithm is based on a mapping of the color code lattice to a spin model, as shown in Ref. [56]. We introduce the use of population annealing, allowing the estimation of the free energy of the different homology classes. This can be used to infer the most probable error class instead of the most probable error case. As a result, we obtain improved thresholds and a higher decoding success rate, which leads to lower logical error rates for the same physical error rate. Our numerical results show that our decoder can reach near-optimal thresholds under code capacity noise (bit-flip and depolarizing) and a high threshold for phenomenological noise.

We provide methods to optimize the hyperparameters of the algorithm, thus reducing the computational resources and time required for a given performance. Additionally, considerable efforts have been made to optimize the code that implements the population annealing decoder. However, the computational runtime required could become a limiting factor when scaling the lattice, preventing the possibility of a real-time decoder implementation for fault-tolerant quantum computation. This can be more challenging in platforms with very fast gates like superconducting qubits, where a QEC cycle can be executed in under 1 μs. Nevertheless, some changes could further increase the speed of the decoder. From the algorithmic side, the PA algorithm can perform multiple independent runs with fewer replicas each and perform a weighted average of the results. This results in a reduction in the statistical and systematic errors as compared to making a single PA run with all the replicas [61,75], which is the case for the implementation in this work. Furthermore, studying possible cluster updates applicable to the color code spin model would be interesting. Cluster updates, as opposed to the single-spin flips used by our algorithm, could reduce the steps needed for thermalization [76,77]. From the hardware side, our decoder, similar to the one shown in Ref. [56], is highly parallelizable, while one could take advantage of this by using better CPUs with more parallelization capabilities, or even multiple CPUs, we believe that the most interesting approach would be the implementation of the code in GPUs. The PA algorithm has already been implemented in GPUs, achieving impressive improvements in the performance of the algorithm [72,73], considerably reducing the average time required per spin flip thanks to the parallelization capabilities of GPUs. We leave the study of the performance of the PA decoder using a GPU implementation and the analysis of the scaling of computational resources for future work. Finally, similar to the SA decoder, a trade-off exists between performance and decoding time. Thus, one could also decrease the decoding quality in exchange for a faster decoding algorithm.

While we have focused on the study of the decoder applied to color codes, the algorithm can be easily applied to other CSS codes, e.g., surface codes or qLDPC codes [27,28,29,30,31,32]. The spin mapping for other CSS codes follows the same equations described in this work, where spins are assigned to stabilizers, and stabilizers sharing a qubit would be coupled. The couplings between spins can be found from the support of the logical operators and any destabilizer operator $D\left(S\right)$ (as the choice of destabilizer is not unique). The main challenge for the application to other codes is to find an efficient way of computing the destabilizer operator for a given syndrome. For some codes, it is possible to find a destabilizer operator for each stabilizer in the code, which allows the computation of the destabilizer for any syndrome S as a linear combination of the destabilizers of the excited stabilizers. However, for some codes (e.g., surface code with periodic boundary conditions) it might not be possible to find destabilizers for a single stabilizer excitation, as those syndromes would not be allowed (due to, e.g., excitations being created and destroyed in pairs). In those cases, the destabilizer can be computed for each syndrome, e.g., by using any other decoder, which may require further computational resources. The last consideration concerns the resource requirements for codes with multiple logical qubits encoded, since the decoder relies on estimating the free energy for each homology class in the system, and the number of homology classes grows exponentially with the number of logical operators. The computational cost can thus become prohibitive for some qLDPC codes like tile codes [78], where the number of logical qubits in a single code can be as high as 18, and potentially higher. A practical application for qLDPC codes may require more advanced techniques to explore spin configurations and homology classes more efficiently.

From the QEC perspective, it would be interesting to understand the discrepancy between our threshold and the estimated optimal threshold for the phenomenological noise model. This could potentially be clarified by studying the performance of the decoder on different code families, and analyzing the effects of boundaries, finite-size effects or the choice of destabilizer operators, among other factors.

The most interesting avenue for future research is the adaptation to circuit-level noise models. Existing works have studied the mapping of circuit-level noise to spin models by introducing additional couplings in the spin model related to the possible errors in the system [65,66], which could open the way for the development of the decoder. A real time optimal decoder for circuit-level noise would maximize the probability of success of QEC, and effectively reduce the required resources to reach a target logical error rate for fault-tolerant applications. Although a real time implementation of this decoder is unlikely due to the estimated time constrains, an optimal circuit-level noise decoder could still find some applications in an experimental setting; e.g., training of neural network decoders or optimizing callibration of gates. The study of the circuit-level noise decoder and its applications are outside of the scope of this study and are left for future work.