Pith. sign in

REVIEW 4 major objections 5 minor 54 references

A recurrent-transformer decoder can be trained to emit one local correction bit per sliding window, so many windows decode in parallel and XOR into a global logical correction for arbitrarily long memory experiments.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

A transformer-based decoder trained on local window labels learns to output per-window logical corrections that can be XORed across sliding windows, enabling parallel decoding with accuracy slightly above belief matching at distances 3 to 7.

T0 review reviewed 2026-08-05 challenge →

load-bearing objection Genuine advance: first no-merge parallel sliding-window AlphaQubit-style decoder, with accuracy competitive on d=3–7; but throughput and 'arbitrarily long memory' claims outrun the evidence. the 4 major comments →

arxiv 2509.03815 v1 pith:Q5IIMRZI submitted 2025-09-04 quant-ph

Learning Neural Decoding with Parallelism and Self-Coordination for Quantum Error Correction

Kai Zhang , Situ Wang , Linghang Kong , Fang Zhang , Zhengfeng Ji , Jianxin Chen This is my paper
classification quant-ph PACS 03.67.Pp
keywords quantum error correctionsurface codeneural decodersliding-window decodingrecurrent transformerparallel decodinglogical error rate per roundself-coordination
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper takes aim at the throughput wall that keeps high-accuracy neural decoders from keeping up with a superconducting qubit's roughly one-microsecond syndrome rounds. The proposed fix is to train a recurrent-transformer decoder, similar to AlphaQubit in design, to emit a single logical-correction bit per overlapping sliding window, with training labels computed from the physical errors inside each window's core region. Because the core regions partition the decoding graph, the per-window bits XOR to the true global correction whenever every window predicts its own bit correctly; the paper's additional claim is that joint training makes neighboring windows 'self-coordinate,' so the occasional individual mistakes cancel in the XOR. Measured logical error rates per round are 0.005152 (d=3), 0.001290 (d=5), and 0.000437 (d=7), slightly better than Belief-Matching at d=3 and d=5. If the scheme holds, AlphaQubit-level accuracy becomes compatible with constant-latency, arbitrarily parallel decoding of long memory experiments.

Core claim

The central claim is that a neural decoder modeled on AlphaQubit can be trained to output one bit per sliding window whose label is the parity of the actual physical errors in the window's core that intersect a chosen logical operator, yi = |E∩E_i^c∩L| mod 2. Since the core regions partition the decoding graph, XORing the per-window bits reproduces the global logical correction if each window's prediction is right. The authors train with this local-labeling scheme on start, bulk, and final windows simultaneously, padding the first and last with zeros to align their semantics, and use a multi-layer recurrent schedule that reads out the core label at every truncation length. They report that t

What carries the argument

The load-bearing mathematical object is the partition identity XOR_i y_i = |E∩L| mod 2, where y_i is the parity of physical errors in window i's core region that intersect a fixed logical-operator representative L. Each training label y_i is a local bit, not a global correction, and the network's one-bit output per window is meant to estimate it; at inference, window bits are simply XORed together. The architecture is AlphaQubit's recurrent transformer (convolutional stabilizer embedder with positional encoding, three syndrome-transformer layers combining self-attention and dilated convolutions, and a readout that pools the final decoder state perpendicular to the logical operator), modified

Load-bearing premise

The load-bearing premise is that adjacent windows, trained jointly but with no mechanism enforcing it, will handle seam syndromes consistently enough that XORing their output bits is correct; the paper's formal no-merge proof assumes a uniqueness property (Assumption 1) that neural-network outputs do not satisfy, and the failure of independently trained windows shows this consistency is learned, not guaranteed.

What would settle it

Decode a long memory experiment at fixed d and p with the proposed scheme and record, after XORing all window bits, the residual syndrome at every seam between windows; then repeat with 10x and 100x more rounds. If seam residuals appear with probability that grows with the number of windows, or if the logical error rate per round drifts upward rather than staying flat, the no-merge self-coordination claim fails. A more direct small-code test: compare the XOR of window predictions against an exact maximum-likelihood decoder's global correction; if the disagreement rate scales with the number of

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • AlphaQubit-type neural decoders can be embedded in the parallel sliding-window scheme, turning a decoder whose latency grows linearly with syndrome rounds into one with asymptotically constant feedback latency.
  • At effective physical error rates matching the Pauli+ noise level (roughly 0.34-0.38%), the decoder's logical error rate per round is 0.005152 at d=3, 0.001290 at d=5, and 0.000437 at d=7, slightly below Belief-Matching at d=3 and d=5, and the fault-tolerant threshold rises from about 0.6% (MWPM) to about 0.7%.
  • The same local-label-plus-XOR recipe should transfer to other modular decoding graphs, including lattice-surgery windows, because it needs only a partition of the decoding graph into core regions and a simulator that can supply ground-truth local errors.
  • Training sample requirements grow exponentially with code distance and with decreasing physical error rate, so scaling beyond d=7 toward d=25 will require better sample efficiency or architecture improvements, not only more compute.
  • End-to-end fine-tuning on experimental hardware data is not supported by the current method, since intermediate-round ground-truth labels exist only in simulation; deployment would require a calibrated circuit-level noise model first.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The paper demonstrates self-coordination only indirectly, through the gap between per-window error rates and the global logical error rate. A direct check would be to expose the seam syndromes: if residual seam flips occur with probability that grows with the number of windows, the constant-LER-per-round claim would fail on very long runs.
  • The local labels depend on a choice of logical representative L. Training the same architecture on multiple representatives, or on a distribution of representatives, could reduce the 1.4-2.6% per-window disagreement rates and make the XOR cancellation more robust.
  • The same 'supervise with local parity labels, then XOR' idea might extend to soft-input or leakage-aware neural decoders and to other code families, provided a simulator can produce local ground-truth errors; the paper's boundary-padding trick suggests the window types need not be learned separately.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The manuscript proposes a neural decoder for surface-code memory experiments that is compatible with parallel sliding-window decoding. The model is a recurrent transformer similar to AlphaQubit, trained to output one logical correction bit per window. Training labels are derived from the overlap of the simulated error set with the window core and a logical operator (Eq. 1), and window predictions are combined by XOR (Eq. 2). The paper claims that this 'self-coordination' avoids the merge step used in conventional sliding-window decoders, and reports logical error rates per round of 0.005152 (d=3), 0.001290 (d=5), and 0.000437 (d=7), slightly below Belief-Matching, with LER per round approximately constant in Fig. 10. Ablations show that a shared model trained on all window types outperforms separately trained window models.

Significance. If the claims hold, this is a useful practical contribution: it offers a route to parallelize AlphaQubit-type neural decoders and keep feedback latency constant, addressing a recognized bottleneck. The paper's strengths include the boundary-padding design, the multi-layer recurrent training strategy, the ablation validating joint training across window types (SepWindow), and the threshold improvement over MWPM. However, the central throughput claim is not directly benchmarked, and the no-merge correctness for a neural decoder rests on correlated window behavior that is only indirectly evidenced. The work is a promising proof of principle, but it does not yet substantiate the systems-level claim in its present form.

major comments (4)
  1. [§6.4, Fig. 10, Eq. (9)] The central scalability claim of a constant logical-error-rate-per-round for arbitrarily long memory is not established. The plotted LER is only for fidelity F > 0.1, which restricts N to roughly 160 (d=3), 500 (d=5), and 1400 (d=7); no confidence intervals or shot counts are given. Eq. (9) assumes a constant per-round error rate, but the data are equally consistent with a slow growth of ε at larger N. Because the XOR combination fails whenever an odd number of windows err, rare long-range correlated failures are precisely what must be bounded. Please report statistical uncertainties, provide longer-N measurements or a quantitative stationarity test, and state the number of independent shots.
  2. [§2.1, §2.2, §7] The headline claim of resolving the throughput limitation of AlphaQubit is never benchmarked. There is no wall-clock inference latency, no throughput measurement, no comparison with the 1 µs syndrome-generation rate, and no scaling of per-window inference cost with code distance. Figure 2 is schematic. If the throughput contribution is to be load-bearing, the paper needs a benchmark of the actual parallel pipeline: per-window inference time, number of parallel decoding units, end-to-end latency as a function of the number of syndrome rounds, and comparison with serial AlphaQubit inference. Otherwise the abstract and Section 7 overstate the result.
  3. [Appendix A, Assumption 1; §2.2] The no-merge proof (Theorem 1 and Conjecture 1) relies on Assumption 1, which is stated for and justified by MWPM with tie-breaking. A neural network that emits only a single bit per window and no local correction set does not satisfy this assumption. Nothing in the architecture or the per-window BCE loss (Eq. 6) enforces consistency of seam handling across adjacent windows. Table 3 shows correlated errors in a minimal 3-window experiment, which is encouraging, but it is not a direct test of the seam consistency needed for many concatenated windows. Please either enforce consistency explicitly, measure seam-inconsistency rates as a function of buffer size and distance, or provide a theoretical argument adapted to the network's output structure.
  4. [§5.1, Eq. (1)] The training labels y_i are defined from a particular simulated error set E. Because of degeneracy, many different E are consistent with the same detector syndrome and the same global logical correction, and these can produce different per-window labels. The network is trained against one arbitrary decomposition, and the paper argues that self-coordination resolves the resulting label ambiguity. However, the magnitude of the ambiguity and its effect on global accuracy is not quantified. Please report the distribution of label vectors (y_1,...,y_m) over consistent error configurations for fixed syndromes, and confirm that the trained predictor's errors are correlated in the way assumed by the XOR scheme.
minor comments (5)
  1. [§3, §4.2.2] The buffer size b and core size c are used before they are defined; define them explicitly in Section 3 (they are later set to b = c = d in §6.1.2).
  2. [Appendix A.4] The probability bound contains apparent typos: 'ˆpn = exp(n/4·wmin)' should include the physical error rate p, and the sentence 'The total probability of those candidates are thus lower bounded' should read 'upper bounded' for a probability. This makes the proof sketch harder to check.
  3. [Table 3] The quantities p1, p2, p3 are window-level misprediction rates, not logical error rates in the usual sense. Consider renaming them to avoid confusion with the global logical error rate p_g.
  4. [Fig. 10] The x-axis label 'Syndrome Measurement Round' should be plural ('Rounds'), and the fidelity cutoff F > 0.1 should be stated in the caption for all panels.
  5. [General] No code or data repository is referenced. Given the training costs reported (up to 2000 GPU hours for d=7) and the dependence on Stim-generated datasets, a public release of the training pipeline and evaluation scripts would materially improve reproducibility.

Circularity Check

0 steps flagged

No circular derivation; the window-label identity is a ground-truth construction, not a fitted prediction, and the self-cited no-merge observation is independently reproduced.

full rationale

The paper's central machinery is supervised learning on simulated ground truth. Eq. (1) defines each window label as the parity of physical errors in that window's core region, and Eq. (2) is the mathematical identity that XORing these ground-truth labels gives the global logical parity. This is definitional for the training target, not a prediction derived from the model, and the network is evaluated on fresh Stim-generated syndromes against external decoders (PyMatching, Belief-Matching), so the reported LERs are not fitted to the claimed outcome. The no-merge parallel scheme is stated as a conditional: 'as long as syndromes near the seam are handled consistently ... the combined result will be correct.' For the neural network this consistency is not enforced or proven; Appendix A proves a related statement only for MWPM under Assumption 1, which the paper explicitly notes does not apply to its network. That is a limitation in the fault-tolerance argument, not a circularity, because the empirical claims (Table 3, Fig. 10, ablations) stand or fall on the measurements rather than on the assumption. The paper does rely on the authors' earlier sliding-window work (Ref. [29]) for the no-merge observation, but Figure 4 independently reproduces the MWPM no-merge effect, and the central contributions—threshold improvement, temporal scalability, ablations—are benchmarked against external algorithms. No load-bearing step reduces to its own input by construction.

Axiom & Free-Parameter Ledger

2 free parameters · 4 axioms · 0 invented entities

The paper introduces no new physical entities and no freely fitted phenomenological constants beyond standard neural-network weights. The main conceptual imports are the sliding-window framework from Ref. [29] and the unproven consistency of neighboring neural-window outputs, which carries the load of the no-merge claim.

free parameters (2)
  • Window buffer and core sizes (b, c) = b = c = d
    Set to code distance d in all experiments; motivated by Figure 4 showing b >= d suffices for merge-free sliding-window MWPM, but it is a hand-picked design parameter.
  • Effective physical error rates p_eff(d) = 0.00380 (d=3), 0.00353 (d=5), 0.00336 (d=7)
    Chosen by matching detector event density to the Pauli+ dataset of Ref. [27]; calibrates the benchmark noise level rather than fitting decoder accuracy.
axioms (4)
  • standard math The core regions {E_i^c} partition the physical error set E, so the XOR of per-window labels equals the global logical flip (Eq. 2).
    Used in Section 3 to define training labels; holds by set-theoretic definition when E is known from simulation.
  • domain assumption The circuit-level depolarizing noise model of Ref. [29] is a faithful enough proxy for quantum hardware noise to validate the decoder.
    Section 6.1.1; all comparisons to MWPM and Belief-Matching and the performance claims are made under this simulated model.
  • ad hoc to paper Adjacent windows will handle seam syndromes consistently enough that merging is unnecessary.
    Section 2.2 assumes 'as long as syndromes near the seam are handled consistently...' For neural networks this is not enforced by any mechanism; joint training is a heuristic.
  • ad hoc to paper Assumption 1 in Appendix A: any two correction subsets with the same boundary are identical.
    Underlies the MWPM proof sketch for no-merge correctness; the authors state it is not expected to hold for neural network outputs.

reviewed 2026-08-05 · how reviews work

0 comments
Cite this review

Pith. "Pith review of Learning Neural Decoding with Parallelism and Self-Coordination for Quantum Error Correction." pith.science (2026). https://pith.science/paper/Q5IIMRZI

@misc{pith2026250903815,
  author       = {Pith},
  title        = {Pith review of: Learning Neural Decoding with Parallelism and Self-Coordination for Quantum Error Correction},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/Q5IIMRZI}},
  note         = {Machine review of arXiv:2509.03815}
}
Share X Bluesky LinkedIn Reddit HN
read the original abstract

Fast, reliable decoders are pivotal components for enabling fault-tolerant quantum computation. Neural network decoders like AlphaQubit have demonstrated significant potential, achieving higher accuracy than traditional human-designed decoding algorithms. However, existing implementations of neural network decoders lack the parallelism required to decode the syndrome stream generated by a superconducting logical qubit in real time. Moreover, integrating AlphaQubit with sliding window-based parallel decoding schemes presents non-trivial challenges: AlphaQubit is trained solely to output a single bit corresponding to the global logical correction for an entire memory experiment, rather than local physical corrections that can be easily integrated. We address this issue by training a recurrent, transformer-based neural network specifically tailored for sliding-window decoding. While our network still outputs a single bit per window, we derive training labels from a consistent set of local corrections and train on various types of decoding windows simultaneously. This approach enables the network to self-coordinate across neighboring windows, facilitating high-accuracy parallel decoding of arbitrarily long memory experiments. As a result, we resolve the throughput limitation that previously prohibited the application of AlphaQubit-type decoders in fault-tolerant quantum computation.

Figures

Figures reproduced from arXiv: 2509.03815 by Fang Zhang, Jianxin Chen, Kai Zhang, Linghang Kong, Situ Wang, Zhengfeng Ji.

Figure 1
Figure 1. Figure 1: Surface code example for d = 7. Data qubits are represented by gray circles. Z stabilizers and X stabilizers are represented by the purple and blue squares (or semi-circle), respectively. Logical Z/X operators are illustrated as red/green rectangles. We also plot red vertices to denote the Z stabilizer syndrome defects, and {e1, e2, e3, e4} to denote 4 possible error chains. use redundant physical qubits t… view at source ↗
Figure 2
Figure 2. Figure 2: An illustration of the relationship between decoder throughput and latency. At a given [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Decoding window visualization for d = 7 and degeneracy in merge seam with logical error. throughput—ensures that all subsequent windows are processed with effectively the same latency. 2.2 Parallel sliding-window decoder without local merging Existing implementations of the parallel sliding-window decoder [29, 30, 31] are usually framed in a hypergraph-based model of decoding. In such a model, a decoding t… view at source ↗
Figure 4
Figure 4. Figure 4: Parallel window decoding without merge. Here we conduct memory experiments up to about [PITH_FULL_IMAGE:figures/full_fig_p007_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Model pipeline. Here we illustrate the model pipeline with [PITH_FULL_IMAGE:figures/full_fig_p008_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Neural network model architecture in detail. [PITH_FULL_IMAGE:figures/full_fig_p009_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Illustration for the global syndrome graph in quantum memory experiment and three kinds [PITH_FULL_IMAGE:figures/full_fig_p010_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: Event density of our noise model and the corresponding MWPM threhold. (a) The effective [PITH_FULL_IMAGE:figures/full_fig_p015_8.png] view at source ↗
Figure 9
Figure 9. Figure 9: Threshold improvement of our neural network decoder. [PITH_FULL_IMAGE:figures/full_fig_p017_9.png] view at source ↗
Figure 10
Figure 10. Figure 10: Logical error rate per round for long time memory experiments under the effective physical [PITH_FULL_IMAGE:figures/full_fig_p018_10.png] view at source ↗
Figure 11
Figure 11. Figure 11: Ablation study. Logical error rate per round of different model variations are tested, along [PITH_FULL_IMAGE:figures/full_fig_p019_11.png] view at source ↗
Figure 12
Figure 12. Figure 12: Detailed training logs for code distance [PITH_FULL_IMAGE:figures/full_fig_p029_12.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

54 extracted references · 44 canonical work pages

  1. [1]

    Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer

    Peter W Shor. “Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer”. SIAM review 41, 303–332 (1999)

    work page 1999

  2. [2]

    How to factor 2048 bit rsa integers with less than a million noisy qubits

    Craig Gidney. “How to factor 2048 bit rsa integers with less than a million noisy qubits” (2025). arXiv:2505.15917

    Pith/arXiv arXiv 2048

  3. [3]

    A quantum engineer’s guide to superconducting qubits

    Philip Krantz, Morten Kjaergaard, Fei Yan, Terry P Orlando, Simon Gustavsson, and William D Oliver. “A quantum engineer’s guide to superconducting qubits”. Applied physics reviews6 (2019)

    2019

  4. [4]

    Trapped-ion quantum computing: Progress and challenges

    Colin D Bruzewicz, John Chiaverini, Robert McConnell, and Jeremy M Sage. “Trapped-ion quantum computing: Progress and challenges”. Applied physics re- views6 (2019)

    work page 2019

  5. [5]

    Logical quantum processor based on reconfigurable atom arrays

    Dolev Bluvstein, Simon J Evered, Alexandra A Geim, Sophie H Li, Hengyun Zhou, Tom Manovitz, Sepehr Ebadi, Madelyn Cain, Marcin Kalinowski, Dominik Hangleiter, et al. “Logical quantum processor based on reconfigurable atom arrays”. Nature 626, 58–65 (2024)

    work page 2024

  6. [6]

    Photonic quantum information processing: A concise review

    Sergei Slussarenko and Geoff J Pryde. “Photonic quantum information processing: A concise review”. Applied physics reviews 6 (2019)

    work page 2019

  7. [7]

    Stabilizer codes and quantum error correction

    Daniel Gottesman. “Stabilizer codes and quantum error correction”. California In- stitute of Technology. (1997)

    1997

  8. [8]

    Topological quan- tum memory

    Eric Dennis, Alexei Kitaev, Andrew Landahl, and John Preskill. “Topological quan- tum memory”. Journal of Mathematical Physics 43, 4452–4505 (2002)

    work page 2002

  9. [9]

    Fault-tolerant quantum computation with constant error

    Dorit Aharonov and Michael Ben-Or. “Fault-tolerant quantum computation with constant error”. In Proceedings of the twenty-ninth annual ACM symposium on Theory of computing. Pages 176–188. (1997)

    work page 1997

  10. [10]

    Quantum error correction with imperfect gates

    A Yu Kitaev. “Quantum error correction with imperfect gates”. In Quantum com- munication, computing, and measurement. Pages 181–188. Springer (1997)

    work page 1997

  11. [11]

    Resilient quantum computation

    Emanuel Knill, Raymond Laflamme, and Wojciech H. Zurek. “Resilient quantum computation”. Science 279, 342–345 (1998)

    work page 1998

  12. [12]

    Matching, euler tours and the chinese postman

    Jack Edmonds and Ellis L. Johnson. “Matching, euler tours and the chinese postman”. Mathematical Programming 5, 88–124 (1973)

    work page 1973

  13. [13]

    Blossom v: a new implementation of a minimum cost perfect matching algorithm

    Vladimir Kolmogorov. “Blossom v: a new implementation of a minimum cost perfect matching algorithm”. Mathematical Programming Computation 1, 43–67 (2009). 21

    work page 2009

  14. [14]

    Exact decoding of quantum error-correcting codes

    Hanyan Cao, Shoukuan Zhao, Dongyang Feng, Zisong Shen, Haisheng Yan, Tang Su, Weijie Sun, Huikai Xu, Feng Pan, Haifeng Yu, et al. “Exact decoding of quantum error-correcting codes”. Physical Review Letters 134, 190603 (2025)

    work page 2025

  15. [15]

    Optimal complexity correction of correlated errors in the surface code

    Austin G Fowler. “Optimal complexity correction of correlated errors in the surface code” (2013). arXiv:1310.0863

    Pith/arXiv arXiv 2013

  16. [16]

    Improved decoding of circuit noise and fragile boundaries of tailored surface codes

    Oscar Higgott, Thomas C Bohdanowicz, Aleksander Kubica, Steven T Flammia, and Earl T Campbell. “Improved decoding of circuit noise and fragile boundaries of tailored surface codes”. Physical Review X 13, 031007 (2023)

    work page 2023

  17. [17]

    Suppressing quantum errors by scaling a surface code logical qubit

    Rajeev Acharya, I. Aleiner, Richard Allen, Trond I. Andersen, Markus Ansmann, Frank Arute, Kunal Arya, Abraham T. Asfaw, Juan Atalaya, Ryan Babbush, Dave Bacon, Joseph C. Bardin, Jo˜ ao Marcos Vensi Basso, Andreas Bengtsson, Sergio Boixo, Gina Bortoli, Alexandre Bourassa, Jenna Bovaird, Leon Brill, Mick Broughton, Bob B Buckley, David A. Buell, Tim Burger...

    work page 2022

  18. [18]

    Efficient near-optimal decoding of the surface code through ensembling

    Noah Shutty, Michael Newman, and Benjamin Villalonga. “Efficient near-optimal decoding of the surface code through ensembling” (2024). arXiv:2401.12434

    Pith/arXiv arXiv 2024

  19. [19]

    Optimization of de- coder priors for accurate quantum error correction

    Volodymyr Sivak, Michael Newman, and Paul Klimov. “Optimization of de- coder priors for accurate quantum error correction”. Physical Review Letters 133, 150603 (2024). 22

    work page 2024

  20. [20]

    Neural network decoders for large-distance 2d toric codes

    Xiaotong Ni. “Neural network decoders for large-distance 2d toric codes”. Quantum 4, 310 (2018)

    work page 2018

  21. [21]

    Neural belief-propagation decoders for quantum error-correcting codes

    Ye-Hua Liu and David Poulin. “Neural belief-propagation decoders for quantum error-correcting codes”. Physical Review Letters 122, 200501 (2019)

    work page 2019

  22. [22]

    Scalable neural network decoders for higher dimensional quantum codes

    Nikolas P Breuckmann and Xiaotong Ni. “Scalable neural network decoders for higher dimensional quantum codes”. Quantum 2, 68 (2018)

    work page 2018

  23. [23]

    Scalable neural decoder for topo- logical surface codes

    Kai Meinerz, Chae-Yeun Park, and Simon Trebst. “Scalable neural decoder for topo- logical surface codes.”. Physical Review Letters 128, 080505 (2021)

    work page 2021

  24. [24]

    A scalable, fast and programmable neural decoder for fault-tolerant quantum computation using surface codes

    Mengyu Zhang, Xiangyu Ren, Guanglei Xi, Zhenxing Zhang, Qiaonian Yu, Fuming Liu, Hualiang Zhang, Shengyu Zhang, and Yi-Cong Zheng. “A scalable, fast and programmable neural decoder for fault-tolerant quantum computation using surface codes” (2023). arXiv:2305.15767

    Pith/arXiv arXiv 2023

  25. [25]

    Ef- ficient and universal neural-network decoder for stabilizer-based quantum error cor- rection

    Gengyuan Hu, Wanli Ouyang, Chao-Yang Lu, Chen Lin, and Han-Sen Zhong. “Ef- ficient and universal neural-network decoder for stabilizer-based quantum error cor- rection” (2025). arXiv:2502.19971

    Pith/arXiv arXiv 2025

  26. [26]

    Generative decoding for quantum error-correcting codes

    Hanyan Cao, Feng Pan, Dongyang Feng, Yijia Wang, and Pan Zhang. “Generative decoding for quantum error-correcting codes” (2025). arXiv:2503.21374

    Pith/arXiv arXiv 2025

  27. [27]

    Learning high-accuracy error decoding for quantum processors

    Johannes Bausch, Andrew W. Senior, Francisco J. H. Heras, Thomas Edlich, Alex Davies, Michael Newman, Cody Jones, Kevin J. Satzinger, Murphy Yuezhen Niu, Sam Blackwell, George Holland, Dvir Kafri, Juan Atalaya, Craig Gidney, Demis Hassabis, Sergio Boixo, Hartmut Neven, and Pushmeet Kohli. “Learning high-accuracy error decoding for quantum processors”. Nat...

    work page 2024

  28. [28]

    A classical architecture for digital quantum computers

    Fang Zhang, Xing Zhu, Rui Chao, Cupjin Huang, Linghang Kong, Guoyang Chen, Dawei Ding, Haishan Feng, Yihuai Gao, Xiaotong Ni, Liwei Qiu, Zhe Wei, Yueming Yang, Yang Zhao, Yaoyun Shi, Weifeng Zhang, Peng Zhou, and Jianxin Chen. “A classical architecture for digital quantum computers”. ACM Transactions on Quan- tum Computing 5, 1 – 24 (2023)

    work page 2023

  29. [29]

    Scalable surface- code decoders with parallelization in time

    Xinyu Tan, Fang Zhang, Rui Chao, Yaoyun Shi, and Jianxin Chen. “Scalable surface- code decoders with parallelization in time”. PRX Quantum (2022)

    work page 2022

  30. [30]

    Parallel window decoding enables scalable fault tolerant quantum computa- tion

    Luka Skoric, Dan E. Browne, Kenton M. Barnes, Neil I. Gillespie, and Earl T. Camp- bell. “Parallel window decoding enables scalable fault tolerant quantum computa- tion”. Nature Communications 14 (2022)

    work page 2022

  31. [31]

    Modular decoding: parallelizable real-time decoding for quantum computers

    H´ ector Bomb ´ ın, Chris Dawson, Ye-Hua Liu, Naomi Nickerson, Fernando Pastawski, and Sam Roberts. “Modular decoding: parallelizable real-time decoding for quantum computers” (2023). arXiv:2303.04846

    Pith/arXiv arXiv 2023

  32. [32]

    Realization of real-time fault- tolerant quantum error correction

    Ciar´ an Ryan-Anderson, Justin Gary Bohnet, K W Lee, Daniel N. Gresh, Aaron M. Hankin, John Gaebler, David Francois, Alexander Chernoguzov, Dario Lucchetti, Na- talie C. Brown, Thomas M. Gatterman, Si Khadir Halit, Kevin A. Gilmore, J. Gerber, Brian Neyenhuis, David Hayes, and Russell P. Stutz. “Realization of real-time fault- tolerant quantum error corre...

    work page 2021

  33. [33]

    Quantum error correction below the surface code threshold

    Google Quantum AI and Collaborators. “Quantum error correction below the surface code threshold”. Nature 638, 920–926 (2025)

    work page 2025

  34. [34]

    Pauli frames for quantum computer architectures

    Leon Riesebos, Xiang Fu, Savvas Varsamopoulos, Carmen G Almudever, and Koen Bertels. “Pauli frames for quantum computer architectures”. In Proceedings of the 54th Annual Design Automation Conference 2017. Pages 1–6. (2017). 23

    work page 2017

  35. [35]

    Fault-tolerant quan- tum computing in the pauli or clifford frame with slow error diagnostics

    Christopher Chamberland, Pavithran Iyer, and David Poulin. “Fault-tolerant quan- tum computing in the pauli or clifford frame with slow error diagnostics”. Quantum 2, 43 (2018)

    work page 2018

  36. [36]

    Quantum computing with realistically noisy devices

    Emanuel Knill. “Quantum computing with realistically noisy devices”. Nature 434, 39–44 (2005)

    work page 2005

  37. [37]

    A game of surface codes: Large-scale quantum computing with lattice surgery

    Daniel Litinski. “A game of surface codes: Large-scale quantum computing with lattice surgery”. Quantum 3, 128 (2019)

    work page 2019

  38. [38]

    Quantum error correction for quantum memories

    Barbara Maria Terhal. “Quantum error correction for quantum memories”. Reviews of Modern Physics 87, 307–346 (2013)

    work page 2013

  39. [39]

    Quantization and training of neural networks for efficient integer-arithmetic-only inference

    Benoit Jacob, Skirmantas Kligys, Bo Chen, Menglong Zhu, Matthew Tang, Andrew Howard, Hartwig Adam, and Dmitry Kalenichenko. “Quantization and training of neural networks for efficient integer-arithmetic-only inference”. In Proceedings of the IEEE conference on computer vision and pattern recognition. Pages 2704–2713. (2018)

    work page 2018

  40. [40]

    Learning both weights and connections for efficient neural network

    Song Han, Jeff Pool, John Tran, and William Dally. “Learning both weights and connections for efficient neural network”. Advances in neural information processing systems28 (2015)

    work page 2015

  41. [41]

    Neu- ral network decoder for near-term surface-code experiments

    Boris M Varbanov, Marc Serra-Peralta, David Byfield, and Barbara M Terhal. “Neu- ral network decoder for near-term surface-code experiments”. Physical Review Re- search 7, 013029 (2025)

    work page 2025

  42. [42]

    Attention is all you need

    Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. “Attention is all you need”. Advances in neural information processing systems 30 (2017)

    work page 2017

  43. [43]

    Deep residual learning for image recognition

    Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. “Deep residual learning for image recognition”. In Proceedings of the IEEE conference on computer vision and pattern recognition. Pages 770–778. (2016)

    work page 2016

  44. [44]

    Stim: a fast stabilizer circuit simulator

    Craig Gidney. “Stim: a fast stabilizer circuit simulator”. Quantum 5, 497 (2021)

    work page 2021

  45. [45]

    Learning to decode the surface code with a recurrent, transformer-based neural network

    Johannes Bausch, Andrew W. Senior, Francisco J. H. Heras, Thomas Edlich, Alex Davies, Michael Newman, Cody Jones, Kevin J. Satzinger, Murphy Yuezhen Niu, Sam Blackwell, George Holland, Dvir Kafri, Juan Atalaya, Craig Gidney, Demis Hassabis, Sergio Boixo, Hartmut Neven, and Pushmeet Kohli. “Learning to decode the surface code with a recurrent, transformer-...

    Pith/arXiv arXiv 2023

  46. [46]

    Sparse blossom: correcting a million errors per core second with minimum-weight matching

    Oscar Higgott and Craig Gidney. “Sparse blossom: correcting a million errors per core second with minimum-weight matching”. Quantum 9, 1600 (2025)

    work page 2025

  47. [47]

    Pymatching: A python package for decoding quantum codes with minimum-weight perfect matching

    Oscar Higgott. “Pymatching: A python package for decoding quantum codes with minimum-weight perfect matching”. ACM Transactions on Quantum Computing 3, 1–16 (2022)

    work page 2022

  48. [48]

    Establishing a new benchmark in quantum computational advantage with 105-qubit zuchongzhi 3.0 processor

    Dongxin Gao, Daojin Fan, Chen Zha, Jiahao Bei, Guoqing Cai, Jianbin Cai, Sirui Cao, Fusheng Chen, Jiang Chen, Kefu Chen, Xiawei Chen, Xiqing Chen, Zhe Chen, Zhiyuan Chen, Zi-Han Chen, Wenhao Chu, Hui Deng, Zhibin Deng, Pei Ding, Xun Ding, Zhuzhengqi Ding, Shuai Dong, Yupeng Dong, Bo Fan, Yu Fu, Song-Ming Gao, Lei Ge, Ming Gong, Jiacheng Gui, Cheng Guo, Sh...

    work page 2025

  49. [49]

    Bagging predictors

    Leo Breiman. “Bagging predictors”. Machine learning 24, 123–140 (1996)

    work page 1996

  50. [50]

    Random forests

    Leo Breiman. “Random forests”. Machine learning 45, 5–32 (2001)

    work page 2001

  51. [51]

    A decision-theoretic generalization of on-line learning and an application to boosting

    Yoav Freund and Robert E Schapire. “A decision-theoretic generalization of on-line learning and an application to boosting”. Journal of computer and system sciences 55, 119–139 (1997)

    work page 1997

  52. [52]

    A sat scalpel for lattice surgery: Representation and synthesis of subroutines for surface-code fault-tolerant quantum computing

    Daniel Bochen Tan, Murphy Yuezhen Niu, and Craig Gidney. “A sat scalpel for lattice surgery: Representation and synthesis of subroutines for surface-code fault-tolerant quantum computing”. In 2024 ACM/IEEE 51st Annual International Symposium on Computer Architecture (ISCA). Pages 325–339. IEEE (2024)

    work page 2024

  53. [53]

    Fusion blossom: Fast mwpm decoders for qec

    Yue Wu and Lin Zhong. “Fusion blossom: Fast mwpm decoders for qec”. In 2023 IEEE International Conference on Quantum Computing and Engineering (QCE). Volume 1, pages 928–938. IEEE (2023)

    work page 2023

  54. [54]

    Proof of finite surface code threshold for matching

    Austin G Fowler. “Proof of finite surface code threshold for matching”. Physical Review Letters 109, 180502 (2012). 25 A Proof sketch for the fault tolerance of sandwich without merge A.1 Preliminaries In the context of a QEC procedure, we call an eventA exponentially unlikely if there exists a threshold pth> 0, such that Pr(A) =O ( poly(d)· ( p pth )⌈d/2...

    work page 2012

This paper was first reviewed by deepseek-v4-flash on August 5, 2026.