Machine-learning-assisted correction of correlated qubit errors in a topological code

A fault-tolerant quantum computation requires an efficient means to detect and correct errors that accumulate in encoded quantum information. In the context of machine learning, neural networks are a promising new approach to quantum error correction. Here we show that a recurrent neural network can be trained, using only experimentally accessible data, to detect errors in a widely used topological code, the surface code, with a performance above that of the established minimum-weight perfect matching (or blossom) decoder. The performance gain is achieved because the neural network decoder can detect correlations between bit-flip (X) and phase-flip (Z) errors. The machine learning algorithm adapts to the physical system, hence no noise model is needed. The long short-term memory layers of the recurrent neural network maintain their performance over a large number of quantum error correction cycles, making it a practical decoder for forthcoming experimental realizations of the surface code.


Introduction
A quantum computer needs the help of a powerful classical computer to overcome the inherent fragility of entangled qubits. By encoding the quantum information in a nonlocal way, local errors can be detected and corrected without destroying the entanglement [1,2]. Since the efficiency of the quantum error correction protocol can make the difference between failure and success of a quantum computation, there is a major push towards more and more efficient decoders [3]. Topological codes such as the surface code, which store a logical qubit in the topology of an array of physical qubits, are particularly attractive because they combine a favorable performance on small circuits with scalability to larger circuits [4][5][6][7][8][9].
In a pioneering work [10], Torlai and Melko have shown that the data processing power of machine learning (artificial neural networks [11][12][13]) can be harnessed to produce a flexible, adaptive decoding al-gorithm. A test on a topological code (Kitaev's toric code [14]) revealed a performance for phase-flip errors that was comparable to decoders based on the minimum-weight perfect matching (MWPM or "blossom") algorithm of Edmonds [15][16][17]. The machine learning paradigm promises a flexibility that the classic algorithms lack, both with respect to different types of topological codes and with respect to different types of errors.
Several groups are exploring the capabilities of a neural network decoder [18][19][20], but existing designs cannot yet be efficiently deployed as a decoder in a surface code architecture [21][22][23]. Two key features which are essential for this purpose are 1: The neural network must have a "memory", in order to be able to process repeated cycles of stabilizer measurement whilst detecting correlations between cycles; and 2: The network must be able to learn from measured data, it should not be dependent on the uncertainties of theoretical modeling.
In this work we design a recurrent neural network decoder that has both these features, and demonstrate a performance improvement over a blossom decoder in a realistic simulation of a forthcoming error correction experiment. Our decoder achieves this improvement through its ability to detect bit-flip (X) and phase-flip (Z) errors separately as well as correlations (Y). The blossom decoder treats a Y-error as a pair of uncorrelated X and Z errors, which explains the improved performance of the neural network. We study the performance of the decoder in a simplified model where the Y-error rate can be adjusted independently of the X-and Z-error rates, and measure the decoder efficiency in a realistic model (density matrix simulation) of a state-of-the-art 17-qubit surface code experiment (Surface-17).
The outline of this paper is as follows. In the next section 2 we summarize the results from the literature we need on quantum error correction with the surface code. The design principles of the recurrent neural network that we will use are presented in Sec. 3, with particular attention for the need of an internal memory in an efficient decoder. This is one key aspect that differentiates our recurrent network from the feedforward networks proposed independently [18][19][20] (see A further set of two-fold σx and σz measurements are performed on the boundary, bringing the total number of measurements to N − 1. Right: Since direct four-fold parity measurements are impractical, the measurements are instead performed by entanglement with an ancilla qubit, followed by a measurement of the ancilla in the computational basis. Both data qubits and ancilla qubits accumulate errors during idle periods (labeled I) and during gate operations (Hadamard H and cnot), which must be accounted for by a decoder. The data qubits are also entangled with the rest of the surface code by the grayed out gates.
Sec. 4). A detailed description of the architecture and training protocol is given in Sec. 5. In Sec. 6 we compare the performance of the neural network decoder to the blossom decoder for a particular circuit model with varying error rates. We conclude in Sec. 7 with a demonstration of the potential of machine learning for real-world quantum error correction, by decoding data from a realistic quantum simulation of the Surface-17 experiment.

Overview of the surface code
To make this paper self-contained we first describe the operation of the surface code and formulate the decoding problem. The expert reader may skip directly to the next section.
In a quantum error correcting (QEC) code, single logical qubits (containing the quantum information to be protected) are spread across a larger array of N noisy physical data qubits [24,25]. The encoding is achieved by N − 1 binary parity check measurements on the data qubits [26]. Before these measurements, the state of the physical system is described by a complex vector |ψ within a 2 N -dimensional Hilbert space H. Each parity check measurement M i projects |ψ onto one of two 2 N −1 -dimensional subspaces, dependent on the outcome s i of the measurement. As all parity check measurements commute, the result of a single cycle of N − 1 measurements is to project |ψ into the intersection of all subspaces H s decided by the measurements s = s 1 , . . . , s N −1 (s i ∈ {0, 1}). This is a Hilbert space of dimension 2 N /2 N −1 = 2, giving the required logical qubit |ψ L .
Repeated parity check measurements s(t) do not affect the qubit within this space, nor entanglement between the logical qubit states and other systems. However, errors in the system will cause the qubit to drift out of the logical subspace. This continuous drift is discretized by the projective measurement, becoming a series of discrete jumps between subspaces H s(t) as time t progresses. Since s(t) is directly measured, the qubit may be corrected, i.e. brought back to the initial logical subspace H s(0) . When performing this correction, a decision must be made on whether to map the logical state |0 , as no a priori relationship exists between the labels in these two spaces. If this is done incorrectly, the net action of the time evolution and correction is a logical bit-flip error. A similar choice must be made for the {|+ L , |− L } logical states, which if incorrect results in a logical phase-flip error.
Information about the best choice of correction (to most-likely prevent logical bit-flip or phase-flip errors) is stored within the measurement vectors s, which detail the path the system took in state-space from H s(0) to H s(t) . The non-trivial task of decoding, or extracting this correction, is performed by a classical decoder. Optimal (maximum-likelihood) decoding is an NP-hard problem [27], except in the presence of specific error models [28]. However, a faulttolerant decoder need not be optimal, and polynomial time decoders exist with sufficient performance to demonstrate error mitigation on current quantum hardware [5]. This sub-optimality is quantified by the decoder efficiency [29] where D L is the probability of a logical error per cycle using the decoder D, and (opt) L is the probability of a logical error per cycle using the optimal decoder [31].
The QEC code currently holding the record for the best performance under a scalable decoder is the surface code [3][4][5]16]. As illustrated in Fig. 1, the surface code is defined on a d × d lattice of data qubits, where d = √ N is the distance of the code. The measurement operators are defined by coloring lattice squares as on a checkerboard. Each square corresponds to a correlated measurement of the stabilizer operator with α = z on the green squares and α = x on the blue squares. The operator σ D α is the Pauli matrix acting on the qubit in the D-corner of the square (labeled a,b,c,d in Fig 1). The checkerboard is extended slightly beyond the boundary of the lattice [32], giving an additional set of two-qubit σ D α σ D α measurements, and bringing the total number of measurements to All measurements commute because green and blue squares either share two corners or none. A bit-flip or phase-flip on any data qubit in the bulk of the code causes two measurements to change sign, producing unit syndrome increments This theme is continued even when the measurement of s i itself is allowed to be faulty; such measurement errors cause two correlated error signals δs i (t) = 1 separated in time, rather than in space. As all observable errors can be built from combinations of bit-flip and phase-flip errors, these measurements allow the mapping of surface-code decoding to the minimum-weight perfect matching (MWPM) problem [5,16]. Every instance of non-zero δs i (t) is mapped to a vertex in a graph, with an edge between two vertices representing the probability of some combination of errors causing these signals. A 'boundary' vertex is included to account for qubits on the edge of the lattice, whose errors may only cause a single error signal. Then, the most probable matching of vertices, weighted by the product of probabilities on individual edges, gives the required error correction. This matching can be found in polynomial time with Edmonds' blossom algorithm [15].
Under current experimental parameters, with the smallest non-trivial N (N = 9, or distance d = √ N = 3), this blossom decoder already crosses the quantum memory threshold -whereby quantum information on a logical qubit can be stored for a longer time than on any physical component. However, the decoder itself performs only with efficiency η d = 0.64, leaving much room for improvement [29].

Neural network detection of correlated errors
The sub-optimality of the blossom decoder comes primarily from its inability to optimally detect Pauli-Y (σ y ) errors [29,31,33]. These errors correspond to a combination of a bit-flip (X) and a phase-flip (Z) on the same qubit, and are thus treated by a MWPM decoder as two independent errors. Since these correlations exist as patterns on the graph, one may expect that the pattern matching capabilities of a neural network could be exploited to identify the correlations, producing an improvement over existing decoders. This is the primary motivation of the research we report in what follows.
A key issue in the design of any practical decoder is to ensure that the decoder is able to operate for an unspecified number of cycles T . A feedforward neural network is trained on a dataset with a specific fixed T . The central advance of this work is to use a recurrent neural network to efficiently decode an arbitrary, unspecified number of cycles. In order to learn time correlations the network possesses an internal memory that it utilizes to store information about previous cycles. This is important because errors on the ancilla qubits or during ancilla qubit readout lead to error signals that are correlated over several cycles.
We adopt the recurrent neural network architecture known as a "long short-term memory" (LSTM) layer [34,35]. (See App. A for details of our network.) These layers have two internal states: a shortterm memory h t , and a long-term memory c t that is updated each cycle and retains information over several cycles. During training, the parameters that characterize the LSTM layers are updated using back propagation, in order to efficiently update and utilize the long-term memory to detect logical errors, even if the corresponding syndrome patterns are non-local in time. The parameters of the LSTM layers themselves are the same for each cycle; only their memory changes. This allows for a very efficient algorithm, whose computational cost per cycle is independent of how many cycles the network has to decode.
We now formulate the QEC problem that a decoder needs to solve. To be useful for upcoming QEC experiments and future fault-tolerant quantum algorithms, it is critical that any decoder uses data that could be generated by such experiments. This implies that the data available to the neural network, both for input and labels, must be data generated by qubit measurements (as opposed to a listing of occurred errors, which is not available in an actual experiment).
The data available to the decoder after T cycles are the T syndromes s(t), and a final syndrome f calculated from readout of the final data qubits. From this, a decoder must output a single bit of data, the so-called "final parity correction" that decides on the correction of the final logical state. The decoder may be trained and tested using the scheme described in Ref. [29]. The system is prepared in a known logical state, chosen from |0 L and |1 L or from |+ L and |− L , which is held for T cycles and then readout. The final logical state can be determined by the parity of all data qubit measurements, to which the final parity correction may be directly added. This gives a standard binary classification problem for the neural network. Since it is a priori unknown in which basis the logical qubit will be measured, we need to train two separate decoders -one for the x-basis and one for the z-basis.

Approaches going beyond blossom decoding
The neural network decoder improves on the blossom decoder by including correlations between Pauli-X and Pauli-Z errors. It is possible to account for these correlations without using machine learning, by adapting the minimum-weight perfect matching (blossom) algorithm.
Fowler [33] and Delfosse and Tillich [36] achieved this by performing repeated rounds of X-error and Z-error decoding in series. After each round of Xerror decoding, the weights on the Z-graph are updated based on the likelihood of underlying Z-errors assuming the X-matching is correct. The overhead from repeated serial repetitions of the blossom algorithm is limited by restriction to a small window of decoding for each repetition, resulting in a constanttime algorithm.
We can compare the results obtained in Ref.
[33] to our results by extracting the improvement of correlated over basic fault-tolerant corrections for a distance-3 code. For a depolarization probability comparable to the one we use in Fig. 3 the improvement is approximately 24%. This is similar to the improvement we obtained with the neural network decoder.
Both the neural network decoder and the improved blossom decoder perform below the optimal maximum-likelihood decoder. Several approaches exist to reach the optimal limit, we mention the incorporation of X-Z correlations via a belief propagation algorithm [37], and approaches based on renormalization group methods or Monte Carlo methods [28,38,39].
Bravyi, Suchara, and Vargo [28] reported a densitymatrix renormalization group (DMRG) method for exact single-round maximum-likelihood decoding in polynomial time, assuming bit-flip and dephasing noise. Their performance continues to be better than the blossom decoder for multi-round decoding. The method is somewhat limited in the choice of error model; in particular it cannot account for Y-errors.
The Markov-chain Monte Carlo method of Hutter, Wootton, and Loss [39] samples over the set of corrections to approximate the maximum-likelihood decoding via the Metropolis algorithm. This again outperforms the blossom decoder, but it suffers from an increased run-time cost, with an additional O(N 2 ) computational cost.

Approaches based on machine learning
The existence of algorithms [28,33,[36][37][38][39] that improve on the blossom decoder does not diminish the appeal of machine learning decoders, since these offer a flexibility to different types of topological codes that a dedicated decoder lacks.
Torlai and Melko [10] implemented a machine learning decoder based on a restricted Boltzmann machine, while Varsamopoulos, Criger, and Bertels [18] and Krastanov and Jiang [19] used feedforward neural networks. The key distinction with our work is that we use a recurrent neural network, and thereby allow the decoder to detect correlations between arbitrary cycles of stabilizer measurements.
Refs. [10] and [19] were limited to the study of models without circuit-level noise (i.e. without measurement error between repeated cycles), and so no direct quantitative comparison with the performance of our decoder is possible.
One feedforward neural network in Ref. [18] was constructed to take the syndrome from 3 cycles as input. While it cannot decode an arbitrary number of cycles, it can account for circuit noise at the 3cycle level. Over that time frame their performance lies within error bars from that of our recurrent neural network. (The equivalence of the Pauli-frame-update error rate of Ref. [18] and our parity-bit error rate is discussed in App. B.)

Design of the neural network decoder
The neural network consists of two LSTM layers with internal state sizes N When a final parity prediction is required from the network at time T , information from the recurrent network is passed to an evaluation layer, along with the syndrome increment between final syndrome f calculated from the data qubit measurements and the last syndrome readout s(T ) from the ancilla qubits. Note that, while s(t) is passed to each decoder in both the x-basis and the z-basis, the final syndrome f is only available to a decoder in its own basis. The memory of the recurrent network solves the issue of how to concatenate multiple decoding cycles, but one remaining issue occurs at the end of the computation: the final syndrome breaks timetranslational invariance. Within any cycle, the decoder must account for the possibility that an error signal (δs i (t) = 1) should be propagated forward in time to future cycles. This is not the case for the final syndrome, as this is calculated directly from the data qubit measurements, and any errors in the data qubits do not propagate forward in time.
To achieve time-translational invariance of the decoder we split the problem into two separate tasks, as shown in Fig. 2. Task 1 is to estimate the probability p 1 that the parity of bit-flip errors during T cycles is odd, based solely on the syndrome increments δ s(t) up to that point (i.e. those extracted from ancilla measurements). Task 2 is to estimate the probability p 2 that the final data qubit measurements make any adjustment to the final parity measurement, based solely on new information from the final syndrome increment δ f (T ). The final parity probability is then given by the probabilistic sum We use two separate networks for the two tasks. The first network gets T rounds of syndrome increments δ s(t) but not the final syndrome increment (upper half of Fig. 2). The second network gets only the last T 0 syndrome increments δ s(t), but its evaluation layer gets the last output of the second LSTM layer concatenated with the final syndrome increment (lower half of Fig. 2). For Surface-17, we observe optimal performance when we allow the task-2 network a window of T 0 = 3 cycles, giving a decoder that works for experiments of three or more cycles. In general, the number of cycles fed to the second network should be on the order of the length of the longest time-correlations between syndromes. As task 2 only requires decoding of a fixed number of cycles, it could potentially be performed by a simpler feedforward network, but we found it convenient to keep the same architecture as task 1 because of the similarity between the two tasks.
We discuss the details of the network architecture and training procedure in App. A. The source code is available [41].

Neural network performance
We determine the neural network performance on the 17-qubit distance-3 surface code, referred to as "Surface-17", which is under experimental development [23].
We take at first a simplified Pauli error channel model [42], similar to Refs. [6,7] but without correlated two-qubit errors. In this model the performance of the blossom decoder is understood and individual error types can be focused upon. Stabilizer measurements are made by entangling two or four data qubits with an ancilla qubit, which is readout in the computational basis (right panel in Fig. 1).
The process is broken into seven steps: four coherent steps over which cnot gates are performed, two steps in which Hadamard gates are performed, and one measurement step. During idle, Hadamard, and cnot steps, both data and ancilla qubits have independent chances of a σ x error (with probability p x ), Figure 3: Comparison of logical qubit decay between blossom and neural network decoders for a Pauli error channel model, with px = py = pz = 0.048% and pm = 0.14%. We plot the probability that the decoder corrects the logical qubit after t cycles of stabilizer measurement and error accumulation. All data is averaged over 5 · 10 4 datasets, with error bars obtained by boot-strapping (using 3σ for the error). Lines are two-parameter fits of the data to Eq. (8).
a σ y error (with probability p y ), and a σ z error (with probability p z ). This implies that the total probability during any step for a qubit to accumulate a y-error (as opposed to an x-error, a z-error, or no error) is With this definition p y = 0 implies that x-errors and z-errors are uncorrelated (it does not imply that there are no y-errors).
Data qubits behave similarly during measurement steps, but ancilla qubits are projected into the computational basis and so cannot incur phase errors. Instead, a measurement has a p m chance of returning the wrong result, without the qubit state being affected. Qubits are reused after measurement without reset, and so the syndromes s i (t) are obtained by changes in the readout m i (t) of an ancilla qubit between rounds, The performance of the logical qubit is measured using the protocol outlined in Ref. [29] (Methods section). The logical qubit is prepared in the |0 state, held for T cycles, and finally measured and decoded. The decoder seeks to determine whether or not the qubit underwent a logical bit-flip during this time. The probability that the decoder obtains the correct answer gives the logical qubit fidelity, which can be plotted as a function of the number of cycles. Fig. 3 shows the decay in fidelity over 300 cycles for p x = p y = p z = 0.048% and p m = 0.14%, which corresponds to a physical error rate of approximately 1% per cycle.
A logical error rate per cycle can be obtained from these figures by a two-parameter fit to the logical fi- Figure 4: Comparison of the error rates of a logical qubit decoded by a neural network and a blossom decoder, for different values of the correlated error rate py. As py increases, at fixed px = pz = 0.048% and pm = 0.14%, the blossom decoder (blue) produces a larger error rate than the neural network decoder (red). Data points are obtained by fitting decay curves, as in Fig. 3.
where t 0 is a constant offset to account for the 'majority vote' behavior of the error correcting circuit at low cycle number [29], and any additional sample preparation and measurement error. We find = 0.209% for the neural network decoder, a substantial improvement over the value = 0.274% for the blossom decoder [30].
To demonstrate that the performance improvement is due to the capability of the neural network to detect error correlations, we show in Fig. 4 how the performance varies with varying p y (at fixed p x = p z = 0.048% and p m = 0.14%). When p y = 0, the σ x and σ z errors are independent and the blossom decoder performs near-optimally [29,31]. The neural network decoder then gives no improvement, but once p y ∼ p x the performance gain is evident.

Conclusion and outlook
In conclusion, we have designed and tested a recurrent neural network decoder that outperforms the standard minimum-weight perfect matching (MWPM, or "blossom") decoder in the presence of correlated bitflip and phase-flip errors. The building block of the network, a long short-term memory layer, allows the decoder to operate over the full duration of a quantum algorithm with multiple cycles. A key feature of our design, which sets it apart from independent proposals [18][19][20], is that the network can be trained solely on experimental data, without requiring a priori assumptions from theoretical modeling.
We believe that our neural network decoder provides a realistic option for utilization in forthcoming experimental QEC implementations [23]. In support Figure 5: Same as Fig. 3, but now for a density matrix simulation of an implementation of Surface-17 using superconducting transmon qubits [29].
of this, we have tested the performance in a real-world setting by using a density matrix simulator to model Surface-17 with state-of-the-art experimental parameters for superconducting transmon qubits [29]. In Fig. 5 we show the decay of the fidelity over 100 cycles for the neural network and blossom decoders, as well as an upper bound on the optimal fidelity. (The latter is extracted directly from the simulation data.) The decoder efficiency (1) of the neural network is η d = 0.81, a 26% improvement over the blossom decoder. This improvement was achieved after training on 4 · 10 6 datasets, which require roughly 60 s to generate on experimental hardware [23], making this approach immediately experimentally viable.
We mention three directions for future research. The first is the extension to other topological codes than the surface code, such as the color code. The neural network itself is agnostic to the type of topological code used, so this extension should be feasible without modifications of the design. Secondly, for low error rates it will be challenging to train a neural network decoder, because then the training dataset is unlikely to contain a sufficient representation of twoqubit errors. This can potentially be overcome by training on data with a higher error rate, but it remains to be seen whether a decoder trained this way will outperform MWPM decoding. Finally, the decoder needs to be scaled-up to surface codes that are deformed by lattice surgery [43] or braiding [4] for the execution of logical gates. For this extension the design of the decoder should be modified so that it is not tied to a single code distance.
neural networks by preventing co-adaptation of feature detectors, arXiv:1207.0580.

A Details of the neural network decoder A.1 Architecture
The decoder is composed of two networks. The first network maps a list of syndrome increments δ s(t) with t = 1, 2, ..., T to a probability p 1 ∈ [0, 1]. The second network maps a list with the last few syndrome increments t = T − T 0 + 1, T − T 0 + 2, ..., T , together with a single final syndrome increment δ f (T ) to a probability p 2 ∈ [0, 1]. The probabilistic sum p = p 1 (1 − p 2 ) + p 2 (1 − p 1 ) of these two outputs is the probability that the logical qubit has incurred a bit-flip error. The cost function we try to minimize is the cross-entropy between this probability and the true final parity of bit-flip errors (labels) plus a small weight regularization term.
We note that p is invariant under the transformation p 1 → 1 − p 1 and p 2 → 1 − p 2 . This ambiguity in the individual error probabilities is irrelevant for the joint operation of the networks. Moreover, it may be easily removed by testing the trained networks separately on a trivial example where all syndromes are zero and both probabilities should be < 1/2.
Both networks consist of two LSTM layers with internal states c i t , h i t ∈ R 64 and a fully connected evaluation layer with 64 rectified linear units. The inputs of the first layer are the syndrome increments. The inputs of the second layer are the outputs of the first layer h 1 t . For the first network, the input of the evaluation layer is the final output of the second LSTM layer, subject to a rectified linear activation function ReL( h 2 T ). For the second network, the input of the evaluation layer is ReL( h 2 T ) concatenated with the final syndrome increment δ f (T ).
The source code including all the network parameters is available [41].

A.2 Training and evaluation
The two networks are trained simultaneously on minibatches of size 64 from a training dataset containing 4 · 10 6 sequences of lengths between T = 11 and T = 20 cycles. At the end of each sequence, the training set contains the final syndrome increment and the final parity of bit-flip errors. One epoch consists of 10 4 mini-batches. The optimization is done using the Adam optimizer [44] with a learning rate of 10 −3 . For regularization we apply dropout [45] with a keep probability of 0.8 after each LSTM layer and after the evaluation layer. In addition, we apply weight decay with a prefactor of 10 −5 to the evaluation layer. After each epoch, the decoder is evaluated on a validation dataset, which consists of 10 4 sequences of lengths between T = 81 and T = 100 cycles. If the logical error rate on the validation dataset reaches a new minimum, the network is stored. The training continues until the logical error rate on the validation dataset has not improved for 100 epochs. We train three decoders and choose the instance that has the lowest logical error rate on the validation dataset.
To evaluate the chosen decoder, we use yet another dataset. This test dataset consists of 5 · 10 4 sequences of length T = 300 for the Pauli error channel model and T = 100 for the density matrix simulation. In contrast to the training and validation datasets, the test dataset contains a final syndrome increment and a final parity of bit-flip errors after each cycle. This cannot be achieved in a real experiment, but is extracted from the simulation to keep the calculation time manageable. We evaluate the decoder on the test dataset for t n = 2 + n n =1 n ≤ T cycles, chosen such that the resolution is high at small cycle numbers and lower at large cycle numbers. If the decoders output is p < 0.5, the final parity of bit-flip errors is predicted to be even and otherwise odd. We then compare this to the true final parity and average over the test dataset to obtain the logical fidelity. Using a two-parameter fit to Eq. (8) we obtain the logical error rate per cycle.

B Parity-bit error versus Pauli-frameupdate error
Ref. [18] described the error rate of the decoder in terms of its ability to apply the correct Pauli frame update. The error rate from Eq. (8) describes the correctness of the parity bit produced by the decoder, without explicitly referring to a Pauli frame update. Here we show that the two error rates are in fact the same.
We recall that a Pauli frame is a list of Pauli X, Y, or Z errors that have occurred to data qubits [2]. Two Pauli frames are equivalent if they are separated by stabilizer measurements, since these act as the identity on the error-free subspace.
We begin by choosing logical operators X L and Z L in terms of Pauli operators on the physical qubits. The choice is not unique because of a gauge freedom: SX L = X L on the logical subspace for any stabilizer operator S.
Consider a syndrome s(t) that contains only a single non-zero stabilizer measurement s i (t), corresponding to a stabilizer operator S i . There exist multiple Pauli frames P i that correct S i and which commute with our chosen logical operators. Ref. [18] considers a 'simple' decoder, which arbitrarily chooses one P i for each S i . Then, given a syndrome s(t) at time t with many non-zero s i , it generates a Pauli frame as P simple =