Main

Recent experimental breakthroughs bring the prospect of logical circuits with quantum error correction to the near future1,2,3. Quantum error correction codes protect logical information by encoding a logical qubit into multiple physical qubits and correcting when the logical information is corrupted. The error syndromes from sequential pairs of stabilizer measurements must be processed by a decoder to determine when a logical error occurs4,5,6,7. However, decoding is itself a challenging task for classical computers. For instance, calculating the most likely error (MLE) in general is a nondeterministic polynomial time (NP)-hard problem8,9 for the surface code10. While solving an NP-hard problem exactly is often infeasible, extensive research has focused on developing efficient approximate decoding strategies. Conventional approaches construct decoding graphs specific to assumed noise model priors and leverage the available efficient graph solvers11,12. However, correlated errors introduce hyperedges that are beyond the reach of matching-based graph solvers13,14 without noise model-driven decomposition15,16,17,18. Because errors inevitably propagate between logical qubits under entangling logical gates, the challenge of correlated errors becomes a key bottleneck issue for decoding logical circuit operations. Hence, an effective, noise-model-agnostic decoder for logical circuits—capable of addressing correlated errors—is critical for generating entangled, fault-tolerant states.

From a data-centric perspective, the objective of a decoder is to determine whether a given syndrome arises from a logical error (Fig. 1a). The challenge is that many physical error configurations manifest an identical syndrome. Conventional algorithmic approaches head-on face the underconstrained inverse problem by manually deriving a probabilistic model for the physical error configurations associated with a given syndrome, relying on the noise model. Driven by the need for noise-model-agnostic and scalable decoders, there have been efforts to develop machine learning (ML)-based decoders. ML decoders frame decoding as a classification problem, aiming directly at the binary prediction of logical error occurrence. By avoiding explicit reconstruction of physical errors, the ML decoder can be more scalable than conventional approaches. Most importantly, ML decoders learn noise from data. The benefits of this noise-model-agnostic approach are twofold. First, it frees ML-based decoders from assumptions embedded in specific noise models. As demonstrated by Varbanov et al.19, the ML-based memory decoder remains robust with increasing Y error rate, a regime where the minimum weight perfect matching (MWPM) performance clearly worsens. Second, it avoids degradation in decoding accuracy20 due to mismatches between the physical noise process \({\mathcal{N}}\) and the assumed prior noise model for the decoder \(\tilde{{\mathcal{N}}}\) (Fig. 1a). However, most ML-decoder efforts have been limited to decoding a single logical qubit, such as a quantum memory19,20,21,22,23,24 or a qubit under single-qubit logical operations3. Here, we develop a modular Multi-Core Circuit Decoder (MCCD) custom-designed from a data-centric perspective (Fig. 1b,c) and demonstrate its efficacy on data from random Clifford circuits simulated with a realistic noise level. We find that MCCD successfully learns to decode correlated errors from a general circuit, demonstrating favorable linear scaling of wall time with circuit depth. Descriptions of the MCCD architecture (Fig. 2), training procedures and numerical details are presented in Methods.

Fig. 1: Decoding logical circuits.
figure 1

a, Decoding can be framed as a binary classification task. On a physical level, the device noise \({\mathcal{N}}\) causes physical errors, and we detect them by measuring stabilizers, which give rise to error syndromes. Each error syndrome (blue squares for violated Z stabilizers) can result from two classes of X errors: class ‘0’ errors preserve the logical Z, while class ‘1’ errors flip it. Conventional algorithmic decoders infer physical errors from syndromes using the error probability \({p}_{\tilde{{\mathcal{N}}}}\) under a prior noise model \(\tilde{{\mathcal{N}}}\). By contrast, a pretrained ML decoder directly classifies the syndrome as logical 0 or 1. b, A sketch of the logical circuit that prepares a logical Bell pair. H and I correspond to the Hadamard and identity logical operations, respectively. Both logical qubits are initialized in \({\left\vert 0\right\rangle }_{L}\) state in logical Z basis. The black squares represent quantum error correction (QEC) rounds where stabilizers are measured. Syndromes are constructed from neighboring stabilizer measurements. \({S}_{t}^{(i)}\) refers to the syndromes of logical qubit i at the tth QEC cycle. c, An ML decoder takes sequences of syndromes from different logical qubits and predicts whether a logical error happened for each logical qubit, denoted as \({\mathbf{y}}_{z}^{(i)}\) for logical qubit i. Our ML-based decoder is composed of a decoding module network that parallels the corresponding logical circuits. Prob, probability. d, Entangling logical operations propagates physical error from one logical qubit to the other. As marked by the red lines, a physical X error on the control logical qubit (top) can propagate through a logical CNOT gate to the target logical qubit (bottom). The syndromes of control and target qubit are correlated, and both reflect the original physical X error in the control qubit.

Full size image
Fig. 2: ML architecture.
figure 2

a, For each element in the gate set, we train a separate decoder module. There is a one-to-one mapping between the logical gates (left box) to the ML decoder module (right box). b, Single-qubit decoder module inner structure based on an LSTM core. The hidden state Ht−1 = ct−1, ht−1 (we omit superscript (q)), has two components ct−1 and ht−1, which are designed to keep track of long-term and short-term history correspondingly. Together with the new syndrome St, Ht−1 follows the internal information flow as shown in the box and outputs the updated hidden state Ht. The red-boxed operations represent a linear layer followed by corresponding activation functions (sigmoid σ and \(\tanh\)). The blue circled operations represent element-wise addition (+), multiplication (×) and \(\tanh\). c, To handle correlated decoding, we use a module that input the hidden states \({H}_{t-1}^{(C)},{H}_{t-1}^{(T)}\) and new syndromes \({S}_{t}^{(C)},{S}_{t}^{(T)}\) from both control (C) and target (T) logical qubits. The hidden states are updated simultaneously.

Full size image

Results

We first train and test MCCD on simulated data from Circuit Type I with only single-qubit gates (Fig. 3a,b). Although training was limited to the circuits of depths up to D = 10, neither the logical accuracy (Fig. 4a,b) nor the wall time (Fig. 4c,d) show any sign of deterioration upon crossing the training depth limit of D = 10. This indicates that MCCD is indeed capable of decoding circuits much deeper than those used for training. Comparison of MCCD performances between code distances d = 3 (Fig. 4a) and d = 5 (Fig. 4b), the improved accuracy of MCCD upon increasing the code distance is consistent with the expected behavior when the noise level, motivated by the experiments2, is below the MCCD’s decoding threshold. Most remarkably, MCCD maintains lower wall time than other decoders as the code distance or circuit depth increases (Fig. 4c,d).

Fig. 3: Mirror-symmetric random circuits.
figure 3

a, A mirror symmetric circuit can be generated for an arbitrary circuit U by concatenating a reversed circuit U† after the forward evolution U. The tilde in \(\tilde{U}\) highlights the existence of noise. In the noiseless limit, the mirror symmetry circuit UU† applied on some initial state \(\left\vert \psi \right\rangle\) should keep the state untouched. Due to the noise, \(\tilde{U}{\tilde{U}}^{\dagger }\left\vert \psi \right\rangle =\left\vert \tilde{\psi }\right\rangle \approx \left\vert \psi \right\rangle\). b, An example of \(\tilde{U}\) sampled from Circuit Type I. c, An example of \(\tilde{U}\) sampled from Circuit Type II.

Full size image
Fig. 4: Decoding performance on Circuit Type I.
figure 4

a,b, Logical accuracy versus circuit depth using surface code with code distance d = 3 (a) and d = 5 (b) for MCCD (red), MLE (orange), BP-OSD (green) and MWPM (blue) decoders. c,d, Wall time taken to decode one syndrome trajectory in log scale with increasing circuit depth for a d = 3 (c) and d = 5 (d) surface code. We evaluate each decoder over 20 independent runs. In each run, we randomly sample 1,000 syndrome trajectories from Type I circuits and average them to obtain a run-level performance estimate. We report the mean across the 20 runs, with error bars showing s.e.m.

Source data

Full size image

When comparing the logical accuracies of the reference decoders for the two code distances d = 3 and d = 5, clearly the noise level of the data is below the error threshold for all the decoders under consideration. Because MLE considers all possible error patterns, it achieves higher accuracy, especially at deeper circuits (Fig. 4a,b). However, this accuracy is achieved at the cost of exponentially increasing wall time (Fig. 4c,d). Meanwhile, while MWPM runs at high speed (Fig. 4c,d), it shows notably lower accuracy compared with MCCD (Fig. 4a,b). Belief propagation with ordered statistics post-processing (BP-OSD) offers better accuracy than MWPM, but its wall time increases sharply with circuit depth for code distance d = 5. In comparison, MCCD shows competitive accuracy with a linear-in-depth wall time scaling.

Inclusion of entangling logical gates, which drastically increases correlated errors, can deteriorate performance and lower the decoding threshold to varying extents for different decoders. Here, we demonstrate that MCCD’s performance remains robust even after the inclusion of entangling logical gates. Building on the above encouraging results on the data from Type I circuits, we follow a curriculum learning approach25 to train an extra module for the logical CNOT gate while keeping single-qubit gate decoder modules and the readout network fixed. To generate diverse training data that include two-qubit logical gates, we sample mirror-symmetric logical circuits sampled from Circuit Type II (Fig. 3a,c). As shown through the improvements in the logical accuracy upon increasing the code distance in Fig. 5a,b, MCCD’s decoding threshold for Type II circuits, which requires correlated decoding, is still above the realistic noise level of our simulated data. Furthermore, our exploration of different noise models showed that MCCD works robustly across different noise models and learns nuanced features of the noise model from data (see Supplementary Section E1 for more details). This extended study used independent training of multiple MCCDs using training data simulated with three different noise models and validation using syndrome data generated with an experimentally motivated noise model. Most importantly, the MCCD’s wall time remains practically linear as a function of circuit depth, even with the correlated errors due to the entangling gates.

Fig. 5: Decoding performance on Circuit Type II.
figure 5

a,b, Logical accuracy versus circuit depth using surface code with code distance d = 3 (a) and d = 5 (b) for MCCD (red), MLE (orange) and BP-OSD (green) decoders. c,d, Wall time taken to decode one syndrome trajectory in log scale with increasing circuit depth for a d = 3 (c) and d = 5 (d) surface code. The inset in d shows a zoomed-in view of computing time for the ML decoder in a linear scale. We evaluate each decoder over 20 independent runs. In each run, we randomly sample 1,000 syndrome trajectories from Type II circuits and average them to obtain a run-level performance estimate. We report the mean across the 20 runs, with error bars showing s.e.m.

Source data

Full size image

By contrast, the MWPM, which is comparable to our MCCD in terms of speed for Circuit Type I, is incapable of handling correlated errors in the Circuit Type II data. Hence, we limit the comparison in Fig. 5 to MLE14 and BP-OSD26,27. Unsurprisingly, MLE shows higher accuracy. However, once again, the exponential cost of MLE14 is prohibitively high. While BP-OSD is faster than MLE at low circuit depth, its wall time rapidly increases with circuit depth at code distance d = 5. Hence, MCCD with linear complexity O(D) for the logical circuit of depth D clearly outperforms the conventional decoders in running time, especially in the large depth region.

Note

Toward the conclusion of this work, we became aware of a recent study3 that used a similar approach to train a neural network decoder for the color code, demonstrating its effectiveness on single-qubit Clifford logical circuits. Recent works that appeared after the initial submission of this work extended matching-based approaches for logical circuit decoding28,29. Our benchmarking study shown in Supplementary Section II finds that MCCD achieves higher decoding accuracy than the LoMatching algorithm introduced by Serra-Peralta et al.29. As in the comparison between MCCD and MWPM for Type I circuits, the matching approach offers greater speed at the cost of reduced accuracy. Incorporating Pauli product decoding by modifying MCCD to reduce its computational load represents a promising direction for future work.

Discussion

In summary, we introduced the pretrainable and modular MCCD along with an efficient training scheme, presenting a ML-based decoder that effectively addresses the challenge of decoding logical quantum circuits with correlated errors. Utilizing a data-centric ML approach with dedicated processing cells (PCs) for each gate type, our decoder effectively captures error propagation through both single-qubit and entangling logical operations. The MCCD’s performance demonstrates three key advantages: (1) noise-model agnosticism that allows application to various quantum hardware platforms without detailed knowledge of underlying noise characteristics, (2) high decoding accuracy competitive with conventional decoders and (3) remarkable practical run time efficiency and promising complexity scaling with circuit depth. This linear scaling behavior with a small prefactor makes MCCD particularly suitable for real-time decoding in practical quantum computing environments with deep logical circuits. Furthermore, our modular design enables straightforward extension to new gate sets or improved physical implementations of existing gates as quantum hardware evolves. The combination of accuracy, speed and adaptability positions MCCD as a promising approach for facilitating the path toward fault-tolerant quantum computation.

Interesting directions of future work include the extension of MCCD to include mid-circuit measurement and feedforward operations30, as well as scaling to larger code distances. While we focused on the transversal implementation of logical Clifford gate6,31,32 in this work, the inherent flexibility of MCCD allows for extending the set of logical operations. Such extension will open doors to teleportation-based implementation of non-Clifford logical gates33,34,35 and lattice surgery implementation of entangling gates36,37.

While current experimental demonstrations of error-corrected logical circuits are limited to relatively small code distances2—making MCCD immediately useful—scaling up the code distance will be necessary for real-time decoding of fault-tolerant deep logical circuits. While the results presented in this work already show that MCCD scales favorably with circuit depth, scaling up the code distance will address three potential challenges. First is the practical challenge of needing a large volume of randomized logical circuit simulation data. Leveraging graphics processing unit-accelerated Clifford simulation and parallelization will be helpful (Supplementary Section III and Supplementary Fig. 5). The second challenge is working with the larger dimension of syndrome data for a larger code. Strategies developed by the ML community for increasing the syntax window for large language models could be productive, as the syndrome sequence is a time sequence. Improving the design of each core by utilizing a more effective scaling attention mechanism and incorporating physical knowledge to sparsify attention could be promising. The third challenge is training with increasingly rare events, as logical error rates decrease with increasing code distance. Again, we can leverage the extensive research on training with imbalanced data in the ML community. Transfer learning by initializing training on a small code distance with a larger logical error rate and oversampling rare or ambiguous cases could be a promising strategy. Furthermore, strategic adoption of progress in language models can enable expansion of the syndrome time window of MCCD to capture longer time-scale temporal correlations.

Methods

At a high level, the syndrome data consist of time sequences, each associated with a logical qubit from quantum error correction rounds. Accumulation of physical noise in each individual code block introduces intrasequence time correlations. Without gate operations, each time sequence will be independently time-translation invariant. This structure motivates the usage of a recurrent structure with a hidden state for each logical qubit to capture temporal correlations. Indeed, a recurrent neural network38 with a single recurrent cell was proposed for decoding quantum memory22. Our goal of developing a versatile logical circuit decoder introduces three new challenges: (1) time-translation invariance is broken with gate operations, (2) entangling gates introduce intersequence correlations (Fig. 1d) and (3) the decoder should be able to handle any circuits built with a fixed gate set. The MCCD tackles all three challenges in one swoop by using multiple PCs, one dedicated PC for each logical gate in the gate set (Fig. 2a). The MCCD handles single-qubit logical gates and entangling logical gates on equal footing by simply feeding syndrome data into the corresponding recurrent cell as the data are collected. The only assumption the MCCD makes is the existence of a native logical gate set for a given quantum hardware, which is a universal assumption for digital quantum computers.

Specifically, the MCCD uses one time-dependent hidden state \({H}_{t}^{(q)}\) per logical qubit q to capture its error history and multiple PCs, one for each gate, to build a modularized decoder. The hidden states serve as a memory to keep track of the error history. The PCs and the readout network are trained for a fixed gate set. To decode deep logical circuits, we design each PC based on the recurrent cell of long short-term memory39, which avoids the vanishing gradient problem of standard recurrent neural networks when processing long sequences. This choice is inspired by the successful memory decoding of up to hundreds of quantum error correction rounds using a long short-term memory architecture for a surface code22. Hence each hidden state Ht−1 = (ct−1, ht−1) has two components, ct−1 and ht−1, which track long-term and short-term history, correspondingly.

Before the logical circuit starts to run, we initialize the hidden states \({H}_{0}^{(q)}\) to all zeros for each logical qubit q. When each logical gate is applied at time t and a new round of syndrome St is extracted, we feed the hidden state Ht−1 and the syndrome data St to the gate-specific PC for the cell to output an updated hidden state Ht. The PC for an entangling logical gate must capture the physical process of error propagation through the entangling operation. For this, this PC is designed to take hidden states and syndromes from both logical qubits (for example, the control and target qubits in the case of CNOT gates in Fig. 2c) as inputs and update the two hidden states simultaneously (Fig. 2c). The hidden states provide error history information, while the new syndromes introduce information regarding new physical errors, both of which are necessary for correlated decoding. Finally, a trainable readout network maps the final hidden state to the logical error prediction output \({\mathbf{y}}_{Z}^{(q)}\). To improve performance, we provide the readout network with the final round syndrome measurement constructed from the data-qubit measurement in addition to the hidden state (only half of the stabilizers can be constructed depending on the measurement basis of the data qubits).

For MCCD to be effective, the training must be driven by a physically meaningful loss function and diverse training data that avoid overfitting. We use a training scheme inspired by logical randomized benchmarking40, as random circuits can prevent MCCD from learning subtle fingerprints of specific circuits used in training. We overcome the difficulty of defining a universal loss function while using random circuits by using mirror-symmetric circuits that evolve a state forward by a random unitary U composed of logical gates in the gate set and then backward by U†, as shown in Fig. 3a. As noiseless implementation of U and U† should keep the initial state unchanged, the differences between the final logical measurements and the initial logical preparation offer ground-truth training labels. Therefore, we use the cross-entropy between the model outputs and training labels in these mirror-symmetric circuits as the loss function to guide the training of the MCCD. To ensure diversity in the training data, we opt for a hardware-efficient implementation of random unitaries. Finally, to ensure that MCCD’s training generalizes to new circuits, we train MCCD with data from logical circuit depth D = 2, 4, 6, 8 and 10 (D = 4, 8, 12, 16 and 20) and test the model on a wide range of unseen circuits with depth up to D = 18 (D = 36) for Circuit Type I (Circuit Type II), defined below.

We demonstrate the efficacy and versatility of MCCD by testing MCCD on two types of mirror-symmetric random logical circuit:

  • Circuit Type I: single-qubit-only logical circuits on each logical qubit. We sample a sequence of random single-qubit gates from the gate set {I, X, Y, Z, H}, followed by the sequence in the reverse order (Fig. 3b).

  • Circuit Type II: random scrambling logical circuit, consists of interlacing layers of single- and two-qubit gates. Each single-qubit gate layer contains randomly sampled gates from the gate set {I, X, Y, Z, H}. Each two-qubit gate layer consists of CNOT gates entangling random pairs of logical qubits; each logical qubit is acted on by only one CNOT. Again, the mirror symmetry is enforced by running the gate sequences in reverse order (Fig. 3c).

We generated the training data using the stim package41 to simulate the logical circuits based on surface code with the circuit-level noise model motivated by the experimental noise in neutral-atom platforms2,14. See the ‘Data generation’ subsection for the details of the simulation and the circuit-level noise model. Dividing our study into the above two circuit types achieves two goals. First, it allows us to benchmark against conventional methods on the easier task of decoding circuits (Type I) without correlated error. Second, it allows us to use a resource-efficient curriculum training strategy25. Specifically, the initial phase of training uses Type I circuits, allowing training on data that are cheaper to generate. The resulting modules then serve as initialization for more complicated Type II circuits, focusing training effort on capturing correlated error structures induced by entangling logical gates, which are not present in Type I circuits, while optimizing for lower overall data generation costs.

A meritorious decoder must optimize between two competing needs: accuracy and speed. While a high accuracy is desired, when a decoder’s speed lags behind the clock cycle of the quantum computer, it will add a crippling burden. Hence, we benchmark the performance of MCCD from two perspectives—logical accuracy and wall time—against three established conventional decoders. Specifically, we consider three popular algorithmic decoders: MWPM12,42, MLE14 and BP-OSD26,27. We compare the decoder performances in decoding logical circuits built using surface code-based logical qubits with two different code distances d = 3 and 5 and transversal logical Clifford gates, including {I, X, Y, Z, H, CNOT}. See the ‘Logical gate implementations’ subsection for details about how the transversal logical operations are implemented on a physical level. We note that, in the following numerical demonstrations of algorithmic decoders, we consider an optimal decoder prior that exactly matches the noise model used in logical circuit simulations, that is, \(\tilde{{\mathcal{N}}}={\mathcal{N}}\). Therefore, the performances of conventional decoders represent an upper bound of what one can get in practice, as full knowledge of the physical noise model is inaccessible in a realistic setup.

Architecture

Our modular ML-based decoder consists of three types of module: (1) decoder modules for single-qubit logical operations, (2) a decoder module for the entangling logical operation and (3) a readout module in the logical Z basis. We consider measurements in the Z logical basis to demonstrate the efficacy of our modular ML-based decoder. However, one can handle the X basis logical measurements by either replacing the X logical measurement with an \(\bar{H}\) followed by a logical Z measurement using our pretrained decoder modules, or train an extra readout network for X logical measurements. In the following, we discuss the architecture of the three types of module.

Decoder modules for single-qubit logical operations

To effectively learn how to decode logical circuits, we observe that different logical operations transform error history differently and potentially introduce various types of physical error depending on the physical implementation of the logical gate. Therefore, we need to train a separate decoder module for each distinct logical operation. We utilize different recurrent modules to process the hidden state of a surface code at a specific time point, according to the gate operation at that time point. Therefore, the number of single-qubit LSTM modules needed is equal to the number of different single-qubit gates in the circuit. Each single-qubit LSTM module takes the hidden state from the previous time step and outputs the hidden state for the next time step.

We use an LSTM cell with two layers in the single-qubit decoder modules. Mathematically, each layer in the LSTM module processes the hidden state at time step t in the following way:

$$\begin{array}{rcl}{i}_{t}&=&\sigma ({W}_{ii}{x}_{t}+{b}_{ii}+{W}_{hi}{h}_{i-1}+{b}_{hi})\\ {f}_{t}&=&\sigma ({W}_{if}{x}_{t}+{b}_{if}+{W}_{hf}{h}_{i-1}+{b}_{hf})\\ {g}_{t}&=&\tanh ({W}_{ig}{x}_{t}+{b}_{ig}+{W}_{hg}{h}_{i-1}+{b}_{hg})\\ {o}_{t}&=&\sigma ({W}_{io}{x}_{t}+{b}_{io}+{W}_{h}{h}_{i-1}+{b}_{ho})\\ {c}_{t}&=&{f}_{t}\odot {c}_{t-1}+{i}_{t}\odot {g}_{t}\\ {h}_{t}&=&{o}_{t}\odot \tanh ({c}_{t})\end{array}$$
(1)

In the context of our logical circuit decoder, xt is the new syndrome obtained at the current time step; ct−1 and ht−1 together, Ht−1 = (ct−1, ht−1), is the hidden state of the logical qubit in the previous time step t − 1. The output of the module is an updated hidden state Ht = (ct, ht).

Unlike regular recurrent neural networks, LSTMs introduce a memory cell (ct) that allows information to be stored over long sequences. Three gates control the memory cell: forget gate, input gate and output gate, which decide what information should be removed from the memory cell, added to the memory and passed to the next step, respectively.

The input to the model contains three parts: ht, the hidden state (short-term memory) at time step t; xt, the input at time step t, corresponding to the syndrome measurement in our decoding problem; and ct, the cell state (long-term memory) for the recurrent neural network core. The weight (W) and bias (b) matrices for each gate are multiplied by xt and ht to control how the next step is updated. The output from the LSTM module contains two parts: an updated hidden state for the next time step ht+1 and an updated cell state ct+1. We use only the hidden state from the output of the previous module as the input hidden state for the next module. Because we use different single-qubit LSTM modules for each time step, depending on the single-qubit gate, the recurrent structure differs from the traditional recurrent LSTM core.

Two-qubit LSTM module

To model the entanglement through a two-qubit gate between two previously noncorrelated surface codes, we introduce the two-qubit LSTM module from the onset of entanglement.

The input of the two-qubit LSTM module is the concatenated hidden state from the two separate codes. Because the physical gate operation on the qubits is not symmetrical, we need to keep the order of concatenation consistent with the order of the gate operation. For the sake of simplicity, we always put the hidden state with the control qubit in the first place. As we are using the same architecture for the two-qubit operation, the two-qubit hidden state is transformed similarly to the single-qubit hidden state. The difference is that the dimension of the hidden state is twice as large. From the output of the two-qubit LSTM module, we split the final hidden state into two in the hidden dimension; we then take the first one as the updated hidden state for the surface code containing the control qubit and the other half as the updated hidden state for the surface code with the target qubit.

Auxiliary readout

The auxiliary readout module aims to output the probability of error for a logical qubit. It consists of two linear layers connected by ReLU activation between them. Because we are dealing with multiple logical qubits, we process the single logical qubit hidden state first and concatenate after the readout module. We use the same linear layers for different types of logical qubit, but process them accordingly before the readout.

Main readout

Similar to the auxiliary readout module, the main readout also serves as a classification module, outputting the error probability of the current logical qubit. The difference lies in the input. The syndrome measurement from the final round, which contains only half of the stabilizers constructed from the final data qubit measurements, is concatenated to the hidden state representation before being fed into the main readout.

Loss function

The total loss of our decoder is a weighted sum of the cross-entropy losses of the main and auxiliary readout modules. We choose to weight the auxiliary loss by a factor of 0.5 (ref. 19).

MCCD training

Training pipeline

There are two intertwined tasks in the error correction for the correlated surface code problem: gate-dependent error correction for single qubits and correlated error correction for two qubits for the CNOT gate. We observe that separating the two tasks and training the model sequentially on the two types of module makes the learning process easier, leading to promising results. Therefore, we use a two-stage training strategy, where we first train the single-qubit-related modules in Circuit Type I and then train the two-qubit LSTM core exclusively in Circuit Type II. In the first stage of training, we optimize parameters in all the single-qubit-related modules. These include all recurrent LSTM modules for single-qubit operations, the main readout and the auxiliary readout. After the single-qubit modules are thoroughly trained, we introduce the two-qubit module into the architecture and freeze everything else except the two-qubit PC, which takes the hidden states of the two entangled logical qubits.

Training hyperparameters

The detailed hyperparameters used in the network for training an MCCD for code distances d = 3 and d = 5 are listed in Supplementary Tables 1 and 2, respectively. The hyperparameters used in training are listed in Supplementary Table 3. Please also see the published code (https://github.com/KimGroup/MCCD.git).

Data generation

The surface code

We consider a rotated surface code. An illustration of the code layout is shown in Supplementary Fig. 1.

Logical gate implementations

We focus on Clifford logical gates with transversal implementations in this work. For clarity, in this section only, we denote logical operations with an overbar, \(\bar{U}\) and physical operations without an overbar U.

For single-qubit logical operations, we consider \(\bar{U}\in \{\bar{I},\bar{X},\bar{Y},\bar{Z},\bar{H}\}\). Each single-qubit logical gate \(\bar{U}\) corresponds to a depth-1 physical circuit where each physical qubit is acted on by physical gate U. The Hadamard gate \(\bar{H}\) swaps the \(\bar{Z}\) and \(\bar{X}\) basis, which requires rotating the surface code after applying H on all physical qubits. This rotation can be done ‘virtually’ by keeping track of the rotation on classical software, so that it can be done effectively and noiselessly on the quantum hardware.

For the two-qubit gate, we consider the CNOT gate, also implemented as a transversal operation. Physically, the two surface codes are moved to adjacency and physical CNOT gates are applied pairwise on the physical qubits between the control and target logical qubits.

Stabilizer measurement physical circuits

The stabilizer measurement circuit couples data qubits with the ancilla qubits. Measuring the ancilla qubits gives us the stabilizer measurement records, which are further processed to obtain syndromes and input into our ML decoder model. This circuit, as illustrated in Supplementary Fig. 2, is applied after each logical gate operation.

Experimentally motivated noise model

For the numerical studies presented in the ‘Results’ section, we use the stim package for simulation. We consider a circuit-level noise model motivated by the current experimental capability of neutral atom array-based quantum computers. Specifically, we use a circuit-level noise model that includes the following physical noises:

  • Each two-qubit physical gate is followed by a two-qubit Pauli noise channel with probability [0.0005, 0.00175, 0.000625, 0.0005, 0, 0, 0, 0.00175, 0, 0, 0, 0.000625, 0, 0, 0.00125]

  • Each single-qubit physical gate is followed by a single-qubit depolarizing model with probability [0.0001, 0.0001, 0.0001]

  • On a physical level, the atoms are moved to achieve flexible connectivity between different physical qubits. This comes at the cost of having idling error due to the extra time taken during the physical qubit movement, which is captured as a Pauli noise channel with probability [4 × 10−7, 4 × 10−7, 1.6 × 10−6]. This error channel is applied when physical qubit movement happens.

  • Resetting a physical qubit has a bit flip error probability of P = 0.002.

  • Measuring a physical qubit has a bit flip error probability of P = 0.002.

Other decoders

We benchmark MCCD against three popular decoders: MLE, BP-OSD and MWPM. Here, we specify the numerical details of these methods.

MWPM

We use the open-source library PyMatching42 with the noise model used for data generation as detailed in the ‘Experimentally motivated noise model’ subsection.

BP-OSD

We use the open-source library stimbposd43. We use the exact noise model used for data generation and set the maximal belief propagation iterations to 20.

MLE

We use the algorithm developed and implemented as in ref. 14.