squares and labelled as $s$, and horizontal and vertical data qubits are
denoted as $H$ and $V$ respectively.

Under these considerations we can define the tensor nodes which form the
overall planar code PEPS tensor network in FIG. 18. The elements of the data
qubit tensors are the probabilities of experiencing Pauli errors given by the
indices. Moreover, the indices $n$, $e$, $s$ and $w$ indicate the tensors to
their north, east, south and west; respectively. The indices are binary and
indicate if either of the adjacent stabilizer generators operates non-
trivially on them as can be seen in the right side of FIG. 18, where one can
see that the state of a data qubit tensor is both dependent on the indices and
the correspondent Pauli operator on the qubit from the error $E_{rec}$. On the
other side, the stabilizer tensor nodes are defined by Kronecker deltas, i.e.
they are either 1 when $n=e=s=w$ and $0$ otherwise. That is because the
stabilizer generators either operate on all their nearest data qubits or do
not operate on any of them, as was earlier shown in FIG. 2.

Figure 18:  On the left, graphical representation of the tensor nodes which
constitute the planar code tensor network. On the right, element values of the
tensors, the superindex indicates the labelling of the tensor node.

Since the probability of error of data qubits is independent from one to
another, considering an error $E_{rec}$ associated to a syndrome and
contracting the tensor network from FIG. 17 results in the summation of
products of tensor probabilities under all the combinations of the stabilizer
generators, which itself is equivalent to finding the probability of the error
class $p(\mathcal{G}E_{rec})$. Unfortunately, and as explained before,
contracting columns increases the vertical bond dimension exponentially and,
thus, the reasonable approach consists in truncating the vertical bond
dimension after each contraction to a truncated value $\chi$. This is often
done through the Schmidt decomposition [27, 182], which allows the resulting
tensor after the column contraction to be represented as a sum of products of
smaller tensors called ”Schmidt tensors”. The SVD is applied to said Schmidt
tensors resulting in the Schmidt values, the truncation follows by only
considering the ”Schmidt tensors” correspondent to the highest $\chi$ Schmidt
values [182]. This allows for obtaining approximate values of the
probabilities of the error classes, which can then be used for decoding at a
higher precision than any of the aforementioned algorithms, if the truncation
of the bond dimension is high enough.

####  V.4.3 TN decoding for the rotated planar code

For the rotated planar code, the tensor network representation of the system
is not as straight forward as in the case of the planar code, since the code
can no longer be mapped directly to a PEPS tensor network. An elaborate and
efficient way of adapting the TN decoder in [27] for rotated planar codes,
while greatly improving their performance was elaborated in [206] as
illustrated in FIG. 19. As depicted in the figure, the rotated planar code is
first adapted to the tensor network model proposed in [27], which does not
correspond to a PEPS state. In order to map such TN to the desired
representation, the stabilizer nodes are split in 4 smaller tensor nodes which
preserve the delta tensor structure themselves [203], i.e. the values are
given by the Kronecker delta. Afterwards, the data qubit nodes altogether with
their adjacent stabilizer nodes are contracted producing the desired PEPS.
Note how the resulting PEPS is no longer isotropic, i.e. if the PEPS is
rotated 45º counter clock-wise, most of the vertical bonds will be of
dimension 2 while the horizontal ones will be of dimension 1.

Figure 19: In a), a rotated planar code of distance 5. In b) the tensor
network one could extract following [27]. In c), the tensor nodes
correspondent to stabilizer generators are split in 4 tensor nodes connected
with themselves. In d), a new tensor network arrangement is proposed for the
rotated planar code. Notice the tensor network can be separated in sets of
tensor nodes which are encircled in dashed violet lines. In e), the
aforementioned encircled tensors are contracted and a new tensor network is
obtained.

Given this new structure, the rotated planar code can be decoded through the
TN decoder. In FIG. 20, we can see an example of the decoding process of an
arbitrary syndrome through the TN decoder for a $5\times 5$ rotated planar
code. In the top image, the error $E$ is presented altogether with the
measured syndrome and in the second image an error $E_{rec}$ which returns the
code to the codespace is presented. This error is found by generating chains
from every non-trivial syndrome element to its nearest virtual check.
Afterwards, the probability cosets of the four logical operators are computed
by contracting the associated tensor network. The combination of each of the
logical operators with $E_{rec}$ is also presented in the third and fourth
row. Finally, the coset with the highest probability is $Y_{L}$ for this
example and, thus, the recovered error by the TN decoder is $E_{rec}Y_{L}$. In
the figure at the bottom, the resulting state of the code after recovery
defined by $E_{rec}Y_{L}E$ can be seen, and, as shown by the highlighted
stabilizer operators it belongs to the stabilizer set, implying that the
correction has been successful.

Figure 20: Graphical representation of a TN decoding process for a specific
syndrome in a 5x5 surface code.

####  V.4.4 Performance and threshold

The tensor network decoder has the highest code threshold out of the ones
considered in this work equal to $0.185$ under depolarizing noise with a bond
dimension $\chi=16$, as can be seen in FIG. 21. It is worth mentioning that
this exceptional performance is highly related to the value of $\chi$, the
maximum value of which scales in an exponential manner as larger
configurations are considered. Recent work has been done studying $\chi$
values for achieving convergence of the tensor network decoding method under
several noise model and code tailoring conditions [204, 206].

Moreover, as can be seen in Table 4, tensor network decoding also suffers
under biased noise in a significant manner. There have been recent studies
which have investigated the effect of biased noise in surface codes and ways
to enhance its performance reaching significant results which allowed for
lower values of $\chi$ in order to obtain a convergence within the tensor
network problem [206, 23]. At the current time, the exceptional performance of
the tensor network decoding scheme motivates researchers to seek for methods
to accelerate its poor run time.

$\eta$ | $p_{th}$
---|---
1/2 | 0.185
1 | 0.175
10 | 0.111
100 | 0.097
1000 | 0.096
Table 4: Probability threshold values for different biases of the rotated
planar code under Pauli noise decoded with the TN decoder with bond dimension
$\chi=16$. Figure 21: Logical error probability with dependence on the
physical error probability of the rotated planar code under depolarizing noise
decoded with the TN decoder with bond dimension $\chi=16$.

####  V.4.5 Complexity

The complexity of the tensor network decoding method is mainly given by two
important tasks: the contraction of the MPS with its nearest MPO and the
truncation of the resulting state. The contraction of the MPS with the MPO has
a complexity of $\mathcal{O}(d\chi^{2})$ while the truncation technique has a
complexity $\mathcal{O}(d\chi^{3})$ [27, 183]. Since for every matrix product
operation there is a need for $d$ truncation techniques, one for each tensor
node within the MPS, the resulting truncation complexity is
$\mathcal{O}(d^{2}\chi^{3})=\mathcal{O}(n\chi^{3})$. Thus, the truncation
complexity ends up defining the overall complexity of the decoding method.

The resulting complexity is a high price to pay for a DQMLD method, as larger
code sizes are considered, the required $\chi$ should be also larger for
taking into account the most probable configurations within the stabilizing
cosets. The cubic growth with the bond dimension truncation harshly
compromises the possible usability of the TN decoder in real-time decoding.
Moreover, the Google Quantum AI team observed that this decoder is many orders
of magnitude slower than the MWPM implementations used for their experiments
[1].

####  V.4.6 Measurement errors

Considering measurement errors in tensor network decoding is a cumbersome
task, since it requires a space-time syndrome extraction which yields
additional tensor nodes to take into account. The Google team in [1] studied
the tensor network decoding process in a distance-5 code for 25 syndrome
extraction rounds by considering a Tanner graph between the syndrome elements
and the circuit-level error mechanisms in a similar manner than the method
used in [102]. Afterwards, this Tanner graph can be rewritten as a tensor
network that evaluates the probability of a logical coset outcome and, it can
be planarized and contracted considering a specific truncation [217].

As with the other decoding methods, considering measurement errors
significantly increases the complexity of the already complex tensor network
decoding method. Nevertheless, the high cost of performing TN decoding allowed
for the best performance in the experimental surface code from Google [1].

###  V.5 Other decoders

Many other decoders have been proposed through the literature for decoding
topological codes other than the mainstream MWPM, UF, BPOSD and TN decoders.
Many of them have been proposed to decode specific families of topological
codes other than the rotated planar code such as the toric or the the color
code. In this section we briefly introduce those decoders and discuss their
capabilities.

####  V.5.1 Cellular-automaton decoder

Cellular-automaton decoders were first proposed for decoding the toric code
[100]. This class of decoders was constructed with the aim of reducing the
decoding problem to simple local update rules in the sense that they only
depend on the nearest neighbours. The authors justify that a cellular
automaton does fit such requirements and, thus, propose the use of an
auxiliary cellular automaton to the toric code such that it communicates long-
range information between the non-trivial syndromes that have been with the
aim that local decision can be made for correcting the associated error. More
specifically, the auxiliary cellular automaton stores real numbers
$\phi_{t}(x)$ at each time step, $t$, of the decoder for each of its cells. In
this sense, the system depends on the error configuration, the activated
syndrome elements at a time step and the value of $\phi$, which includes the
values for every cell $x$. In order to update the system state from a time $t$
to the next time step $t+1$, $c$ elementary updates of $\phi$ are done based
only on the information of the nearest neighbors and another step where the
error and the syndrome on the system at such time step is updated too. For
doing so, a nearest syndrome is triggered based on an update rule. By
repeating this $\tau$ times, the closest potential partners are found when two
syndromes cancel each other, implying that a matching has been found, recovery
Pauli operation. The authors in [100] propose that $phi$ represents an
attractive force between the measured syndrome, emulating an electrostatic or
gravitational field which can be discretized into update rules since they can
be discretized to local dynamics. Therefore, they propose to emulate the long
field attraction of those fields to represent that the closest triggered
syndromes are attracted, and they propose the local dynamics induced by those
laws to updated the values locally.

Figure 22: Visual representation of the 2D cellular automaton decoder for the
toric code with periodic boundaries. The blue dots, represented by lattice
$V$, are the data qubits while the green boxes, represented by lattice
$\Lambda$, depict the cellular automaton decoder. Figure taken from [100].

The update rule proposed by the authors is based on selecting which of the
neighbour syndromes is activated as a function of the field intensity provided
by the values of $\phi$. In this sense, they look for the the adjacent cell
with largest field value and then move there with a probability $1/2$.
Regarding the function $\phi$, a local discretization of the Gauss’ law was
selected for emulating the long field attraction [100]. There have been other
proposals for the update rule of the cellular automaton decoder such as the so
called Toom’s rule [97, 132] or the sweep rule [131, 214]. Most of the
cellular automaton decoders have been studied for toric codes with boundaries
in $d$ dimensions [100, 97, 132, 131, 214], but some lattices without
boundaries have examined [214]. Additionally, it was shown that the decoders
for the toric code can be applied to decode color codes [130] and, thus,
cellular automaton decoders can also be applied for this family of QECCs.
Unfortunately, its application for a rotated planar code has not been
investigated.

Regarding the threshold achieved by this class of decoders it is noteworthy to
say that the noise model considered has been primarily an i.i.d. phase flip
model [100, 97, 132, 131, 214]. In this sense, a threshold of $8.2\%$ was
claimed in [100] for a 2D toric code, while a MWPM decoder exhibits a
$10.31\%$ threshold for such code [221]. However, a threshold of $15.5\%$ was
claimed in [132] for the cubic toric code using the sweep rule. In terms of
the complexity of this decoder, it can naturally be integrated in a parallel
way by communicating the processing cores locally and, therefore, it is
usually seemed as a fast decoder [100, 131, 214]. In this sense, the 2D
cellular automaton of [100] requires a number of updates in the order of
$\log^{5}(d)$ updates, while the 3D implementation requires a number of
updates in the order of $\log^{3}(d)$. As the authors discuss, this comes from
the fact that the cellular automata decoder accepts a parallel implementation
from construction [100]. The sweep decoder implementation in [131] requires a
runtime $\mathcal{O}(d)$, so linear in $d$.

An important feature of cellular automaton decoders is that they are robust
for the case that measurement errors are considered [131, 214]. Specifically,
this decoder is deemed to be a single-shot decoder, which implies that
measurement errors can be dealt with a single decoding round (recall Appendix
A). This is specially interesting for a decoder since as discussed before, the
way in which decoders usually deal with noisy syndromes is by performing $d$
measurement rounds and then solving the space-time like obtained graph [214].

####  V.5.2 Renormalization group decoder

The renormalization group (RG) decoder was proposed as a fast and efficient
decoder for the Kitaev toric code [61]. The main idea behind this decoder is
that the toric code can be seen as a concatenated code so that the decoding
problem can be resolved from the smaller codes that form it. The toric code is
not exactly a concatenated code, but the authors propose that it can be
actually considered to be one when allowing the blocks of the concatenation to
share qubits, so they are actually overlapped [61]. Following this rationale,
the RG decoder computes the logical error probabilities of the smallest codes
in the concatenation, which then are used as the noise model for the second
layer of codes on the concatenation. the process is repeated until reaching
the top layer of the code, which actually reperesents the complete toric code
and, thus, the estimation of the error is obtained for correction. The authors
discuss that since the small codes for the concatenation are small open-
boundary topological codes, those can be decoded by brute force [61].

As stated, the renormalization decoder was originally proposed for the Kitaev
toric code, so with periodic boundaries, but modifications for decoding color
codes [178], the 3D cubic code [25, 222, 226] qudit topological codes [222, 5,
111] and the four-dimensional toric code (both for periodic and open boundary
conditions) [62] have also been proposed. Interestingly, the RG decoder was
the first known algorithm to decode the color code. The RG decoder has not
been investigated for the rotated planar code discussed thorugh this paper,
but it could be valid, in principle, by using the ideas for decoding open
boundary four-dimensional toric codes [62] since the rotated planar code is
essentially a rotated toric code with boundaries.

Figure 23: Example of a code block decomposition used for RG decoding. Each of
the edges represnt a qubit (12 total). In this example, a subcode of two
qubits is used for RG. The dashed lines represent qubits shared by two blocks
due to the fact that the toric code is not exactly a concatenated code. Figure
taken from [61].

Regarding the code threshold achieved by RG decoders, its standard version
shown a threshold of $7.8\%$ for the depolarizing noise model, which falls
short when compared to the $15.5\%$ threshold obtained by decoding it with the
MWPM decoder. However, the application of belief-propagation decoder before
the RG decoder was proposed in [61]. This was done so that the smallest codes
of the concatenation can start the decoding with the probability distribution
given by BP implying that the RG is more accurate globally. By doing so, the
BP+RG decoder achieved a $16.5\%$ threshold, which exceeds that of the MWPM
decoder by itself [61]. This, however, was comparing the performance with the
MPWM alone, i.e. belief-matching would also increase the threshold [51, 102].
In addition, it does not exceed the threshold achieved by the tensor network
decoder, which stands between $17\%$ and $18.5\%$ [27].

Similar to the cellular automata decoder, the RG decoder admits a
parallelization of the decoding problem since each of the codes forming a
layer of the concatenation can be decoded in at the same time [61]. This
implies that the complexity of the algorithm is a function of the number of
concatenation layers, which scales logarithmically with the distance and,
thus, number of qubits of the code. Therefore, the decoding complexity of the
standard RG decoder is in the order of $\mathcal{O}(d)$ if the complete
parallelization is done, while in the order of $\mathcal{O}(d^{2}\log{d})$ if
the decoding is done serially [61]. Therefore, this decoder is considered to
be a fast decoder. The BP+RG approach for increasing the threshold will suffer
a toll in the complexity coming from having to execute BP too. It is
noteworthy to say that whenever faulty syndrome measurements coming from
circuit level noise are considered, the RG decoder needs $d$ rounds of
measurements for dealing with them, implying that the complexity of the
decoder will also increase [214].

####  V.5.3 Neural-network decoders

Neural-network (NN) decoders are a result of applying machine learning (ML)
techniques for decoding quantum error correction codes [212]. In order to do
so, the authors of the NN decoder proposed reducing the decoding problem to
the well-studied ML problem of classification, which generally consist on
optimizing the assignment of known labels (generally low-dimensional) to known
inputs (generally high-dimensional) with the scope of afterwards using the
optimized assignment to label inputs that are unknown. A toy example of a
classification problem in ML is to label photos of cats and dogs, i.e. to say
which photos depict cats and which dogs [185]. The stage in which the
classifier is optimized with known data is named training. Hence, NN decoders
need a training stage before being able to decode. In the context of the
analogy with machine learning, the authors propose to decompose an error into
three multi-qubit Pauli operators as $E=STL$, where $S$ is an element of the
stabilizer, $T$ is any fixed Pauli that produces the error syndrome (usually
referred as pure error) and $L$ is a logical Pauli operator [212]. Note that
this decomposition is standard in the field of quantum error correction [85].
Due to the degenerate nature of QECCs, any recovery operator
$E^{\prime}=S^{\prime}TL$ will successfully correct the corrupted codeword
implying that the stabilizer element of the recovery operator can be assigned
arbitrarily with no impact in the logical error rate of the correcting method.
In addition, the authors discuss that the pure error can be produced using a
parallel table look-up since each element of the error syndrome depends on a
unique pure error independently of the others [212]. The algorithms performing
such two assignments is named as the simple decoder. Hence, the NN decoder is
based on the fact that since the rotated planar code encodes one logical
qubit, the logical operators associated are
$\mathrm{\hat{I},\hat{X},\hat{Y},\hat{Z}}$ (the hat refers to the fact that
those operators are defined over the logical qubit) and, therefore, decoding
can be done with as a classification problem with those four labels.

The way in which the classification problem was dealt with in [212] was by
using feed-forward neural networks. The neural network in question is defined
by a graph consisted of many artificial neuron layers which are connected
among them. The neurons are defined by a so called-activation function which
depends on an array of weights, $\bar{w}$, of length $m$ and a bias $b$. Since
the NN is of the feed forward type, the neurons calculate the nonlinear
activation function ($\bar{x}$ is the input and $*$ refers to the inner
product), $\bar{y}=(1+\mathrm{exp}(-(\bar{w}*\bar{x}+b)))^{-1}$, and pass it
to the subsequent layer until the output layer is reached, where the result of
the activation function is rounded to $\\{0,1\\}$ so that the output of the
algorithm is obtained [212]. The layers between the input and output layers
are named as hidden layers in the terminology of ML. As explained before, a
neural network requires a training stage before it can operate over a set of
unknown data. Therefore, for the NN decoder, a training stage where the
weights and biases of the neurons are trained is needed. The authors of [212]
select the average cross-entropy as the cost function to optimize the
activation function and produce a training set directly sampling errors at an
error probability where the MWPM decoder has a $25\%$ logical error rate. The
cost-function was minimized by stochastic gradient descent, while the number
of elements of the training set was limited to at most $10^{6}$ samples.

Figure 24: Graphical depiction of the feed-forward neural network used for the
NN decoder. The example consists of an input layer (i), a hidden layer (h) and
an output layer (o). The inputs represent the syndrome data, while the outputs
refer to the estimated logical error. Each of the neurons in every layer
compute the activation function as a function of their received information
and pass the information to the next layer. Figure taken from [212].

The NN decoder in [212] proved to be an efficient method for decoding small
distance, $d\in\\{3,5,7\\}$, rotated planar codes achieving similar
performance as the MWPM decoder while maintaining a similar complexity. As a
result of the interesting performance of this decoder, several studies
discussing ML decoders for the rotated planar code have been proposed such as
the deep neural network based decoder in [40, 211] or the reinforcement
learning based decoder in [195]. The deep neural network decoder proved a
better threshold than MWPM at the cost of a higher complexity, while the
reinforcement learning decoder proved an almost linear complexity at the cost
of a worse code threshold [211]. Combinations of NN decoders with RG decoders
have also been proposed [210]. Machine learning based decoding methods have
also been proposed for other topological codes such as the toric code [201,
126, 141, 4, 218, 77, 60, 151, 146], the color code [7] or the semionic code
[209]. Each of the proposed ML decoders for each of the codes provide either a
faster decoding or a better threshold than other methods, showing the natural
trade-off between accuracy and speed.

Circuit level noise has also been considered for neural network decoders, i.e.
faulty syndrome data arising from noisy gates and measurements [212, 40, 7,
39]. In a similar fashion as other decoders, dealing with noisy measurements
requires approximately $d$ syndrome measurement rounds, implying that the
runtime of the decoders increases. Importantly, NN decoder should be trained
using this error model so that they can cope with it, i.e. training is
specific to the noise model in consideration [212]. The performance of the NN
decoder of [212] achieves the same performance as MWPM for this scenario.

To sum up, NN decoders are promising in the quest of obtaining accurate and
fast decoders for decoding not only rotated planar codes but also other
families of error correcting codes. Some of the problematic behind this family
of decoders is the training cost, which may scale exponentially with the code
distance [214]. This is one of the main reasons behind the fact that most of
the NN-based decoders have only been tested for small distances $d<10$ [146].
Interestingly, promising results have been obtained for decoding the toric
code with an NN+UF decoder that achieves high threshold with almost linear
complexity, while having been tested up to $d=255$ [146]. However, the need of
a training stage before operation implies that NN and ML decoders might not be
the best choice when the noise fluctuates over time, as it occurs for
superconducting qubit platforms [70, 72]. Additionally, it is important to
state that mapping the decoding problem to a ML classification problem works
well for the rotated planar code or other topological codes since they encode
a low number of logical qubits, implying that the possible logical errors is
not too high. However, since the number of logical errors scales as $2^{2k}$
with the number of logical qubits [86], $k$, these methods may not be
implementable for other families of codes with higher coding rates such as
QLDPC codes.

####  V.5.4 MaxSAT decoder

The MaxSAT decoder has been recently proposed as an efficient algorithm to
decode color codes [12]. This decoder is based on the analogy between the
decoding problem of the color code and the LightsOut puzzle when the error
model in consideration is the bit-flip noise. The LightsOut puzzle refers to a
problem where a lattice whose faces are associated with switches and lights
can be either on or off. In such lattice, toggling a switch on the lattice
implies that all its neighbouring lights change their previous state, i.e. if
they were on they are turned of and vice versa. The LightsOut problem then
tries to find out a sequence of switch actions so that all lights are turned
off. The puzzle has two important properties: toggling a switch twice is the
same as not doing anything and the state of a light only depends on how often
its neighbour switch have been toggled (independence on the order). The
authors argue that this problem is similar to the decoding process of a color
code by doing the following analogy:

  * •

Data qubits $\leftrightarrow$ switches.

  * •

Checks $\leftrightarrow$ lights.

  * •

Syndrome $\leftrightarrow$ initial light configuration.

  * •

Decoding estimate $\leftrightarrow$ switch set that is a solution.

  * •

Minimum-weight decoding estimate $\leftrightarrow$ solution with minimum
switch operations.

Figure 25: LightsOut and color code ($d=11$) decoding analogy. The marked
faces represent the initial configuration (syndrome), while the green data
qubits represent a possible solution of the problem which is not necessarily
minimal. Figure taken from [12].

Therefore, the authors exploit such an analogy to propose a decoding methods
based on solving the LightsOut puzzle. The main idea is to find the minimal
solution set for the puzzle, which is equivalent to a decoding estimate of
minimum weight matching the syndrome measurement. In order to obtain the
minimal solution of the LightsOut puzzle, the authors formulate such problem
as a maximum satisfiability (MaxSAT) problem, which generally refers to the
problem of determining the maximum number of clauses of a Boolean function
that can be made true by assigning true values to the variables [127].
Following this rationale, the authors formulate the decoding problem as the
MaxSAT problem

$\begin{split}\forall f\in
F:&\bigoplus_{v\in\mathcal{F}_{\mathrm{switches}}(f)}\mathrm{switch}_{v}=\mathcal{F}_{\mathrm{init}}(f),\\\
&\forall f\in F:\mathrm{not}(\mathrm{switch}_{f}),\end{split}$ (21)

where $f\in F$ refer to the lights or faces, the $\mathrm{switch}_{v}$ are
Boolean variables representing if a switch is toggled,
$\mathcal{F}_{\mathrm{switches}}(f)$ is a discrete function that takes a face
$f$ and returns the set of switches surrounding it; and
$\mathcal{F}_{\mathrm{init}}$ is a Boolean function that describes the initial
configuration of the system (associated with the measured syndrome).
$\bigoplus$ denotes the exclusive-or (XOR) Boolean operation. In equation
(21), the constraints in the first line represent the satisfiability problem,
and the second are the soft constraints so that such problem is maximum.
Hence, color code decoding can be done by solving such MaxSAT problem [12].
The authors discuss many MaxSAT solvers for decoding the color code.

The MaxSAT decoder for bit-flip error noise in color codes was proven to have
a very high threshold of $10.1\%$ [12]. This is near the optimal $10.9\%$
threshold obtained by the MPS or TN decoder, and substantially exceed the
$\approx 9\%$ of the MWPM, $8\%$ of the Uf and $7.8\%$ of the RG decoders.
This excellent threshold does not come free of charge since it implies a
higher decoding runtime. The authors do not discuss the complexity of the
MaxSAT decoder, but they do explain that the runtime is slower than the ones
of MWPM, UF and RG decoders, while it is faster than the TN decoder. This is
consistent with the typical performances versus complexity trade-off discussed
throughout this review. The toll in runtime comes from the fact that the
MaxSAT problem is an NP-hard problem [12]. Importantly, the authors argue that
the MaxSAT decoder is faster whenever the physical error rate is lower, which
is a desired feature as QECCs are expected to be working in sub-threshold
noise levels.

In conclusion, the MaxSAT decoder is an efficient decoding method for the
color code that exhibits a very high code threshold for bit-flip noise with a
more reasonable complexity when compared with the tensor network decoder.
However, at the time of writing, the MaxSAT decode is yet a limited approach,
mainly due to the fact that only bit-flip noise is considered. This is very
important since the LightsOut analogy proposed by the authors in [12] depends
on such error model assumption. Additionally, no faulty measurements have been
considered and it is rather unclear if the decoder will be able to operate
whenever circuit noise level is considered. Nevertheless, this decoding method
has been very recently proposed and generalizations of it for noises with
other structures (importantly the depolarizing channel) and other families of
topological codes can be expected as future work.

###  V.6 Software Packages

In this section an overview regarding the existing software packages for
surface code decoding simulation will be covered. Fortunately, the scientific
community has provided a large number of open source repositories for
performing simulations of several decoders of the surface code and other
topological codes and, thus, we will cover several of them (the most popular
and used ones) as a reference for people on the community of quantum error
correction. We provide a graphical overview in FIG. 26.

Figure 26: Sketch representing the available software packages for each
mentioned decoder. Each edge connects each decoder (green circle), with the
software packages which support it (pink circles). The decoders mentioned in
the figure are the Cellular Automata decoder (CA), the MaxSAT decoder, the
Union Find decoder (UF), the Minimum Weight Perfect Matching decoder (MWPM),
the Tensor Network decoder (TN) the Neural Network decoder (NN), the Belief
Propagation + Order Statistics Decoder (BPOSD) and the Renormalized Group
decoder (RG).

Whenever considering numerical simulations of a surface code, it is important
to be able to generate the samples of the noise following the distribution of
interest for a certain scenario so that the decoder operates over such noise
model. In this sense, generating samples for data qubit noise is pretty
straightforward by considering the specific distribution of the Pauli channel
for each of the qubits (See section IV). Nevertheless, whenever circuit-level
noise for faulty check measuments is considered, sampling the noise is not a
trivial task [89]. Therefore, the Stim repository by Craig Gidney was
developed for sampling circuit-level noise for the sake of obtaining samples
of noise that accurately resemble the errors that a surface code experiences
over such scenario [89]. Stim samples circuit noise to all qubits within the
code, including measurement qubits, at a fast speed and is the simulator of
choice when considering stabilizing circuit noise. This repository can analyze
a $d=100$ surface code circuits in approximately 15 seconds for sampling
circuit shots at a rate of 1000 samples per second.

Regarding software implementations of the minimum weight perfect matching
decoder there are several open source repositories which successfully simulate
realizations of the decoder at a sufficient speed. The most popular and
quickest one considering serial computation is Oscar Higgot’s the Pymatching
repository [104, 101], the latest version of which, implements the Sparse
Blossom implementation of the MWPM decoder. The Fusion Blossom algorithm [229]
is also available at the GitHub repository by Yue Wu [227] which, as explained
before, albeit having a worse serial performance than Pymatching, allows
parallel decoding improving the complexity at each additional node and
eventually surpassing the performance of Pymatching. Additionally, the QECSIM
repository by David Tuckett [203] also stands as a fair simulator for the
minimum weight perfect matching which also allows other decoding methods.
Another recent software package that incorporates Pymatching and Fusion
Blossom (by calling those repositories) was posted in the _Plaquette_
repository by the QC Design team [133]. Interestingly, such repository
incorporates Stim too, allowing the combination of all those repositories in a
single one.

An implementation of the UF decoder can be found in the _Qsurface_ [107]. The
package allows the simulation of the standard union-find decoder [53] as well
as a modification of it by the authors of Qsurface which they name as Union-
find Node-Suspension decoder. The authors claim that an improved threshold can
be obtained by using such modified decoder while maintaining complexity.
Moreover, such package includes an implementation of the MWPM algorithm. The
previously discussed Plaquette package [133] also includes an implementation
of the UF decoder by Delfosse and Nickerson. The inclusion of this decoder is
specially interesting for the Plaquette package since the circuit-level noise
obtained from Stim can be directly used for testing the UF decoder.

The BPOSD algorithm was originally thought as a general decoder for QLDPC
codes [159]. However, a surface code can be seen as a sparse code as the
distance of the code increases (due to the fact that the weight of the
stabilizer is constant independently of the size). In this sense, the _BP+OSD:
A decoder for quantum LDPC codes_ package by Joschka Roffe [175] implements
the BPOSD decoder for general QLDPC codes. For simulating surface codes, the
parity check matrix [71] of such code should be used whenever defining the
QLDPC code to be decoded by the BPOSD implementation.

The aforementioned QECSIM repository [203] does also include an implementation
of the tensor network decoder. The package include the possibility of tuning
the truncation parameter that is used for the TN decoder. Another
implementation of the tensor network decoder can be found in the
_SweepContractor_ repository by Cristopher Chubb [47] which is based in the
sweep line algorithm of [46].

In the case of cellular automaton decoders, the repository _Sweep-Decoder-
Boundaries_ by Michael Vasmer [213] implements the version of the decoder
using the sweep rule as presented in [131, 214]. As discussed in the papers,
the implementation of the decoder admits simulations using circuit-level
noise. Additionally, the repository _LocalToricDecoder_ by Kasper
Duivenvoorden implements the version of the cellular automaton using Toom’s
rule as proposed in [97, 132]. We have been unable to find software packages
implementing the other cellular automaton decoders discussed.

Concerning the RG decoder, the _QTop_ repository by Jacob Marks [145] presents
an implementation of it. However, it is noteworthy to say that the author
stated in the repository that such software package is not being actively
maintained and, thus, it may be unreliable. Anyway, the code is available
there for anyone that may be interested in testing it or using it to code its
own version of RG decoders.

With respect to neural network decoders, the repository _Neural Network
Decoders for Quantum Error Correcting Codes_ by Stefan Krastanov [125]
implements the neural network decoder proposed in [126] for the toric code.
Moreover, Pooya Ronagh developed a the repository _Deep Neural Decoders for
Fault-Tolerant Quantum Error Correction_ [163] for the deep neural network
decoder proposed in [40] for decoding rotated planar codes. Interestingly, the
authors of both repositories programmed the decoders so that other neural
networks than the ones in [126, 40] can be incorporated. Hence, those
repositories provide freedom to integrate other neural network decoders of the
literature. Finally, the repository _neural_network_decoder_ by Paul
Baireuther [8]contains the implementation of the neural network decoder for
the color code in [7].

To finish with this section, there is a repository with the implementation of
the MaxSAT decoder presented in [12]. The repository, developed at the
Technical University of Munich, is named _QECC: An MQT tool for Quantum Error
Correcting Codes written in C++_ [13] and is intended to be a more general
tool for QEC than just the MaxSAT decoder for color codes. At the time of
writing, the authors of the repository state that the project is still in
early development and, thus, will contain other QEC software tools. The main
ideas used for the software package were presented in [14]. Either way, at the
moment of writing, the MaxSAT decoder and a decoder for QLDPCs based on the UF
decoder [52] are present in the software package. Note that since surface
codes can be seen as QLDPC codes, the UF decoder implemented in [13] can in
principle be used to decode such families of codes.

##  VI Discussion

Figure 27: Graphical illustration showcasing the complexity and probability
threshold of the decoders studied in this work. This comparative figure is
inspired by a figure in [12].

The construction of a fault-tolerant quantum computer remains as the Holy
Grail of quantum computing so that the groundbreaking theoretical potential of
such technology can be achieved. The key element to solve this quandary is
quantum error correction. Quantum information has proven to be so frail that
the scientific community has accepted that quantum computing will be
unrealizable without QEC. One of the principal elements of a QECC is the
decoder, or the classical algorithm that is used to estimate which error has
corrupted the quantum information. Due to the urgent necessity of obtaining
fast and accurate enough decoders that can operate in real-time for
experimentally implemented QECCs, the number of papers related to this is
increasing in a very fast pace. In this sense, the QEC community is strongly
pushing the state-of-the-art of the topic so that fault-tolerance can be a
reality as fast as possible.

As presented in the main text, the main decoders for the rotated planar code
family are the MWPM, UF, BPOSD and TN decoders. FIG. 27 is an illustrative
representation of the accuracy versus runtime trade-off discussed through the
text for those decoders. At the time of writing, it seems that the MWPM is an
strong candidate due to its high threshold and the fact that it always returns
the $X$ and $Z$-errors of minimum weight matching the observed
syndrome282828Note that this is not the same as returning the overall minimum
weight errors since $X$ and $Z$ errors are evaluated independently and, as
such, $Y$ errors are considered as events of double weight as opposed to Pauli
errors of weight 1.. In addition, the MWPM decoder presents a considerable
worst-case complexity when compared to other decoding methods, but recent
implementations of the algorithm have proven to present an almost linear
expected complexity [104, 229], making this method even more powerful yet. On
the other hand, UF also stands as a fair contestant due to its decoding speed
which comes from a linear worst-case complexity. Nevertheless, as discussed
before, the MWPM implementations with an average complexity lower than
$\mathcal{O}(n^{2})$ [104], even reaching linearity given that enough nodes
for parallelization are available [229], make the candidacy of the UF decoder
to significantly lose strength. Anyway, it is noteworthy to state that many of
those fast MWPM implementations were constructed based on many ideas
introduced by UF decoding. The BPOSD-0 decoder lays in a middle ground between
the MWPM and UF decoders whenever the rotated planar code is considered. As
discussed before, increasing the search depth of the OSD algoirthm has a
considerable impact on the worst-case complexity of the decoder and, thus, the
benefits of this decoder will probably be lost due to the fact that the
threshold of the code would not increase as much. In this sense, it seems that
the MWPM decoder is a better candidate for the specific instance of surface
codes. Nonetheless, the BPOSD algorithm was proposed as a general decoder for
QLDPC codes [159] and, therefore, it is the best candidate for decoding such
family of codes which is being studied thoroughly at the time of writing. As
seen in the earlier section, its implementation allows the circumnavigation of
split beliefs in conventional belief propagation decoding, which have posed a
great hurdle to conventional BP decoding for QLDPC codes [172, 159]. The TN
decoder achieves the highest code threshold for the rotated planar code,
albeit at the expense of the largest worst-case computational complexity. Both
the benefit and drawback of this algorithm is a result of the fact that it is
an effort to solve the maximum-likelihood (ML) problem explicitly, and this is
why it is usually referred as the ML decoder292929Note that in the terminology
of Section II the TN actually solves the DQMLD problem, but the literature on
the TN decoder refers to this just as ML.. In this sense, the TN decoder is an
almost brute force approach where such brute force search is limited by the
bond dimension, $\chi$, which is the approximation parameter that is needed
for this method to be actually implementable for codes of considerable size.
Hence, the bond dimension is the parameter that will be in charge of the
accuracy and speed of the algorithm. Due to the enormous growth in bond
dimension in the surface code tensor network contraction, the tensor network
is not really considered for real-time decoding but is studied cautiously as
an effective degenerate quantum maximum likelihood decoder. Also this decoder
presents the possibility of the experimental implementation of codes beyond
break-even with poorer hardware capabilities due to its high threshold. The
conclusion to this is that the choice of the decoder for a future real-time
implementation of surface codes remains as an open question. This quandary is
even more complex taking into account the existence of other decoding
approaches such as the CA, RG, NN or MaxSAT decoders discussed in this review.
Each of those may provide interesting features that may be beneficial for
specific families of codes or even adaptations of them may be interesting for
the context of rotated planar codes. For example, machine learning base
decoders are gaining popularity on the recent times, probably due to the huge
interest in machine learning in general.

In this line, recent breakthroughs have been achieved in the experimental
implementations of surface codes over superconducting qubit platforms [128,
1]. Both of the experimental implementations were based on the rotated planar
code discussed throughout this review. In [128], Andreas Wallraff’s group at
ETH Zurich led an experiment based on the rotated planar code of distance
three by means of a processor consisted of 17 transmon qubits. Krinner et al.
used the obtained data after multiple measurement rounds in order to run the
MWPM decoder for estimating the errors corrupting the quantum information. In
[1], the Google Quantum AI realized an experiment based on the rotated planar
codes of distances 3 and 5 by means of their expanded Sycamore device
consisted of 72 transmon qubits. The authors actually run experiments for the
distance 5 rotated planar codes since the actual data for the distance 3 code
can be obtained from such code. Acharya et al. used the obatined data to
decode the errors by means of the TN and belief-matching decoders303030Recall
that the belief-matching decoder combines the output of a BP decoder in order
to reweight the edges of the graph in the MWPM problem [102].. In this way,
the authors proved that the logical error rate obtained by the rotated planar
code improved as the distance of the code increased for both decoders. This
result is really important since the code was operating in a sub-threshold
noise level and it represents an experimental proof that the performance of
the codes can be increased by increasing the distance (recall the threshold
theorem). Importantly, both of the experiments performed the execution of the
decoding algorithm by dealing with the measured data in a post-processing
stage, i.e. no real-time decoding was actually performed. However, both of
these experiments represent the state-of-the-art of experimental
implementations of surface codes and they are an effort to progress towards
the ultimate goal of fault-tolerant quantum computes.

Following the present discussion, and as it has been seen throughout the text,
the decoding stage stands as a pivotal operation within the successful
functioning of, not only the surface code, but any correcting code in general.
One should be aware of the fact that the named code threshold depends on three
aspects: the code family in consideration, the decoding method for the code
and the noise model in consideration [2, 124]. In this sense, it is
straightforward to see that designing decoding algorithms is crucial in terms
of the ability of a family of codes to correct errors. The intrinsic locality
and degeneracy of the surface code allows for several decoding processes to
present themselves as valid candidates for future real device implementation.
Nevertheless, in addition to the code threshold for a decoding method, two
other critical aspects stand as limiting factors for the implementation of
surface codes decoding in a real-time fashion when implemented on experimental
hardware: run time and circuit-level noise.

Decoding runtime refers to the actual time that a decoder requires to ouptut
an estimate of the error that has corrupted the logical qubit encoded by a
code. Hence, this inherently imposes a delay in the error correcting system
that is hazardous for its actual operation. This comes from the fact that,
once the syndrome measurement has been done, the data qubits will still
continue to suffer from errors as they will not stop to decohere. Thus, if the
delay between measuring the checks and applying the recovery operation is too
high, then the algorithm will fail, with high probability, the actual error
configuration when recovery is executed. This is especially important by
taking into account that the decoherence times of state-of-the-art qubits are
short313131Note that this is not true for all qubit technologies such as ion
traps, but those present additional problems such as the fact that their
operation times, quantum gates, are very slow. [71]. As seen in through this
review, it is pretty fair to state that maintaining code threshold while
reducing the actual complexity of a decoder is a hard problem. This is a
result of the trade-off of being fast against considering more error
configurations, which actually relates to code performance. This logic comes
from the fact that the traditional comparison of accurate and fast is done in
terms of code threshold and worst case complexity. However, it is a recent
trend to benchmark runtime by expected complexity, i.e. an average of the
number of operation required to decode different error patterns. The rationale
behind this is that worst-case events are generally exponentially rare,
implying that their impact will not be as high in code performance as other
more frequent cases. This effect should be more important whenever hardware
noise improves lower to sub-threshold physical error rates and, thus, expected
runtime might be a better benchmark for decoding algorithms. In this sense,
desigining faster decoding algorithms that are able to maintain the
capabilities of the code in terms of decoding accuracy is a critical issue for
the QEC field. It is important to state that significant advances in this
direction are being obtained with proposals such as Sparse Blossom [104] or
Fussion Blossom [229].

On the other side, considering circuit-level noise is fundamental so that
surface codes are successful when implemented in real hardware. As explained
before, the consequence of such noise associated to imperfect gates, SPAM and
error propagation results in measurement errors that make the decoder not to
be able to correctly estimate the actual error that has corrupted the data
qubits of code (refer to Section IV). In this sense, considering circuit-level
noise is sometimes referred as fault-tolerant error models as it is
considering all the errors of the elements of the system [212]. Circuit-level
noise is usually alleviated by means of multiple measurement rounds, in the
order of $\mathcal{O}(d)$, so that the additional errors that led to
measurement errors can be taken into account for the decoding problem (refer
to Appendix A for a more detailed description). Nevertheless, such multi-round
measurement results in a toll for complexity and, hence, runtime. This
directly hinders the previously discussed necessity of being fast in decoding
so that error correction is successful. Additionally, even when the multiple
measurement protocol is applied, the code threshold significantly decreases
(usually an order of magnitude) in comparison to thresholds that only consider
data qubit noise [102, 82]. The direct result of this is that hardware
requirements for sub-threshold code implementation become even more stringent.
Therefore, circuit-level noise adds another layer of complexity to the already
difficult decoding implementation in real hardware. In this sense, improving
gate fidelities and decoherence parameters, as well a other noise sources, of
state-of-the-art quantum processors will be a very important for obtaining
fault-tolerant quantum computers.

Moreover, tailoring both codes and decoders to the specific structure of the
noise that the qubits experience is being investigated so that the actual
correcting performance for such noise. A widespread example of this is the
bias towards $Z$-errors that many state of the art qubit technologies such as
silicon spin qubits or ion traps exhibit [71, 3]. As described in section IV,
this comes from the fact that the dephasing time, $T_{2}$, of such qubits is
much smaller than the energy relaxation time, $T_{1}$. As previously
discussed, running the aforementioned decoders over biased noise models
usually contributes to a worse threshold than for the depolarizing channel.
This, however, occurs due to the fact that the code/decoder is not tailored to
work over noise exhibiting such tendency. Specifically, since $X$ and
$Z$-errors are decoded independently, then one of the decoding problems
results to be more dense if the noise is biased, i.e. it will experience
errors with higher weight more probably, and, thus, the actual threshold will
be lower since such decoding sub-problem will fail more often. In this sense,
the community has actually studied how to deal with some of those noise
structures so that performance is maintained or even enhanced. Some examples
include:

  * •

The rectangular surface code: using a surface code with rectangular shape
makes the minimal weight logical error $Z_{L}$ to require more physical $Z$
operators, increasing the $Z$-distance $d_{Z}$ and, consequently, increasing
the number of $Z$-errors it can correct: $(d_{Z}-1)/2$ [137]. On the negative
side, this is at the expense of increasing the number of necessary data qubits
to $d_{X}d_{Z}$. In FIG. 28, a rectangular code of distances $d_{X}=5,d_{Z}=7$
is shown, notice how the logical operator $Z_{L}$ requires additional Pauli
operators than for the $X_{L}$ operator. This code construction may use the
reviewed decoders in order to estimate the channel errors.

Figure 28: Graphical representation of a $d_{X}=5,d_{Z}=7$ rectangular rotated
planar. $X_{L}$ and $Z_{L}$ operators are also represented.

  * •

Clifford deformation: in Clifford deformed surface codes, the check qubits are
conjugated respect to a unitary operator from the Clifford group [200] so that
other valid stabilizers are obtained [198]. By means of this stabilizer
modifications, the new stabilizer codes can be constructed so that they are
more susceptible to $Z$-noise. For example, the XY-code is a surface code
which, instead of having $X$\- and $Z$-checks, has $Y$\- and $X$-checks, both
of which are susceptible to $Z$-noise. A graphical depiction of the XY-code is
given in the top figure of FIG. 29. As a result of such susceptibility to
$Z$-errors, the associated decoder can make use of the correlation between $X$
and $Y$-errors, i.e. $XY=Z$, in order to be more accurate in detecting
$Z$-noise [206, 102, 56]. Another popular Clifford deformed surface code is
the XZZX surface code [23, 231]. For this code, all check qubits act equally
on their surrounding data qubits operating two $X$ and two $Z$ operators as
shown in the bottom figure of FIG. 29. One can see that the commutation
between the checks is maintained, since adjacent checks either anti-commute
twice or directly commute. An interesting characteristic of the XZZX code is
that there is only one set of $Z$ physical operators which produce a logical
operator. As is shown in FIG. 29, all the products of this logical operator
with the stabilizer set produce physical operators which are composed of $X$,
$Y$ and $Z$-operators. This feature complicates the probability of a logical
phase-flip, $Z_{L}$, error under a highly $Z$-biased noise model. Moreover,
for the case in which the $Z$-bias is infinite, e.g. a pure dephasing channel,
the XZZX surface code operates as a series of disjoint repetition codes that
can be decoded independently. The data qubits of such repetition codes are the
top-left to bottom-right diagonals of the overall XZZX code, as can be seen in
the bottom of FIG. 29, where the diagonal consisting of two $Z$ physical
errors produces syndromes in their top-left and bottom-right sides. Given this
condition, the threshold of the XZZX code reaches an outstanding $50\%$ [23,
231], while reducing the amount of required qubits significantly. Therefore,
it can be seen that a bias towards $Z$-errors is not only not problematic, but
also beneficial if the code and decoder are tailored for such model.

Figure 29: On the top, a graphical representation of a rotated planar XY code
with the operators of the stabilizer generators. On the bottom, the same
representation but for the rotated planar XZZX code altogether with a $Z_{L}$
operator

  * •

$X/Z$ correlation:  another important approach to improve the performance of
surface codes is to make decoders aware of the fact that $Y$-errors represent
a correlation between the $X$ and $Z$ errors. One downside of the independent
$X$ and $Z$ decoding of CSS codes such as the surface code is that it makes
the decoding blind of the correlation among those errors, i.e. it is usually
considered that $p_{Y}=p_{X}p_{Z}$. However, as seen in Section IV, the Pauli
noise models have $p_{X}\approx p_{Y}$ (both in biased and depolarizing) and,
thus, by not taking this into account the decoder underestimates the frequency
in which $Y$-errors corrupt the data qubits of the code. A method in order to
circumvent this problem (without explicitly changing the structure of the
code) consists in first decoding for one of the errors and, afterwards, using
the partial recovered error in order to decode the other error. E.g., given an
error in a CSS surface code, first decode the $X$-error, and then consider
that, for recovering for the $Z$-error, every qubit has an updated probability
of undergoing a $Z$-error defined by:

$\begin{split}&P(Z|X=1)=\frac{p_{Y}}{p_{X}+p_{Y}}\\\
&P(Z|X=0)=p_{Z},\end{split}$ (22)

where, $P(Z|X=1)$ is the probability that a specific data qubit undergoes a
phase-flip $Z$ given that it has been considered to undergo a bit-flip $X$,
and $P(Z|X=0)$ is the probability that a qubit which is considered to not have
undergone a bit-flip has undergone a phase-flip $Z$. This can be done once
[54, 80, 102] or in a recursive manner [56, 232]. Moreover, it can be combined
with the XY-code in order to enhance the susceptibility of the code towards
$Z$-noise [102, 56].

Thus, it is important from the decoding (and code construction point of view)
to consider the actual noise that the qubits of the surface code experience.
As seen for the XZZX code, this tailoring does actually even significantly
improve the code performance without needing to lose resources. Even if we
have discussed noise bias here, there are many other important subtleties in
the nature of the noise for each qubits technology that should be considered
for integration in real hardware. For example, multi-qubit error correlation
and time-varying noise are examples of this. The fact that the actual
distribution of the errors in a real quantum processor is independent seems to
be generally false. In this sense, studying the correlated nature of noise is
an incipient sub-field in the topic and, thus, tailoring decoding to such
correlated nature should improve the performance of the codes over such models
[96]. Note that this quandary is not new for classical error correction [202],
implying that many ideas of dealing with such noise can be extrapolated to the
quantum domain. Modifications of decoders to take into account correlated
noise have been already proposed for quantum turbo codes over channels with
memory, resulting in a considerably improved performance of the code when
compared to the decoder that is blind to the correlation [147]. Additionally,
the noise experienced by superconducting qubits has been proven to be time-
varying [70, 72], which implies that the performance of the codes experiences
a degradation. In this sense, studying adaptive decoders that can estimate the
noise level [219] at a certain time in order to follow such fluctuating nature
of the noise should considerably improve the performance [192].

To conclude, quantum error correction is still in a primitive stage before the
potential of quantum computing can be unleashed by fault-tolerant machines. In
this sense, surface codes represent the most promising family of codes to be
implemented in the early post-NISQ era, principally due to their locality
feature (and, in the case of planar instances, two-dimensional qubit placing)
and their high tolerance to quantum noise. As extensively reviewed in this
article, decoders represent a central part of QEC methods as they are key
elements in posing a threshold for a code. Moreover, we have discussed the
importance of the runtime of this algorithms due to the accumulation of other
errors if the estimation of the channel error results to be too slow. As a
result of this, there exists an important trade-off between accuracy and speed
of decoders which implies that a selection of a decoder for real-time decoding
depends on many factors that go from the hardware noise level to the pace at
which more errors accumulate. Hence, the selection of the best decoder for an
experimental implementation of a surface code is still an open question that
many research teams, both in academia and industry, are trying to resolve. Due
to the extense zoo of possible qubit technologies being investigated nowadays,
it is possible that many of the exisitng candidates, or new ones, are the best
fit as a function of the specifics of each of the quantum computing platforms.
There is much work left to do, and each of us on the field should contribute
our share in this Herculean quest. We live in exciting times.

## Data availability

The data that supports the findings of this study is available from the
corresponding authors upon reasonable request.

## Competing Interests

The authors declare no competing interests.

## Acknowledgements

We want to acknowledge Nicolas Delfosse, Pavel Panteleev, Christopher Chubb,
David Tuckett, Michael Newman, Iñigo Barasoain and Javier Oliva for fruitful
discussions.

This work was supported by the Spanish Ministry of Economy and Competitiveness
through the ADELE (Grant No. PID2019-104958RB-C44) and MADDIE projects (Grant
No. PID2022-137099NB-C44), by the Spanish Ministry of Science and Innovation
through the proyect Few-qubit quantum hardware, algorithms and codes, on
photonic and solid-state systems (PLEC2021-008251), by the Ministry of
Economic Affairs and Digital Transformation of the Spanish Government through
the QUANTUM ENIA project call - QUANTUM SPAIN project, and by the European
Union through the Recovery, Transformation and Resilience Plan -
NextGenerationEU within the framework of the Digital Spain 2025 Agenda.

## References

  * Acharya  _et al._ [2023] Acharya, Rajeev, Igor Aleiner, Richard Allen, Trond I. Andersen, Markus Ansmann, Frank Arute, Kunal Arya, Abraham Asfaw, Juan Atalaya, Ryan Babbush, Dave Bacon, _et al._ (2023), “Suppressing quantum errors by scaling a surface code logical qubit,” Nature 614 (7949), 676–681.
  * Aharonov and Ben-Or [2008] Aharonov, Dorit, and Michael Ben-Or (2008), “Fault-tolerant quantum computation with constant error rate,” SIAM Journal on Computing 38 (4), 1207–1282, https://doi.org/10.1137/S0097539799359385 .
  * Aliferis  _et al._ [2009] Aliferis, P, F Brito, D P DiVincenzo, J Preskill, M Steffen, and B M Terhal (2009), “Fault-tolerant computing with biased-noise superconducting qubits: a case study,” New Journal of Physics 11 (1), 013061.
  * Andreasson  _et al._ [2019] Andreasson, Philip, Joel Johansson, Simon Liljestrand, and Mats Granath (2019), “Quantum error correction for the toric code using deep reinforcement learning,” Quantum 3, 183.
  * Anwar  _et al._ [2014] Anwar, Hussain, Benjamin J Brown, Earl T Campbell, and Dan E Browne (2014), “Fast decoders for qudit topological codes,” New Journal of Physics 16 (6), 063038.
  * Arute  _et al._ [2019] Arute, Frank, Kunal Arya, Ryan Babbush, Dave Bacon, Joseph C. Bardin, Rami Barends, Rupak Biswas, Sergio Boixo, Fernando G. S. L. Brandao, David A. Buell, _et al._ (2019), “Quantum supremacy using a programmable superconducting processor,” Nature 574 (7779), 505–510.
  * Baireuther  _et al._ [2019] Baireuther, P, M D Caio, B Criger, C W J Beenakker, and T E O’Brien (2019), “Neural network decoder for topological color codes with circuit level noise,” New Journal of Physics 21 (1), 013003.
  * Baireuther [2018] Baireuther, Paul (2018), “neural_network_decoder,” .
  * Bass and Zohar [2022] Bass, Steven D, and Erez Zohar (2022), “Quantum technologies in particle physics,” Philosophical Transactions of the Royal Society A: Mathematical, Physical and Engineering Sciences 380 (2216), 20210072, https://royalsocietypublishing.org/doi/pdf/10.1098/rsta.2021.0072 .
  * Battistel [2022] Battistel, Francesco (2022),  _Mitigating Leakage and Noise in Superconducting Quantum Computing_ , Phd thesis (TU Delft, Delft, Netherlands), available at https://repository.tudelft.nl/islandora/object/uuid%3A07d93422-d07c-492e-8d65-592344e01936.
  * Bennett and Brassard [1984] Bennett, C H, and G. Brassard (1984), “Quantum cryptography: Public key distribution and coin tossing,” in  _Proceedings of IEEE International Conference on Computers, Systems, and Signal Processing_ (India) p. 175.
  * Berent  _et al._ [2023a] Berent, Lucas, Lukas Burgholzer, Peter-Jan H. S. Derks, Jens Eisert, and Robert Wille (2023a), “Decoding quantum color codes with MaxSAT,” arXiv:2303.14237 [quant-ph] .
  * Berent  _et al._ [2023b] Berent, Lucas, Lukas Burgholzer, Peter-Jan H. S. Derks, Thomas Grurl, and Christoph Pichler (2023b), “Qecc: An mqt tool for quantum error correcting codes written in c++,” .
  * Berent  _et al._ [2023c] Berent, Lucas, Lukas Burgholzer, and Robert Wille (2023c), “Software tools for decoding quantum low-density parity-check codes,” in  _Proceedings of the 28th Asia and South Pacific Design Automation Conference_, ASPDAC ’23 (Association for Computing Machinery, New York, NY, USA) p. 709–714.
  * van den Berg  _et al._ [2023] van den Berg, Ewout, Zlatko K. Minev, Abhinav Kandala, and Kristan Temme (2023), “Probabilistic error cancellation with sparse pauli–lindblad models on noisy quantum processors,” Nature Physics 10.1038/s41567-023-02042-2.
  * Berrou  _et al._ [1993] Berrou, C, A. Glavieux, and P. Thitimajshima (1993), “Near shannon limit error-correcting coding and decoding: Turbo-codes. 1,” in  _Proceedings of ICC ’93 - IEEE International Conference on Communications_, Vol. 2, pp. 1064–1070 vol.2.
  * Bharti  _et al._ [2022] Bharti, Kishor, Alba Cervera-Lierta, Thi Ha Kyaw, Tobias Haug, Sumner Alperin-Lea, Abhinav Anand, Matthias Degroote, Hermanni Heimonen, Jakob S. Kottmann, Tim Menke, Wai-Keong Mok, Sukin Sim, _et al._ (2022), “Noisy intermediate-scale quantum algorithms,” Rev. Mod. Phys. 94, 015004.
  * Biamonte  _et al._ [2017] Biamonte, Jacob, Peter Wittek, Nicola Pancotti, Patrick Rebentrost, Nathan Wiebe, and Seth Lloyd (2017), “Quantum machine learning,” Nature 549 (7671), 195–202.
  * Bohr [1913] Bohr, Niels (1913), “On the constitution of atoms and molecules,” in  _Niels Bohr, 1913-2013: Poincaré Seminar 2013_, edited by Olivier Darrigol, Bertrand Duplantier, Jean-Michel Raimond, and Vincent Rivasseau (Springer International Publishing, Cham) pp. 13–33.
  * Bombin and Martin-Delgado [2006] Bombin, H, and M. A. Martin-Delgado (2006), “Topological quantum distillation,” Phys. Rev. Lett. 97, 180501.
  * Bombin and Martin-Delgado [2007] Bombin, H, and M. A. Martin-Delgado (2007), “Optimal resources for topological two-dimensional stabilizer codes: Comparative study,” Phys. Rev. A 76, 012305.
  * Bombín [2015] Bombín, Héctor (2015), “Single-shot fault-tolerant quantum error correction,” Phys. Rev. X 5, 031043.
  * Bonilla Ataides  _et al._ [2021] Bonilla Ataides, J Pablo, David K. Tuckett, Stephen D. Bartlett, Steven T. Flammia, and Benjamin J. Brown (2021), “The xzzx surface code,” Nature Communications 12 (1), 2172.
  * Bravyi  _et al._ [2018] Bravyi, Sergey, Matthias Englbrecht, Robert König, and Nolan Peard (2018), “Correcting coherent errors with surface codes,” npj Quantum Information 4 (1), 55.
  * Bravyi and Haah [2013] Bravyi, Sergey, and Jeongwan Haah (2013), “Quantum self-correction in the 3d cubic code model,” Phys. Rev. Lett. 111, 200501.
  * Bravyi and Hastings [2014] Bravyi, Sergey, and Matthew B. Hastings (2014), “Homological product codes,” in  _Proceedings of the Forty-Sixth Annual ACM Symposium on Theory of Computing_, STOC ’14 (Association for Computing Machinery, New York, NY, USA) p. 273–282.
  * Bravyi  _et al._ [2014] Bravyi, Sergey, Martin Suchara, and Alexander Vargo (2014), “Efficient algorithms for maximum likelihood decoding in the surface code,” Phys. Rev. A 90, 032326.
  * Bravyi and Kitaev [1998] Bravyi, Sergey B, and Alexei Yu. Kitaev (1998), “Quantum codes on a lattice with boundary,” arXiv:quant-ph/9811052 .
  * Breuckmann and Eberhardt [2021a] Breuckmann, Nikolas P, and Jens N. Eberhardt (2021a), “Balanced product quantum codes,” IEEE Transactions on Information Theory 67 (10), 6653–6674.
  * Breuckmann and Eberhardt [2021b] Breuckmann, Nikolas P, and Jens Niklas Eberhardt (2021b), “Quantum low-density parity-check codes,” PRX Quantum 2, 040101.
  * Breuckmann and Londe [2022] Breuckmann, Nikolas P, and Vivien Londe (2022), “Single-shot decoding of linear rate ldpc quantum codes with high performance,” IEEE Transactions on Information Theory 68 (1), 272–286.
  * Briegel  _et al._ [2009] Briegel, H J, D. E. Browne, W. Dür, R. Raussendorf, and M. Van den Nest (2009), “Measurement-based quantum computation,” Nature Physics 5 (1), 19–26.
  * Brun  _et al._ [2006] Brun, Todd, Igor Devetak, and Min-Hsiu Hsieh (2006), “Correcting quantum errors with entanglement,” Science 314 (5798), 436–439, https://www.science.org/doi/pdf/10.1126/science.1131563 .
  * Brun  _et al._ [2014] Brun, Todd A, Igor Devetak, and Min-Hsiu Hsieh (2014), “Catalytic quantum error correction,” IEEE Transactions on Information Theory 60 (6), 3073–3089.
  * Burnett  _et al._ [2019] Burnett, Jonathan J, Andreas Bengtsson, Marco Scigliuzzo, David Niepce, Marina Kudra, Per Delsing, and Jonas Bylander (2019), “Decoherence benchmarking of superconducting qubits,” npj Quantum Information 5 (1), 54.
  * Cai  _et al._ [2022] Cai, Zhenyu, Ryan Babbush, Simon C. Benjamin, Suguru Endo, William J. Huggins, Ying Li, Jarrod R. McClean, and Thomas E. O’Brien (2022), “Quantum Error Mitigation,” arXiv:2210.00921 [quant-ph] .
  * Calderbank and Shor [1996] Calderbank, A R, and Peter W. Shor (1996), “Good quantum error-correcting codes exist,” Phys. Rev. A 54, 1098–1105.
  * Chamberland and Campbell [2022] Chamberland, Christopher, and Earl T. Campbell (2022), “Universal quantum computing with twist-free and temporally encoded lattice surgery,” PRX Quantum 3, 010331.
  * Chamberland  _et al._ [2023] Chamberland, Christopher, Luis Goncalves, Prasahnt Sivarajah, Eric Peterson, and Sebastian Grimberg (2023), “Techniques for combining fast local decoders with global decoders under circuit-level noise,” Quantum Science and Technology 8 (4), 045011.
  * Chamberland and Ronagh [2018] Chamberland, Christopher, and Pooya Ronagh (2018), “Deep neural decoders for near term fault-tolerant experiments,” Quantum Science and Technology 3 (4), 044002.
  * Chamberland  _et al._ [2020] Chamberland, Christopher, Guanyu Zhu, Theodore J. Yoder, Jared B. Hertzberg, and Andrew W. Cross (2020), “Topological and subsystem codes on low-degree graphs with flag qubits,” Phys. Rev. X 10, 011022.
  * Chandra  _et al._ [2010] Chandra, Anjan K, Arnab Das, and Bikas K. Chakrabarti (2010),  _Quantum Quenching, Annealing and Computation_ , 1st ed. (Springer-Verlag Berlin, DE).
  * Chi  _et al._ [2022] Chi, Yulin, Jieshan Huang, Zhanchuan Zhang, Jun Mao, Zinan Zhou, Xiaojiong Chen, Chonghao Zhai, Jueming Bao, Tianxiang Dai, Huihong Yuan, Ming Zhang, _et al._ (2022), “A programmable qudit-based quantum processor,” Nature Communications 13 (1), 1166.
  * Choi [1975] Choi, Man-Duen (1975), “Completely positive linear maps on complex matrices,” Linear Algebra and its Applications 10 (3), 285–290.
  * Chow  _et al._ [2009] Chow, J M, J. M. Gambetta, L. Tornberg, Jens Koch, Lev S. Bishop, A. A. Houck, B. R. Johnson, L. Frunzio, S. M. Girvin, and R. J. Schoelkopf (2009), “Randomized benchmarking and process tomography for gate errors in a solid-state qubit,” Phys. Rev. Lett. 102, 090502.
  * Chubb [2021] Chubb, Christopher T (2021), “General tensor network decoding of 2d pauli codes,” arXiv:2101.04125 [quant-ph] .
  * Chubb [2022] Chubb, Cristopher T (2022), “Sweepcontractor.jl,” .
  * Chung  _et al._ [2001] Chung, Sae-Young, G.D. Forney, T.J. Richardson, and R. Urbanke (2001), “On the design of low-density parity-check codes within 0.0045 db of the shannon limit,” IEEE Communications Letters 5 (2), 58–60.
  * Cirac  _et al._ [2021] Cirac, J Ignacio, David Pérez-García, Norbert Schuch, and Frank Verstraete (2021), “Matrix product states and projected entangled pair states: Concepts, symmetries, theorems,” Rev. Mod. Phys. 93, 045003.
  * Crest  _et al._ [2022] Crest, Julien du, Mehdi Mhalla, and Valentin Savin (2022), “Stabilizer Inactivation for Message-Passing Decoding of Quantum LDPC Codes,” arXiv:2205.06125 [quant-ph] .
  * Criger and Ashraf [2018] Criger, Ben, and Imran Ashraf (2018), “Multi-path Summation for Decoding 2D Topological Codes,” Quantum 2, 102.
  * Delfosse  _et al._ [2022] Delfosse, Nicolas, Vivien Londe, and Michael E. Beverland (2022), “Toward a union-find decoder for quantum ldpc codes,” IEEE Transactions on Information Theory 68 (5), 3187–3199.
  * Delfosse and Nickerson [2021] Delfosse, Nicolas, and Naomi H. Nickerson (2021), “Almost-linear time decoding algorithm for topological codes,” Quantum 5, 595.
  * Delfosse and Tillich [2014] Delfosse, Nicolas, and Jean-Pierre Tillich (2014), “A decoding algorithm for css codes using the x/z correlations,” in  _2014 IEEE International Symposium on Information Theory_, pp. 1071–1075.
  * Delfosse and Zémor [2020] Delfosse, Nicolas, and Gilles Zémor (2020), “Linear-time maximum likelihood decoding of surface codes over the quantum erasure channel,” Phys. Rev. Res. 2, 033042.
  * deMarti iOlius  _et al._ [2022a] deMarti iOlius, Antonio, Josu Etxezarreta Martinez, Patricio Fuentes, and Pedro M. Crespo (2022a), “Performance enhancement of surface codes via recursive MWPM decoding,” arXiv:2212.11632 [quant-ph] .
  * deMarti iOlius  _et al._ [2022b] deMarti iOlius, Antonio, Josu Etxezarreta Martinez, Patricio Fuentes, Pedro M. Crespo, and Javier Garcia-Frias (2022b), “Performance of surface codes in realistic quantum hardware,” Phys. Rev. A 106, 062428.
  * Dennis  _et al._ [2002] Dennis, Eric, Alexei Kitaev, Andrew Landahl, and John Preskill (2002), “Topological quantum memory,” Journal of Mathematical Physics 43 (9), 4452–4505, https://pubs.aip.org/aip/jmp/article-pdf/43/9/4452/8171926/4452_1_online.pdf .
  * DiVincenzo  _et al._ [1998] DiVincenzo, David P, Peter W. Shor, and John A. Smolin (1998), “Quantum-channel capacity of very noisy channels,” Phys. Rev. A 57, 830–839.
  * Domingo Colomer  _et al._ [2020] Domingo Colomer, Laia, Michalis Skotiniotis, and Ramon Muñoz-Tapia (2020), “Reinforcement learning for optimal error correction of toric codes,” Physics Letters A 384 (17), 126353.
  * Duclos-Cianci and Poulin [2010] Duclos-Cianci, Guillaume, and David Poulin (2010), “Fast decoders for topological quantum codes,” Phys. Rev. Lett. 104, 050504.
  * Duivenvoorden  _et al._ [2019] Duivenvoorden, K, N. P. Breuckmann, and B. M. Terhal (2019), “Renormalization group decoder for a four-dimensional toric code,” IEEE Transactions on Information Theory 65 (4), 2545–2562.
  * Edmonds [1965] Edmonds, Jack (1965), “Paths, trees, and flowers,” Canadian Journal of Mathematics 17, 449–467.
  * Einstein  _et al._ [1935] Einstein, A, B. Podolsky, and N. Rosen (1935), “Can quantum-mechanical description of physical reality be considered complete?” Phys. Rev. 47, 777–780.
  * Ekert [1991] Ekert, Artur K (1991), “Quantum cryptography based on bell’s theorem,” Phys. Rev. Lett. 67, 661–663.
  * Emerson  _et al._ [2007] Emerson, Joseph, Marcus Silva, Osama Moussa, Colm Ryan, Martin Laforest, Jonathan Baugh, David G. Cory, and Raymond Laflamme (2007), “Symmetrized characterization of noisy quantum processes,” Science 317 (5846), 1893–1896, https://www.science.org/doi/pdf/10.1126/science.1145699 .
  * Etxezarreta Martinez [2022] Etxezarreta Martinez, Josu (2022),  _Decoherence and quantum error correction for quantum computing and communications_ , Phd thesis (Tecnun - Universidad de Navarra, Donostia, Spain), available at https://arxiv.org/pdf/2202.08600.pdf.
  * Etxezarreta Martinez  _et al._ [2019] Etxezarreta Martinez, Josu, Pedro M. Crespo, and Javier Garcia-Frías (2019), “Depolarizing channel mismatch and estimation protocols for quantum turbo codes,” Entropy 21 (12), 1133.
  * Etxezarreta Martinez  _et al._ [2023] Etxezarreta Martinez, Josu, Antonio deMarti iOlius, and Pedro M. Crespo (2023), “The superadditivity effects of quantum capacity decrease with the dimension for qudit depolarizing channels,” arXiv:2301.10132 [quant-ph] .
  * Etxezarreta Martinez  _et al._ [2021] Etxezarreta Martinez, Josu, Patricio Fuentes, Pedro Crespo, and Javier Garcia-Frias (2021), “Time-varying quantum channel models for superconducting qubits,” npj Quantum Information 7 (1), 115.
  * Etxezarreta Martinez  _et al._ [2020] Etxezarreta Martinez, Josu, Patricio Fuentes, Pedro M. Crespo, and J. Garcia-Frias (2020), “Approximating decoherence processes for the design and simulation of quantum error correction codes on classical computers,” IEEE Access 8, 172623–172643.
  * Etxezarreta Martinez  _et al._ [2023] Etxezarreta Martinez, Josu, Patricio Fuentes, Antonio deMarti iOlius, Javier Garcia-Frias, Javier Rodríguez Fonollosa, and Pedro M. Crespo (2023), “Multiqubit time-varying quantum channels for nisq-era superconducting quantum processors,” Phys. Rev. Res. 5, 033055.
  * Evenbly and Vidal [2014] Evenbly, G, and G. Vidal (2014), “Class of highly entangled many-body states that can be efficiently simulated,” Phys. Rev. Lett. 112, 240502.
  * Fawzi  _et al._ [2020] Fawzi, Omar, Antoine Grospellier, and Anthony Leverrier (2020), “Constant overhead quantum fault tolerance with quantum expander codes,” Commun. ACM 64 (1), 106–114.
  * Ferris and Poulin [2014] Ferris, Andrew J, and David Poulin (2014), “Tensor networks and quantum error correction,” Phys. Rev. Lett. 113, 030501.
  * Feynman [1982] Feynman, Richard P (1982), “Simulating physics with computers,” International journal of theoretical physics 21 (6/7), 467–488.
  * Fitzek  _et al._ [2020] Fitzek, David, Mattias Eliasson, Anton Frisk Kockum, and Mats Granath (2020), “Deep q-learning decoder for depolarizing noise on the toric code,” Phys. Rev. Res. 2, 023230.
  * Fossorier [2001] Fossorier, MPC (2001), “Iterative reliability-based decoding of low-density parity check codes,” IEEE Journal on Selected Areas in Communications 19 (5), 908–917.
  * Fossorier and Lin [1995] Fossorier, MPC, and Shu Lin (1995), “Soft-decision decoding of linear block codes based on ordered statistics,” IEEE Transactions on Information Theory 41 (5), 1379–1396.
  * Fowler [2013] Fowler, Austin G (2013), “Optimal complexity correction of correlated errors in the surface code,” arXiv e-prints , arXiv:1310.0863arXiv:1310.0863 [quant-ph] .
  * Fowler [2015] Fowler, Austin G (2015), “Minimum weight perfect matching of fault-tolerant topological quantum error correction in average o(1) parallel time,” Quantum Info. Comput. 15 (1–2), 145–158.
  * Fowler  _et al._ [2012] Fowler, Austin G, Matteo Mariantoni, John M. Martinis, and Andrew N. Cleland (2012), “Surface codes: Towards practical large-scale quantum computation,” Phys. Rev. A 86, 032324.
  * Fowler  _et al._ [2009] Fowler, Austin G, Ashley M. Stephens, and Peter Groszkowski (2009), “High-threshold universal quantum computation on the surface code,” Phys. Rev. A 80, 052312.
  * Fuentes  _et al._ [2020] Fuentes, Patricio, Josu Etxezarreta Martinez, Pedro M. Crespo, and Javier Garcia-Frias (2020), “Approach for the construction of non-calderbank-steane-shor low-density-generator-matrix–based quantum codes,” Phys. Rev. A 102, 012423.
  * Fuentes  _et al._ [2021] Fuentes, Patricio, Josu Etxezarreta Martinez, Pedro M. Crespo, and Javier Garcia-Frías (2021), “Degeneracy and its impact on the decoding of sparse quantum codes,” IEEE Access 9, 89093–89119.
  * Fuentes  _et al._ [2022] Fuentes, Patricio, Josu Etxezarreta Martinez, Pedro M. Crespo, and Javier Garcia-Frías (2022), “On the logical error rate of sparse quantum codes,” IEEE Transactions on Quantum Engineering 3, 1–12.
  * Gallager [1962] Gallager, R (1962), “Low-density parity-check codes,” IRE Transactions on Information Theory 8 (1), 21–28.
  * Ghosh  _et al._ [2013] Ghosh, Joydip, Austin G. Fowler, John M. Martinis, and Michael R. Geller (2013), “Understanding the effects of leakage in superconducting quantum-error-detection circuits,” Phys. Rev. A 88, 062329.
  * Gidney [2021] Gidney, Craig (2021), “Stim: a fast stabilizer circuit simulator,” Quantum 5, 497, arXiv:2103.02202 [quant-ph] .
  * Golub and Van Loan [2013] Golub, Gene H, and Charles F. Van Loan (2013),  _Matrix Computations_ , 4th ed. (John Hopkins University Press, EN).
  * Gorini  _et al._ [1976] Gorini, Vittorio, Andrzej Kossakowski, and E. C. G. Sudarshan (1976), “Completely positive dynamical semigroups of N‐level systems,” Journal of Mathematical Physics 17 (5), 821–825, https://pubs.aip.org/aip/jmp/article-pdf/17/5/821/8148306/821_1_online.pdf .
  * Gottesman [1998] Gottesman, D (1998), “The heisenberg representation of quantum computers,”  .
  * Gottesman [1997] Gottesman, Daniel (1997),  _Stabilizer codes and quantum error correction_ , Phd thesis (California Institute of Technology, Pasadena, CA), available at https://thesis.library.caltech.edu/2900/2/THESIS.pdf.
  * Grassl  _et al._ [1997] Grassl, M, Th. Beth, and T. Pellizzari (1997), “Codes for the quantum erasure channel,” Phys. Rev. A 56, 33–38.
  * Gu  _et al._ [2023] Gu, Shouzhen, Eugene Tang, Libor Caha, Shin Ho Choe, Zhiyang He, and Aleksander Kubica (2023), “Single-shot decoding of good quantum LDPC codes,” arXiv:2306.12470 [quant-ph] .
  * Harper and Flammia [2023] Harper, Robin, and Steven T. Flammia (2023), “Learning correlated noise in a 39-qubit quantum processor,” arXiv:2303.00780 [quant-ph] .
  * Harrington [2004] Harrington, James W (2004),  _Analysis of Quantum Error-Correcting Codes: Symplectic Lattice Codes and Toric Codes_ , Phd thesis (California Institute of Technology, Pasadena, CA), available at http://thesis.library.caltech.edu/1747/.
  * Hastings [2009] Hastings, M B (2009), “Superadditivity of communication capacity using entangled inputs,” Nature Physics 5 (4), 255–257.
  * Hastings  _et al._ [2020] Hastings, Matthew B, Jeongwan Haah, and Ryan O’Donnell (2020), “Fiber Bundle Codes: Breaking the $N^{1/2}\operatorname{polylog}(N)$ Barrier for Quantum LDPC Codes,” arXiv e-prints , arXiv:2009.03921arXiv:2009.03921 [quant-ph] .
  * Herold  _et al._ [2015] Herold, Michael, Earl T. Campbell, Jens Eisert, and Michael J. Kastoryano (2015), “Cellular-automaton decoders for topological quantum memories,” npj Quantum Information 1 (1), 15010.
  * Higgott [2022] Higgott, Oscar (2022), “Pymatching: A python package for decoding quantum codes with minimum-weight perfect matching,” ACM Transactions on Quantum Computing 3 (3), 10.1145/3505637.
  * Higgott  _et al._ [2023] Higgott, Oscar, Thomas C. Bohdanowicz, Aleksander Kubica, Steven T. Flammia, and Earl T. Campbell (2023), “Improved decoding of circuit noise and fragile boundaries of tailored surface codes,” Phys. Rev. X 13, 031007.
  * Higgott and Breuckmann [2023] Higgott, Oscar, and Nikolas P. Breuckmann (2023), “Improved single-shot decoding of higher-dimensional hypergraph-product codes,” PRX Quantum 4, 020332.
  * Higgott and Gidney [2023] Higgott, Oscar, and Craig Gidney (2023), “Sparse Blossom: correcting a million errors per core second with minimum-weight matching,” arXiv:2303.15933 [quant-ph] .
  * Horsman  _et al._ [2012] Horsman, Dominic, Austin G Fowler, Simon Devitt, and Rodney Van Meter (2012), “Surface code quantum computing by lattice surgery,” New Journal of Physics 14 (12), 123011.
  * Hsieh and Le Gall [2011] Hsieh, Min-Hsiu, and Fran çois Le Gall (2011), “Np-hardness of decoding quantum error-correction codes,” Phys. Rev. A 83, 052331.
  * Hu [2020] Hu, Mark S (2020), “Qsurface,” .
  * Huang  _et al._ [2020a] Huang, He-Liang, Dachao Wu, Daojin Fan, and Xiaobo Zhu (2020a), “Superconducting quantum computing: a review,” Science China Information Sciences 63 (8), 180501.
  * Huang  _et al._ [2022] Huang, Hsin-Yuan, Michael Broughton, Jordan Cotler, Sitan Chen, Jerry Li, Masoud Mohseni, Hartmut Neven, Ryan Babbush, Richard Kueng, John Preskill, and Jarrod R. McClean (2022), “Quantum advantage in learning from experiments,” Science 376 (6598), 1182–1186, https://www.science.org/doi/pdf/10.1126/science.abn7293 .
  * Huang  _et al._ [2020b] Huang, Shilin, Michael Newman, and Kenneth R. Brown (2020b), “Fault-tolerant weighted union-find decoding on the toric code,” Phys. Rev. A 102, 012419.
  * Hutter  _et al._ [2015] Hutter, Adrian, Daniel Loss, and James R Wootton (2015), “Improved hdrg decoders for qudit and non-abelian quantum error correction,” New Journal of Physics 17 (3), 035017.
  * Häffner  _et al._ [2008] Häffner, H, C.F. Roos, and R. Blatt (2008), “Quantum computing with trapped ions,” Physics Reports 469 (4), 155–203.
  * Iyer and Poulin [2015] Iyer, Pavithran, and David Poulin (2015), “Hardness of decoding quantum stabilizer codes,” IEEE Transactions on Information Theory 61 (9), 5209–5223.
  * Jafferis  _et al._ [2022] Jafferis, Daniel, Alexander Zlokapa, Joseph D. Lykken, David K. Kolchmeyer, Samantha I. Davis, Nikolai Lauk, Hartmut Neven, and Maria Spiropulu (2022), “Traversable wormhole dynamics on a quantum processor,” Nature 612 (7938), 51–55.
  * Jeruchim [1984] Jeruchim, M (1984), “Techniques for estimating the bit error rate in the simulation of digital communication systems,” IEEE Journal on Selected Areas in Communications 2 (1), 153–170.
  * Jordan  _et al._ [2008] Jordan, J, R. Orús, G. Vidal, F. Verstraete, and J. I. Cirac (2008), “Classical simulation of infinite-size quantum lattice systems in two spatial dimensions,” Phys. Rev. Lett. 101, 250602.
  * Joshi  _et al._ [2021] Joshi, Atharv, Kyungjoo Noh, and Yvonne Y Gao (2021), “Quantum information processing with bosonic qubits in circuit qed,” Quantum Science and Technology 6 (3), 033001.
  * Kandala  _et al._ [2019] Kandala, Abhinav, Kristan Temme, Antonio D. Córcoles, Antonio Mezzacapo, Jerry M. Chow, and Jay M. Gambetta (2019), “Error mitigation extends the computational reach of a noisy quantum processor,” Nature 567 (7749), 491–495.
  * Khatami  _et al._ [2023] Khatami, Mohammad Hassan, Udson C Mendes, Nathan Wiebe, and Philip M Kim (2023), “Gate-based quantum computing for protein design,” PLoS Comput. Biol. 19 (4), e1011033.
  * Khatri  _et al._ [2020] Khatri, Sumeet, Kunal Sharma, and Mark M. Wilde (2020), “Information-theoretic aspects of the generalized amplitude-damping channel,” Phys. Rev. A 102, 012401.
  * Kim  _et al._ [2023] Kim, Youngseok, Andrew Eddins, Sajant Anand, Ken Xuan Wei, Ewout van den Berg, Sami Rosenblatt, Hasan Nayfeh, Yantao Wu, Michael Zaletel, Kristan Temme, and Abhinav Kandala (2023), “Evidence for the utility of quantum computing before fault tolerance,” Nature 618 (7965), 500–505.
  * Kitaev [2003] Kitaev, AYu (2003), “Fault-tolerant quantum computation by anyons,” Annals of Physics 303 (1), 2–30.
  * Knill and Laflamme [1997] Knill, Emanuel, and Raymond Laflamme (1997), “Theory of quantum error-correcting codes,” Phys. Rev. A 55, 900–911.
  * Knill  _et al._ [1998] Knill, Emanuel, Raymond Laflamme, and Wojciech H. Zurek (1998), “Resilient quantum computation,” Science 279 (5349), 342–345, https://www.science.org/doi/pdf/10.1126/science.279.5349.342 .
  * Krastanov [2017] Krastanov, Stefan (2017), “Neural network decoders for quantum error correcting codes,” .
  * Krastanov and Jiang [2017] Krastanov, Stefan, and Liang Jiang (2017), “Deep neural network probabilistic decoder for stabilizer codes,” Scientific Reports 7 (1), 11003.
  * Krentel [1988] Krentel, Mark W (1988), “The complexity of optimization problems,” Journal of Computer and System Sciences 36 (3), 490–509.
  * Krinner  _et al._ [2022] Krinner, Sebastian, Nathan Lacroix, Ants Remm, Agustin Di Paolo, Elie Genois, Catherine Leroux, Christoph Hellings, Stefania Lazar, Francois Swiadek, Johannes Herrmann, Graham J. Norris, _et al._ (2022), “Realizing repeated quantum error correction in a distance-three surface code,” Nature 605 (7911), 669–674.
  * Kschischang  _et al._ [2001] Kschischang, FR, B.J. Frey, and H.-A. Loeliger (2001), “Factor graphs and the sum-product algorithm,” IEEE Transactions on Information Theory 47 (2), 498–519.
  * Kubica and Delfosse [2023] Kubica, Aleksander, and Nicolas Delfosse (2023), “Efficient color code decoders in $d\geq 2$ dimensions from toric code decoders,” Quantum 7, 929.
  * Kubica and Preskill [2019] Kubica, Aleksander, and John Preskill (2019), “Cellular-automaton decoders with provable thresholds for topological codes,” Phys. Rev. Lett. 123, 020501.
  * Kubica [2018] Kubica, Aleksander M (2018),  _The ABCs of the Color Code: A Study of Topological Quantum Codes as Toy Models for Fault-Tolerant Quantum Computation and Quantum Phases Of Matter_ , Phd thesis (California Institute of Technology, Pasadena, CA), available at https://thesis.library.caltech.edu/10955/.
  * Kumar  _et al._ [2023] Kumar, Shreya P, Carlos Alberto D., Marcello Massaro, Matteo Santandrea, Varun Seshadri, Antal Száva, Trevor Vincent, and Raphael Weber (2023), “Plaquette: an all-encompassing fault-tolerance software package,” .
  * Kuo and Lu [2012] Kuo, Kao-Yueh, and Chung-Chin Lu (2012), “On the hardness of decoding quantum stabilizer codes under the depolarizing channel,” in  _2012 International Symposium on Information Theory and its Applications_ , pp. 208–211.
  * Kuo and Lu [2020] Kuo, Kao-Yueh, and Chung-Chin Lu (2020), “On the hardnesses of several quantum decoding problems,” Quantum Information Processing 19 (4), 123.
  * Lami and Giovannetti [2015] Lami, L, and V. Giovannetti (2015), “Entanglement–breaking indices,” Journal of Mathematical Physics 56 (9), 10.1063/1.4931482, 092201, https://pubs.aip.org/aip/jmp/article-pdf/doi/10.1063/1.4931482/15971238/092201_1_online.pdf .
  * Lee  _et al._ [2021] Lee, Jonghyun, Jooyoun Park, and Jun Heo (2021), “Rectangular surface code under biased noise,” Quantum Information Processing 20 (7), 231.
  * Leverrier and Zemor [2022] Leverrier, A, and G. Zemor (2022), “Quantum tanner codes,” in  _2022 IEEE 63rd Annual Symposium on Foundations of Computer Science (FOCS)_ (IEEE Computer Society, Los Alamitos, CA, USA) pp. 872–883.
  * Levin and Wen [2005] Levin, Michael A, and Xiao-Gang Wen (2005), “String-net condensation: A physical mechanism for topological phases,” Phys. Rev. B 71, 045110.
  * Lindblad [1976] Lindblad, G (1976), “On the generators of quantum dynamical semigroups,” Communications in Mathematical Physics 48 (2), 119–130.
  * Liu and Poulin [2019] Liu, Ye-Hua, and David Poulin (2019), “Neural belief-propagation decoders for quantum error-correcting codes,” Phys. Rev. Lett. 122, 200501.
  * MacKay  _et al._ [2004] MacKay, DJC, G. Mitchison, and P.L. McFadden (2004), “Sparse-graph codes for quantum error correction,” IEEE Transactions on Information Theory 50 (10), 2315–2330.
  * Madsen  _et al._ [2022] Madsen, Lars S, Fabian Laudenbach, Mohsen Falamarzi. Askarani, Fabien Rortais, Trevor Vincent, Jacob F. F. Bulmer, Filippo M. Miatto, Leonhard Neuhaus, Lukas G. Helt, Matthew J. Collins, Adriana E. Lita, _et al._ (2022), “Quantum computational advantage with a programmable photonic processor,” Nature 606 (7912), 75–81.
  * Mangini  _et al._ [2022] Mangini, Stefano, Lorenzo Maccone, and Chiara Macchiavello (2022), “Qubit noise deconvolution,” EPJ Quantum Technology 9 (1), 29.
  * Marks [2017] Marks, Jacob (2017), “Qtop,” .
  * Meinerz  _et al._ [2022] Meinerz, Kai, Chae-Yeun Park, and Simon Trebst (2022), “Scalable neural decoder for topological surface codes,” Phys. Rev. Lett. 128, 080505.
  * Mohd Izhar  _et al._ [2018] Mohd Izhar, Mohd Azri, Zunaira Babar, Hung Viet Nguyen, Panagiotis Botsinis, Dimitrios Alanis, Daryus Chandra, Soon Xin Ng, and Lajos Hanzo (2018), “Quantum turbo decoding for quantum channels exhibiting memory,” IEEE Access 6, 12369–12381.
  * Montanaro [2016] Montanaro, Ashley (2016), “Quantum algorithms: an overview,” npj Quantum Information 2 (1), 15023.
  * Murg  _et al._ [2007] Murg, V, F. Verstraete, and J. I. Cirac (2007), “Variational study of hard-core bosons in a two-dimensional optical lattice using projected entangled pair states,” Physical Review A 75 (3), 10.1103/physreva.75.033605.
  * Nakayama and Hagiwara [2020] Nakayama, Ayumu, and Manabu Hagiwara (2020), “Single quantum deletion error-correcting codes,” in  _2020 International Symposium on Information Theory and Its Applications (ISITA)_ , pp. 329–333.
  * Ni [2020] Ni, Xiaotong (2020), “Neural Network Decoders for Large-Distance 2D Toric Codes,” Quantum 4, 310.
  * Nielsen and Chuang [2011] Nielsen, Michael A, and Isaac L. Chuang (2011),  _Quantum Computation and Quantum Information: 10th Anniversary Edition_ , 10th ed. (Cambridge University Press, USA).
  * Ollitrault  _et al._ [2021] Ollitrault, Pauline J, Alexander Miessen, and Ivano Tavernelli (2021), “Molecular quantum dynamics: A quantum computing perspective,” Accounts of Chemical Research 54 (23), 4229–4238.
  * Orús [2014] Orús, R (2014), “A practical introduction to tensor networks: Matrix product states and projected entangled pair states,” Annals of Physics 349, 117–158.
  * Orús and Vidal [2008] Orús, R, and G. Vidal (2008), “Infinite time-evolving block decimation algorithm beyond unitary evolution,” Phys. Rev. B 78, 155117.
  * Orús and Vidal [2009] Orús, Román, and Guifré Vidal (2009), “Simulation of two-dimensional quantum systems on an infinite lattice revisited: Corner transfer matrix for tensor contraction,” Phys. Rev. B 80, 094403.
  * Outeiral  _et al._ [2021] Outeiral, Carlos, Martin Strahm, Jiye Shi, Garrett M. Morris, Simon C. Benjamin, and Charlotte M. Deane (2021), “The prospects of quantum computing in computational molecular biology,” WIREs Computational Molecular Science 11 (1), e1481, https://wires.onlinelibrary.wiley.com/doi/pdf/10.1002/wcms.1481 .
  * Panteleev and Kalachev [2021a] Panteleev, Pavel, and Gleb Kalachev (2021a), “Asymptotically Good Quantum and Locally Testable Classical LDPC Codes,” arXiv:2111.03654 [cs.IT] .
  * Panteleev and Kalachev [2021b] Panteleev, Pavel, and Gleb Kalachev (2021b), “Degenerate Quantum LDPC Codes With Good Finite Length Performance,” Quantum 5, 585.
  * Panteleev and Kalachev [2022] Panteleev, Pavel, and Gleb Kalachev (2022), “Quantum ldpc codes with almost linear minimum distance,” IEEE Transactions on Information Theory 68 (1), 213–229.
  * Pattison  _et al._ [2021] Pattison, Christopher A, Michael E. Beverland, Marcus P. da Silva, and Nicolas Delfosse (2021), “Improved quantum error correction using soft information,” arXiv e-prints , arXiv:2107.13589arXiv:2107.13589 [quant-ph] .
  * Pearl [1998] Pearl, Judea (1998),  _Probabilistic Reasoning in Intelligent Systems_ , 1st ed. (Morgan Kaufmann, CA, USA).
  * Pooya [2018] Pooya, Ronagh (2018), “Deep neural decoders for fault-tolerant quantum error correction,” .
  * Poulin and Chung [2008] Poulin, David, and Yeojin Chung (2008), “On the iterative decoding of sparse quantum codes,” Quantum Info. Comput. 8 (10), 987–1000.
  * Poulin  _et al._ [2009] Poulin, David, Jean-Pierre Tillich, and Harold Ollivier (2009), “Quantum serial turbo codes,” IEEE Transactions on Information Theory 55 (6), 2776–2798.
  * Preskill [2012] Preskill, John (2012), “Quantum computing and the entanglement frontier,” arXiv:1203.5813 [quant-ph] .
  * Preskill [2018] Preskill, John (2018), “Quantum Computing in the NISQ era and beyond,” Quantum 2, 79.
  * Raussendorf and Briegel [2001] Raussendorf, Robert, and Hans J. Briegel (2001), “A one-way quantum computer,” Phys. Rev. Lett. 86, 5188–5191.
  * Raussendorf and Harrington [2007] Raussendorf, Robert, and Jim Harrington (2007), “Fault-tolerant quantum computation with high threshold in two dimensions,” Phys. Rev. Lett. 98, 190504.
  * Raveendran [2021] Raveendran, Nithin (2021),  _Trapping Sets of Iterative Decoders for Quantum and Classical Low-Density Parity Check Codes_ , Phd thesis (The University of Arizona, Arizona, USA), available at https://repository.arizona.edu/handle/10150/662344.
  * Raveendran  _et al._ [2022] Raveendran, Nithin, Narayanan Rengaswamy, Asit Kumar Pradhan, and Bane Vasić (2022), “Soft syndrome decoding of quantum ldpc codes for joint correction of data and syndrome errors,” in  _2022 IEEE International Conference on Quantum Computing and Engineering (QCE)_, pp. 275–281.
  * Raveendran and Vasić [2021] Raveendran, Nithin, and Bane Vasić (2021), “Trapping Sets of Quantum LDPC Codes,” Quantum 5, 562.
  * Reed and Solomon [1960] Reed, I S, and G. Solomon (1960), “Polynomial codes over certain finite fields,” Journal of the Society for Industrial and Applied Mathematics 8 (2), 300–304, https://doi.org/10.1137/0108018 .
  * Rivas and Huelga [2011] Rivas, Angel, and Susana F. Huelga (2011),  _Open quantum systems - An Introduction_ , 1st ed. (Springer Berlin, Heidelberg, DE).
  * Roffe [2022] Roffe, Joschka (2022), “Bp+osd: A decoder for quantum ldpc codes,” .
  * Roffe  _et al._ [2023] Roffe, Joschka, Lawrence Z. Cohen, Armanda O. Quintavalle, Daryus Chandra, and Earl T. Campbell (2023), “Bias-tailored quantum LDPC codes,” Quantum 7, 1005.
  * Roffe  _et al._ [2020] Roffe, Joschka, David R. White, Simon Burton, and Earl Campbell (2020), “Decoding across the quantum low-density parity-check code landscape,” Phys. Rev. Res. 2, 043423.
  * Sarvepalli and Raussendorf [2012] Sarvepalli, Pradeep, and Robert Raussendorf (2012), “Efficient decoding of topological color codes,” Phys. Rev. A 85, 022317.
  * Sarvepalli  _et al._ [2009] Sarvepalli, Pradeep Kiran, Andreas Klappenecker, and Martin Rötteler (2009), “Asymmetric quantum codes: constructions, bounds and performance,” Proceedings of the Royal Society A: Mathematical, Physical and Engineering Sciences 465 (2105), 1645–1672, https://royalsocietypublishing.org/doi/pdf/10.1098/rspa.2008.0439 .
  * Sauter  _et al._ [1986] Sauter, Th, W. Neuhauser, R. Blatt, and P. E. Toschek (1986), “Observation of quantum jumps,” Phys. Rev. Lett. 57, 1696–1698.
  * Schlör [2019] Schlör, Steffen (2019),  _Intrinsic decoherence in superconducting quantum circuits_ , Phd thesis (Karlsruher Institut für Technologie, Karlsruhe, Germany), available at https://inis.iaea.org/search/search.aspx?orig_q=RN:51064817.
  * Schollwöck [2011] Schollwöck, Ulrich (2011), “The density-matrix renormalization group in the age of matrix product states,” Annals of Physics 326 (1), 96–192.
  * Schuch  _et al._ [2007] Schuch, Norbert, Michael M. Wolf, Frank Verstraete, and J. Ignacio Cirac (2007), “Computational complexity of projected entangled pair states,” Phys. Rev. Lett. 98, 140506.
  * Schumacher [1995] Schumacher, Benjamin (1995), “Quantum coding,” Phys. Rev. A 51, 2738–2747.
  * Sermanet  _et al._ [2014] Sermanet, Pierre, David Eigen, Xiang Zhang, Michael Mathieu, Rob Fergus, and Yann LeCun (2014), “Overfeat: Integrated recognition, localization and detection using convolutional networks,” Publisher Copyright: © 2014 International Conference on Learning Representations, ICLR. All rights reserved.; 2nd International Conference on Learning Representations, ICLR 2014 ; Conference date: 14-04-2014 Through 16-04-2014.
  * Shor [1995] Shor, Peter W (1995), “Scheme for reducing decoherence in quantum computer memory,” Phys. Rev. A 52, R2493–R2496.
  * Shor [1994] Shor, PW (1994), “Algorithms for quantum computation: discrete logarithms and factoring,” in  _Proceedings 35th Annual Symposium on Foundations of Computer Science_, pp. 124–134.
  * Silva  _et al._ [2008] Silva, M, E. Magesan, D. W. Kribs, and J. Emerson (2008), “Scalable protocol for identification of correctable codes,” Phys. Rev. A 78, 012347.
  * Slussarenko and Pryde [2019] Slussarenko, Sergei, and Geoff J. Pryde (2019), “Photonic quantum information processing: A concise review,” Applied Physics Reviews 6 (4), 10.1063/1.5115814, 041303, https://pubs.aip.org/aip/apr/article-pdf/doi/10.1063/1.5115814/14575021/041303_1_online.pdf .
  * Smith and Smolin [2007] Smith, Graeme, and John A. Smolin (2007), “Degenerate quantum codes for pauli channels,” Phys. Rev. Lett. 98, 030501.
  * Smith and Yard [2008] Smith, Graeme, and Jon Yard (2008), “Quantum communication with zero-capacity channels,” Science 321 (5897), 1812–1815, https://www.science.org/doi/pdf/10.1126/science.1162242 .
  * Spitz  _et al._ [2018] Spitz, Stephen T, Brian Tarasinski, Carlo W. J. Beenakker, and Thomas E. O’Brien (2018), “Adaptive weight estimator for quantum error correction in a time-dependent environment (adv. quantum technol. 1/2018),” Advanced Quantum Technologies 1 (1), 1870015, https://onlinelibrary.wiley.com/doi/pdf/10.1002/qute.201870015 .
  * Steane [1996] Steane, Andrew (1996), “Multiple-particle interference and quantum error correction,” Proceedings: Mathematical, Physical and Engineering Sciences 452 (1954), 2551–2577.
  * Stricker  _et al._ [2020] Stricker, Roman, Davide Vodola, Alexander Erhard, Lukas Postler, Michael Meth, Martin Ringbauer, Philipp Schindler, Thomas Monz, Markus Müller, and Rainer Blatt (2020), “Experimental deterministic correction of qubit loss,” Nature 585 (7824), 207–210.
  * Sweke  _et al._ [2020] Sweke, Ryan, Markus S Kesselring, Evert P L van Nieuwenburg, and Jens Eisert (2020), “Reinforcement learning decoders for fault-tolerant quantum computation,” Machine Learning: Science and Technology 2 (2), 025005.
  * Tarjan [1975] Tarjan, Robert Endre (1975), “Efficiency of a good but not linear set union algorithm,” J. ACM 22 (2), 215–225.
  * Terhal [2015] Terhal, Barbara M (2015), “Quantum error correction for quantum memories,” Rev. Mod. Phys. 87, 307–346.
  * Tiurev  _et al._ [2022] Tiurev, Konstantin, Peter-Jan H. S. Derks, Joschka Roffe, Jens Eisert, and Jan-Michael Reiner (2022), “Correcting non-independent and non-identically distributed errors with surface codes,” arXiv:2208.02191 [quant-ph] .
  * Tokunaga and Fujii [2014] Tokunaga, Yuuki, and Keisuke Fujii (2014), “Thresholds of surface codes on the general lattice structures suffering biased error and loss,” AIP Conference Proceedings 1633 (1), 198–200, https://pubs.aip.org/aip/acp/article-pdf/1633/1/198/12136612/198_1_online.pdf .
  * Tolar [2018] Tolar, J (2018), “On Clifford groups in quantum computing,” in  _Journal of Physics Conference Series_, Journal of Physics Conference Series, Vol. 1071, p. 012022, arXiv:1810.10259 [quant-ph] .
  * Torlai and Melko [2017] Torlai, Giacomo, and Roger G. Melko (2017), “Neural decoder for topological codes,” Phys. Rev. Lett. 119, 030501.
  * Tse and Viswanath [2005] Tse, David, and Pramod Viswanath (2005),  _Fundamentals of Wireless Communication_ (Cambridge University Press, USA).
  * Tuckett [2020] Tuckett, David K (2020), “Tailoring surface codes: Improvements in quantum error correction with biased noise (qecsim),” .
  * Tuckett  _et al._ [2018] Tuckett, David K, Stephen D. Bartlett, and Steven T. Flammia (2018), “Ultrahigh error threshold for surface codes with biased noise,” Phys. Rev. Lett. 120, 050505.
  * Tuckett  _et al._ [2020] Tuckett, David K, Stephen D. Bartlett, Steven T. Flammia, and Benjamin J. Brown (2020), “Fault-tolerant thresholds for the surface code in excess of $5\%$ under biased noise,” Phys. Rev. Lett. 124, 130501.
  * Tuckett  _et al._ [2019] Tuckett, David K, Andrew S. Darmawan, Christopher T. Chubb, Sergey Bravyi, Stephen D. Bartlett, and Steven T. Flammia (2019), “Tailoring surface codes for highly biased noise,” Phys. Rev. X 9, 041031.
  * Turchette  _et al._ [2000] Turchette, Q A, C. J. Myatt, B. E. King, C. A. Sackett, D. Kielpinski, W. M. Itano, C. Monroe, and D. J. Wineland (2000), “Decoherence and decay of motional quantum states of a trapped atom coupled to engineered reservoirs,” Phys. Rev. A 62, 053807.
  * Valls  _et al._ [2021] Valls, Javier, Francisco Garcia-Herrero, Nithin Raveendran, and Bane Vasić (2021), “Syndrome-based min-sum vs osd-0 decoders: Fpga implementation and analysis for quantum ldpc codes,” IEEE Access 9, 138734–138743.
  * Varona and Martin-Delgado [2020] Varona, S, and M. A. Martin-Delgado (2020), “Determination of the semion code threshold using neural decoders,” Phys. Rev. A 102, 032411.
  * Varsamopoulos  _et al._ [2020a] Varsamopoulos, Savvas, Koen Bertels, and Carmen G. Almudever (2020a), “Decoding surface code with a distributed neural network–based decoder,” Quantum Machine Intelligence 2 (1), 3.
  * Varsamopoulos  _et al._ [2020b] Varsamopoulos, Savvas, Koen Bertels, and Carmen Garcia Almudever (2020b), “Comparing neural network based decoders for the surface code,” IEEE Transactions on Computers 69 (2), 300–311.
  * Varsamopoulos  _et al._ [2017] Varsamopoulos, Savvas, Ben Criger, and Koen Bertels (2017), “Decoding small surface codes with feedforward neural networks,” Quantum Science and Technology 3 (1), 015004.
  * Vasmer [2021] Vasmer, Michael (2021), “Sweep-decoder-boundaries,” .
  * Vasmer  _et al._ [2021] Vasmer, Michael, Dan E. Browne, and Aleksander Kubica (2021), “Cellular automaton decoders for topological quantum codes with noisy measurements and beyond,” Scientific Reports 11 (1), 2027.
  * Verstraete and Cirac [2004] Verstraete, F, and J. I. Cirac (2004), “Renormalization algorithms for quantum-many body systems in two and higher dimensions,” arXiv:cond-mat/0407066 [cond-mat.str-el] .
  * Vidal [2007] Vidal, G (2007), “Entanglement renormalization,” Phys. Rev. Lett. 99, 220405.
  * Villalonga [2022] Villalonga, Benjamin (2022), “Maximum likelihood decoders of stabilizer codes under device noise using tensor networks,” APS March Meeting.
  * Wagner  _et al._ [2020] Wagner, Thomas, Hermann Kampermann, and Dagmar Bruß (2020), “Symmetries for a high-level neural decoder on the toric code,” Phys. Rev. A 102, 042411.
  * Wagner  _et al._ [2022] Wagner, Thomas, Hermann Kampermann, Dagmar Bruß, and Martin Kliesch (2022), “Pauli channels can be estimated from syndrome measurements in quantum error correction,” Quantum 6, 809.
  * Wahl  _et al._ [2023] Wahl, Misty A, Andrea Mari, Nathan Shammah, William J. Zeng, and Gokul Subramanian Ravi (2023), “Zero noise extrapolation on logical qubits by scaling the error correction code distance,” arXiv:2304.14985 [quant-ph] .
  * Wang  _et al._ [2003] Wang, Chenyang, Jim Harrington, and John Preskill (2003), “Confinement-higgs transition in a disordered gauge theory and the accuracy threshold for quantum memory,” Annals of Physics 303 (1), 31–58.
  * Watson  _et al._ [2015] Watson, Fern H E, Hussain Anwar, and Dan E. Browne (2015), “Fast fault-tolerant decoder for qubit and qudit surface codes,” Phys. Rev. A 92, 032309.
  * Wiberg [1996] Wiberg, Niclas (1996),  _Codes and decoding on general graphs_ , Phd thesis (Linköping University,, Linköping , Sweden), available at https://www.semanticscholar.org/paper/Codes-and-Decoding-on-General-Graphs-Wiberg/eb44d50bce92b4ce2c0ea53bd8ede95f628ee3cb.
  * Wiebe  _et al._ [2012] Wiebe, Nathan, Daniel Braun, and Seth Lloyd (2012), “Quantum algorithm for data fitting,” Phys. Rev. Lett. 109, 050505.
  * Wilde  _et al._ [2014] Wilde, Mark M, Min-Hsiu Hsieh, and Zunaira Babar (2014), “Entanglement-assisted quantum turbo codes,” IEEE Transactions on Information Theory 60 (2), 1203–1222.
  * Wootton [2015] Wootton, James (2015), “A simple decoder for topological codes,” Entropy 17 (4), 1946–1957.
  * Wu [2022] Wu, Yue (2022), “Fusion blossom,” .
  * Wu  _et al._ [2022] Wu, Yue, Namitha Liyanage, and Lin Zhong (2022), “An interpretation of Union-Find Decoder on Weighted Graphs,” arXiv:2211.03288 [quant-ph] .
  * Wu and Zhong [2023] Wu, Yue, and Lin Zhong (2023), “Fusion Blossom: Fast MWPM Decoders for QEC,” arXiv:2305.08307 [quant-ph] .
  * Wu  _et al._ [2021] Wu, Yulin, Wan-Su Bao, Sirui Cao, Fusheng Chen, Ming-Cheng Chen, Xiawei Chen, Tung-Hsun Chung, Hui Deng, Yajie Du, Daojin Fan, Ming Gong, _et al._ (2021), “Strong quantum computational advantage using a superconducting quantum processor,” Phys. Rev. Lett. 127, 180501.
  * Xu  _et al._ [2023] Xu, Qian, Nam Mannucci, Alireza Seif, Aleksander Kubica, Steven T. Flammia, and Liang Jiang (2023), “Tailored xzzx codes for biased noise,” Phys. Rev. Res. 5, 013035.
  * Yuan [2022] Yuan, Y & Lu, CCh (2022), “A Modified MWPM Decoding Algorithm for Quantum Surface Codes Over Depolarizing Channels,” arXiv e-prints , arXiv:2202.11239arXiv:2202.11239 [quant-ph] .
  * Zhong  _et al._ [2020] Zhong, Han-Sen, Hui Wang, Yu-Hao Deng, Ming-Cheng Chen, Li-Chao Peng, Yi-Han Luo, Jian Qin, Dian Wu, Xing Ding, Yi Hu, Peng Hu, _et al._ (2020), “Quantum computational advantage using photons,” Science 370 (6523), 1460–1463, https://www.science.org/doi/pdf/10.1126/science.abe8770 .

## Appendices

##  Appendix A Multiple-round decoding for measurement errors

Throughout this article, surface code decoders have been described as
correcting errors arising from data qubit errors, i.e. considering that check
measuremnts are noiseless. However, this simplified perspective is overly
optimistic because circuit-level noise arising from gate and SPAM errors make
syndrome measurement to be noisy too. As mentioned in the main article section
on error models and decoding, circuit level noise will lead to incorrect
syndromes. If we attempt to decode an erroneous syndrome, the recovered error
will likely result in a logical error. Therefore, a new approach is needed to
account this type of errors in the code. The common technique consists in
performing multiple syndrome extracting rounds. When a check qubit undergoes a
change in its measurement value, it implies a non-trivial syndrome element for
such measurement round. Subsequently, decoding algorithms can be employed by
connecting check qubits within a particular time instance to themselves in the
following time, creating a graph containing space and time information of the
errors. Recall that not every decoding algorithm requires this multiple-round
measurements as, for example, the cellular automaton decoders [100, 214].
These type of decoders are usually known as single-shot decoders [103]. It is
important to say that not every QEC family can admit a single-shot decoding
algorithm [103].

Figure 30: Graphical representation of an error in a space-time surface code.

FIG. 30 illustrates a graphical depiction of three decoding rounds. In this
example, three rounds of syndrome extraction have been computed, where the
temporal direction progresses upwards. During the initial syndrome extraction,
all checks yield a measurement of 0, assuming an absence of errors. This set
of measurements serves as the starting point. In the subsequent syndrome
extraction, two checks undergo a measurement change: a green $X$-check
transitions into 1, as does an orange $Z$-check. These altered check
measurements are classified as non-trivial syndrome elements. In the third
round, the measurement values of two checks change again, designating them as
non-trivial syndrome elements. One of these checks is the orange check from
the second decoding round, which reverts back to 0, while the other one is an
$X$-check. It is worth noting that although the $X$-check from the second
syndrome extraction retains a measurement value of 1, it is not considered a
non-trivial syndrome element since its measurement value did not change.

To implement perfect matching methods like MWPM or UF, the dashed purple lines
in FIG. 30 are taken into account. These lines represent edges that connect
different time instances separated by one syndrome extraction. The resulting
perfect matching will consist of space edges and time edges. Space edges
correspond to Pauli errors within the data qubits, while time edges represent
faulty measurements that do not require actual error recovery within the code.
In FIG. 30, a potential perfect matching is indicated by red lines, which
consist of two time edges and one space edge.

Usually, it is considered that a distance $d$ surface code requires
$\mathcal{O}(d)$ syndrome extraction rounds per decoding round [102, 38, 105]
in order to preserve the distance property323232A measurement error within a
check which repeats itself over half the times of syndrome extraction rounds
will produce a logical error.. Considering several syndrome extractions
further complicates the decoding process, since it significantly increases the
number of nodes within decoding graphs and the connectivity of the graph.
Specifically, a surface code of arbitrary distance $d$, which has $d^{2}-1$
checks, results to have $d(d^{2}-1)$ checks. Moreover, even by considering
multiple decoding rounds for dealing with faulty measurements, the threshold
of the codes decrease dramatically due to such effect caused by circuit-level
noise when compared to just data qubit noise [82, 102, 38].

In conclusion, measurement errors pose a significant challenge to the
successful implementation of the surface code. The accurate extraction of
syndromes is crucial for effective error correction. Faulty-measurements lead
to lower code thresholds, implying that the hardware requirements for error
correction are more stringent. Therefore, dealing with circuit-level noise and
noisy measurements is critical to reach the fault-tolerant quantum computing
paradigm.

##  Appendix B QECC numerical simulations

Monte Carlo computer simulations of the $d\times d$ rotated planar codes with
$d\in\\{3,5,7,9,11\\}$ have been performed with the objective of obtaining the
performance curves and thresholds of the code when decoded with MWPM, UF,
BPOSD and TN decoders.

Each round of the numerical simulation is performed by generating an $N$-qubit
Pauli operator, calculating its associated syndrome, and finally running the
decoding algorithm using the associated syndrome as its input (note that for
the simulations performed in this paper, no SPAM or gate errors are
considered). Once the error is estimated by the decoder, it is used to
determine if a logical error has occurred on the codestate by using the
channel error [86]. The operational figure of merit we use to evaluate the
performance of these quantum error correction schemes is the Logical Error
Rate ($P_{L}$), i.e. the probability that a logical error has occurred after
the recovery operation.

Regarding the software implementations of the decoders used to obtain the
simulations in Section V have been: QECSIM for the MWPM and tensor network
decoder [203], the BPOSD implementation of Joschka Roffe for the BPOSD decoder
[175] and an implementation coded by ourselves for the UF decoder by Delfosse
and Nickerson [53].

For the numerical Monte Carlo methods employed to estimate the $P_{L}$ of the
rotated planar codes, we have applied the following rule of thumb to select
the number of simulation runs, $N_{\mathrm{runs}}$ [115], as

$N_{\mathrm{runs}}=\frac{100}{P_{L}}.$ (23)

As explained in [115], under the assumption that the observed error events are
independent, this results in a $95\%$ confidence interval of about
$(0.8\hat{P_{L}},1.25\hat{P_{L}})$, where $\hat{P_{L}}$ refers to the
empirically estimated value for the logical error rate.