Symmetry-Tied Unfolded Belief Propagation for Real-Time qLDPC Decoding

Quantum computers protect information by spreading each logical bit over many noisy physical qubits and repeatedly measuring parity checks, called syndromes. A classical decoder must turn each round of syndromes into a correction within about a microsecond. If it is slower, unprocessed rounds pile up and the computation fails. Today's most accurate neural decoders are large convolutional networks that so far run at tens of microseconds on a GPU. The fastest classical decoder, belief propagation (BP, an iterative message-passing algorithm that passes probability estimates back and forth along the parity-check graph), is cheap and parallel, but it often fails to converge on quantum codes. We propose to turn BP itself into the neural network. We truncate BP to a fixed number of iterations, make each iteration's damping, momentum and prior-reweighting coefficients learnable, and tie those coefficients across the code's symmetry group so the trainable parameter count stays tiny. We replace BP's usual output, a guess at which physical qubits flipped, with a direct prediction of the logical outcome. The resulting decoder has a fixed, data-independent schedule that maps naturally to an FPGA, a reconfigurable chip that can be placed next to the quantum hardware.

The claim is a resource claim, not just an accuracy claim. On the [[144,12,12]] Gross code, a learned unfolded BP with a few hundred to a few thousand parameters should beat hand-tuned BP variants and BP with a variable-latency post-processing step (BP-OSD) at equal latency. It should also reach a better point on the trade-off between logical error rate and FPGA resource use than the convolutional decoders that currently define real-time neural decoding. We do not expect it to match the best convolutional decoder's peak accuracy. The question is how much of that accuracy survives once you pay only for an algorithm's structure rather than for a generic network.

What exists and where the gap is

Three bodies of work frame the proposal. The first motivates it. Improved Belief Propagation Decoding Algorithms for Surface Codes recasts BP as energy minimization and adds optimizer-style updates: momentum, AdaGrad step scaling, and EWAInit, which reweights priors from previous marginals. EWAInit gains one to three orders of magnitude in logical error over plain BP and matches BP-OSD on planar codes, with constant time per parallel iteration. However, its coefficients are hand-tuned, it is evaluated only under phenomenological code-capacity noise, and it was never put on hardware. The second supplies the method. Unfolding WMMSE Using Graph Neural Networks truncates an iterative wireless solver to 4 layers with learned, permutation-equivariant updates. It slightly exceeds the 100-iteration solver's sum-rate (83.21 vs 82.94) and transfers to unseen network sizes. That work is continuous, millisecond-scale and GPU-bound. We carry its recipe into a discrete, microsecond, FPGA regime, where gradients must pass through GF(2) parity, the binary arithmetic of the checks.

The third body constrains and competes. Scalable Neural Decoders for Practical Fault-Tolerant Quantum Computation (Cascade) builds a translation-equivariant CNN for the Gross code. It reaches a logical error near $10^{-10}$ at $p=0.1\%$, a suppression slope of about $p^{11}$ against about $p^5$ for BP-OSD, but runs at about 40 μs on an H200 and was not synthesized. Sparse Streaming Neural Decoders does put a sparse INT8/INT4 CNN on an AMD Versal HBM FPGA. It covers a d=11 surface code at 50.6% LUT and 38.0% DSP use, and maps to the Gross code through an affine activation-banking scheme for non-local check neighbors. That banking scheme is exactly what an unfolded BP needs, and we reuse it. SAQ contributes a differentiable relaxation of GF(2) logical constraints, which we reuse for training. SAQ's own nullspace post-processing has variable runtime, which is the kind of latency tail we are designing out.

Rethink the Role of Neural Decoders in Quantum Error Correction argues that training-data scale, at around $10^7$ samples, matters more than architecture for near-term surface codes. This appears to cut against an inductive-bias proposal. We treat it as a hypothesis to test: if it holds for unfolded BP too, our sample-efficiency advantage disappears and only the hardware advantage remains.

Learned-weight BP for small quantum codes may exist in literature this file does not cover. What we found no trace of is the specific combination proposed here. That combination has four parts: optimizer-style BP updates learned end to end; weights tied by code automorphisms; a logical-class readout to handle degeneracy; and synthesis under a per-round deterministic latency budget on a non-planar qLDPC code at circuit-level noise.

Core Claim

Let $G$ be the decoding graph from Stim's detector error model, the circuit-level map from fault mechanisms to the syndrome bits ("detectors") and logical observables they flip. Let $\Gamma$ be the group of graph automorphisms induced by the code's symmetry, which for the bivariate-bicycle Gross code means toroidal shifts. For iterations $k=1,\dots,K$, every edge orbit $o$ under $\Gamma$ gets three learnable coefficients: a damping weight $\alpha_{k,o}$, a momentum weight $\beta_{k,o}$ and a prior-mixing weight $\gamma_{k,o}$. These parameterize the Momentum-BP and EWAInit-BP update rules. The parameter count therefore scales with $K$ times the number of orbits, not with the number of edges. For the Gross code the number of orbits is a small constant independent of the lattice translations.

To handle chips whose symmetry is broken by defective qubits or uneven gate fidelities, we add an untied, L1-penalized residual offset per check. It is zero unless the data demand it. The final marginals feed a small readout that predicts the logical-observable flips directly. The readout is a parity-aware linear layer followed by a tiny shared MLP over each logical's support. We train with SAQ's differentiable logical loss, so degenerate errors that differ only by a stabilizer are never penalized for disagreeing with the sampled physical error.

All of this is a fixed dataflow graph: $K$ rounds of local adds, lookup-table log-domain operations and multiplies, then a readout. Latency is $K$ times the per-iteration pipeline depth plus a constant, with no data-dependent branches.

Research Program

The work has three stages. First, we build the trainable unfolded decoder in a differentiable simulator over Stim detector error models for rotated surface codes at d=3 to 11 and for the Gross code. We cover circuit-level depolarizing noise over sliding windows of syndrome rounds, so it decodes in a streaming fashion. We train at one moderately high error rate, following Cascade's single-rate protocol, and evaluate across rates.

Second, we quantize to INT8 and INT4 with quantization-aware training, following the compression pipeline in Rethink. We synthesize on the Versal HBM part using the activation-banking layout from Sparse Streaming. We report measured clock, per-round latency, LUT, DSP and memory use, rather than analytical estimates with derating factors.

Third, we probe where the inductive bias helps and where it hurts. We run sample-efficiency curves from $10^4$ to $10^7$ training shots, sweep $K$, and run broken-symmetry experiments in which Stim noise is made non-uniform: a few qubits get elevated error rates or a defective coupler. These show whether the untied residual recovers what strict tying loses, which is the expressivity-versus-invariance problem raised for equivariant models.

Baselines

The naive reference is plain min-sum BP run for the same fixed $K$ iterations with standard flooding schedule and a single global damping constant. It shows what fixing the latency costs before any learning.

The strongest classical competitor at equal structure is hand-tuned Momentum-BP and EWAInit-BP from Improved Belief Propagation Decoding Algorithms for Surface Codes. Its reported results are a code-capacity threshold of about 10% on planar surface codes and about 13.6% on toric codes. We found no reported result on Lacuna for EWAInit-BP under circuit-level noise or on the Gross code at circuit level, so we will run it ourselves. To keep the comparison fair, it gets the same $K$ and a Bayesian-optimization budget over its global hyperparameters equal in wall-clock to our training budget. Beating it means a lower logical error at every $p$ in the range 0.1% to 0.5% at equal $K$.

BP-OSD is the accuracy reference for conventional iterative decoding, with its variable latency included. Cascade's paper reports it as roughly $p^5$ scaling and about 4,000 times worse than Cascade at $p=0.1\%$. We will match BP-OSD's logical error at fixed latency, or show the latency at which it catches up.

The strongest neural competitor is Cascade, which reports a logical error of about $10^{-10}$ at $p=0.1\%$ on the Gross code with about $p^{11}$ suppression, and about 40 μs GPU latency. We retrain it on identical Stim data with the same shot budget. The hardware-realized neural competitor is the Sparse Streaming decoder at 50.6% LUT and 38.0% DSP for d=11, and we compare on the same FPGA part. Beating these does not mean matching Cascade's floor. It means a strictly better logical-error-versus-resource Pareto front: lower logical error at equal LUT/DSP and per-round latency, or equal logical error at substantially lower resource use.

Three ablations isolate the key ingredients. The first unties all coefficients, which isolates the symmetry tying. The second removes the logical readout and predicts physical errors, which isolates the degeneracy handling. The third replaces learned coefficients with the best hand-tuned ones at the same $K$, which isolates learning itself.

Why not just…?

Why not just tune EWAInit-BP's hyperparameters better? This is the most serious threat, because a handful of well-chosen global constants might capture most of the gain. Our bet is that iteration-dependent, orbit-dependent schedules can break trapping sets that a single constant cannot. Under circuit-level noise the decoding graph has many more short cycles and distinct fault types than at code capacity. The learned-versus-hand-tuned ablation at equal $K$ and equal search budget settles this directly. If the gap is under a factor of two in logical error across the $p$ range, we will report that learning adds little and reframe the work around the readout and the hardware.

Why not just quantize Cascade onto the FPGA? Sparse Streaming has already shown that convolutional decoders fit on a Versal part, and Cascade is far more accurate than any BP variant on record. If a quantized Cascade-sized model fits the per-round budget on the Gross code, it will likely beat us on accuracy. Our case rests on resources and scaling. Convolutional decoders' cost grows with channel width and depth, while unfolded BP's cost is fixed by the graph and $K$. That leaves room for more logical qubits per chip, or for future higher-distance codes. The Pareto comparison on the same part is the test. If our front is dominated, the proposal fails.

Why not just train a small TCN on much more data, as Rethink recommends? Rethink shows that INT4 TCNs meet 1 μs at d=9 with up to $2.5\times10^7$ samples on planar codes, but that study does not cover non-local qLDPC codes. Our sample-efficiency curves on both surface and Gross codes test whether the BP structure substitutes for data. If a TCN trained on $10^7$ shots matches us on the Gross code at equal resources, the data-scale view wins in this regime as well, and we will say so.

Proposed Experiments

The decisive experiment is on the Gross code under Stim circuit-level depolarizing noise from $p=0.05\%$ to $0.5\%$. We plot logical error per round against synthesized per-round latency and LUT/DSP use for every baseline above. Error rates near Cascade's $10^{-10}$ cannot be measured by direct sampling, so we estimate them by fitting the suppression slope at higher $p$ and extrapolating, applying the same procedure to all decoders. Our prediction is that learned unfolded BP will show a clearly steeper slope than BP-OSD's roughly $p^5$ while staying within the microsecond-per-round budget.

The second experiment repeats the comparison on rotated surface codes at d=3 to 11 and tests transfer across distances without retraining. Because the weights are tied by orbit, the same parameters apply to larger lattices, as UWMMSE's did for larger networks.

The third experiment uses the Sycamore experimental syndromes at d=3 and 5 from Suppressing quantum errors by scaling a surface code logical qubit, where Rethink also validated. This checks whether the untied residual captures real device non-uniformity, measured as logical error per cycle against the tensor-network decoder's reported (2.914 ± 0.016)% at d=5.

The proposal is falsified if either of two things happens. One is that hand-tuned EWAInit-BP matches the learned version at equal $K$. The other is that a quantized convolutional decoder dominates our accuracy-versus-resources front on the same FPGA.