betaFeedback

WorksPhysics and Astronomy

TCBP-JOBS: GPU-Accelerated Quantum Error Correction Decoding and Noise Learning with Near-Optimal Accuracy

Abstract

Achieving near-optimal quantum error correction (QEC) decoding accuracy often requires computationally expensive searches that limit both large-scale simulation and real-time operation. We introduce trajectory-calibrated belief propagation (TCBP), which learns calibrated fault probabilities from BP trajectories, and jittered OSD beam search (JOBS), which uses these probabilities to guide parallel GPU searches. Across surface, color and bivariate-bicycle code memory and surgery circuits, TCBP-JOBS achieves logical error rates comparable to those of the Tesseract most-likely-error decoder at physical error rates of 0.1% to 0.4%, and up to 4.5×\times lower on the largest codes. Serial speedups over Tesseract's sparsified presets range from 10×\times to 7,400×\times, and against unsparsified long-beam Tesseract they reach 13,000×\times on the bivariate-bicycle codes, at logical error rate ratios of 0.97 to 1.57. At lower physical error rates (10−410^{-4} to 5×10−45\times10^{-4}), rare-event splitting on the gross code shows that Tesseract is more accurate. Batched execution accelerates offline simulation for rapid, efficient exploration of large-scale QEC design spaces. For QPUs with longer logical clock cycles, our serial memory and logical-surgery experiments demonstrate accuracy comparable to Tesseract while meeting the millisecond-scale latency requirements of online feed-forward operation. Beyond memory and logic decoding, we demonstrate using TCBP-JOBS for confidence scores for postselection in memory and magic-state cultivation, enabling end-to-end color code cultivation. Together, these methods provide a GPU framework for accelerating QEC research via accurate decoding, noise estimation, and confidence assessment.

Introduction and Summary of Main Results

Quantum computers promise to solve problems that are intractable for classical machines, most notably the simulation of quantum systems in chemistry and materials science [77, 2, 109, 73], along with a growing set of problems with credible super-quadratic speedups [69] and cryptographic tasks such as factoring large integers [114, 47], but this promise rests on quantum error correction (QEC). Physical qubits fail at rates of around 10−310^{-3} per operation, while useful fault-tolerant quantum algorithms are expected to require logical error rates of 10−1010^{-10} or lower. QEC bridges this gap by encoding logical qubits redundantly across many physical qubits and repeatedly measuring parity checks whose outcomes, called syndromes, reveal information about underlying errors while preserving the logical quantum state. The need for fault-tolerant quantum computing (FTQC) has prompted industry roadmaps that target fault-tolerant machines within this decade [51, 63, 106], and the QEC codes these machines will use are still being discovered. While the surface code [38] has been the default choice for over a decade, recently quantum low-density parity-check (qLDPC) codes, such as the bivariate-bicycle codes [6], have emerged that encode many logical qubits per block at a fraction of the physical-qubit overhead. These high-rate codes continue to inspire new code constructions, syndrome-extraction circuits and hardware co-designs aimed at reducing the cost of fault tolerance [104, 8, 133, 62, 10]. To accelerate progress toward practical fault-tolerant quantum computing, rapid exploration of a broader fault-tolerant design space spanning codes, architectures, and hardware co-designs is needed.

At the core of QEC are decoders—classical algorithms that infer likely error corrections from observed syndromes. Decoders serve two distinct but complementary roles in quantum error correction. Offline, a QEC code and its fault-tolerant protocols are evaluated by simulating their circuit implementations under realistic noise and decoding millions to billions of sampled syndromes. These studies are used to estimate logical error rates, characterize performance over many rounds of QEC, assess the impact of different physical noise models, and compare competing circuit implementations and decoder configurations. Decoders are central to QEC: their accuracy determines the performance achievable by a QEC code, while their computational performance determines the scale and speed of QEC design-space exploration. Online, once QEC codes are implemented in the quantum processor, the decoder must process syndromes and return corrections within the latency constraints of the target hardware architecture for the computation to proceed [117]. Decoding is NP-hard in general [64], so both uses depend on decoders that are simultaneously fast and accurate.

Decoders for general codes, however, have been either fast or accurate, but not both. While belief propagation (BP) and its descendants [108, 83] are fast and apply to any code, BP frequently fails to converge on quantum codes. The post-processor most commonly run on the non-converged shots, called ordered statistics decoding (OSD), commits to a single ordered ranking of likely faults and only searches around those instances. An accuracy gap results and in turn changes how codes are evaluated. For example, when Tesseract [1] is used to decode the 288-qubit circuit of the [[144,12,12]][[144,12,12]] gross code, its accuracy matches distance-13 to distance-15 surface codes encoding 12 logical qubits at SI1000 noise and p=0.1%p = 0.1\%, resulting in a 14–19× savings in physical qubits. In contrast, decoding with two faster decoders, BP+OSD and correlated matching, results in accuracy on par with only the distance-11 surface code, yielding only a 10× physical-qubit savings [1]. The faster decoders sacrifice accuracy on the very qLDPC codes researchers seek to design and improve due to their high rates.

At the other extreme, most-likely-error decoders such as Tesseract deliver up to two orders of accuracy improvement, but require runtimes of milliseconds per round on small surface codes to seconds per round on qLDPC codes due to the exponential search space. The computational performance of such decoders prevents their use in real-time execution for QPUs with both low (milliseconds) and high (microseconds) logical clock speeds [98]. Further, using these highly accurate decoders render QEC research slow, and reduces the number of codes QEC researchers can study or requires changing to lower-accuracy, fast decoders for QEC code design and exploration. Decoding 24.2 million shots of one Tesseract benchmark across 28 circuits consumes 130,257 CPU thread-hours [Goo25a], which is equivalent to around 12 weeks on a 64-core server (see Appendix § 12). Every task of QEC research that requires accurate decoding consumes this same cost, such as estimating very low logical error rates, computing confidence values for post-selection, and learning the noise of a device from its syndromes.

This work presents two algorithmic approaches that, when used together, result in accuracy

comparable to most-likely-error decoding at physical error rates of 0.1% to 0.4%, at the speed of a parallel GPU decoder. The approach builds on the observation that BP computes a belief about every fault at every iteration, which OSD then discards, and typically keeps only one final value per fault and one ordering of the faults. We introduce Trajectory-Calibrated BP (TCBP), which replaces BP’s final beliefs with calibrated probabilities computed by a single MLP that reads each fault’s entire BP trajectory; the model is fitted once per code family on simulated shots in about 10 s and does not require experimental data. A second technique, called Jittered OSD Beam Search (JOBS), uses these probabilities as the starting point for a population of searches. It perturbs the ordering to form 16 draws per shot (tunable parameter), solving OSD-0 in each ordering, and then refines every solution with a bounded beam search, with all of it running on the GPU. Across 72 surface, color and bivariate-bicycle code circuits at p=0.1%p = 0.1\% to 0.4%, TCBP-JOBS is shown to achieve logical error rates comparable to or lower than those of the Tesseract configurations evaluated. Against sparsified short-beam Tesseract, it achieves significantly lower LER in 17 of 36 code/noise settings and significantly higher LER in one, with no statistically significant difference in the remaining settings. The largest LER reduction is 4.5×4.5\times, achieved on the gross code at p=0.2%p = 0.2\% SI1000 noise. Against sparsified long-beam Tesseract, it achieves comparable or lower LER at p=0.2% and 0.4% SI1000 noise, with a maximum reduction of 2.7×2.7\times. It does so while decoding up to 13,000× faster across all evaluated circuits and keeping every shot in a narrow, millisecond-scale latency band.

Figure 1 shows an overview of TCBP-JOBS. TCBP-JOBS shifts the speed–accuracy frontier for general codes, and provides not only a correction but calibrated fault probabilities and a per-shot confidence. We demonstrate the application of TCBP-JOBS to five settings:

Figure 1. Overview of TCBP-JOBS: A short run of BP produces a trajectory of beliefs for every fault, which TCBP maps to calibrated probabilities with one small MLP shared by all faults; JOBS uses these probabilities to search many jittered OSD orderings in parallel on the GPU and returns the cheapest correction it finds. TCBP alone (light green) supports noise learning, whose learned rates feed back into BP as priors, and reweighting of downstream decoders such as matching. TCBP+JOBS (dark green) enables code design exploration at a fraction of the compute cost of most-likely-error decoding, real-time decoding at lower latency for the same logical error rate, post-selection using the complementary gap, and importance sampling to estimate logical error rates far below what direct sampling can reach. The insets are schematic.

  • Code design exploration. TCBP-JOBS evaluates QEC codes with accuracy comparable to Tesseract at p=0.1%p = 0.1\% to 0.4% on joint XYZ decoding graphs, at up to ∼13,000× lower single-shot latencies (see Appendix § 11). It decodes the 24.2-million-shot Tesseract benchmark in 45 minutes on one GB200 GPU with a geometric-mean logical error rate ratio of 1.05 in its favor; in contrast Tesseract requires 130,257 CPU thread-hours. The ability to evaluate more shots efficiently opens the door to expanded design exploration of codes, circuits and layouts for a given hardware platform, while improved decoder accuracy may enable higher logical-qubit yield and larger computations from the same device.

  • Real-time decoding for QPUs with lower logical clock speeds. TCBP-JOBS delivers logical error rates comparable to Tesseract at p=0.1%p = 0.1\% to 0.4%, at millisecond-scale serial latencies on a single GPU, making the decoder practical for, e.g., neutral atom and ion trap quantum processors. For twelve rounds of gross-code memory at p=0.2%p = 0.2\%, decoding takes 4.08 ms; for gross-code logical-surgery measurement, decoding takes 13.5 ms per shot, and results in 27 failures versus 41 and 10.2 s for multi-pass Tesseract.

  • Noise learning. The same TCBP model enables learning the error rate of every fault from recorded, unlabeled detector data alone: on the gross code, 15 minutes of learning on one GPU yields a decoder within 2–3% of the logical error rate obtained with the true rates, and about 10 s of learning comes within 1.4–1.8× of it, versus 9–27× for a uniform prior, which makes it suitable for online use alongside calibration.

  • Complementary-gap based post-selection. Because JOBS visits many valid corrections, it can report the gap between the best competing logical class and its answer at almost no extra cost, giving a per-shot confidence up to ∼2k\sim2^k faster than other decoders which require decoding once for each of the 2k2^k observable classes, where kk is the number of observables.

Discarding 1% of shots improves the LER of the gross code by ∼28×\sim28 \times at p=0.2%p = 0.2\%. In magic-state cultivation, TCBP-JOBS reduces the binary-Y diagnostic error (wrong-sign decoded logical-Y expectation) by 2.1 to 4.7× under identical postselection rules with the original cultivation and grafted surface-escape protocol [55], and enables end-to-end color code cultivation with up to 2.8× higher modeled throughput per installed qubit.

  • Importance sampling. Fast decoding makes rare-event splitting affordable: we estimate the logical error rate of TCBP-JOBS on the gross code down to 10−1210^{-12} at a fraction of the cost of direct sampling. In this regime Tesseract is more accurate: the gap is visible at p=5×10−4p = 5 \times10^{-4}, 2×10−42 \times10^{-4} and 10−410^{-4}, and TCBP-JOBS fails on some four-fault configurations that Tesseract corrects.

The paper is organized as follows. In § 3, we introduce Trajectory-Calibrated BP. We show that BP’s ranking of faults is often poor exactly when OSD is needed, and that a small MLP over BP trajectories improves it, reducing OSD-0 failures by 2.1× on a surface code and 3.7× on the gross code with only the ordering changed. In general, TCBP enables the weights of the decoding graphs to be updated, which can improve the performance of a wide range of decoders. In § 4, we introduce Jittered OSD Beam Search. We present a GPU-parallel search over perturbed OSD orderings that reaches accuracy at parity with or better than Tesseract at p=0.1%p = 0.1\% to 0.4%0.4\%, with millisecond-scale serial latency. We use the TCBP model for label-free noise learning and JOBS for a search-limited complementary gap that enables post-selection in memory experiments and magic-state cultivation in § 5 and § 6. Finally, in § 7, we use rare-event splitting to probe logical error rates of 10−1210^{-12}, and find that TCBP-JOBS is less accurate than Tesseract at these low physical error rates.

Background and Related Work

This section provides a brief overview of Quantum Error Correction (QEC) and decoding of QEC codes. We describe the challenge of real-time decoding, and prior art on decoding algorithms.

Quantum Error Correction and Decoding

Qubits are fragile: every gate, idle step, and measurement can introduce an error. QEC protects information by redundantly encoding kk logical qubits into n>kn > k physical qubits. A code’s distance dd describes the distance between logical codewords, which quantifies how many errors can be reliably detected. Stabilizer codes enable stabilizer measurements which remove entropy from the system, and whose outcomes reveal errors. One goal for QEC codes is to protect the logical qubits by having a high distance, and doing so with the highest rate k/nk/n possible, reducing the physical qubit overhead needed for QEC. The surface code [29, 38] is a widely studied QEC code which has been demonstrated in experimental settings with excellent error suppression properties. It requires only nearest-neighbor connectivity but requires a ∼d2\sim d^2 patch of physical qubits per single logical qubit. High rate Quantum low-density parity-check (QLDPC) codes [119, 104, 8] encode many logical qubits per block at a fraction of this overhead: the [[144,12,12]][[144, 12, 12]] gross code [6] encodes 12 logical qubits in 144 physical qubits, about 10× fewer than surface codes of the same distance. This comes with other tradeoffs, such as the need for higher-weight, long-range checks, pushing additional complexity onto hardware realizing these codes. Despite these challenges, several full architectures have been proposed for enabling large scale FTQС with high rate QLDPC codes [133, 98, 116, 10].

Decoding. Measuring the stabilizers of a QEC code produces syndrome data which is sent to a classical processor called a decoder. Quantum circuits implementing these stabilizer measurements are called stabilizer rounds, code cycles, syndrome extraction cycles (SECs), or QEC cycles. They are designed to produce detectors which are parities of sets of measurements which are deterministic in the absence of noise [46, 35]. Decoders operate on a detector error model (DEM) [46]: a binary matrix H∈F2m×nH \in\mathbb{F}_2^{m \times n} with a real vector P∈RnP \in\mathbb{R}^n in which each of the nn columns is an error mechanism (fault) with prior probability pjp_j and each of the mm rows is a detector. A second binary matrix LL records which logical observables each mechanism flips. Given the measured syndrome σ\sigma, decoding solves

HF=σHF = \sigma

for a fault vector FF. Due to quantum degeneracy, the system has many solutions for FF, and we say the decoder succeeds if LFLF matches the true observable flips. Optimal (maximum likelihood) decoding selects the most probable logical class and is #P\#\mathrm{P}-hard [64]; most practical decoders instead approximate the most likely error (MLE), the minimum-cost solution with cost ∑jwjFj\sum_j w_j F_j and wj=ln⁡1−pjpjw_j = \ln\frac{1-p_j}{p_j}, which is NP\mathrm{NP}-hard in general [12, 64].

By viewing each of the rows (checks) and columns (faults) of the DEM as two different node types, we can view the entries of HH as an adjacency matrix of a bipartite graph called the Tanner graph. For the surface code, each mechanism flips at most two detectors (after decomposition), and so the fault nodes of the Tanner graph can be collapsed into edges of a graph of detector nodes. Here we say HH is graph-like and MLE decoding reduces to minimum-weight perfect matching (MWPM) [36, 29]. In QLDPC DEMs, mechanisms flip many detectors, and so the adjacency matrix of HH describes a hypergraph, and matching does not apply. The current default general-purpose decoder is BP-OSD [104, 108]. Belief propagation (BP) [42, 103] is an iterative algorithm which passes messages on the Tanner graph of HH to estimate the posterior probability of every mechanism; if the hard decision of these posteriors satisfies σ\sigma, BP has converged. On quantum codes, degeneracy and short cycles frequently prevent convergence [102], especially under circuit-level noise. Ordered statistics decoding (OSD) [37] then sorts the columns of HH by BP’s posteriors, uses Gaussian elimination to find the first linearly independent set of columns, and solves for the unique correction supported on them (OSD-0). Higher-order OSD (exhaustive or combination sweep, OSD-CS) flips a parametrized subset of the remaining columns and keeps the most probable valid correction found. OSD-HO-E(i) (OSD with exhaustive sweep with ii additional columns) is a higher-order extension to OSD which takes the OSD-0 solution, and adds all ii column subsets to a search for valid (syndrome resolving) fault patterns of higher probability. By extending ii to include all remaining columns, one would recover the (combinatorially expensive) MLE solution. OSD’s answer is only as good as its column ordering: error mechanisms ranked low are unlikely to be recovered even with large sweeps using higher order OSD.

Real-time Decoding

QEC cycles run continuously on the hardware, and every cycle TcycleT_{\mathrm{cycle}} produces a new round of syndromes, from every ∼1 μs\sim1\,\mu\mathrm{s} on superconducting qubits [53] to every few milliseconds on trapped ions and neutral atoms [98]. A real-time decoder must therefore satisfy three requirements at once. The first is accuracy: a correction succeeds only if it lies in the same logical class as the error that actually occurred, and every decoding mistake adds to the logical error rate (LER) of the computation. The second is throughput: if syndromes are decoded more slowly than they are generated, unprocessed syndromes accumulate and the computation suffers an exponential slowdown—the backlog problem [117, 60]. The third is latency: nonClifford gates implemented with magic states require a feed-forward correction that depends on a decoded logical measurement [75], so the computation stalls until the decoder responds [87]. Because decoding time depends on the syndrome, the tail of the latency distribution matters as much as its mean: a single slow decode delays every operation that depends on it [34, 87].

Related Work

Matching and clustering decoders: MWPM decoders for the surface code have been accelerated in software [59, 131] and extended to correlated errors by reweighting edges [39] or with BP-derived weights (belief-matching) [57]. Ensembles of matching decoders with perturbed priors approach maximum likelihood accuracy, either by voting (Harmony) [115] or by combining the best local solutions (Libra) [65]. HyperBlossom [127] generalizes the blossom algorithm to hypergraphs with certifiable proximity bounds. Union-find decoders [32, 74, 101] grow clusters around syndrome bits until each cluster can be corrected locally; generalized union-find extends this to qLDPC codes [30] using a GF(2)GF(2) validity check per cluster. Color codes are decoded by reducing the problem to matching [66, 48, 76].

Pre-decoders: Pre-decoders remove simple, local errors before a slower global decoder runs, reducing the syndrome density it sees [26, 111, 107, 3, 23]. Local neural networks built from 3D convolutions are well suited to this role [CGS+23]: NVIDIA’s Ising pre-decoders are 3D CNNs that run on GPUs ahead of PyMatching for surface codes [COL+26] and Chromobius for color codes [99]; they reduce both latency and logical error rates, the latter by 347×347\times for distance-31 color codes. QuantiSpect [56] factorizes these convolutions to reduce their cost. These pre-decoders exploit the geometric locality of topological codes; qLDPC codes lack this locality.

Message-passing decoders: Several variants improve BP’s convergence on quantum codes. Memory BP [68] adds a memory term to the posterior updates, and Relay-BP [83] chains memory-BP legs with disordered memory strengths, matching or exceeding BP-OSD on bivariate bicycle (BB) codes without post-processing. GARI [86] rewrites the correlated DEM to remove short cycles and runs an ensemble of 24 randomized min-sum decoders, matching Relay-BP. Other approaches learn the BP update schedule by reinforcement learning [84], run ensembles of BP decoders on syndromes transformed by code automorphisms [70], decimate the least reliable mechanisms with guessing on a few branches (BP-GDG) [44], modify the Tanner graph to break degenerate symmetries [25, 134], or flip syndrome bits of oscillating mechanisms and re-run short BP trials in parallel (BP-SF) [128, 132]. Neural BP learns message weights from data [78, 92].

Post-processing for BP: Besides OSD [104, 108], several post-processors reduce OSD’s cost. Some shrink the problem before elimination, by removing reliable mechanisms [67], restricting OSD to high-likelihood columns [88], or constraining and terminating the sweep early [81]. Best-first OSD [9] traverses the syndrome-consistent solutions in order of increasing cost, matching BP-OSD with 100×100\times fewer queries. Localized statistics decoding (LSD) [HBQ+25] performs OSD’s elimination on independent clusters grown from BP’s soft information, ambiguity clustering (AC) [125] splits the problem after BP into independently decodable clusters, and the ordered Tanner forest [28] and closed-branch [27] decoders avoid matrix inversion altogether. With the exception of automorphism ensembles [70], which require a code with a large automorphism group, these methods commit to a single ordering derived from one BP run.

Search-based and exact decoders: Integer programming [72] and MaxSAT [94] decoders find the exact MLE, and tensor-network decoders [15, 20 LXZ+26, 96] approximate maximum likelihood decoding; these are generally orders of magnitude too slow for real-time use. Tesseract [1, 41] finds the MLE with A* search and pruning heuristics, and shows that MLE decoding makes the gross code 14–19× more efficient than surface codes, compared with 10× under BP-OSD and correlated matching. Decision-tree decoders [100] search over branches of the solution space with optimality guarantees. The beam search decoder [135] branches on the least reliable mechanism, re-runs masked BP on each branch, and keeps a fixed beam of the most reliable paths, achieving up to 17× lower logical error rates than BP-OSD on the gross code with sub-millisecond 99.9th percentile latency on a single CPU core. Perturbing a ranking and re-decoding is a classical idea for improving soft-decision decoders, from Chase decoding [19] to sampling diverse candidates with Gumbel perturbations [71].

Neural decoders: Neural networks decode the surface code accurately [118 VCB17, 14], and AlphaQubit 2 [113] decodes surface codes up to distance 11 and color codes up to distance 9 in under 1 μ\mus per cycle with near-optimal accuracy. A transformer decoder has been trained on GPUs for magic state distillation on neutral atoms [97]. Recent work extends neural decoders to BB codes with recurrent transformers [4], graph neural networks [61] and code-specific convolutional neural networks [43]; these report mixed results against BP-OSD on the gross code and must be trained for every code and noise model.

Hardware decoders: FPGA, ASIC, and superconducting-logic decoders for the surface code include LUT-based [DLJ22], union-find [33, 79], clustering [5, 138], MWPM [123, 130], predecoding [107, 3], and cryogenic [121] designs, as well as network-integrated decoding systems [129, 80]. For qLDPC codes, FPGA/ASIC designs exist for BP and OSD [124, 45], Relay-BP completes a BP iteration in 24 ns on an FPGA for the gross code [85], GARI decodes the gross code at 596 ns per round on a single FPGA [11], learned BP schedules have been mapped to FPGA and ASIC [89], and Vegapunk [136] decouples the check matrix offline to enable sub-microsecond greedy hierarchical decoding. FPGA-tailored variants of OSD and clustering remain slower and less accurate than Relay-BP under fixed cycle budgets [88].

GPU decoders: CUDA-Q QEC [95] provides GPU-accelerated BP, Relay-BP, and BP-OSD, and was used for the first real-time decoding of a qLDPC code [98]; its batched BP-OSD-0 has also been used to run automorphism ensembles on a GPU [105]. Markidis et al. [91] run Relay-BP followed by an on-device OSD-0 on data-center and commodity GPUs, Wang et al. [132] run BP-SF trials concurrently on the GPU, and TensorMLD [LXZ+26] contracts compressed tensor networks on GPUs and FPGAs. Neural decoders and pre-decoders run on GPUs and TPUs by design [COL+26, OCLB26, SEH+25]. To the best of our knowledge, no prior GPU decoder runs higher-order OSD, or a search beyond OSD-0, entirely on the device.

Soft outputs and post-selection: A decoder can report how close the best competing logical class is to its answer—the complementary gap—which predicts logical failures and enables post-selection [13, 49, 112, 90]. Exact gaps require one constrained decode per competing class, so practical decoders approximate them, for example from the agreement among an ensemble [115].

Trajectory-Calibrated Belief Propagation

Decoders like OSD rely on BP to rank the faults, and this ranking is often poor precisely when OSD is needed: OSD only runs on shots where BP fails to converge, which under circuit-level SI1000 noise is 92.5% of the shots of a distance-11 surface code at p=0.2%p = 0.2\% and every shot of the gross code at p=0.3%p = 0.3\% (§ 3.1). On these shots BP’s marginals oscillate or stall on trapping sets created by degeneracy and short cycles [102], so the final LLR of a fault reflects where BP happened to stop rather than how likely the fault is. Figure 2(a) shows a typical failure: a true fault produces a strong, early dip that BP later abandons, while a spurious fault drifts slowly towards a small final LLR and is ranked ahead of it. Ordering by the minimum LLR over all iterations recovers part of this information [95], but it records only the depth of an excursion and not its timing or stability. Our key observation is that the whole trajectory of a fault’s marginal LLRs carries far more information about whether that fault occurred than any single value taken from it, and that the mapping from trajectories to probabilities can be learned once for a code family.

Trajectory-Calibrated BP (TCBP)

Figure 2. Trajectory-Calibrated BP (TCBP). (a) BP updates the marginal LLR of every fault at every iteration; a true fault can produce a strong but oscillating signal and finish with a higher LLR than a spurious fault that settles slowly (illustrative trajectories). (b) TCBP builds T+4T+4 features from each fault’s trajectory and applies one small MLP, shared by every fault, to obtain a calibrated probability that the fault fired. (c) Ordering the columns by these probabilities places the true faults earlier, so OSD needs a shorter prefix K∗K^{*} of the ordering to explain the syndrome.

Model. For a fault jj and TT BP iterations, TCBP reads the marginal LLRs ℓj,1,…,ℓj,T\ell_{j,1},\ldots,\ell_{j,T} and appends four features: the iteration of the minimum LLR normalized by TT, the number of sign changes of the successive slopes, the final slope ℓj,T−ℓj,T−1\ell_{j,T}-\ell_{j,T-1}, and the prior LLR of the fault. A multilayer perceptron with two hidden layers of 16 units maps these T+4T+4 features to a logit, whose logistic transform is the calibrated probability p^j=P(ej=1∣ℓj,1:T,pj)\hat{p}_j=P(e_j=1\mid\ell_{j,1:T},p_j) (Figure 2(b)). The same MLP is applied independently to every fault, so for T=10T=10 the entire model has only 529 weights, its cost is a few hundred multiply-adds per fault, and it parallelizes trivially across the columns of HH on a GPU. BP itself is unchanged: TCBP only taps the marginals BP already computes, and OSD then sorts the columns by p^j\hat{p}_j instead by the final LLR (Figure 2(c)).

Training. TCBP needs no experimental data. The model is fitted on shots simulated from HH alone, with a training error rate drawn log-uniformly between 10−410^{-4} and 10−210^{-2} for every fault, so the labels are known and the model learns how trajectory shapes relate to error probabilities rather than the rates of one operating point; the BP configuration used for fitting (method, iteration count, clipping and precision) must match the one used for decoding. Fitting took 9.8 s for the surface code DEM with 24,485 faults and 11.5 s for the gross code DEM with 67,752 faults on one NVIDIA H100, and reduced the held-out cross-entropy of the per-fault probabilities from 0.0053 to 0.0034 and from 0.0107 to 0.0092 respectively. A model fitted once can be reused across the error rates and distances of a code family.

TCBP Improves the Ranking Given to OSD

To isolate the effect of the ranking, we decode identical circuit-sampled shots with the same BP front end (10 iterations of sum-product BP, clip value 15, FP32) and OSD-0, and change only the column ordering between the final LLR, the minimum LLR and TCBP. We compare for the distance-11 rotated surface code with 11 rounds of SI1000 noise at p=0.2%p = 0.2\% (204,800 shots) and the [[144,12,12]][[144, 12, 12]] gross code with 12 rounds at p=0.3%p = 0.3\% (32,768 shots) [1]. We report two metrics. The first, K∗K^*, measures the ranking itself and uses only what the decoder sees: for each shot and ordering, K∗K^* is the smallest number of leading columns whose span contains the measured syndrome, i.e., the shortest prefix of the ordering in which OSD-0 can find a syndrome-compatible correction. The correction OSD-0 returns lies entirely within these K∗K^* columns, so a smaller K∗K^* means that OSD-0 explains the syndrome with fewer and higher-ranked faults. K∗K^* does not consult the simulated faults and does not require them to lie within the prefix; it is therefore only a proxy for accuracy, since a short prefix can still yield a correction in the wrong logical class. The second metric is the logical error rate, for which we compare the observable flips of the OSD-0 correction with those of the faults the simulator actually sampled.

Figure 3(a, b) shows that TCBP shifts the entire distribution of K∗K^* to the left, reducing its median from 112 (final LLR) and 75 (minimum LLR) to 51 on the surface code, and from 886 and 750 to 528 on the gross code. This translates directly into accuracy when measured against the simulated faults (Figure 3(c)): OSD-0 fails on 136 surface code shots with the TCBP ordering compared with 285 for the final LLR and 248 for the minimum LLR; it fails on 8.2% of gross code shots compared with 30.8% and 12.9%. The improvement is consistent shot by shot—on the gross code, 7,832 shots fail only with the final-LLR ordering while 427 fail only with TCBP—and it added only 5–8% to the batched OSD-0 decode time for the runs. A better ranking does not remove OSD’s dependence on a single ordering; § 4 uses these calibrated scores as the starting point for a search over many orderings.

TCBP Provides Calibrated Outputs

The previous section described how fault rankings can be improved by TCBP, which is useful for OSD, but the outputs provide more information than just a ranking: they can be interpreted as a calibrated probability. That is, if TCBP’s output for a given fault is 0.1, that can be interpreted to mean that there is a 10% chance that the fault actually occurred on this shot. This can be used for per-shot downstream decoder fault reweighting (similar to Belief Matching [57]), or it can be used for noise learning as described in § 5.

To test the ability of TCBP to return calibrated output probabilities, we again use the gross code at p=0.3%p = 0.3\%, collecting TCBP outputs and binning the outputs in log space, and then comparing the predicted error probability of each bin with the fraction of mechanisms in that bin that were actually flipped in the sampled error. A perfectly calibrated decoder places every bin on the line y=xy = x.

Figure 4 shows that TCBP’s outputs track the diagonal across the range where nearly all faults occur, with only a mild overconfidence at the high end. Below 10−410^{-4}, outside the range of rates the model was trained on, the outputs drift from the diagonal, but these bins contain well under 1% of the sampled faults. The raw BP posteriors are calibrated only above 10−110^{-1}; below that they overstate confidence by one to two orders of magnitude, and running more iterations does not help. TCBP’s outputs can therefore be used directly as probabilities, not just as a ranking. The effects of this capability will be discussed in § 5.

Figure 4. Per-column calibration of TCBP and raw BP posteriors on the gross code at p=0.3%p = 0.3\%. Every mechanism of every shot is one sample (65,53665{,}536 shots ×\times 67,75267{,}752 mechanisms per series). Predicted P(error)P(\mathrm{error}) is binned in log space (10 bins per decade) and plotted against the fraction of mechanisms in the bin that were flipped in the sampled error; a calibrated decoder places every bin on the dotted y=xy = x line. Bins with no observed errors are omitted. Raw BP posteriors are 1/(1+eLLR)1/(1 + e^{\mathrm{LLR}}) from the final iteration with message clipping at 15 (lower bound ≈3×10−7\approx3 \times10^{-7}).

Jittered OSD Beam Search

Section 3 improved the ranking that OSD receives, but conventional OSD only explores solutions that are derived from that one ranking. OSD [37, 108] sorts the columns of HH from the most to the least likely fault, and Gaussian elimination selects the first linearly independent columns in that order as a basis BB. The OSD-0 correction solves HBeB=sH_B e_B = s for the syndrome ss and sets every other fault to zero. Higher-order OSD, typically the combination sweep [108], then tries to lower the cost by switching on one or two of the remaining free columns at a time and solving again for the basis part. It stops there: the sweep never combines more than two free columns, and every candidate is built on the same basis. If the true faults fall late in an imperfect ordering, or the cheapest correction differs from OSD-0 in more than two free columns, the combination sweep does not find it. Jittered OSD Beam Search (JOBS) replaces this single path with a population of searches, each started from a different plausible ordering, that run in parallel on a GPU and return the cheapest correction any of them finds. Algorithm 1 lists the steps for one shot.

Algorithm 1: JOBS for one BP-non-converged shot (one round of draws).

Input: HH, syndrome ss, ordering scores σj\sigma_j (smaller is more likely), priors pjp_j with cost CC of Eq. (1); draws DD, noise scale β\beta, window pad α\alpha, beam width WW, depth LL, patience PP

Output: correction e∗e^* with He∗=sHe^* = s

  1. K∗←K^* \leftarrow smallest prefix of the columns sorted by σ\sigma whose span contains ss;

  2. M←⌈αK∗⌉M \leftarrow\lceil\alpha K^* \rceil; // M≥K∗M \ge K^*, so the window of draw 0 spans ss

  3. for d=0,…,D−1d = 0,\ldots,D-1 in parallel do

  4. σ′←σ\sigma' \leftarrow\sigma if d=0d=0, else σ+βg\sigma+\beta g with gj∼Gumbel⁡(0,1)g_j \sim\operatorname{Gumbel}(0,1) seeded from ss;

  5. Hd←H_d \leftarrow the MM leading columns of HH sorted by σ′\sigma';

  6. if s∉span⁡(Hd)s \notin\operatorname{span}(H_d) then continue;

  7. eliminate HdH_d in order: basis BB, and OSD-0 correction ede_d with HB(ed)B=sH_B(e_d)_B=s;

  8. foreach free (non-pivot) column jj of HdH_d do

  9. uj←u_j \leftarrow the vector with (uj)j=1(u_j)_j=1, basis part solving HB(uj)B=hjH_B(u_j)_B=h_j, and zeros elsewhere; // Huj=hj+hj=0Hu_j=h_j+h_j=0, so adding uju_j to a correction preserves the syndrome

  10. B←{ed}B \leftarrow\{e_d\};

  11. for ℓ=1,…,L\ell=1,\ldots,L do

  12. N←{e⊕uj:e∈B, j free}N \leftarrow\{e\oplus u_j:e\in B,\ j\ \text{free}\}; // flip jj, compensate on BB

  13. B←B \leftarrow the WW cheapest distinct, not previously visited corrections in NN;

  14. ed←arg min⁡e∈B∪{ed}C(e)e_d \leftarrow\underset{e\in B\cup\{e_d\}}{\operatorname{arg\,min}} C(e);

  15. if ede_d has not improved for PP steps then break;

  16. return e∗=arg min⁡dC(ed)e^*=\underset{d}{\operatorname{arg\,min}} C(e_d) over the draws that were not discarded;

Jittered orderings. For each shot, JOBS takes one score σj\sigma_j per fault, here the calibrated TCBP probability written as an LLR, σj=log⁡1−p^jp^j\sigma_j=\log\frac{1-\hat p_j}{\hat p_j}, so that a smaller score means a more likely fault, and forms DD orderings, or draws. Draw zero sorts the columns by the score itself, so the search always contains the ordering that OSD would have used. Each of the remaining D−1D-1 draws adds independent Gumbel noise [71], scaled by β\beta, to every score and sorts the columns again, so likely faults still tend to come first. Two faults with nearly equal scores exchange places in many draws, while a fault that TCBP separates clearly from the rest keeps its position. The draws therefore concentrate on the orderings that the scores cannot tell apart, which is where a single ordering is most likely to be wrong, and the search becomes more productive as the scores become better calibrated. The noise is seeded from the syndrome, so a shot is searched with the same draws on every call and the decoder’s output is repeatable.

Search window. One important speed optimization is that JOBS does not eliminate over all of HH. Before any noise is applied, it computes K∗K^*, the smallest prefix of the unperturbed ordering whose span contains the syndrome (§ 3.1), and fixes a window size of ⌈αK∗⌉\lceil\alpha K^*\rceil columns for the shot, with α=8\alpha=8 by default. The number of columns is shared by all draws, but due to the shuffles, the column contents are not: each draw keeps the leading ⌈αK∗⌉\lceil\alpha K^*\rceil columns of its own jittered ordering, so the noise changes which columns a draw may use as well as their order. A jittered draw whose window does not span faults consistent with the syndrome is discarded; the window of draw zero contains its K∗K^* columns by construction, so every shot returns at least its draw-zero correction. The window adapts the work to the shot: an easy syndrome with a small K∗K^* is searched in a small matrix, and the smaller K∗K^* that TCBP produces (Figure 3) directly reduces the cost of every draw.

Figure 3. OSD-0 with three column orderings from the same 10 iterations of BP, on identical circuit-sampled shots. (a, b) Distribution of K∗K^*, the smallest prefix of the ordering whose columns can explain the syndrome, over BP-non-converged shots. (c) OSD-0 logical error rate with 95% Wilson intervals; labels give the reduction of TCBP relative to the final-LLR ordering.

Beam search from each OSD-0 correction. Each draw is eliminated in its own order and yields its own basis and OSD-0 correction. From that correction JOBS runs a beam search over syndrome-preserving moves. A move flips one free column jj of the draw’s window, on or off, and adds to the basis part the solution xx of HBx=hjH_Bx = h_j, where hjh_j is column jj of HH, so the result still satisfies He=sHe = s. Each step extends every correction in the beam by one move and keeps the WW cheapest distinct results that the draw has not visited before, which prevents the beam from cycling between the same states. Where the combination sweep stops at two free columns, the beam can move up to LL flips away from OSD-0. The search of a draw stops after LL steps, or earlier once PP consecutive steps have not improved its best correction. Corrections are compared by their log-likelihood cost under the prior,

C(e)=∑j:ej=1log⁡1−pjpj,(1)C(e) = \sum_{j:e_j=1} \log\frac{1-p_j}{p_j}, \tag*{(1)}

where pjp_j is the prior probability of fault jj from the detector error model. The TCBP scores decide where JOBS searches, and the prior decides which candidate wins. Every candidate satisfies the syndrome, so the search never repairs invalid candidates; it compares different valid explanations of the same detector data. JOBS returns the correction of least cost over all draws. We use D=16D = 16 draws, β=1\beta= 1, beam width W=32W = 32, depth L=40L = 40 and patience P=8P = 8 throughout, with a single round of draws; the implementation can repeat the DD draws with fresh noise for as long as a round lowers the best cost. JOBS runs only on shots where BP does not converge; it can optionally search the converged shots as well and return the cheaper of BP’s correction and its own.

Relation to other search decoders. Other decoders also replace a single BP decision with a bounded search. BP with guided decimation guessing [44] runs several rounds of BP, decimates in each round the fault it expects to be most likely to have flipped, and keeps both values of that fault open in a small number of rounds. The beam search decoder of [135] branches in every round on both values of the least reliable fault, runs BP again on each path with the fixed faults masked out, and prunes the paths to a beam. Both interleave the search with repeated BP runs. JOBS runs BP once per shot and spends its search budget after BP, on orderings and on moves between corrections that already satisfy the syndrome. The draws of a shot are independent of each other, as are the shots of a batch, so the elimination and beam stages of all draws run concurrently on the device; § 4.2 describes the GPU implementation.

Complementary gap. The search evaluates many valid corrections, each with a cost and a logical class. JOBS can record the lowest cost seen in every class and report the difference between the two cheapest classes as a confidence score for the shot. § 6 defines this score and uses it for postselection.

The rest of this section evaluates TCBP-JOBS as a hard decoder, first for accuracy against Tesseract on identical shots and then for latency and throughput. The decoder settings are listed in Table 1.

error modelcircuit DEM, undecomposed, loops flattened, disjoint errors approximated; DEM rates as priors
BPsum-product, 10 iterations, message clip ±15\pm15, fp32
TCBP modelinit_tcbp_model(H, seed=1); training rates log-uniform in [10−4,10−2][10^{-4}, 10^{-2}], fitted at the BP settings above
column orderingTCBP scores (draw 0); draws 1–15 re-sorted after Gumbel noise of temperature 1.0
windowfirst ⌈8K∗⌉\lceil8K^* \rceil columns, K∗K^* the smallest prefix spanning the syndrome
beam searchwidth 32, depth 40, patience 8; one round
converged shotsBP’s answer kept, not passed to JOBS (also searched in § 6.1 and Appendix § 12)
latency runsbatch size 1, one decode() per shot, host wall clock, one GB200 GPU
throughput runsbatch size 4096 (16,384 in Appendix § 12)
failureany observable wrong, or syndrome not reproduced

Table 1. TCBP-JOBS configuration used throughout: the tcbp-jobs preset of the nv-qldpc decoder, plugin defaults otherwise.

Accuracy against Tesseract on the same shots

TCBP-JOBS is a high-accuracy decoder, providing logical error rates comparable to MLE decoders at the physical error rates tested in this section; § 7 examines even lower error rate regimes. We focus the accuracy analysis in this section relative to Tesseract, another high-accuracy decoder. The comparison uses the shots from 72 circuits under SI1000 noise (joint XYZ decoding), namely the rotated surface code at distance 7, 9, 11 and 13, the color code at the same distances, and the bivariate-bicycle codes [[72,12,6]][[72, 12, 6]], [[90,8,10]][[90, 8, 10]], [[108,8,10]][[108, 8, 10]] and [[144,12,12]][[144, 12, 12]], each in XX and ZZ memory at p=0.001p = 0.001, 0.0020.002 and 0.0040.004. Both decoders work on the joint XYZXYZ decoding graph of each circuit throughout: its full, undecomposed DEM, with the detectors of the XX and the ZZ checks and every error mechanism in one decoding problem, including the mechanisms that flip detectors of both types. Neither decoder splits it into separate XX and ZZ problems.

Stim circuits: All circuits evaluated were derived/generated from the Tesseract repository [1].3 For the surface and color codes, we get byte-identical circuits to those in the repository up to d=11d = 11. d=13d = 13 codes were not present in the repository, so they were generated using the same generators. For BB codes, we modified the circuits in the repository such that no physical qubit in the circuit has more than one operation on it in one time step by inserting TICK instructions. These noiseless circuits were then passed through the SI1000 noise model for different physical error rates.

Decoder configurations: All Tesseract data in this section uses either the short-beam preset or the long-beam preset, both with error sparsification enabled. As described in the Tesseract decoder Python presets, we refer to these as “short beam, sparsified”4 and “long beam, sparsified”5. The long-beam setting at the same sparsification is more accurate but slower: it costs 1.3 to 2 times the decode time per shot at p=0.001p = 0.001, and its median decode time is 1.2 to 2.4 times the short-beam median at p=0.002p = 0.002 and 1.7 to 5.5 times at p=0.004p = 0.004. The short-beam run decodes each stream from shot 0 until its 25th logical error, and a little past it; we call these shots the prefix of the stream. The longest streams, at p=0.001p = 0.001, run to 1.3×1081.3 \times10^8 shots per circuit. The long beam was run on every shot of the prefix at p=0.002p = 0.002 and 0.0040.004; that comparison follows the main results. TCBP-JOBS decodes the same prefix with BP (10 iterations, FP32), JOBS with TCBP column ordering, the same DEM rates as prior, and batches of 4,096 shots on one NVIDIA GB200; JOBS runs only on the shots where BP does not converge, which is the decoder’s default.6 A shot fails if any logical observable is wrong. The comparison is paired per shot: we count the shots that only Tesseract gets wrong and the shots that only JOBS gets wrong, test them with an exact two-sided McNemar test, and report the ratio of the two logical error rates (LER) on the common prefix. The McNemar test uses only these discordant shots: if the two decoders were equally accurate, a discordant shot would be equally likely to count against either of them, so the observed split is compared with a binomial distribution of probability 1/21/2. A small test pp-value, pMcNp_{\mathrm{McN}} in the tables, means that one decoder fails more often than the other on the same shots. The Tesseract failing shots come from a run on x86 CPUs; a second run on Grace CPUs reproduced the same failing shots on all 72 circuits. The two runs stop at different points past the 25th failure, so they share 6.2×1086.2 \times10^{8} of the 6.6×1086.6 \times10^{8} prefix shots.

In addition to the results below that compare against runs with sparsification enabled, we also report serial decoding latency results against unsparsified long-beam Tesseract in Appendix § 11 and batched throughput results in Appendix § 12. We note that the LER performance of TCBP-JOBS is largely at parity or better compared to this Tesseract preset as well.

Results: comparison with sparsified short-beam Tesseract. Table 2 gives the comparison pooled over the XX and ZZ memory experiments, and Figure 5 plots the pooled LER ratio against distance; the per-basis rows are in the appendix. Up to distance 9, and on the [[72, 12, 6]] code, the two decoders are at parity at every pp: the LER ratios (Tesseract LER divided by TCBP-JOBS LER) are 0.9 to 1.2 and no row is statistically significant enough to show non-parity (pMcN≥0.09p_{\mathrm{McN}} \ge0.09). At p=0.002p = 0.002 and 0.0040.004 JOBS has the lower LER from distance 10 upward in all three families, and the ratio grows with distance, reaching 3.0 to 4.5 at distance 12 and 13 at p=0.002p = 0.002. There almost every discordant shot is a Tesseract failure: 40 shots fail only under Tesseract against 1 only under JOBS on the [[144, 12, 12]] code, and 35 against 1 on the surface code at distance 13. At p=0.001p = 0.001 the result depends on the family. The surface code has a ratio of 2.6 at distance 13 (37 against 1) and 1.2 at distance 11 (18 against 5, pMcN=0.01p_{\mathrm{McN}} = 0.01), and the color code a ratio of 1.9 at distance 13 (85 against 31) while at parity from distance 7 to 11. The bicycle codes are at parity or slightly below, 0.8 to 1.0, and one row is significant in Tesseract’s favor: the [[108, 8, 10]] code, with an LER ratio of 0.8 and 13 shots failing only under Tesseract against 32 only under JOBS (pMcN=7×10−3p_{\mathrm{McN}} = 7 \times10^{-3}). A possible explanation is that the residual failures there are few-fault events that Tesseract’s search finds and that TCBP-JOBS occasionally misses on these degenerate codes; § 7 finds such events on the gross code at lower physical error rates. Each pooled row has 50 to 170 Tesseract failures, so a single LER ratio has a 95% interval of roughly 0.7 to 1.4 times its value even with the pairing.

Results: comparison with sparsified long-beam Tesseract. The short-beam setting is Tesseract’s fastest preset, not its most accurate one. At p=0.002p = 0.002 and 0.0040.004 the long beam was run at the same sparsification on every shot of the 48 prefixes, 1.7×1061.7 \times10^{6} shots, so the long-beam columns of Table 2 and the lower row of Figure 5 are paired with the same shots. Summed over all codes, the long beam fails 563 shots at p=0.002p = 0.002 and 1,005 at p=0.004p = 0.004, against 699 and 1,260 for the short beam and 478 and 811 for TCBP-JOBS; 148 shots fail only under the long beam against 63 only under JOBS at p=0.002p = 0.002 (pMcN=5×10−9p_{\mathrm{McN}} = 5 \times10^{-9}), and 433 against 239 at p=0.004p = 0.004. The gain is again on the largest codes. At p=0.002p = 0.002 the LER ratio is 1.9 to 2.2 at distance 12 and 13 (12 shots fail only under Tesseract against 1 only under JOBS on the [[144, 12, 12]] code); the other rows are at 1.0 to 1.4 and, apart from [[72, 12, 6]] (1.2, pMcN=0.04p_{\mathrm{McN}} = 0.04), not significant. At p=0.004p = 0.004 it is 2.7 and 2.5 on the [[144, 12, 12]] and [[108, 8, 10]] codes (51 versus 7 and 55 versus 9), 2.0 and 1.5 on the surface code at distance 13 and 11, and 1.4 on the color code at distance 13; the other rows are at 0.9 to 1.2 and not significant. No row at either noise level is significant in the long beam’s favor. At p=0.001p = 0.001 the prefixes hold 6.6×1086.6 \times10^{8} shots and the long beam was not run on all of them, so those cells of Table 2 are empty. In summary, TCBP-JOBS is at parity with or more accurate than Tesseract’s long-beam setting at p=0.002p = 0.002 and 0.0040.004, with ratios of 0.9 to 2.7; at p=0.001p = 0.001 we did not make this comparison.

Batched cost. Figure 6 puts the two decoders on one device each: a 72-core Grace CPU running sparsified Tesseract with every core busy against one GB200 GPU running TCBP-JOBS in batches of 4,096 shots, both measured as throughput rather than latency. The GPU is 2.6 to 1,400 times faster, the least on the surface codes at p=0.001p = 0.001 and the most on the color and bicycle codes against the long beam. TCBP-JOBS thus matches or exceeds the accuracy of sparsified Tesseract (Figure 5)

Figure 5. Ratio of Tesseract to TCBP-JOBS logical error rate on the common shot prefix against code distance, one panel per pp and one line per code family, XX and ZZ memory pooled; the two distance-10 bicycle codes are drawn side by side ([[90, 8, 10]] left, [[108, 8, 10]] right). Top row: short-beam sparsified Tesseract; error bars are approximate 95% intervals from the paired counts, with the failures common to both decoders held fixed. Bottom row: long-beam sparsified Tesseract on the whole prefix at p=0.002p = 0.002 and 0.0040.004, points and bars as in the top row; the long-beam sparsified was not run on the whole prefix at p=0.001p = 0.001, so that panel is left out. The dashed line is parity.

codeppshotsfails Jfails TT-only / J-onlyratiopMcNp_{\mathrm{McN}}fails TT-only / J-onlyratiopMcNp_{\mathrm{McN}}
[[72, 12, 6]]0.001118k665914 / 210.90.31––––
[[72, 12, 6]]0.0029.8k606917 / 81.20.117118 / 71.20.04
[[72, 12, 6]]0.00492614515940 / 261.10.1115636 / 251.10.20
[[90, 8, 10]]0.00126.7M888517 / 201.00.74––––
[[90, 8, 10]]0.002179k325023 / 51.69×10−49 \times10^{-4}3812 / 61.20.24
[[90, 8, 10]]0.0048195110365 / 132.02×10−92 \times10^{-9}6330 / 181.20.11
[[108, 8, 10]]0.001110.6M987913 / 320.87×10−37 \times10^{-3}––––
[[108, 8, 10]]0.002401k215135 / 52.41×10−61 \times10^{-6}3015 / 61.40.08
[[108, 8, 10]]0.0048203111591 / 73.7<10−10<10^{-10}7755 / 92.54×10−94 \times10^{-9}
[[144, 12, 12]]0.001221.7M555317 / 191.00.87––––
[[144, 12, 12]]0.002356k115040 / 14.5<10−10<10^{-10}2212 / 12.03×10−33 \times10^{-3}
[[144, 12, 12]]0.0044522612197 / 24.7<10−10<10^{-10}7051 / 72.72×10−92 \times10^{-9}
color d=7d=70.001200k58556 / 90.90.61––––
color d=7d=70.00214k9410419 / 91.10.0910318 / 91.10.12
color d=7d=70.0041.4k13413222 / 241.00.8813022 / 261.00.67
color d=9d=90.0011.2M545212 / 141.00.85––––
color d=9d=90.00217k515313 / 111.00.845211 / 101.01.00
color d=9d=90.004819999543 / 471.00.758731 / 430.90.20
color d=11d=110.00115.5M13513448 / 491.01.00––––
color d=11d=110.00225k365228 / 121.40.023911 / 81.10.65
color d=11d=110.0046047411182 / 451.51×10−31 \times10^{-3}8444 / 341.10.31
color d=13d=130.00130.8M6011485 / 311.95×10−75 \times10^{-7}––––
color d=13d=130.00220k125348 / 74.41×10−81 \times10^{-8}2619 / 52.27×10−37 \times10^{-3}
color d=13d=130.00445188172131 / 472.02×10−102 \times10^{-10}12385 / 501.43×10−33 \times10^{-3}
surface d=7d=70.001575k46504 / 01.10.12––––
surface d=7d=70.00230k54584 / 01.10.12584 / 01.10.12
surface d=7d=70.0042.0k53589 / 41.10.27589 / 41.10.27
surface d=9d=90.00113.2M1401414 / 31.01.00––––
surface d=9d=90.002116k51555 / 11.10.22534 / 21.00.69
surface d=9d=90.0042.0k505715 / 81.10.215511 / 61.10.33
surface d=11d=110.00159.2M698218 / 51.20.01––––
surface d=11d=110.002268k395320 / 61.49×10−39 \times10^{-3}397 / 71.01.00
surface d=11d=110.0042.0k346338 / 91.92×10−52 \times10^{-5}5127 / 101.58×10−38 \times10^{-3}
surface d=13d=130.001182.5M235937 / 12.63×10−103 \times10^{-10}––––
surface d=13d=130.002258k175135 / 13.01×10−91 \times10^{-9}3217 / 21.97×10−47 \times10^{-4}
surface d=13d=130.0041.8k267458 / 102.82×10−92 \times10^{-9}5132 / 72.07×10−57 \times10^{-5}

Table 2. TCBP-JOBS against Tesseract on the same shot prefix, both with the circuit’s DEM rates as prior, X and Z memory pooled. Shots is the prefix decoded by both; fails J and fails T are the failures of TCBP-JOBS and of Tesseract on it. T-only and J-only are the shots that fail under one decoder only. Ratio is Tesseract LER over JOBS LER. pMcNp_{\mathrm{McN}} is the exact two-sided McNemar test on the discordant shots. Short beam: Tesseract’s short-beam sparsified setting on the whole prefix. Long beam: the long-beam sparsified setting on the whole prefix, run at p=0.002p = 0.002 and 0.0040.004. At p=0.001p = 0.001 it was not run on the whole prefix (dashes): decoding again only the short-beam failures gives a lower bound on the long-beam failures, and that bound proved loose at p=0.002p = 0.002 and 0.0040.004. The XX and ZZ experiments agree within their intervals; the per-basis table for the short beam is in the appendix. The Tesseract prefix ends shortly after its 25th short-beam failure, so its short-beam LER on the prefix is biased upward by a few percent; the paired columns are not.

at a fraction of the device time. Two other comparisons are more favorable still: single-shot latency, where the GPU is not amortized over a batch (§ 4.2), and Tesseract without sparsification (Appendix § 12), which is sometimes needed to close part of the LER gap to TCBP-JOBS.

Figure 6. Batched throughput ratio of TCBP-JOBS on one GB200 GPU to sparsified Tesseract running on a 72-core Grace CPU (assuming perfect workload sharing across the CPUs). One panel per pp and one line per code family, XX and ZZ memory pooled; the two distance-10 bicycle codes are drawn side by side ([ [90, 8, 10] ] left, [ [108, 8, 10] ] right). Both are throughput measurements with every core or the whole GPU busy, not latencies (§ 4.2).

Potential for real-time decoding

A minimum decoding throughput is needed to enable real-time decoding and avoid the backlog problem [117, 60]. Parallelizing decoders across windows can help meet these throughput requirements with additional hardware resources, subject to the costs of overlapping windows, boundary handling and communication [110, 120, 7]. Online decoding also contributes to the reaction time of the classical control and decoding system. Following the definition in the Supplementary Information, Sec. III.D.1 of Ref. [53], reaction time is the time required for the control system to respond to a logical measurement by executing a dependent logical operation. It comprises

Treact=Tdecode+Tcontrol,(2)T_{\mathrm{react}} = T_{\mathrm{decode}} + T_{\mathrm{control}}, \tag*{(2)}

where TdecodeT_{\mathrm{decode}} is decoder latency and TcontrolT_{\mathrm{control}} accounts for gate execution, physical readout and the control system’s response to the decoded outcome. This reaction time limits the rate of logical operations requiring feed-forward [75, 87]. The measurements below characterize decoder-call latency as a contribution to the complete reaction time.

The allowable reaction time depends on the architecture and workload. A 10 µs reaction time is assumed in superconducting resource estimates discussed in Ref. [24]; Google’s distance-5 surface-code experiment demonstrated a mean software decoding latency of 63 μ\mus [53]. GPU decoding has also been demonstrated on atomic platforms: BP-OSD on Quantinuum Helios achieved a 67 μ\mus median for Bring’s code [98], and the NVIDIA–QuEra neutral-atom study reported sub-millisecond decoding for a distance-3 magic-state-distillation circuit [97]. These decoder measurements establish precedents on their respective workloads; a full-system reaction-time budget must also account for control and communication. Here we evaluate whether TCBP-JOBS can deliver accuracy comparable to Tesseract at decoding latencies relevant to AMO feed-forward operations.

Figure 7 compares serial decoder latency with logical error rate across the three code families. TCBP-JOBS retains the accuracy established in § 4.1 while substantially reducing mean serial decoding time. At p=0.002p = 0.002, its geometric-mean speedups over sparsified short-beam Tesseract are 18×\times, 251×\times, and 376×\times for surface, color, and bicycle codes, respectively. Against sparsified long-beam Tesseract, the corresponding speedups are 30×\times, 866×\times, and 1,357×\times. More importantly, the maximum average decode time across all memory experiments of dd rounds was 18 ms/shot, even at the near-threshold error rate of p=0.4%p = 0.4\%. The mean per-round times ranged from 55 μ\mus to 1.5 ms, which should be suitable for real-time operation of many AMO systems. Table 3 reports the speedups together with the accompanying logical-error-rate ratios.

Figure 7. Mean serial decode latency per shot (dd rounds) against logical error rate per round for the three code families. Each curve joins four code sizes at one physical error rate. TCBP-JOBS uses one GB200 GPU and batch size one; Tesseract uses one Grace core per process under full CPU load, and both of its settings use error sparsification. Accuracy comes from paired decoding of common prefixes. Long-beam results are available at p=0.2%p = 0.2\% and 0.4%0.4\% only.

familyppspeedupLER ratiospeedupcodeLER ratio
Tesseract short beam (sparsified) / TCBP-JOBS
surface0.1%10×1.4×27×d132.6×
surface0.2%18×1.5×65×d133.0×
surface0.4%81×1.6×283×d132.9×
color0.1%54×1.1×129×d131.9×
color0.2%251×1.6×506×d134.4×
color0.4%660×1.3×833×d91.0×
BB0.1%71×0.9×123×[[144, 12, 12]]1.0×
BB0.2%376×2.1×486×[[144, 12, 12]]4.5×
BB0.4%1,300×2.6×1,607×[[90, 8, 10]]2.1×
Tesseract long beam (sparsified) / TCBP-JOBS
surface0.2%30×1.2×118×d131.9×
surface0.4%270×1.4×1,126×d132.0×
color0.2%866×1.3×1,885×d132.2×
color0.4%3,312×1.1×4,580×d90.9×
BB0.2%1,357×1.4×1,899×[[108, 8, 10]]1.4×
BB0.4%6,275×1.8×7,384×[[108, 8, 10]]2.6×

Table 3. TCBP-JOBS serial speedup and Tesseract-to-JOBS LER ratio for the memory experiments above. Left: geometric means over four code sizes. Right: the code with the largest speedup and its own LER ratio. Both Tesseract settings use error sparsification. CPU latencies are measured under full load; speedups against an otherwise idle system would be approximately 10–25% smaller.

GPU execution. JOBS exploits parallelism within a single shot: its independent perturbed orderings undergo elimination and beam search concurrently on the GPU. This parallelism remains available at batch size one. Search effort also adapts to the syndrome. BP-converged shots retain their correction without invoking JOBS, the search window scales with K∗K^*, and beam patience terminates draws that cease improving. These mechanisms reduce work on easier shots while allowing harder syndromes more search effort.

Hierarchical decoding for AMO systems. Zhao et al. [137] evaluate ultra-high-rate qLDPC memories for reconfigurable atom arrays using a hierarchy of BP, Relay-BP and an integer-programming MLE decoder implemented in Gurobi. Non-converging shots advance to the next tier, making the expensive final stage rare enough to sustain high simulation throughput. Their Appendix C discusses extending this approach to real-time decoding and identifies faster approximate decoders as candidates to replace exact integer programming. A rare slow fallback can nevertheless delay a logical operation that depends on its result, even when average throughput meets the syndrome arrival rate. TCBP-JOBS addresses this bottleneck by retaining BP’s fast path and applying TCBP-guided parallel GPU search to the remaining shots. The measured accuracy–latency tradeoffs here motivate its use as a high-accuracy fallback in such a hierarchy, potentially replacing or supplementing the Relay-BP and integer-programming stages. Our measurements cover different codes and noise models from those of Ref. [137]; evaluating the replacement on their code family remains future work, and JOBS does not certify MLE optimality. The complementary gap from JOBS (§ 6) could aid in deciding when to pass data to additional decoding stages.

Timing methodology. We measure TCBP-JOBS decode times on one NVIDIA GB200 using CUDA-Q QEC 0.9.0 [95], batch size one, and one decode() call per shot. The host timer surrounds the call and conversion of the returned result to a NumPy array. Model fitting, decoder construction, and 200 warm-up calls are excluded. Each circuit contributes the first 20,000 shots of its seeded stream, or the entire accuracy prefix when shorter. Tesseract runs as one single-threaded process pinned to each physical Grace CPU core, with all cores occupied; its timing uses the decoder’s internal timer. Its distributions cover the first 10,000 shots per stream at p=0.001,0.002,p = 0.001, 0.002, and 1,000 at p=0.004p = 0.004. Accuracy is evaluated separately on the common prefixes described above.

Measured decoder latencies. Averaged over the two memory bases, mean TCBP-JOBS latency at p=0.002p = 0.002 ranges from 0.64 ms for the distance-7 surface code to 4.97 ms for the distance-13 color code. The gross code takes 4.08 ms. At p=0.004p = 0.004, these times increase, reaching 14.9 ms for the distance-13 color code and 17.8 ms for the gross code. Each timing represents a complete memory shot containing dd syndrome-extraction rounds.

Logical-surgery decoder latency. Memory experiments characterize decoding accuracy and cost, while logical operations expose the feed-forward dependencies that make reaction time important. In logical surgery, the decoded outcome of a joint logical measurement can determine subsequent operations, placing decoding on the computation’s critical path [75]. We therefore evaluate TCBP-JOBS on a simulated intra-block logical measurement of Xˉ1Xˉ2\bar{X}_1\bar{X}_2 on two logical qubits of a single [[144,12,12]][[144, 12, 12]] gross code block, performed by lattice surgery with a graph gadget: 24 vertex checks attached to the support of Xˉ1Xˉ2\bar{X}_1\bar{X}_2 and 50 edge qubits merge the two logicals into one stabilizer, giving a [[194, 11, 12]] merged code that is measured for 12 rounds, followed by one round of the original code and a transversal readout. The circuit uses 383 physical qubits (144 data, 50 edge and 189 ancilla qubits), 2,481 detectors and 13 observables: the surgery outcome and the 12 logical Xˉ\bar{X} observables, and a shot fails if any of them is decoded incorrectly. SI1000 noise is applied to steps 2–5; the initial preparation, which includes an ideal reference measurement of the ZZ checks, and the final transversal readout are noiseless, following the circuit construction. We decode each shot over the full circuit and report the software-side decoder latency that contributes to the reaction time of AMO feed-forward operations. Table 4 compares four decoders on the same first 100,000 shots at each physical error rate. A failure is any wrong observable or an invalid correction; Relay-BP non-convergence also counts as failure. The stronger Tesseract baseline uses two passes and a long beam with a basis-tagged DEM.

ppdecoderfailuresmean (ms)p50 (ms)p99 (ms)
0.1%TCBP-JOBS03.953.3613
0.1%Tesseract multi-pass + long04201726,522
0.1%Tesseract short + sparsify41,51383012,115
0.1%Relay-BP (relay300)181.841.1310.4
0.2%TCBP-JOBS2713.511.842.9
0.2%Tesseract multi-pass + long4110,2375,32250,458
0.2%Tesseract short + sparsify2,34220,24619,61846,272
0.2%Relay-BP (relay300)2,75323.36.5239
0.4%TCBP-JOBS55,91452.953.1116
0.4%Tesseract multi-pass + long47,772102,882103,544144,392
0.4%Tesseract short + sparsify96,70563,79364,59285,584
0.4%Relay-BP (relay300)99,867238238244

Table 4. Accuracy and serial latency on the surgery shots above. Each row uses the same 100,000-shot prefix at its noise rate. Failure includes any wrong observable, invalid correction, or Relay-BP non-convergence. GPU decoders use one GB200, batch size one; Tesseract uses one Grace core per process under full CPU load. Multi-pass Tesseract uses two passes, a long beam and a basis-tagged DEM. Timing boundaries are described in the text.

At p=0.002p = 0.002, TCBP-JOBS fails 27 shots against 41 for multi-pass Tesseract, with mean decoding times of 13.5 ms and 10.2 s, respectively. Relay-BP has a lower median latency than JOBS (6.50 ms against 11.8 ms), but fails 2,753 shots and has a longer tail: its p99 is 239 ms against 42.9 ms for JOBS. Only 0.375% of JOBS calls exceed 50 ms, compared with 11.0% for Relay-BP. At p=0.001p = 0.001, neither JOBS nor multi-pass Tesseract fails in these 100,000 shots. A longer paired accuracy run on the same stream finds 10 failures for each on their common 6.3-million-shot prefix, including three failures unique to each decoder. The p=0.004p = 0.004 results are a stress test: both decoders fail on roughly half the shots, despite JOBS retaining a large latency advantage.

Figure 8 shows the measured JOBS latency distributions. The surgery measurements use a batch-one decoder on one GB200 GPU using CUDA-Q QEC 0.9.0 [95], with one process per GPU pinned to four Grace cores, and 20 warm-up calls per 2,500-shot piece. The host timer surrounds only decode(), with a Python-list syndrome prepared beforehand and NumPy conversion of the result afterward. Tesseract uses its internal decode timer, with one process per physical Grace core and all cores occupied. These surgery timings were measured separately from the memory results above.

Figure 8. TCBP-JOBS serial latency for gross-code X1X2X_1X_2 logical surgery. Each panel contains 100,000 shots, including failures. Shading shows measured histograms with logarithmic bins. Curves are Gaussian kernel-density estimates in log latency, transformed to density per millisecond; smoothing is for display only. Lines mark the empirical median and p99. The horizontal axis is logarithmic and vertical scales differ. Panel (c) is a stress test with 55.9% failures.

Noise Learning

A decoder needs the probability of every error mechanism in the detector error model (DEM). On hardware these rates are not known. They drift between calibrations, and a decoder run with stale or uniform rates loses accuracy. This section shows that the TCBP posteriors support an unsupervised estimate of all per-mechanism rates from unlabeled detector data, in minutes on one GPU, and that decoding with the learned rates matches the accuracy of decoding with the true rates to within a few percent at p=0.002p = 0.002 and 0.004.

Learning procedure

Estimating error rates from the output of running error detection circuits, instead of from dedicated characterization experiments such as randomized benchmarking, goes back to Fowler et al. [40]. Our procedure follows the estimator of Wagner et al. [126], who combine belief propagation with expectation-maximization: the E-step sums the posterior marginal of every error over the recorded syndromes, and the M-step sets each rate to that sum divided by the number of shots. Unlike earlier methods that count the errors in a decoder’s hard decisions, this uses the full posterior of each error. On concatenated codes the factor graph is a tree, BP marginals are exact, and the estimator is optimal. The authors note that the method could be applied to qLDPC codes, where the difficulty is that BP is no longer exact. We take up that case with two changes. First, the E-step uses the calibrated TCBP posteriors of § 3 in place of the BP marginals. Second, the M-step multiplies each rate by the ratio of its posterior mass on the device data to its posterior mass on a reference stream simulated from the current rates, which cancels the bias that remains in the posteriors. With exact posteriors the reference mass equals the expected number of occurrences of the error and the update reduces to theirs.

As detailed in Figure 9, the input to the procedure is a set of NN detector shots from the circuit under test. No error labels and no nominal rates are used. The unknowns are the mm rates pjp_j of the DEM, one per mechanism (m=67,752m = 67{,}752 for the gross code below). The start is uniform: every pjp_j is set to the single rate that reproduces the mean detector event rate of the data.

Figure 9. Noise learning with TCBP. The inputs are recorded detector shots and the structure of the detector error model; no error labels or nominal rates are used. Each pass decodes the device shots and a reference set of shots simulated from the current rates, sums the calibrated TCBP posterior of every mechanism over each set, and multiplies each rate by the ratio of the two sums. The three variants share this loop and differ in what is learned: one rate per mechanism, one rate per class of mechanisms that repeat across rounds, or the parameters of a small physical noise model. Stronger assumptions about the noise reduce the number of shots needed.

Learning is an expectation-maximization (EM) loop over the TCBP decoder. The E-step decodes the NN shots with the current rates and records, for every mechanism, the calibrated posterior probability p^j\hat{p}_j that TCBP assigns to it (§ 3). Summing over shots gives a posterior mass per mechanism. The same decoder with the same rates is also run on a matched reference stream of NN shots simulated from the current rates. The M-step multiplies each rate by the ratio of the two masses, device over reference. Where the device data show more of a mechanism than the current model predicts, the rate goes up, and vice versa. The reference stream cancels the residual bias of the TCBP calibration, because the same miscalibration acts on both streams. The loop runs four passes, or fewer when the rate update falls below a tolerance.

Two variants trade generality for shot efficiency. The tied variant shares one rate across mechanisms that are translates of each other in time, which cuts the number of unknowns by the number of rounds and reaches a given accuracy with fewer shots. The parametric variant fits a small physical noise model, such as a per-gate Pauli channel, through a design matrix that maps model parameters to DEM rates. Both reuse the same E-step. The results below use the per-mechanism variant, which makes no assumption beyond the DEM structure.

Experimental setup

For experimental evaluation, we choose the [[144,12,12]][[144, 12, 12]] bivariate-bicycle (gross) code, 12 rounds of syndrome extraction, ZZ-basis memory, and circuit-level SI1000 noise at physical error rate p∈{0.001,0.002,0.004}p \in\{0.001, 0.002, 0.004\}. The circuits and the seeded detector streams are those of the Tesseract comparison. The DEM has 1,728 detectors, 67,752 mechanisms and 12 observables. All runs use one NVIDIA GB200.

The TCBP model is fitted once per pp, in about 10s, on rates the fitting routine draws itself, with no knowledge of the true rates. Learning data are the first NN shots of a late segment of the stream, NN from 2102^{10} to 2212^{21}, disjoint from the evaluation shots. Learning time is wall-clock time of the EM loop on the GPU, excluding data loading and the TCBP fit.

Decoding uses BP with 10 iterations in FP32, followed by JQBS with TCBP column ordering. The learned rates are ordinary DEM priors and can be given to any decoder; only the EM loop itself requires TCBP. We evaluate them with TCBP-JQBS because it is accurate and fast enough for this experiment. The same TCBP model is used for all four priors: uniform, the single start rate described above (2.59×10−42.59 \times10^{-4}, 4.88×10−44.88 \times10^{-4} and 8.71×10−48.71 \times10^{-4} at the three pp); learned, the per-mechanism rates after learning on 2212^{21} shots with the default stopping rule, which ends the EM loop after four passes here; learned, 16 passes, the rates after 16 passes with the tolerance off on 2192^{19} shots (905 s on one GB200), the setting we recommend; oracle, the rates of the DEM the shots were sampled from. Every arm decodes the same stream from shot 0 in chunks of 4,096. A shot fails if any of the 12 observables is wrong or the correction does not reproduce the syndrome. The second case did not occur. An arm stops at 2×1062 \times10^{6} shots or after 3,300 s of wall time, with no failure-based stop. Arms that hit the time cap decoded a prefix of the stream, so they are compared shot by shot on the longest prefix all arms reached, with an exact McNemar test on the shots where exactly one arm fails. Rate accuracy is the median over mechanisms of ∣log⁡(p^j/pj)∣|\log(\hat{p}_j/p_j)|, where pjp_j is the true rate. The same study was repeated with a second seed for the TCBP fit and the learning run, and on the XX-basis circuits.

Results

Table 5 gives learning time and accuracy. Time is linear in NN, about 0.43 ms per shot, and does not depend on pp. The start rate has median error 1.36, 1.30 and 1.18 at p=0.001p = 0.001, 0.002 and 0.004. One run over 2172^{17} shots takes 57 s and reduces it to 0.20 to 0.38. More shots help at p=0.002p = 0.002 and 0.004. At p=0.001p = 0.001 the error stops at 0.18 from 2192^{19} shots on.

Table 5. Noise learning on the gross code, one GB200. Error is the median over the 67,752 mechanisms of ∣log⁡(learned/true)∣\lvert\log(\mathrm{learned}/\mathrm{true})\rvert. The uniform start has error 1.36 / 1.30 / 1.18 at p=0.001p = 0.001 / 0.002 / 0.004. At p=0.001p = 0.001 the 2212^{21}-shot run stopped after three passes (682 s).

NNtimemedian ∣log⁡(learned/true)∣\lvert\log(\mathrm{learned}/\mathrm{true})\rvert p=0.001p=0.0010.0020.0020.0040.004
2172^{17}57 s0.2520.2000.377
2192^{19}227 s0.1790.1450.339
2212^{21}910 s0.1820.1190.326

Table 6 gives the logical error rate (LER) of TCBP-JOBS under the four priors. Intervals are 95% Clopper–Pearson. Learning from the uniform start lowers the LER by a factor of 22 at p=0.002p = 0.002 and 6 at p=0.004p = 0.004 with the default stopping rule, and by 27 and 9 with 16 passes. It also makes decoding 3 to 7 times faster per shot, because BP under the uniform prior converges on far fewer shots and JOBS runs more often. Against the oracle, the learned prior with the default stopping rule is 1.2 times worse at p=0.002p = 0.002 (81 against 66 failures; on the common prefix 4 shots fail only under learned and 2 only under oracle) and 1.45 times worse at p=0.004p = 0.004, where the paired test on the common prefix of 28,672 shots is decisive: 1,303 shots fail only under learned and 477 only under oracle. With 16 passes the gap closes: 1.03 at p=0.002p = 0.002 (68 against 66 failures, 13 against 11 discordant, p=0.84p = 0.84) and 1.02 at p=0.004p = 0.004 (3,143 against 2,907 discordant on the common prefix of 172,032 shots, p=3×10−3p = 3 \times10^{-3}, significant only because that prefix holds 11,000 failures). Against the default-rule learned prior the 16-pass prior is 0.84 times at p=0.002p = 0.002 (p=0.06p = 0.06) and 0.71 times at p=0.004p = 0.004 (p<10−300p < 10^{-300}). The X-basis circuits give the same picture: default rule 64 against 50 oracle failures at p=0.002p = 0.002 and 1.45 at p=0.004p = 0.004; 16 passes 50 against 50 (1.00) and 1.03. Learning on 2172^{17} shots with 16 passes (227 s) is already within 1.00 to 1.08 of the oracle, and learning on 2212^{21} shots (3,620 s) halves the rate error again, to 0.05, but moves the LER by at most one discordant shot in 2×1062 \times10^{6}. We therefore recommend the learned prior as 16 EM passes with the tolerance off on 2192^{19} shots, 905 s on one GB200, within 1.02 to 1.03 of the DEM prior at p=0.002p = 0.002 to 0.004. At p=0.001p = 0.001 every learned and oracle prior fails 0 or 1 shots in 2×1062 \times10^{6} (the one X-basis failure is the same shot under the oracle and both learned priors), so no claim is made there beyond the 9-to-1 drop from the uniform prior. The second seed changes every failure count by 1 to 2%. The same picture was obtained on an independent SI1000 construction of the gross code, the unmodified ZZ-memory circuit of the Tesserract repository’s test data, with freshly sampled shots at p=0.002p = 0.002, 0.003 and 0.004 and every arm stopped at 200 failures, which fixes each ratio to about 20%: the learned prior at 1.05, 1.00 and 1.03 times the oracle LER with 16 passes and at 1.06, 1.20 and 1.39 times with the default rule.

Table 6. Logical error rate of TCBP-JOBS on the gross code under four rate priors, ZZ basis, one seed. Uniform: one rate matched to the mean detector event rate. Learned: per-mechanism rates from 2212^{21} unlabeled shots with the default stopping rule (four passes). Learned, 16 passes: from 2192^{19} shots with 16 passes and the tolerance off. Oracle: the true rates. Every arm decodes the same stream from shot 0. Arms with fewer than 2×1062 \times10^{6} shots stopped at the 3,300 s wall-time cap. Decode time is per shot, batched, on one GB200, measured separately with CUDA-Q QEC 0.9.0 on the first 131,072 shots of each arm (28,672 under the uniform prior at p=0.004p = 0.004).

pppriorshotsfailsLER (95% CI)μ\mus/shot
0.001uniform2,000,00094.5×10−64.5 \times10^{-6} (2.1–8.5×10−68.5 \times10^{-6})399
0.001learned2,000,00015×10−75 \times10^{-7} (0.01–2.8×10−62.8 \times10^{-6})150
0.001learned, 16 passes2,000,00000 (0–1.8×10−61.8 \times10^{-6})149
0.001oracle2,000,00000 (0–1.8×10−61.8 \times10^{-6})149
0.002uniform315,3922869.1×10−49.1 \times10^{-4} (8.18.1–10.2×10−410.2 \times10^{-4})3,007
0.002learned2,000,000814.1×10−54.1 \times10^{-5} (3.23.2–5.0×10−55.0 \times10^{-5})433
0.002learned, 16 passes2,000,000683.4×10−53.4 \times10^{-5} (2.62.6–4.3×10−54.3 \times10^{-5})413
0.002oracle2,000,000663.3×10−53.3 \times10^{-5} (2.62.6–4.2×10−54.2 \times10^{-5})408
0.004uniform28,67216,4410.573 (0.568–0.579)20,251
0.004learned131,07212,2609.4×10−29.4 \times10^{-2} (9.29.2–9.5×10−29.5 \times10^{-2})5,623
0.004learned, 16 passes172,03211,3476.6×10−26.6 \times10^{-2} (6.56.5–6.7×10−26.7 \times10^{-2})4,354
0.004oracle180,22411,6416.5×10−26.5 \times10^{-2} (6.46.4–6.6×10−26.6 \times10^{-2})4,158

Stopping rule versus shot count. The decoder’s accuracy is set by when the EM loop stops rather than by how many shots it sees. Table 7 and Figure 10 compare the default rule, which stops after four passes from 2122^{12} shots up, with 16 passes and the tolerance off, each learned from N=210N = 2^{10} to 2192^{19} shots and then decoded over the same 2×1062 \times10^{6} shots as the oracle arm; the ratio is learned failures over oracle failures on the common prefix. From 2142^{14} shots up the ratio under the default rule is flat in NN: 1.2 to 1.3 at p=0.002p = 0.002 and 1.45 to 1.6 at p=0.004p = 0.004, up to the 2212^{21}-shot run of Table 6, although the median rate error keeps falling, from 0.33 to 0.12 at p=0.002p = 0.002. With 16 passes the arm reaches the oracle at p=0.002p = 0.002 from 2162^{16} shots in ZZ memory (ratio 1.00, 18 shots fail only under learned against 18 only under oracle, p=1.00p = 1.00; the same at 2172^{17}, 15 against 15), and in XX memory from 2172^{17} shots (1.08, p=0.50p = 0.50, then 1.00 at 2192^{19}). At p=0.004p = 0.004 it reaches 1.02 to 1.05 from 2162^{16} shots in both bases; the 1.02 at 2192^{19} is still significant against the oracle (p=3×10−3p = 3 \times10^{-3}) because the common prefix holds 11,000 failures. Learning time is linear in shots times passes: 12, 29, 57 and 228 s under the default rule and 46, 114, 227 and 905 s with 16 passes at 2142^{14}, 2162^{16}, 2172^{17} and 2192^{19} shots on one GB200. The cheapest prior indistinguishable from the oracle at p=0.002p = 0.002 is therefore 16 passes on 2162^{16} shots, 114 s, against 909 s for the default 2212^{21}-shot run that stays at 1.23. Below 2162^{16} shots the 16-pass prior no longer reaches the oracle, because it is then limited by the shots and not by the passes.

NNtime (s)p=0.002p = 0.002 defaultp=0.002p = 0.002 16 passesp=0.004p = 0.004 defaultp=0.004p = 0.004 16 passes
2102^{10}2.4 / 3412.62.127.881.96
2112^{11}8.8 / 341.931.595.671.51
2122^{12}9.3 / 361.701.582.231.28
2132^{13}10 / 401.381.331.811.17
2142^{14}12 / 461.301.361.621.12
2162^{16}29 / 1141.181.001.481.04
2172^{17}57 / 2271.331.001.451.03
2192^{19}228 / 9051.181.031.451.02
2212^{21}909 / 36231.231.031.441.02

Table 7. Learned over oracle logical error rate on the common prefix against learning shots NN and EM stopping rule, gross code, ZZ memory, seed 1. Default: the default stopping rule, which runs four passes from 2122^{12} shots up, one pass at 2102^{10}, and at 2112^{11} four passes at p=0.002p = 0.002 and two (4.6 s) at p=0.004p = 0.004. 16 passes: tolerance off. Time is the learning time on one GB200, default / 16 passes. The 2212^{21} row is the learned arm of Table 6 under the default rule and the 2212^{21}-shot 16-pass learning. From 2142^{14} shots up XX memory differs by at most 0.08 except at 2172^{17} under the default rule (1.16) and at 2162^{16} with 16 passes (1.20, p=0.08p = 0.08); below 2142^{14} shots it is shown in Figure 10. 0 or 1 failures in 2×1062 \times10^{6} shots, so their LERs are upper bounds of about 2×10−62 \times10^{-6}, not measurements. At p=0.001p = 0.001 learning on 2212^{21} shots ran three passes and did not improve on 2192^{19} shots. At p=0.004p = 0.004 the arms are time-capped at unequal shot counts, and the paired comparison on the common prefix is the equal-shot result. The second seed varies only the TCBP fit and the learning run, since the shots are fixed. The median log error can hide a tail of badly estimated mechanisms that matter for decoding. The uniform prior is the learner’s data-derived start rate, one value for all mechanisms. A different uniform choice, such as the nominal pp, would change the uniform arm but not the learned or oracle arms.

Figure 10. Learned over oracle logical error rate on the common prefix against the learning time on one GB200, gross code, one panel per pp; the learning shots run from 2102^{10} to 2192^{19} along each curve. Blue: default stopping rule. Red: 16 passes with the tolerance off. Circles and solid lines: ZZ memory; squares and dashed lines: XX memory. The gray band is the uniform prior, that is, no learning; the dotted line is the oracle. The learning time excludes the TCBP model fit, about 10 s. Arms with a poor prior decode more slowly and reach the 3,300 s cap on a shorter prefix. At p=0.001p = 0.001 every learned arm fails 0 or 1 shots in 2×1062 \times10^{6} and is not shown.

Accuracy versus learning time. Figure 10 plots the same ratio against the wall time of the learning run. Without learning, the uniform prior is 24 to 27 times worse than the oracle at p=0.002p = 0.002 and 9 times worse at p=0.004p = 0.004. Under the default rule the learner makes a single pass over 2102^{10} shots in 2.4 s, and the prior is still 8 to 13 times worse than the oracle, with a median rate error of 1.1 (the XX-memory run at p=0.002p = 0.002 made three passes, 6.6 s, and reached 3.5). Four passes over 2122^{12} or 2132^{13} shots take 9 to 10 s and bring the ratio to 1.4 to 1.7 at p=0.002p = 0.002 and 1.8 to 2.2 at p=0.004p = 0.004; 2142^{14} shots, 12 s, give 1.3 and 1.6. Most of the gain over the uniform prior is therefore obtained in about 10 s of learning on one GB200. The remaining factor of 1.2 to 1.6 does not shrink with more shots under the default rule and is removed only by the 16-pass setting on 2162^{16} shots or more, from 114 s. Below 2142^{14} shots the learning time is no longer proportional to NN, since a pass costs about 2 s whatever the shot count; 16 passes then take 34 to 40 s, and their prior is limited by the shots: its median rate error stays at 0.45 to 0.65 from 2102^{10} to 2132^{13} shots and the ratio at 1.2 to 2.7. Every prior learned from fewer than 2142^{14} shots is significantly worse than the oracle at the 5% level. The times exclude the TCBP model fit, about 10 s per pp, which every prior needs, the oracle included.

Discussion

At p=0.002p = 0.002 a learning run over 2172^{17} shots costs about the same GPU time as decoding 1.3×1051.3 \times10^{5} shots with the learned prior, or 1.9×1041.9 \times10^{4} shots with the uniform prior. At this cost the rates can be re-learned between calibrations, from the shots the experiment produces anyway, without labels and without stopping the device. The decoder then keeps a current rate model instead of the one from the last calibration. Where the decoder cannot wait that long, four passes over 2132^{13} shots give a prior within a factor of 1.4 to 1.8 of the oracle in 10 s (Figure 10). A warm start from the previous rates needs fewer passes than the uniform start used here. The tied and parametric variants reach the same accuracy from fewer shots, which shortens the window over which the noise must be stationary.

Limitations

The learning data are simulated from the same DEM the oracle uses, so the study measures recovery of a known model, not model mismatch on hardware. At p=0.001p = 0.001 the learned and oracle arms have

Complementary gap and magic-state cultivation

TCBP-JOBS naturally provides a complementary-gap score through its decoding search. We first evaluate this score as a postselection criterion in memory experiments, then apply it to magic-state cultivation. In cultivation, TCBP-JOBS reduces the binary-YY diagnostic error—the fraction of accepted shots whose decoder-corrected logical-YY expectation has the wrong sign relative to the target state [21]—by up to 4.7×4.7\times relative to the original desaturation/matching decoder used by Gidney et al. [55], while using the same cultivation and grafted surface-escape circuit and hard-postselection rules. Combining JOBS with direct color-code escape yields up to 2.8×2.8\times higher modeled throughput per installed qubit than the original surface-matching configuration at the selected binary-YY error ceilings.

The complementary gap measures the cost separation between competing logical explanations of the observed syndrome. Let HH map modeled faults ee to detector outcomes and LL map them to logical labels. In the decoder’s independent-binary fault model, with fault probabilities pjp_j, the minimum cost in class ℓ\ell and the exact complementary gap are

Wℓ(s)=min⁡He=s, Le=ℓ∑jejlog⁡1−pjpj,(3)W_{\ell}(s) = \min_{H e=s,\ L e=\ell} \sum_j e_j \log\frac{1-p_j}{p_j}, \tag*{(3)}
Δ(s)=min⁡ℓ≠ℓ∗Wℓ(s)−Wℓ∗(s),(4)\Delta(s) = \min_{\ell\ne\ell_*} W_{\ell}(s) - W_{\ell_*}(s), \tag*{(4)}

where ss is the syndrome and ℓ∗\ell_* minimizes WℓW_\ell.

TCBP guides search ordering. JOBS records candidate costs and logical labels, including for detector error models with hyperedges. The score used here, Δ^JOBS\widehat{\Delta}_{\mathrm{JOBS}}, is the difference between the lowest encountered costs in the two best logical classes. The correction returned by JOBS is selected separately and need not belong to the lowest-cost encountered class. These minimum costs do not sum probabilities over all faults within a class, and finite search may miss competing classes. We therefore evaluate the score empirically through observed error rates after postselection. When only one class is encountered, the score is infinite. These shots are retained, although some still contain errors.

Postselection on memory experiments

A decoder that returns only a correction gives no indication of how close the decision was. The score Δ^JOBS\widehat{\Delta}_{\mathrm{JOBS}} measures ambiguity among the logical classes encountered during search. A small score indicates competing classes with similar candidate costs, while a large score indicates greater separation among the encountered classes. We test whether discarding low-score shots preferentially removes decoding failures.

Figure 11 tests this on memory circuits of the three code families of § 4.1 under SI1000 noise at p=0.002p = 0.002 in the ZZ basis. JOBS searches every shot, including those on which BP converged, so that every shot receives a score. We sort the shots by Δ^JOBS\widehat{\Delta}_{\mathrm{JOBS}} and discard those with the lowest score first; shots in which only one class was encountered have an infinite score and are discarded last. The figure plots the failure probability per round of the retained shots against the fraction discarded. Long-beam Tesseract is shown for reference at zero discard; the evaluated implementation does not provide a comparable postselection score.

Figure 11. Postselection on the JOBS gap in memory experiments. Failure probability per round of the retained shots against the fraction of shots discarded, lowest Δ^JOBS\widehat{\Delta}_{\mathrm{JOBS}} first, for SI1000 circuits at p=0.002p = 0.002 in the ZZ basis. Filled markers show TCBP-JOBS at 0, 0.1%, 1% and 10% discarded; bands are 95% confidence intervals. Open markers show long-beam Tesseract, with and without sparsification; the evaluated implementation provides no comparable postselection score.

Cultivation experiment

Gidney et al. combine cultivation and complementary-gap postselection, injecting and cultivating in a color code before growing into a grafted, matchable code [55]. We compare their desaturation/matching decoder with TCBP-JOBS on that construction, and with direct growth in triangular 6.6.6 color codes. We call the grafted route “surface” for brevity. The label d1→15d_1 \to15 denotes cultivation and final code distances.

We simulate non-Clifford T/T†T/T^{\dagger} gates using CliffT [21], with uniform circuit-level Pauli noise p=10−3p = 10^{-3}. For d1=3d_1 = 3, we simulate 2282^{28} color attempts and 5⋅2275 \cdot2^{27} surface attempts. For d1=5d_1 = 5, we simulate 2302^{30} attempts for each construction. JOBS uses 16 search draws. The three surface policies use the same simulated shots. The JOBS “same checks” policy retains the original matching baseline’s hard-postselection rules. The “relaxed checks” policy removes automatic rejection on selected escape-stage detector events, while retaining their outcomes for decoding and preserving cultivation postselection. The direct color-code escape experiment uses JOBS on a different code construction than that of Gidney et al. [55] and therefore tests the combined effect of the construction and decoding choices.

Following the released end-to-end analysis accompanying CliffT [21], we classify each simulated shot using its decoder-corrected logical-YY expectation value, evaluated before terminal stabilizer

projection. In the target frame, where the ideal state has ⟨YL⟩=1/2\langle Y_L\rangle= 1/\sqrt{2}, define

DY=12+⟨YL⟩corr2,(5)D_Y = \frac{1}{2} + \frac{\langle Y_L\rangle_{\mathrm{corr}}}{\sqrt{2}}, \tag*{(5)}
pbinY=Pr⁡(DY<1/2∣accepted).p_{\mathrm{binY}} = \Pr(D_Y < 1/2 \mid\text{accepted}).

We call pbinYp_{\mathrm{binY}} the binary-YY diagnostic error rate and estimate it as the fraction of accepted shots satisfying DY<1/2D_Y < 1/2, equivalently ⟨YL⟩corr<0\langle Y_L\rangle_{\mathrm{corr}} < 0. This criterion thresholds a simulated expectation value, not an individual YLY_L measurement outcome, and is distinct from full magic-state infidelity. Evaluating full magic-state infidelity would also require a full-Pauli recovery for matching, whose analysis specifies only the correction needed for this diagnostic. Acceptance is the fraction of all physical attempts retained, including hard rejects in the denominator.

Accuracy, postselection and factory resources

With identical hard postselection and no score cut, TCBP-JOBS reduces the binary-YY diagnostic error by 2.1×2.1\times for 3→153\to15 and 4.7×4.7\times for 5→155\to15, without changing the quantum circuit or accepted population. The respective error rates decrease from 3.09×10−33.09\times10^{-3} to 1.48×10−31.48\times10^{-3} and from 5.31×10−45.31\times10^{-4} to 1.13×10−41.13\times10^{-4}. For 3→153\to15, applying a JOBS score cut of 15 nats further lowers the error rate to 4.19×10−64.19\times10^{-6}, while acceptance falls from 53.88% to 37.11%. These comparisons test the complete decoder. Isolating TCBP’s contribution requires an ablation.

Panels (a,b) of Figure 12 show how complementary-gap thresholds trade acceptance for diagnostic accuracy in cultivation. The same-check surface curves compare the two decoders on a common hard-selected population; relaxed surface checks and direct color escape provide additional operating points. The two downward arrows in (b) are surface-matching thresholds with zero observed errors; they indicate statistical upper bounds, not zero error rates.

Figure 12. Complementary-gap postselection, cultivation yield and throughput. (a,b) Accepted-shot binary-YY diagnostic error versus acceptance for 3→153 \to15 and 5→155 \to15 at circuit-level noise p=10−3p = 10^{-3}. Markers denote tested gap thresholds; dashed lines are visual guides. Error bars are pointwise two-sided 95% Clopper–Pearson intervals. Downward arrows show one-sided 95% upper bounds where no errors were observed. Orange labels give selected relaxed-JOBS thresholds in nats. Black rings identify the operating points used in (c,d). (c) Highest measured acceptance among tested thresholds whose two-sided 95% error interval has its upper endpoint below 10−510^{-5} for 3→153 \to15 (solid bars) or 10−610^{-6} for 5→155 \to15 (hatched bars). Acceptance error bars are pointwise 95% intervals. Intervals are not adjusted for selection among thresholds. (d) Accepted states per 1,000 reference QEC cycles per factory unit, including rejected work with early abort. One reference cycle is assigned ten equal-duration circuit steps, matching the repeated escape syndrome-extraction rounds in both constructions. This is an approximate time unit, not a count of syndrome rounds experienced by each state. Footprints below the bars give physical qubits per unit for 3→153 \to15 / 5→155 \to15.

Figure 12(c) compares exploratory yields. For each policy, we select the highest acceptance among tested thresholds whose 95% binary-YY error interval has its upper endpoint below the target. With identical hard checks, JOBS raises acceptance from 34.52% to 37.11% for 3→153\to15, and from 4.40% to 4.99% for 5→155\to15. Relaxing escape checks further raises the latter yield to 9.75%. This gain comes from changing the rejection policy. Matching with equivalently relaxed checks remains untested, leaving open whether it offers the same benefit. Direct color escape reaches 10.24%. The four selected 5→155\to15 policies, in that order, contain 27, 31, 75 and 46 binary errors, with different measured error rates. These binary-YY error ceilings do not establish corresponding bounds on full magic-state infidelity.

A factory unit is one reusable injection–cultivation–escape pipeline, attempting one state at a time. Its accepted rate is r=a/τˉr = a/\bar{\tau}, where aa is acceptance and τˉ\bar{\tau} is mean time per attempt. We assign equal duration to the simulator’s circuit steps (Stim intervals) and define one reference QEC-cycle duration as ten such steps. This matches the repeated escape rounds in both constructions: one reset layer, eight CNOT layers and one measurement layer. We use this duration as an approximate time unit throughout the factory, including injection and cultivation; it does not count actual syndrome rounds or calibrate unequal hardware operation durations. We assume an attempt stops at the end of the step containing its first rejecting check. Attempts rejected by the decoder’s gap consume the full circuit time.

Figure 12(d) shows the accepted-state production rate per factory unit. Surface matching and direct color JOBS produce respectively 39.0 and 58.4 accepted states per 1,000 reference QEC cycles for 3→153\to15, and 6.51 and 13.6 for 5→155\to15. Combining throughput and footprint, direct color escape with JOBS provides 2.0×2.0\times and 2.8×2.8\times higher modeled throughput per installed qubit than surface matching for 3→153\to15 and 5→155\to15, respectively, at the selected binary-YY error ceilings. These gains combine architecture, decoder and rejection-policy changes. At 5 →\to 15, direct color and relaxed surface JOBS have nearly equal throughput per unit, while color uses 340 versus 463 qubits. At 3 →\to 15, relaxing surface checks increases yield but barely changes throughput because more time is spent on attempts that would otherwise stop early.

Closely spaced TT gates may require parallel factory units or states prepared and stored in advance. Hardware estimates must also include gate durations, decoding and transfer times, and errors accumulated during storage.

Importance Sampling

The logical error rates shown in § 4 extend down to p=0.001p = 0.001, where TCBP-JOBS fails on 55 of approximately 2.2×1082.2 \times10^{8} shots of the [[144, 12, 12]] gross code, including both XX and ZZ memory experiments. Probing the logical error rate at significantly lower physical error rate is prohibitively expensive with Monte Carlo. At a logical error rate of order 10−1210^{-12}, direct Monte Carlo sampling requires approximately 101410^{14} shots to observe 100 failures. In this section we use the splitting method of Bravyi and Vargo [16] to explore this regime. Splitting expresses the logical error rate at low pp as the directly measured rate at high pp multiplied by a product of failure-probability ratios between neighboring values of pp. Each ratio is an average of likelihood ratios over fault configurations on which the decoder fails, sampled by a Markov chain (Appendix § 13).

We study the gross code’s 12-round ZZ memory experiment under SI1000 noise, from p=0.004p = 0.004 to p=10−4p = 10^{-4}. The method requires one decoder along a run, so each pp for which we estimate the logical error is associated with one full splitting run from p0p_0 to pp using a decoder trained at pp.

Where splitting and Monte Carlo methods overlap, they produce consistent logical error rate estimates using the same decoder. We have no independent verification below the range accessible to direct Monte Carlo sampling, and incomplete exploration of the failure set can potentially bias the splitting estimates downward. We use 128 parallel chains per run to improve exploration, and 8 independent runs to assess statistical variation. Figure 13 shows the median and range of these estimates. This range is not a confidence interval, though, and cannot indicate any bias shared across all 8 runs.

Figure 13. Logical error rate per 12 rounds of the [[144, 12, 12]] code, ZZ memory, SI1000 noise. Filled symbols: splitting, median of 8 independent runs, bands show the range of the runs. Open symbols: Monte Carlo by the same decoder, with 95% intervals. Circles and squares: TCBP-JOBS with a TCBP model trained at the DEM rates of each pp. Every splitting point from p=3×10−3p = 3 \times10^{-3} to 10−410^{-4} is the endpoint of its own set of runs, and the Monte Carlo points from p=4×10−3p = 4 \times10^{-3} to 10−310^{-3} use the model trained at the sampled pp. Triangles: short-beam Tesseract, same prior at all pp, with splitting started from the Monte Carlo point at p=0.002p = 0.002.

The low-error-rate regime reveals decoder limitations that are difficult to probe with direct sampling. In particular, failure to correct low-weight fault configurations can significantly increase the logical error rate. Splitting samples these rare failures and can therefore provide examples that help diagnose decoder limitations. For a fixed decoder under SI1000 noise, each fault probability scales linearly with pp as p→0p \to0, so the asymptotic logarithmic slope equals the minimum number of faults that causes a decoder failure. For an optimal decoder of the gross code’s standard circuit, this exponent is 5, corresponding to its circuit-level distance of 10 [17].

In a separate experiment using the original TCBP model of § 3, the measured local slope decreases to approximately 5 at p=10−4p = 10^{-4}. However, this is not its asymptotic limit. Among 3,840 stored failing configurations at p=2×10−4p = 2 \times10^{-4}, two contain four faults and 16 contain five. The presence of four-fault failures establishes that the asymptotic exponent of this decoder configuration is at most 4. Modifications to the decoder parameters (in particular increasing the JOBS draws from 16 to 64), or using Tesseract with the same prior, corrects all 18 configurations, showing that these particular failures can potentially be avoided.

The TCBP-JOBS experiments used 8 independent splitting runs, requiring 2×1072 \times10^{7} decoder calls and just over 1 node-hour per run on nodes equipped with four B200 GPUs. Increasing the JOBS draws from 16 to 64 increased the cost per run to approximately 2.5 node-hours. We estimate that a direct Monte Carlo calculation of the TCBP-JOBS LER using approximately 101410^{14} shots at p=10−4p = 10^{-4} would require about 5×1065 \times10^{6} node-hours, or approximately 600 node-years. The eight short-beam Tesseract runs required approximately 24 hours on a single 144-core CPU.

Conclusions

We introduced trajectory-calibrated belief propagation and jittered OSD beam search as a GPU-accelerated approach to high-accuracy quantum error correction decoding. Across 72 surface, color and bivariate-bicycle memory circuits at p=0.1%p = 0.1\% to 0.4%0.4\%, TCBP-JOBS achieves logical error rates comparable to or lower than the tested Tesseract configurations in nearly all settings, with the largest gains on the largest codes at p≥0.2%p \ge0.2\%. Serial decoding is 10× to 7,400× faster than sparsified Tesseract and up to 13,000× faster than its unsparsified long-beam preset, and one GPU decodes the 24.2-million-shot Tesseract benchmark in 45 minutes. Mean serial latencies stay below 18 ms per memory shot and are 13.5 ms per gross-code surgery shot at p=0.2%p = 0.2\%, which is relevant to AMO feed-forward workloads. The same components serve three further tasks. TCBP’s calibrated probabilities support unsupervised noise learning that comes within 2–3% of the oracle-prior logical error rate on simulated gross-code data. The JOBS search provides a complementary-gap score for postselection in memory experiments and magic-state cultivation. Its speed makes rare-event splitting affordable down to logical error rates near 10−1210^{-12}; at the physical error rates this reaches (10−410^{-4} to 5×10−45 \times10^{-4}), Tesseract is more accurate than TCBP-JOBS on the gross code. Future directions. With minor exceptions7 8, nearly every data point in this paper was collected using a single set of default parameters, for both TCBP model creation and JOBS searches. Given the limited number of codes studied in this paper, we expect that many optimizations for speed or accuracy on new codes remain for further studies. The first open question is whether the accuracy gap to Tesseract at low physical error rates, where TCBP-JOBS fails on some four-fault configurations (§ 7), can be closed by changing how the TCBP model is trained or by increasing the JOBS search effort. Further open questions include how many BP iterations TCBP needs, how min-sum BP compares with sum-product BP as its front end, how best to train and initialize the TCBP model, and how to choose JOBS search parameters for a given code.

Additionally, integrating the decoder with a quantum control system and evaluating complete reaction times are the next steps toward establishing its suitability for real-time fault-tolerant computation. Such studies should evaluate sustained throughput and latency tails against the arrival rates and feed-forward deadlines of specific hardware schedules. Another direction is to explore alternatives to the current ⌈αK∗⌉\lceil\alpha K^{*} \rceil search-window rule, assessing how window selection changes the tradeoff between search cost and logical error rate.

Acknowledgments

We acknowledge the use of AI-assisted tools (Anthropic and OpenAI models) in the preparation of this manuscript. The authors reviewed and validated all resulting technical content and retain responsibility for the scientific claims and final manuscript.

Supplementary tables

Table 8: Per-basis version of the comparison of TCBP-JOBS with sparsified short-beam Tesseract, one row per circuit: bivariate-bicycle codes. Shots is the prefix decoded by both. Fails are counted on that prefix. T-only and J-only are the shots that fail under one decoder only. Ratio is Tesseract LER over JOBS LER. pMcNp_{\mathrm{McN}} is the exact two-sided McNemar test on the discordant shots.

codeppbasisshotsfails Tfails JT-only / J-onlyratiopMcNp_{\mathrm{McN}}
[[72, 12, 6]]0.001XX55k33358 / 100.90.81
[[72, 12, 6]]0.001ZZ63k26316 / 110.80.33
[[72, 12, 6]]0.002XX6.8k443811 / 51.20.21
[[72, 12, 6]]0.002ZZ3.0k25226 / 31.10.51
[[72, 12, 6]]0.004XX437727015 / 131.00.85
[[72, 12, 6]]0.004ZZ489877525 / 131.20.07
[[90, 8, 10]]0.001XX19.7M535710 / 140.90.54
[[90, 8, 10]]0.001ZZ7.0M32317 / 61.01.00
[[90, 8, 10]]0.002XX101k251413 / 21.87×10−37 \times10^{-3}
[[90, 8, 10]]0.002ZZ77k251810 / 31.40.09
[[90, 8, 10]]0.004XX332491934 / 42.66×10−76 \times10^{-7}
[[90, 8, 10]]0.004ZZ487543231 / 91.77×10−47 \times10^{-4}
[[108, 8, 10]]0.001XX68.0M415510 / 240.70.02
[[108, 8, 10]]0.001ZZ42.6M38433 / 80.90.23
[[108, 8, 10]]0.002XX225k251118 / 42.34×10−34 \times10^{-3}
[[108, 8, 10]]0.002ZZ176k261017 / 12.61×10−41 \times10^{-4}
[[108, 8, 10]]0.004XX393591149 / 15.4<10−10<10^{-10}
[[108, 8, 10]]0.004ZZ427562042 / 62.81×10−71 \times10^{-7}
[[144, 12, 12]]0.001XX133.7M262311 / 81.10.65
[[144, 12, 12]]0.001ZZ88.0M27326 / 110.80.33
[[144, 12, 12]]0.002XX196k25521 / 15.01×10−51 \times10^{-5}
[[144, 12, 12]]0.002ZZ159k25619 / 04.24×10−64 \times10^{-6}
[[144, 12, 12]]0.004XX22665956 / 07.2<10−10<10^{-10}
[[144, 12, 12]]0.004ZZ226561741 / 23.32×10−102 \times10^{-10}

Table 8. Per-basis version of the comparison of TCBP-JOBS with sparsified short-beam Tesseract, one row per circuit: bivariate-bicycle codes. Shots is the prefix decoded by both. Fails are counted on that prefix. T-only and J-only are the shots that fail under one decoder only. Ratio is Tesseract LER over JOBS LER. pMcNp_{\mathrm{McN}} is the exact two-sided McNemar test on the discordant shots.

codeppbasisshotsfails Tfails JT-only / J-onlyratiopMcNp_{\mathrm{McN}}
color d=7d=70.001XX112k28302 / 40.90.69
color d=7d=70.001ZZ88k27284 / 51.01.00
color d=7d=70.002XX7.0k575010 / 31.10.09
color d=7d=70.002ZZ7.0k47449 / 61.10.61
color d=7d=70.004XX696544814 / 81.10.29
color d=7d=70.004ZZ71278868 / 160.90.15
color d=9d=90.001XX758k27289 / 101.01.00
color d=9d=90.001ZZ463k25263 / 41.01.00
color d=9d=90.002XX7.0k26256 / 51.01.00
color d=9d=90.002ZZ9.8k27267 / 61.01.00
color d=9d=90.004XX446465122 / 270.90.57
color d=9d=90.004ZZ373494821 / 201.01.00
color d=11d=110.001XX8.0M485717 / 260.80.22
color d=11d=110.001ZZ7.5M867831 / 231.10.34
color d=11d=110.002XX12k261217 / 32.23×10−33 \times10^{-3}
color d=11d=110.002ZZ13k262411 / 91.10.82
color d=11d=110.004XX292503238 / 201.60.02
color d=11d=110.004ZZ312614244 / 251.50.03
color d=13d=130.001XX16.8M533041 / 181.84×10−34 \times10^{-3}
color d=13d=130.001ZZ14.0M613044 / 132.05×10−55 \times10^{-5}
color d=13d=130.002XX9.0k26424 / 26.51×10−51 \times10^{-5}
color d=13d=130.002ZZ11k27824 / 53.45×10−45 \times10^{-4}
color d=13d=130.004XX228743564 / 252.14×10−54 \times10^{-5}
color d=13d=130.004ZZ223985367 / 221.82×10−62 \times10^{-6}

Table 9. Per-basis comparison, continued: color codes. Columns as in Table 8.

Table 10: Per-basis comparison, continued: rotated surface codes. Columns as in Table 8.

codeppbasisshotsfails Tfails JT-only / J-onlyratiopMcNp_{\mathrm{McN}}
surface d=7d=70.001XX271k25241 / 01.01.00
surface d=7d=70.001ZZ305k25223 / 01.10.25
surface d=7d=70.002XX15k26242 / 01.10.50
surface d=7d=70.002ZZ15k32302 / 01.10.50
surface d=7d=70.004XX1.0k31303 / 21.01.00
surface d=7d=70.004ZZ1.0k27236 / 21.20.29
surface d=9d=90.001XX8.0M83832 / 21.01.00
surface d=9d=90.001ZZ5.2M58572 / 11.01.00
surface d=9d=90.002XX54k26252 / 11.01.00
surface d=9d=90.002ZZ61k29263 / 01.10.25
surface d=9d=90.004XX1.0k28258 / 51.10.58
surface d=9d=90.004ZZ1.0k29257 / 31.20.34
surface d=11d=110.001XX29.2M42367 / 11.20.07
surface d=11d=110.001ZZ30.0M403311 / 41.20.12
surface d=11d=110.002XX84k261611 / 11.66×10−36 \times10^{-3}
surface d=11d=110.002ZZ185k27239 / 51.20.42
surface d=11d=110.004XX1.0k322217 / 71.50.06
surface d=11d=110.004ZZ1.0k311221 / 22.67×10−57 \times10^{-5}
surface d=13d=130.001XX77.0M331221 / 02.81×10−61 \times10^{-6}
surface d=13d=130.001ZZ105.5M261116 / 12.43×10−43 \times10^{-4}
surface d=13d=130.002XX157k26818 / 03.28×10−68 \times10^{-6}
surface d=13d=130.002ZZ101k25917 / 12.81×10−41 \times10^{-4}
surface d=13d=130.004XX843341327 / 62.63×10−43 \times10^{-4}
surface d=13d=130.004ZZ949401331 / 43.13×10−63 \times10^{-6}

Table 10. Per-basis comparison, continued: rotated surface codes. Columns as in Table 8.

Serial decoding latency on the bivariate bicycle codes

This appendix supports the serial-latency comparison in the main text but is focused on a comparison to the unsparsified Tesseract long-beam preset rather than the sparsified long-beam preset. Latency means one shot decoded at a time with no batching: Tesseract as a single-threaded process, TCBP-JOBS as single-shot using as much of the GPU as it is configured to use. Both decoders decoded the same 2,000 Stim-sampled shots per code (SI1000, p=0.2%p = 0.2\%, Z basis, Tesseract benchmark circuits). Tesseract [1] ran its long-beam preset without sparsification (--beam 20 --beam-climbing --num-det-orders 21 --pqlimit 10610^{6} --no-revisit-dets --det-order-index, commit 54569b4) on Grace (Neoverse-V2) cores of a GB200 node. TCBP-JOBS ran on one GB200 GPU of the same node.

Tesseract’s decode time is sensitive to system load: with one process per core on all cores the mean per shot is 1.1 to 3.8 times higher than on an otherwise idle machine. However, obtaining data with only one process per machine is prohibitively computationally expensive. We first collect long-beam latency data using all cores and then we obtain the quiet-core mean, by re-decoding a random subset of the same shots alone on an idle machine (30 shots per code; 160 for [[144, 12, 12]]), forming the per-shot loaded/quiet ratio, and dividing the 2,000-shot loaded mean by it. The published mean for the same circuit and flags [Goo25a] is shown for reference; its hardware configuration (CPU architecture and number of cores per machine) is not specified, so a direct comparison cannot be made.

Table 11: Serial per-shot decoding time, same 2,000 shots per code, SI1000 p=0.2%p = 0.2\%, Z basis. Tesseract ran its long-beam preset without sparsification; its times are quiet-core means (see text); TCBP-JOBS times are single-shot decode() on one GB200. Speedup is the ratio of means. PR254 refers to [Goo25a].

As Table 11 shows, the speedup measured on our own GB200 hardware is 6,000 to 13,000 times; against PR254’s published means it is 11,000 to 19,000 times. TCBP-JOBS has a short tail: its p99 is within 4 times its mean on every code. The two decoders’ accuracy at these settings is compared in Appendix C on 0.5 to 2.6 million shots per code.

codeTesseract long beam, 1 Grace coreTCBP-JOBS, 1 GB200speedup
quiet-core meanPR254 meanmeanp99vs. quiet corevs. PR254
[[72, 12, 6]]7.5 s13.0 s1.23 ms2.3 ms6,10010,600
[[90, 8, 10]]19.4 s35.2 s1.91 ms5.0 ms10,10018,400
[[108, 8, 10]]31.5 s44.7 s2.36 ms7.7 ms13,30018,900
[[144, 12, 12]]53.5 s70.8 s4.09 ms16.0 ms13,10017,300

Table 11.

Batched decoding: the Tesseract benchmark at p=0.2%p = 0.2\%

This section complements the data in § 4.1 and is focused on unsparsified long-beam comparisons whereas the main paper focused on sparsified comparisons (both long-beam and short-beam).

In a research setting the quantity of interest is the time to decode a large number of shots, so we compare throughput rather than latency. We decoded every circuit of the Tesseract [1] SI1000 benchmark at p=0.2%p = 0.2\% (surface, color and bivariate bicycle codes, X and Z bases, 28 circuits) with TCBP-JOBS, using for each circuit and basis exactly the number of shots that were published with the unsparsified long-beam preset in results [Goo25a], 24.2 million shots in all. TCBP-JOBS ran with preset tcbp-jobs-sc (10 sum-product BP iterations, JOBS with the TCBP ordering, 16 draws), which differs from the configuration of Table 1 only in that JOBS also searches the BP-converged shots and returns the cheaper of BP’s correction and its own. It ran on one GB200 GPU with decode_batch calls of 16,384 shots; time is the wall time of the decode calls, including this additional search. Tesseract’s time is its own per-shot decode time summed over worker threads. Both decoders used the circuits’ own detector error models. Table 12 gives the accuracy and the per-shot time on each side with X and Z pooled; Table 13 converts the totals into wall time, assuming Tesseract’s thread-hours spread perfectly over a 64-core server.

Table 12: Tesseract long beam without sparsification [Goo25a] versus TCBP-JOBS on the Tesseract benchmark at p=0.2%p = 0.2\%, X and Z bases pooled, identical shot counts per circuit and basis. LER is the logical error rate per shot (any observable wrong; Tesseract low-confidence shots counted as errors). Ratios are Tesseract over TCBP-JOBS; the interval is the 95% Clopper–Pearson bound on each LER, combined conservatively. Totals over the 24.2 million shots: Tesseract 130,257 thread-hours, TCBP-JOBS 44.8 GPU-minutes.

Tesseract, 1 CPU threadTCBP-JOBS, 1 GB200, batchedratio T/J
codeshotsfailsLERs/shotfailsLERμ\mus/shotLER [95% CI]time
surface d32.60M29,4911.13×10−21.13 \times10^{-2}0.00020229,7131.14×10−21.14 \times10^{-2}50.99 [1.0, 1.0]41
surface d50.82M3,8064.63×10−34.63 \times10^{-3}0.004253,7354.54×10−34.54 \times10^{-3}121.02 [1.0, 1.1]343
surface d72.16M3,2691.52×10−31.52 \times10^{-3}0.02993,4071.58×10−31.58 \times10^{-3}200.96 [0.9, 1.0]1,471
surface d92.60M1,2284.73×10−44.73 \times10^{-4}0.1231,2494.81×10−44.81 \times10^{-4}360.98 [0.9, 1.1]3,408
surface d112.60M3901.50×10−41.50 \times10^{-4}0.3843881.49×10−41.49 \times10^{-4}721.01 [0.8, 1.2]5,350
color d30.58M12,2692.13×10−22.13 \times10^{-2}0.0013712,1182.10×10−22.10 \times10^{-2}51.01 [1.0, 1.0]266
color d51.04M14,0731.35×10−21.35 \times10^{-2}0.14914,0891.35×10−21.35 \times10^{-2}151.00 [1.0, 1.0]10,145
color d70.60M3,7776.27×10−36.27 \times10^{-3}2.893,9416.54×10−36.54 \times10^{-3}340.96 [0.9, 1.0]85,594
color d91.10M2,7622.51×10−32.51 \times10^{-3}11.33,0792.80×10−32.80 \times10^{-3}800.90 [0.8, 1.0]141,348
color d111.83M2,5771.41×10−31.41 \times10^{-3}28.22,0601.13×10−31.13 \times10^{-3}2041.25 [1.2, 1.4]138,377
[[72, 12, 6]]0.54M3,3046.09×10−36.09 \times10^{-3}13.13,4076.28×10−36.28 \times10^{-3}550.97 [0.9, 1.0]239,983
[[90, 8, 10]]2.60M5772.22×10−42.22 \times10^{-4}35.35662.18×10−42.18 \times10^{-4}1351.02 [0.9, 1.2]261,448
[[108, 8, 10]]2.60M2399.19×10−59.19 \times10^{-5}46.01977.58×10−57.58 \times10^{-5}1781.21 [0.9, 1.6]257,978
[[144, 12, 12]]2.58M1445.58×10−55.58 \times10^{-5}71.0923.57×10−53.57 \times10^{-5}3881.57 [1.1, 2.3]183,119
geometric mean1.0513,242

Table 12. Tesseract long beam without sparsification versus TCBP-JOBS on the Tesseract benchmark at p=0.2%p = 0.2\%, X and Z bases pooled, identical shot counts per circuit and basis. LER is the logical error rate per shot (any observable wrong; Tesseract low-confidence shots counted as errors). Ratios are Tesseract over TCBP-JOBS; the interval is the 95% Clopper–Pearson bound on each LER, combined conservatively. Totals over the 24.2 million shots: Tesseract 130,257 thread-hours, TCBP-JOBS 44.8 GPU-minutes.

Table 13: Wall time to decode the benchmark of Table 12: Tesseract’s thread-hours spread perfectly over a 64-core server versus one GB200 GPU. Ratios are of summed times.

circuitsshotsTesseract, 64 coresTCBP-JOBS, 1 GB200ratio
surface codes (10)10.8 M6.0 h5.8 min62
color codes (10)5.1 M11.9 days8.3 min2,060
bivariate bicycle codes (8)8.3 M10.4 weeks31 min3,400
all 2824.2 M12.1 weeks45 min2,720

Table 13. Wall time to decode the benchmark of Table 12: Tesseract’s thread-hours spread perfectly over a 64-core server versus one GB200 GPU. Ratios are of summed times.

TCBP-JOBS matches Tesseract’s accuracy over the benchmark (geometric-mean LER ratio 1.05, with 1.25 at color d=11d = 11 and 1.57 at [[144, 12, 12]] in its favor and 0.90 at color d=9d = 9 against it) while decoding the full set in 45 minutes on one GPU. The same work is 130,000 thread-hours for Tesseract, or about 12 weeks on a 64-core server; on the bivariate bicycle codes alone it is 10 weeks against half an hour.

Rare-event splitting

This appendix describes the logical error rate estimator of Section 7. We summarize the splitting method of Bravyi and Vargo [16], and then discuss several modifications we made to apply it to TCBP-JOBS on the gross code.

We use the notation of Section 2. The detector error model (DEM) of the 12-round ZZ memory circuit of the [[144,12,12]][[144, 12, 12]] code has m=1,728m = 1{,}728 detectors and n=67,752n = 67{,}752 faults, with check matrix HH and logical matrix LL for its 12 observables. A fault configuration is a vector F∈{0,1}nF \in\{0,1\}^{n} whose entry FjF_j is 1 if fault jj occurred, and its weight is the number of faults it contains. The faults are the independent error mechanisms in the DEM derived using an SI1000 circuit noise model [50]. This model has a single physical error rate pp that scales all noise parameters, with qj(p)q_j(p) denoting the resulting probability of fault jj. Faults occur independently, so a configuration has probability

Pr⁡p(F)=∏j=1nqj(p)Fj(1−qj(p))1−Fj.(6)\Pr_p(F) = \prod_{j=1}^{n} q_j(p)^{F_j}\left(1-q_j(p)\right)^{1-F_j}. \tag*{(6)}

We distinguish these true rates qj(p)q_j(p), which generate the faults, from the prior pjp_j that the decoder is given. The syndrome of FF is σ=HF\sigma= HF. The decoder maps σ\sigma to a prediction of the observable flips, and it fails on FF if that prediction differs from LFLF in any of the 12 observables. We write B\mathcal{B} for the set of configurations on which the decoder fails. The logical error rate per 12 rounds is then PL(p)=∑F∈BPr⁡p(F)P_{\mathrm{L}}(p) = \sum_{F\in\mathcal{B}} \Pr_p(F), and the distribution of failures at pp is πp(F)=Pr⁡p(F)/PL(p)\pi_p(F) = \Pr_p(F)/P_{\mathrm{L}}(p) for F∈BF \in\mathcal{B} and zero otherwise.

Bravyi and Vargo splitting method

Direct Monte Carlo sampling draws configurations from Pr⁡p\Pr_p and counts how many fall in B\mathcal{B}, which needs of order 1/PL(p)1/P_{\mathrm{L}}(p) shots. Splitting avoids this by considering only failing configurations F∈BF \in\mathcal{B}. Choose a decreasing sequence of physical error rates p0>p1>⋯>pKp_0 > p_1 > \cdots> p_K, also called levels, with p0p_0 large enough that PL(p0)P_{\mathrm{L}}(p_0) can be measured directly. Then

PL(pK)=PL(p0)∏k=0K−1PL(pk+1)PL(pk),PL(pk+1)PL(pk)=EF∼πpk[rk(F)],rk(F)=Pr⁡pk+1(F)Pr⁡pk(F).(7)P_{\mathrm{L}}(p_K) = P_{\mathrm{L}}(p_0)\prod_{k=0}^{K-1}\frac{P_{\mathrm{L}}(p_{k+1})}{P_{\mathrm{L}}(p_k)}, \qquad\frac{P_{\mathrm{L}}(p_{k+1})}{P_{\mathrm{L}}(p_k)} = \mathbb{E}_{F\sim\pi_{p_k}}\left[r_k(F)\right], \qquad r_k(F) = \frac{\Pr_{p_{k+1}}(F)}{\Pr_{p_k}(F)}. \tag*{(7)}

The first equality is a telescoping product. The second follows from writing both logical error rates as sums over the same set B\mathcal{B}. Each ratio is the average of the reweighting factor rkr_k over failures at the higher level. The factor rk(F)r_k(F) is computed from (6), without calling the decoder. If neighboring levels are close, rkr_k varies little over the failures at pkp_k and a modest number of samples gives each ratio accurately, although the product of all ratios may be many orders of magnitude.

The samples of πpk\pi_{p_k} come from a Markov chain. Bravyi and Vargo use a Metropolis chain that proposes flipping one uniformly chosen fault, accepts the proposal with the usual probability min⁡[1,Pr⁡pk(F′)/Pr⁡pk(F)]\min[1,\Pr_{p_k}(F')/\Pr_{p_k}(F)], and rejects it whenever the proposed configuration F′F' is not in B\mathcal{B}, which takes one decoder call to decide. They estimate each ratio from the chains at both of its levels with an acceptance-ratio estimator, which combines samples of πpk\pi_{p_k} and πpk+1\pi_{p_{k+1}} and has a lower variance than the one-sided average in (7). Their levels are spaced by pk+1=pk2−1/wkp_{k+1} = p_k 2^{-1/\sqrt{w_k}}, where wk=max⁡(d/2,pkN)w_k = \max(d/2, p_kN) for a code of distance dd with NN fault locations is roughly the weight of a typical failure at pkp_k. Each chain starts from an uncorrectable error constructed by hand, and PL(p0)P_{\mathrm{L}}(p_0) comes from an asymptotic formula or from Monte Carlo sampling. Their simulations are of the surface code decoded by minimum-weight matching. (7) itself assumes nothing about the code or the decoder beyond the requirement that the decoder must be a fixed function of the syndrome, so that B\mathcal{B} is a well-defined set that is the same at every level.

Adapting splitting to TCBP-JOBS on the gross code

We made several changes to the splitting method to optimize its performance for TCBP-JOBS on the gross code. We kept Eq. (7) and changed how the failures are sampled, how each ratio is estimated, and how a run starts. These changes address both the size of the DEM and the increased throughput of the GPU decoder when using batched execution.

Chain move

Evolving the chains by flipping one fault per step leads to slow exploration. A failing configuration at p0=0.004p_0 = 0.004 contains about 130 of the 67,752 faults, most of which do not contribute to the failure, and a uniformly chosen flip rarely changes a significant fault. We use the partial-resampling move of Ref. [93] instead. At level kk, each step selects every fault independently with probability 1/41/4 and redraws each selected fault from its own rate qj(pk)q_j(p_k), leaving the others as they are. Redrawing a subset of independent coordinates from their own distribution leaves Pr⁡pk\Pr_{p_k} unchanged, so there is no Metropolis acceptance probability to compute, and the proposal is accepted only if the new configuration remains in B\mathcal{B}. Each step therefore costs one decoder call per chain. The fraction of accepted proposals is between 37% and 47% at p=0.004p = 0.004, depending on the decoder of the run, and between 8% and 15% below p=0.002p = 0.002.

Population and resampling

A run evolves 128 chains together and sends their 128 syndromes to the decoder as one batch at every step. Multiple chains are required because single chains rarely move between failures caused by different small sets of faults. Transitions between failures caused by different small sets of faults can require rare intermediate configurations, making such transitions infrequent at low pp. At the end of level kk, we resample the 128 final configurations with replacement, each with probability proportional to the average of rkr_k along its chain, and the 128 copies are the starting configurations of level k+1k+1. Types of failure that become relatively more likely at the lower error rate are thereby duplicated and the others are thinned. This reduces bias but comes at a loss of diversity. In the runs to p=10−4p = 10^{-4}, the 128 chains at the last level descend from a median of 22 of the 128 starting configurations. Runs to higher targets pass through fewer levels and retain more, with a median of 33 at p=10−3p = 10^{-3}.

Ratio estimate

Each ratio in Eq. (7) is estimated as the average of rk(F)r_k(F) over the second half of the steps of every chain at level kk. The first half is discarded to allow the chains to relax to πpk\pi_{p_k}. We did not use the acceptance-ratio estimator given in Ref. [16].

Chain evolution

Let μ(p)=∑jqj(p)\mu(p) = \sum_j q_j(p) be the expected number of faults in a shot, which is 126 at p=0.004p = 0.004 and 3.2 at p=10−4p = 10^{-4}. We space the levels so that ∣ln⁡pk+1−ln⁡pk∣≤2/μ(pk)|\ln p_{k+1} - \ln p_k| \le2/\sqrt{\mu(p_k)}, which has the same form as the rule of Ref. [16], with steps about three times as wide.

For each target physical error rate pp, we use a decoder trained at that target and hold it fixed throughout the splitting run. Each run begins with 20,000 Monte Carlo shots at p0=0.004p_0 = 0.004, using that run’s decoder to estimate PL(p0)P_{\mathrm{L}}(p_0) and obtain failing configurations to initialize the 128 chains.

The level-spacing rule gives 12 steps for the full interval from p0=0.004p_0 = 0.004 to p=10−4p = 10^{-4}; runs targeting higher pp terminate earlier. Every chain takes 1,000 steps at each of the first two levels and 2,000 steps at each subsequent level used to estimate a ratio. For the p=10−4p = 10^{-4} endpoint, this requires approximately 2.8×1062.8 \times10^{6} decoder calls per run, or 2.2×1072.2 \times10^{7} calls across eight independent runs.

Uncertainty

We performed eight independent MCMC runs for each target pp, each with a separate random seed and Monte Carlo sample at p0p_0. We assess statistical variability across independent runs because resampling gives chains within a run shared ancestors. Figure 13 shows the median and full range of the logical error rate estimates. This range is not a confidence interval and does not capture a bias shared by all runs, such as that caused by incomplete exploration of the failure set.

Limits

The spread across runs cannot indicate any bias that may be shared by all runs. If every chain misses a class of failures, the runs can agree while underestimating the logical error rate. Monte Carlo using same decoder validates the splitting estimates at five error rates from p=0.003p = 0.003 to p=0.001p = 0.001. The ratio of the splitting estimate to the Monte Carlo estimate lies between 0.79 and 0.98, each within about two standard errors of 1, but all five lie below 1, with a weighted mean of 0.92±0.040.92 \pm0.04. This check does not establish that the chains explore all relevant failures at lower pp.

We also computed the Gelman–Rubin statistic R^\hat{R} for ln⁡rk\ln r_k at each level [54]. This statistic compares variation between chains with variation within chains and approaches 1 as the chains converge to the same distribution. The largest R^\hat{R} across levels is 1.2 in a typical run and 1.3 in the worst run, indicating that the chains are not completely mixing. As discussed before, this is unsurprising, as transitions between distinct failing sectors are suppressed.

References

  1. [1][ABHS25] Laleh Aghababaie Beni, Oscar Higgott, and Noah Shutty. Tesseract: A search-based decoder for quantum error correction, 2025.arxiv.org/abs/2503.10988
  2. [2][AGDLHG05] Alán Aspuru-Guzik, Anthony D. Dutoi, Peter J. Love, and Martin Head-Gordon. Simulated quantum computation of molecular energies. Science, 309(5741):1704–1707, 2005.pubmed.ncbi.nlm.nih.gov/16151006
  3. [3][AVA+24] Narges Alavisamani, Suhas Vittal, Ramin Ayanzadeh, Poulami Das, and Moinuddin Qureshi. Promatch: Extending the reach of real-time quantum error correction with adaptive precoding. In ASPLOS, 2024.arxiv.org/abs/2404.03136
  4. [4][BAH+26] John Blue, Harshil Avlani, Zhiyang He, Liu Ziyin, and Isaac L. Chuang. Machine learning decoding of circuit-level noise for bivariate bicycle codes. Quantum, 10:2149, 2026.DOI
  5. [5][BBB+23] Ben Barber, Kenton M. Barnes, Tomasz Bialas, Okan Buğdaycı, Earl T. Campbell, Neil I. Gillespie, Kauser Johar, Ram Rajan, Adam W. Richardson, Luka Skoric, Canberk Topal, Mark L. Turner, and Abbas B. Ziad. A real-time, scalable, fast and highly resource efficient decoder for a quantum computer, 2023.DOI
  6. [6]Sergey Bravyi, Andrew W. Cross, Jay M. Gambetta, Dmitri Maslov, Patrick Rall, and Theodore J. Yoder. High-threshold and low-overhead fault-tolerant quantum memory. Nature, 627:778–782, 2024.DOI
  7. [7]Héctor 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.org/abs/2303.04846
  8. [8]Nikolas P. Breuckmann and Jens Niklas Eberhardt. Quantum low-density parity-check codes. PRX Quantum, 2(4):040101, 2021.DOI
  9. [9]Michele Banfi, Marco Ferrari, Antonino Favano, Alberto Tarable, and Luca Barletta. Best-first ordered statistics decoding of quantum LDPC codes, 2026.arxiv.org/abs/2605.25777
  10. [10]Aditya Bhardwaj, Muzhou Ma, Nadine Meister, Robbie King, Dolev Bluvstein, John Preskill, Madelyn Cain, Qian Xu, and Hsin-Yuan Huang. High-rate qldpc processors, 2026.arxiv.org/abs/2607.28795
  11. [11]Daniel Báscones, Arshpreet Singh Maan, Valentin Savin, and Francisco Garcia-Herrero. A scalable FPGA architecture for real-time decoding of quantum LDPC codes using GARI, 2026.arxiv.org/abs/2605.01035
  12. [12]Elwyn Berlekamp, Robert McEliece, and Henk van Tilborg. On the inherent intractability of certain coding problems. IEEE Transactions on Information Theory, 24(3):384–386, 1978.DOI
  13. [13]Héctor Bombín, Mihir Pant, Sam Roberts, and Karthik I. Seetharam. Fault-tolerant post-selection for low overhead magic state preparation, 2022.DOI
  14. [14]Johannes Bausch, Andrew W. Senior, Francisco J. H. Heras, et al. Learning high-accuracy error decoding for quantum processors. Nature, 635:834–840, 2024.DOI
  15. [15]Sergey Bravyi, Martin Suchara, and Alexander Vargo. Efficient algorithms for maximum likelihood decoding in the surface code. Physical Review A, 90(3):032326, 2014.DOI
  16. [16]Sergey Bravyi and Alexander Vargo. Simulation of rare events in quantum error correction. Physical Review A, 88(6):062308, 2013.DOI
  17. [17]Bin Cheng, Naixu Guo, and Feng Pan. Certifying quantum code and circuit distances at scale. 2026.arxiv.org/abs/2611.08247
  18. [19]David Chase. A class of algorithms for decoding block codes with channel measurement information. IEEE Transactions on Information Theory, 18(1):170–182, 1972.
  19. [20]Christopher T. Chubb. General tensor network decoding of 2D Pauli codes, 2021.arxiv.org/abs/2101.04125
  20. [21]Bradley Chase and Farrokh Labib. Clifft: Fast exact simulation of near-clifford quantum circuits, 2026.
  21. [23]Laura Caune, Brendan Reid, Joan Camps, and Earl Campbell. Belief propagation as a partial decoder, 2023.
  22. [24]Laura Caune, Luka Skoric, Nick S. Blunt, et al. Demonstrating real-time and low-latency quantum error correction with superconducting qubits, 2024.
  23. [25]Julien du Crest, Mehdi Mhalla, and Valentin Savin. Stabilizer inactivation for message-passing decoding of quantum LDPC codes. In IEEE Information Theory Workshop (ITW), 2022.
  24. [26]Nicolas Delfosse. Hierarchical decoding to reduce hardware requirements for quantum computing, 2020.
  25. [27]Antonio deMarti iOlius and Josu Etxezarreta Martinez. The closed-branch decoder for quantum LDPC codes, 2024.
  26. [28]Antonio deMarti iOlius, Imanol Etxezarreta Martinez, Joschka Roffe, and Josu Etxezarreta Martinez. An almost-linear time decoding algorithm for quantum LDPC codes under circuit-level noise, 2024.
  27. [29]Eric Dennis, Alexei Kitaev, Andrew Landahl, and John Preskill. Topological quantum memory. Journal of Mathematical Physics, 43(9):4452–4505, 2002.DOI
  28. [30]Nicolas Delfosse, Vivien Londe, and Michael E. Beverland. Toward a union-find decoder for quantum LDPC codes. IEEE Transactions on Information Theory, 68(5):3187–3199, 2022.
  29. [32]Nicolas Delfosse and Naomi H. Nickerson. Almost-linear time decoding algorithm for topological codes. Quantum, 5:595, 2021.
  30. [33]Poulami Das, Christopher A. Pattison, Srilatha Manne, Douglas M. Carmean, Krysta M. Svore, Moinuddin Qureshi, and Nicolas Delfosse. AFS: Accurate, fast, and scalable error-decoding for fault-tolerant quantum computers. In HPCA, 2022.
  31. [34]Nicolas Delfosse, Andres Paz, Alexander Vaschillo, and Krysta M. Svore. How to choose a decoder for a fault-tolerant quantum computer? the speed vs accuracy trade-off, 2023.
  32. [35]Peter-Jan H.S. Derks, Alex Townsend-Teague, Ansgar G. Burchards, and Jens Eisert. Designing fault-tolerant circuits using detector error models. Quantum, 9:1905, November 2025.
  33. [36]Jack Edmonds. Paths, trees, and flowers. Canadian Journal of Mathematics, 17:449–467, 1965.
  34. [37]Marc P. C. Fossorier and Shu Lin. Soft-decision decoding of linear block codes based on ordered statistics. IEEE Transactions on Information Theory, 41(5):1379–1396, 1995.
  35. [38]Austin G. Fowler, Matteo Mariantoni, John M. Martinis, and Andrew N. Cleland. Surface codes: Towards practical large-scale quantum computation. Physical Review A, 86(3):032324, 2012.DOI
  36. [39]Austin G. Fowler. Optimal complexity correction of correlated errors in the surface code, 2013.arxiv.org/abs/1310.0863
  37. [40]Austin G. Fowler, D. Sank, J. Kelly, R. Barends, and John M. Martinis. Scalable extraction of error models from the output of error detection circuits, 2014.arxiv.org/abs/1405.1454
  38. [41]Dragana Grbic, Laleh Aghababaie Beni, and Noah Shutty. Accelerating the tesseract decoder for quantum error correction, 2026.arxiv.org/abs/2602.02985
  39. [42]Robert Gallager. Low-density parity-check codes. IRE Transactions on Information Theory, 8(1):21–28, 1962.
  40. [43]Andi Gu, J. Pablo Bonilla Ataides, Mikhail D. Lukin, and Susanne F. Yelin. Scalable neural decoders for practical fault-tolerant quantum computation, 2026.arxiv.org/abs/2604.08358
  41. [44]Anqi Gong, Sebastian Cammerer, and Joseph M. Renes. Toward low-latency iterative decoding of QLDPC codes under circuit-level noise, 2024.arxiv.org/abs/2403.18901
  42. [45]Francisco Garcia-Herrero and Javier Valls. Exploring the FPGA and ASIC design space of belief propagation and ordered statistics decoders for quantum error correction codes. EPJ Quantum Technology, 2025.DOI
  43. [46]Craig Gidney. Stim: a fast stabilizer circuit simulator. Quantum, 5:497, July 2021.DOI
  44. [47]Craig Gidney. How to factor 2048 bit RSA integers with less than a million noisy qubits, 2025.arxiv.org/abs/2505.15917
  45. [48]Craig Gidney and Cody Jones. New circuits and an open source decoder for the color code, 2023.arxiv.org/abs/2312.08813
  46. [49]Craig Gidney, Michael Newman, Peter Brooks, and Cody Jones. Yoked surface codes, 2023.arxiv.org/abs/2312.04522
  47. [50]Craig Gidney, Michael Newman, Austin Fowler, and Michael Broughton. A fault-tolerant honeycomb memory. Quantum, 5:605, 2021.DOI
  48. [51]Google Quantum AI. Google quantum AI roadmap. https://quantumai.google/qecmilestone, 2024.
  49. [53]Google Quantum AI and Collaborators. Quantum error correction below the surface code threshold. Nature, 638:920–926, 2025.DOI
  50. [54]Andrew Gelman and Donald B. Rubin. Inference from iterative simulation using multiple sequences. Statistical Science, 7(4):457–472, 1992.DOI
  51. [55]Craig Gidney, Noah Shutty, and Cody Jones. Magic state cultivation: growing T states as cheap as CNOT gates, 2024.arxiv.org/abs/2409.17595
  52. [56]Pan Gao, Xu-Sheng Xu, Ji-Ze Han, et al. QuantiSpect: A structure-aware lightweight 3D CNN pre-decoder for scalable surface code quantum error correction, 2026.arxiv.org/abs/2607.18204
  53. [57]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(3):031007, 2023. arXiv:2203.04948.DOI
  54. [59]Oscar Higgott and Craig Gidney. Sparse blossom: correcting a million errors per core second with minimum-weight matching, 2023.DOI
  55. [60]Adam Holmes, Mohammad Reza Jokar, Ghasem Pasandi, Yongshan Ding, Massoud Pedram, and Frederic T. Chong. NISQ+: Boosting quantum computing power by approximating quantum error correction. In ISCA, 2020.arxiv.org/abs/2004.04794
  56. [61]Gengyuan Hu, Wanli Ouyang, Chao-Yang Lu, Chen Lin, and Han-Sen Zhong. Efficient and universal neural-network decoder for stabilizer-based quantum error correction, 2025.arxiv.org/abs/2502.19971
  57. [62]Yifan Hong. Quantum ldpc codes with design rate 1/5 and good performance below 1000 physical qubits, 2026.arxiv.org/abs/2607.27644
  58. [63]IBM Quantum. IBM quantum roadmap. https://www.ibm.com/quantum/roadmap, 2024.
  59. [64]Pavithran Iyer and David Poulin. Hardness of decoding quantum stabilizer codes. IEEE Transactions on Information Theory, 61(9):5209–5223, 2015.arxiv.org/abs/1310.3235
  60. [65]Cody Jones. Improved accuracy for decoding surface codes with matching synthesis, 2024.arxiv.org/abs/2408.12135
  61. [66]Aleksander Kubica and Nicolas Delfosse. Efficient color code decoders in d ≥ 2 dimensions from toric code decoders. Quantum, 7:929, 2023.DOI
  62. [67]Ching-Feng Kung, Kao-Yueh Kuo, and Ching-Yi Lai. Efficient approximate degenerate ordered statistics decoding for quantum codes via reliable subset reduction, 2024.arxiv.org/abs/2412.21118
  63. [68]Kao-Yueh Kuo and Ching-Yi Lai. Exploiting degeneracy in belief propagation decoding of quantum codes. npj Quantum Information, 8:111, 2022.DOI
  64. [69]Philipp Kammerlander, Thomas E. O’Brien, Robbie King, Rolando D. Somma, Mária Kieferová, Brad Lackey, Alexander Schmidhuber, Siddhartha Jain, Andi Gu, Yuri Alexeev, Shouvanik Chakrabarti, Ruslan Shaydülin, Pietro M. Posta, Guang Hao Low, Dar Gilboa, Matthias Troyer, Barry C. Sanders, Matthias Christandl, Elica Kyoseva, Catherine Lefebvre, and Ryan Babbush. The compendium of superquadratic computational quantum advantages, 2026.arxiv.org/abs/2610.32595
  65. [70]Stergios Koutsioumpas, Hasan Sayginel, Mark Webster, and Dan E. Browne. Automorphism ensemble decoding of quantum LDPC codes, 2025.arxiv.org/abs/2503.01738
  66. [71]Wouter Kool, Herke van Hoof, and Max Welling. Stochastic beams and where to find them: The Gumbel-Top-k trick for sampling sequences without replacement. In International Conference on Machine Learning (ICML), 2019.arxiv.org/abs/1903.06059
  67. [72]Andrew J. Landahl, Jonas T. Anderson, and Patrick R. Rice. Fault-tolerant quantum computing with color codes, 2011.arxiv.org/abs/1108.5738
  68. [73]Joonho Lee, Dominic W. Berry, Craig Gidney, William J. Huggins, Jarrod R. McClean, Nathan Wiebe, and Ryan Babbush. Even more efficient quantum computations of chemistry through tensor hypercontraction. PRX Quantum, 2(3):030305, 2021.DOI
  69. [74]Matthias C. Löbl, Susan X. Chen, Stefano Paesani, and Anders S. Sørensen. Breadth-first graph traversal union-find decoder, 2024.arxiv.org/abs/2407.15988
  70. [75]Daniel Litinski. A game of surface codes: Large-scale quantum computing with lattice surgery. Quantum, 3:128, 2019.DOI
  71. [76]Seok-Hyung Lee, Andrew Li, and Stephen D. Bartlett. Color code decoder with improved scaling for correcting circuit-level noise. Quantum, 9:1609, 2025.DOI
  72. [77]Seth Lloyd. Universal quantum simulators. Science, 273(5278):1073–1078, 1996.pubmed.ncbi.nlm.nih.gov/8688088
  73. [78]Ye-Hua Liu and David Poulin. Neural belief-propagation decoders for quantum error-correcting codes. Physical Review Letters, 122(20):200501, 2019.DOI
  74. [79]Namitha Liyanage, Yue Wu, Alexander Deters, and Lin Zhong. Scalable quantum error correction for surface codes using FPGA. In IEEE International Symposium on Field-Programmable Custom Computing Machines (FCCM), 2023.arxiv.org/abs/2301.08419
  75. [80]Namitha Liyanage, Yue Wu, Emmet Houghton, and Lin Zhong. Network-integrated decoding system for real-time quantum error correction with lattice surgery, 2025.arxiv.org/abs/2504.11805
  76. [81]Jifan Liang, Qianfan Wang, Lvzhou Li, Linqi Song, and Xiao Ma. A low-complexity BP-OSD algorithm for quantum LDPC codes. The European Physical Journal Special Topics, 234(20):6211–6222, 2025.DOI
  77. [83]Tristan Müller, Thomas Alexander, Michael E. Beverland, Markus Bühler, Blake R. Johnson, Thilo Maurer, and Drew Vandeth. Improved belief propagation is sufficient for real-time decoding of quantum memory, 2025.arxiv.org/abs/2506.01779
  78. [84]Mohsen Moradi, Ghilas Aissou, Taejoon Kim, Remi A. Chou, and David G. M. Mitchell. Low-latency belief-propagation decoding of quantum LDPC codes with reinforcement-learned scheduling, 2026.arxiv.org/abs/2610.15857
  79. [85]Thilo Maurer, Markus Bühler, Michael Kröner, Frank Haverkamp, Tristan Müller, Drew Vandeth, and Blake R. Johnson. Real-time decoding of the gross code memory with FPGAs, 2025.arxiv.org/abs/2510.21600
  80. [86]Arshpreet Singh Maan, Francisco Garcia-Herrero, Alexandru Paler, and Valentin Savin. Decoding correlated errors in quantum LDPC codes. Nature Communications, 2025. arXiv:2510.14060.arxiv.org/abs/2510.14060
  81. [87]Satvik Maurya, Abtin Molavi, Aws Albarghouthi, and Swamit Tannu. A case for elastic quantum error correction decoders. In European Conference on Computer Systems (EuroSys), 2026.
  82. [88]Satvik Maurya, Thilo Maurer, Markus Bühler, Drew Vandeth, and Michael E. Beverland. FPGA-tailored algorithms for real-time decoding of quantum LDPC codes, 2025.arxiv.org/abs/2511.21660
  83. [89]Mohsen Moradi, Vahid Nourozi, Wei Tang, and David Mitchell. Hardware-efficient reinforcement-learned scheduling for quantum LDPC decoders, 2026.arxiv.org/abs/2611.04179
  84. [90]Nadine Meister, Christopher A. Pattison, and John Preskill. Efficient soft-output decoders for the surface code, 2024.arxiv.org/abs/2405.07433
  85. [91]Stefano Markidis, Luca Pennati, and Ivy Peng. Engineering low-latency, high-throughput quantum decoders on NVIDIA GPUs, 2026.arxiv.org/abs/2610.28867
  86. [92]Sisi Miao, Alexander Schnerring, Haizheng Li, and Laurent Schmalen. Neural belief propagation decoding of quantum LDPC codes using overcomplete check matrices. In IEEE Information Theory Workshop (ITW), 2023.arxiv.org/abs/2212.10245
  87. [93]Michael Mullan, Matthew Weippert, and Winton Brown. Improved methods for determining quantum error correcting code performance and fault tolerance. 2026.arxiv.org/abs/2607.27153
  88. [94]Mohammadreza Noormandipour and Tobias Haug. MaxSAT decoders for arbitrary CSS codes, 2024.arxiv.org/abs/2410.01673
  89. [95]NVIDIA. CUDA-Q QEC: GPU-accelerated quantum error correction. https://developer.nvidia.com/cuda-qx, 2025.
  90. [96]NVIDIA. CUDA-Q QEC tensor network decoder: TensorNetworkDecoder API documentation. https://nvidia.github.io/cudaqx/api/qec/tensor_network_decoder_api.html, 2025.
  91. [97]NVIDIA. NVIDIA and QuEra decode quantum errors with AI. https://developer.nvidia.com/blog/nvidia-and-quera-decode-quantum-errors-with-ai/, 2025.
  92. [98]NVIDIA. NVIDIA NVQLink architecture integrates accelerated computing with quantum processors. https://developer.nvidia.com/blog/nvidia-nvqlink-architecture-integrates-accelerated-computing-with-quantum-processors/, 2025. Real-time decoding of Bring’s code on Quantinuum Helios.
  93. [99]Jan Olle, Christopher Chamberland, Muyuan Li, and Igor Baratta. Fast and accurate AI-based pre-decoders for color codes, 2026. NVIDIA Ising Decoding.arxiv.org/abs/2607.10058
  94. [100]Kai R. Ott, Bence Hetényi, and Michael E. Beverland. Decision-tree decoders for general quantum LDPC codes, 2025.arxiv.org/abs/2502.16408
  95. [101]Tommaso Peduzzi, Lukas Bödeker, Luis Colmenarez, Markus Müller, et al. Reducing decoding latency in quantum error correction by early starting clustering, 2026.arxiv.org/abs/2609.15612
  96. [102]David Poulin and Yeojin Chung. On the iterative decoding of sparse quantum codes. Quantum Information and Computation, 8(10):987–1000, 2008.arxiv.org/abs/0801.1241
  97. [103]Judea Pearl. Probabilistic Reasoning in Intelligent Systems: Networks of Plausible Inference. Morgan Kaufmann, 1988.
  98. [104]Pavel Panteleev and Gleb Kalachev. Degenerate quantum LDPC codes with good finite length performance. Quantum, 5:585, 2021.DOI
  99. [105]qec.Codes. GPU-accelerated automorphism ensemble decoding of quantum LDPC codes. https://qec.codes/blog/autdec/, 2025.
  100. [106]Quantinuum. Quantinuum unveils accelerated roadmap to achieve universal, fully fault-tolerant quantum computing by 2030. https://www.quantinuum.com/press-releases/quantinuum-unveils-accelerated-roadmap-to-achieve-universal-fault-tolerant-quantum-computing-by-2030, 2025.
  101. [107]Gokul Subramanian Ravi, Jonathan M. Baker, Arash Fayyazi, Sophia Fuhui Lin, Ali Javadi-Abhari, Massoud Pedram, and Frederic T. Chong. Better than worst-case decoding for quantum error correction. In ASPLOS, 2023.arxiv.org/abs/2208.08547
  102. [108]Joschka Roffe, David R. White, Simon Burton, and Earl Campbell. Decoding across the quantum low-density parity-check code landscape. Physical Review Research, 2(4):043423, 2020.
  103. [109]Markus Reiher, Nathan Wiebe, Krysta M. Svore, Dave Wecker, and Matthias Troyer. Elucidating reaction mechanisms on quantum computers. Proceedings of the National Academy of Sciences, 114(29):7555–7560, 2017.DOI
  104. [110]Luka Skoric, Dan E. Browne, Kenton M. Barnes, Neil I. Gillespie, and Earl T. Campbell. Parallel window decoding enables scalable fault tolerant quantum computation. Nature Communications, 14, 2023.
  105. [111]Samuel C. Smith, Benjamin J. Brown, and Stephen D. Bartlett. Local predecoder to reduce the bandwidth and latency of quantum error correction. Physical Review Applied, 19(3):034050, 2023.
  106. [112]Samuel C. Smith, Benjamin J. Brown, and Stephen D. Bartlett. Mitigating errors in logical qubits, 2024.DOI
  107. [113]Andrew W. Senior, Thomas Edlich, Francisco J. H. Heras, et al. A scalable and real-time neural decoder for topological quantum codes, 2025. AlphaQubit 2.arxiv.org/abs/2512.07737
  108. [114]Peter W. Shor. Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer. SIAM Journal on Computing, 26(5):1484–1509, 1997.DOI
  109. [115]Noah Shutty, Michael Newman, and Benjamin Villalonga. Efficient near-optimal decoding of the surface code through ensembling, 2024.arxiv.org/abs/2401.12434
  110. [116]Felix Tripier, Woo Chang Chung, Jacob Young, Safwan Alam, Bryce Bjork, Aharon Brodutch, Finn Lasse Buessen, Nolan J. Coble, Thomas Dellaert, Dmitri Maslov, Martin Roetteler, Edwin Tham, Mark Webster, Min Ye, John Gamble, Andrii Maksymov, J. P. Marceaux, and Nicolas Delfosse. Fault-tolerant quantum computing with trapped ions: The walking cat architecture, 2026.arxiv.org/abs/2604.19481
  111. [117]Barbara M. Terhal. Quantum error correction for quantum memories. Reviews of Modern Physics, 87(2):307–346, 2015.DOI
  112. [118]Giacomo Torlai and Roger G. Melko. Neural decoder for topological codes. Physical Review Letters, 119(3):030501, 2017.DOI
  113. [119]Jean-Pierre Tillich and Gilles Zémor. Quantum LDPC codes with positive rate and minimum distance proportional to the square root of the blocklength. IEEE Transactions on Information Theory, 60(2):1193–1202, 2014.DOI
  114. [120]Xinyu Tan, Fang Zhang, Rui Chao, Yaoyun Shi, and Jianxin Chen. Scalable surface-code decoders with parallelization in time. PRX Quantum, 4:040344, 2023.arxiv.org/abs/2209.09219
  115. [121]Yosuke Ueno, Masaaki Kondo, Masamitsu Tanaka, Yasunari Suzuki, and Yutaka Tabuchi. QECOOL: On-line quantum error correction with a superconducting decoder for surface code. In DAC, 2021.DOI
  116. [123]Suhas Vittal, Poulami Das, and Moinuddin Qureshi. Astrea: Accurate quantum error-decoding via practical minimum-weight perfect-matching. In ISCA, 2023.
  117. [124]Javier Valls, Francisco Garcia-Herrero, Nithin Raveendran, and Bane Vasić. Syndrome-based min-sum vs OSD-0 decoders: FPGA implementation and analysis for quantum LDPC codes. IEEE Access, 9:138734–138743, 2021.DOI
  118. [125]Stasiu Wolanski and Ben Barber. Introducing ambiguity clustering: an accurate and efficient decoder for qLDPC codes. In IEEE International Conference on Quantum Computing and Engineering (QCE), 2024. arXiv:2406.14527.arxiv.org/abs/2406.14527
  119. [126]Thomas Wagner, Hermann Kampermann, Dagmar Bruß, and Martin Kliesch. Optimal noise estimation from syndrome statistics of quantum codes. Physical Review Research, 3(1):013292, 2021.DOI
  120. [127]Yue Wu, Binghong Li, Kathleen Chang, Shruti Puri, and Lin Zhong. Minimum-weight parity factor decoder for quantum error correction, 2025.arxiv.org/abs/2508.04969
  121. [128]Ming Wang, Ang Li, and Frank Mueller. Fully parallelized BP decoding for quantum LDPC codes can outperform BP-OSD, 2025.DOI
  122. [129]Yue Wu, Namitha Liyanage, and Lin Zhong. LEGO: QEC decoding system architecture for dynamic circuits, 2024.arxiv.org/abs/2410.03073
  123. [130]Yue Wu, Namitha Liyanage, and Lin Zhong. Micro blossom: Accelerated minimum-weight perfect matching decoding for quantum error correction. In ASPLOS, 2025.DOI
  124. [131]Yue Wu and Lin Zhong. Fusion blossom: Fast MWPM decoders for QEC, 2023.arxiv.org/abs/2305.08307
  125. [132]Ming Wang, Yanbo Zhao, Ang Li, and Frank Mueller. GPU-based parallel BP decoding for quantum LDPC memory, 2026.arxiv.org/abs/2610.13879
  126. [133]Theodore J. Yoder et al. Tour de gross: A modular quantum computer based on bivariate bicycle codes, 2025.arxiv.org/abs/2506.03094
  127. [134]Keyi Yin, Xiang Fang, Jixuan Ruan, Hezi Zhang, Dean Tullsen, Andrew Sornborger, Chenxu Liu, Ang Li, Travis Humble, and Yufei Ding. SymBreak: Mitigating quantum degeneracy issues in QLDPC code decoders by breaking symmetry, 2024.arxiv.org/abs/2412.02885
  128. [135]Min Ye, Dave Wecker, and Nicolas Delfosse. Beam search decoder for quantum LDPC codes, 2025.arxiv.org/abs/2512.07057
  129. [136]Kaiwen Zhou et al. Vegapunk: Accurate and fast decoding for quantum LDPC codes with online hierarchical algorithm and sparse accelerator. In MICRO, 2025.DOI
  130. [137]Chen Zhao, Casey Duckering, Andi Gu, Nishad Maskara, and Hengyun Zhou. Towards ultra-high-rate quantum error correction with reconfigurable atom arrays, 2026.arxiv.org/abs/2604.16209
  131. [138]Abbas B. Ziad, Ankit Zalawadiya, Canberk Topal, Joan Camps, György P. Gehér, Matthew P. Stafford, and Mark L. Turner. Local clustering decoder: a fast and adaptive hardware decoder for the surface code, 2024.DOI

Paper details

vlnc:W_xh37u4wy
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Physics and Astronomy

AI-assisted tools

View statement
Looking for related papers…
Contents