Quantum computers protect information by repeatedly measuring "syndromes," the parity checks that reveal where errors may have hit, and a classical decoder must turn each syndrome into a correction within about a microsecond. Fast, small decoders sit next to the chip, and accurate but slow decoders sit far away behind a narrow cable. A practical system therefore has to decide, round by round, which syndromes the cheap local decoder can safely handle and which must be sent off-chip. For the planar surface code, this split is already engineered: Better Than Worst-Case Decoding for Quantum Error Correction resolves the more than 90% of syndromes that are trivial with a tiny cryogenic filter that recognizes local "cliques," and sends the rest to a room-temperature matcher. That rule depends on the grid geometry. It has no counterpart for quantum low-density parity-check (QLDPC) codes, the high-rate codes whose check graphs are irregular and non-local, where error clusters do not separate into isolated planar patches.
We propose a triage rule that is defined for any parity-check matrix and draws on degeneracy. In a quantum code, many different physical error patterns produce the same syndrome and have the same effect on the stored data, provided they differ by a stabilizer, meaning a combination of checks. Only the logical class, or coset, of the correction matters. Our local decoder runs a few cheap randomized decoders. If all of their candidate corrections land in the same logical class, it commits locally, even when the candidates disagree qubit by qubit. If they disagree on the logical class, it offloads. The offload threshold, the number of local candidates, and their iteration budget are then chosen jointly under a bandwidth budget and a local-compute budget. The claim is that this rule gives a better trade-off between logical error rate and offload bandwidth than syndrome-weight or convergence-based rules, and that its calibration transfers across code families without retraining.
Core Claim
Existing local-versus-remote rules use signals that ignore degeneracy. Syndrome weight measures how much went wrong, not whether the answer is ambiguous. A belief-propagation failure flag fires whenever messages oscillate. Belief Propagation Decoding of Quantum LDPC Codes with Guided Decimation attributes that oscillation to several equally valid error patterns satisfying the same syndrome, and many of those patterns are logically equivalent. Both signals therefore overcount hard cases in a way that matters for degenerate codes. A coset-level disagreement score avoids this, and testing whether a candidate falls in a given class is cheap. Given a syndrome-consistent candidate $e$, its logical label is $\ell(e) = L e \bmod 2$, where $L$ is the $2k \times 2n$ matrix of logical operators of an $[[n,k]]$ code written in binary symplectic form. That is $2k$ parity computations, independent of graph shape.
With $K$ local candidates $e_1,\dots,e_K$, we define the risk score
$$ r = 1 - \max_{c} \frac{1}{K}\sum_{j=1}^{K} \mathbf{1}[\ell(e_j) = c], $$
and set $r = 1$ if any candidate fails the syndrome check. The score $r$ is a crude Monte Carlo estimate of how much of the posterior falls outside the leading coset. This is the quantity that the exact #P-complete coset sum in Minimal Trellises for Degenerate Decoding of Quantum Stabilizer Codes computes exactly. We do not try to approximate that sum well. We only use it to decide where to spend the expensive decoder.
Research Program
The local tier runs $K$ guided-decimation decoders, following Belief Propagation Decoding of Quantum LDPC Codes with Guided Decimation. Each runs belief propagation, a message-passing estimate of each qubit's error probability, and repeatedly fixes the most confident qubit until the syndrome is satisfied. Each decoder is capped at $T$ iterations and diversified by randomized tie-breaking and small perturbations of the prior. We reuse guided decimation because it reaches parity with ordered-statistics post-processing without matrix inversion, and because its early hard decisions steer toward some valid degenerate solution. That property is what makes several independent runs informative about coset ambiguity.
We also include the edge-weighted belief-propagation variant from Evolutionary BP+OSD Decoding for Low-Latency Quantum Error Correction. That paper tunes message weights by differential evolution and cuts iterations from 32 to 5. It supplies a cheaper local candidate generator. The remote tier is BP with ordered-statistics decoding (BP-OSD), which solves the leftover ambiguity by Gaussian elimination at $O(n^3)$ cost.
The allocation layer is where joint discrete and continuous resource allocation enters. The discrete decision is whether each round commits locally or offloads. The continuous knobs are the threshold $\lambda$, the candidate count $K$, and the iteration cap $T$. We pose the problem as
$$ \min_{\lambda, K, T} \; P_L(\lambda,K,T) \quad \text{s.t.} \quad \Pr[r > \lambda] \le \beta, \quad K\,T\,|E| \le C, $$
where $P_L$ is the logical error rate of the combined system, $\beta$ is the allowed offload fraction set by cable bandwidth, $|E|$ is the number of edges in the code's check graph, and $C$ is the local message-update budget. For fixed $(K,T)$, the threshold $\lambda$ is set by dual ascent on the bandwidth constraint, in the style of the primal-dual allocator in Resource Allocation via Graph Neural Networks in Free Space Optical Fronthaul Networks. The small discrete grid over $(K,T)$ is searched exhaustively. Joint Subcarrier and CPU Time Allocation for Mobile Edge Computing motivates the joint treatment: it shows that choosing the offload rule and the compute split separately wastes resources. We test whether the same holds here by comparing against tuning $(K,T)$ first and then $\lambda$.
Topology generalization is tested through calibration transfer. Because $r$, $\beta$, and $C/|E|$ are normalized quantities, a $(\lambda, K, T/\text{degree})$ setting fitted on one code can be deployed unchanged on another. This follows the size-independent-feature idea of Scalable Network Adaptation for Cloud-Rans: An Imitation Learning Approach. We deliberately avoid that paper's branch-and-bound oracle, which has no tractable analogue over quantum cosets.
Baselines
The naive reference points are the two extremes. In local-only decoding, the guided-decimation ensemble commits every round, offloading nothing. In offload-all, every round goes to BP-OSD. Offload-all sets the accuracy ceiling for the two-tier system and is the denominator of our main metric: the ratio of the two-tier logical error rate to the offload-all logical error rate, plotted against offload fraction.
The strongest existing triage rule is the statistical-provisioning approach of Better Than Worst-Case Decoding for Quantum Error Correction. It reports a 70–99%+ off-chip bandwidth reduction on surface codes, with more than 90% of syndromes handled on-chip. Its clique rule cannot be applied to QLDPC graphs, so we port its spirit as a syndrome-weight threshold: rounds whose syndrome weight falls below a cutoff are decoded locally. The cutoff is tuned by the same dual ascent to hit the same offload fraction $\beta$.
The second strong competitor is a convergence trigger, which mirrors how the evolutionary BP+OSD decoder of Evolutionary BP+OSD Decoding for Low-Latency Quantum Error Correction invokes OSD only when BP fails. Here a round is offloaded if a single local decoder fails to converge within $T$, or by a margin variant if its minimum log-likelihood margin is below a tuned cutoff. This is the most serious threat, because it costs one decoder run rather than $K$.
The key ablation replaces coset disagreement with physical disagreement, the mean pairwise Hamming distance among the $K$ candidates, at identical $K$, $T$, and $\beta$. If physical disagreement matches coset disagreement, degeneracy is not doing the work and the central claim fails.
A second ablation decouples allocation by fixing $(K,T)$ at the compute-optimal local setting and only then tuning $\lambda$. This isolates the benefit of joint allocation.
Fairness is enforced in three ways. All rules see the same Stim-generated syndromes, the same remote decoder, and the same tuning set. All are scored at matched offload fraction, and compute-matched where relevant: the convergence trigger may use $K\cdot T$ iterations of a single decoder.
As an external accuracy anchor, GraphQEC in Efficient and Universal Neural-Network Decoder for Stabilizer-Based Quantum Error Correction reports a logical error rate of $9.55\times10^{-5}$ on a distance-12 bivariate bicycle code, an 18-fold improvement over BP-OSD, but at 157 μs per cycle. We cite this as the accuracy a slow remote tier could reach, not as a local-tier competitor.
Beating the field means two things. First, at every offload budget $\beta$ between 1% and 20%, the two-tier error ratio must be strictly lower than under both the syndrome-weight and convergence triggers, with confidence intervals from at least $10^7$ rounds per point. Second, the offload fraction needed to stay within 10% of the offload-all error rate must be at least halved relative to the best competitor.
Why not just…?
Why not just threshold on syndrome weight, as the cryogenic surface-code design does? On the surface code, low weight nearly implies an easy, local fix. On QLDPC codes, a single check graph connects distant qubits, so even modest-weight syndromes can be logically ambiguous, while some heavy syndromes have one dominant coset. The file contains no QLDPC evidence either way; Better Than Worst-Case Decoding for Quantum Error Correction evaluates only surface codes. The matched-$\beta$ comparison settles it directly. We also run it on rotated surface codes, where we expect weight thresholding to be competitive and our rule should at least tie.
Why not just offload whenever local belief propagation fails to converge? This is the real threat, because it is cheaper. The degeneracy argument is that non-convergence often reflects oscillation among logically equivalent solutions (Belief Propagation Decoding of Quantum LDPC Codes with Guided Decimation), so the trigger should offload many harmless rounds. Conversely, a converged run can still land in the wrong coset with no warning. We will report the confusion matrix of each trigger against ground-truth local failure. If the compute-matched convergence or margin trigger matches the coset vote, we will say so, and the contribution shrinks to the allocation and transfer study.
Why not just run a strong decoder for every round and skip triage? The latency evidence rules this out for now. GraphQEC runs at 157 μs per cycle (Efficient and Universal Neural-Network Decoder for Stabilizer-Based Quantum Error Correction), and Rethink the Role of Neural Decoders in Quantum Error Correction finds that only INT4-quantized lightweight models meet a 1 μs FPGA budget, even for surface codes up to distance 9. BP-OSD's cubic elimination is likewise the cost that the evolutionary-BP work tries to avoid triggering.
Why not just train a graph neural network to predict when to offload? That needs labels from a remote decoder on every code, and it reintroduces the training cost and topology overfitting that the file documents. GraphQEC used 64 GPUs for a month. Rethink the Role of Neural Decoders in Quantum Error Correction reports that architectures transfer poorly between surface codes and QLDPC structures. We include a small learned calibrator that maps vote statistics and syndrome weight to risk as an optional add-on. If it alone beats the raw vote under cross-family transfer, that is a useful negative result for the training-free design.
Proposed Experiments
The code families are those already used in the file. The bivariate bicycle codes $[[72,12,6]]$, $[[90,8,10]]$, and $[[144,12,12]]$ come from Evolutionary BP+OSD Decoding for Low-Latency Quantum Error Correction. The generalized bicycle codes $[[882,24]]$ and $[[882,48,16]]$ and the hypergraph-product code $[[1922,50,16]]$ come from Belief Propagation Decoding of Quantum LDPC Codes with Guided Decimation. The $[[129,28]]$ hypergraph-product code comes from Decoding Quantum LDPC Codes Using Graph Neural Networks. Rotated surface codes at distances 3–13 serve as a sanity regime. Syndromes are generated with Stim under code-capacity depolarizing noise and phenomenological noise, across physical error rates spanning each code's sub-threshold region.
For the guided-decimation decoders themselves, no reported numerical threshold was found on Lacuna; that paper reports only curves. We therefore re-run BP-OSD and guided decimation ourselves as reference points and check that they reproduce the reported qualitative parity.
The first decisive check is the ablation of coset versus physical disagreement at matched $K$, $T$, and $\beta$. Under the degeneracy hypothesis, the gap should grow on the more degenerate, higher-rate codes and vanish on low-degeneracy instances.
The second decisive check is transfer. We fit $(\lambda, K, T/\text{degree})$ on $[[72,12,6]]$ alone and deploy it unchanged on the other six codes. We report the achieved offload fraction against the target $\beta$, and the error ratio against per-code tuned settings. Success means the achieved $\beta$ stays within a factor of 1.5 of target and the error ratio stays within 20% of per-code tuning.
The third check is joint versus decoupled allocation across a sweep of local budgets $C$.
The fourth is a resource estimate. We report on-chip message updates per round in units of $|E|$ for each rule at matched accuracy. Using the INT4 FPGA cost model of Rethink the Role of Neural Decoders in Quantum Error Correction, we ask whether a $K$-candidate ensemble at the chosen $T$ plausibly fits the 1 μs budget. We will flag this as an estimate, not a synthesized result.
References
- Better Than Worst-Case Decoding for Quantum Error Correction
- Belief Propagation Decoding of Quantum LDPC Codes with Guided Decimation
- Minimal Trellises for Degenerate Decoding of Quantum Stabilizer Codes
- Evolutionary BP+OSD Decoding for Low-Latency Quantum Error Correction
- Resource Allocation via Graph Neural Networks in Free Space Optical Fronthaul Networks
- Joint Subcarrier and CPU Time Allocation for Mobile Edge Computing
- Scalable Network Adaptation for Cloud-Rans: An Imitation Learning Approach
- Efficient and Universal Neural-Network Decoder for Stabilizer-Based Quantum Error Correction
- Rethink the Role of Neural Decoders in Quantum Error Correction
- Decoding Quantum LDPC Codes Using Graph Neural Networks