Research
Scaling classical hardware for accurate real-time quantum error correction
Rapids puts a distance-19 surface-code decoder under a microsecond on one FPGA, removing the speed-accuracy trade-off that currently forces larger codes.
- arXiv
- 2611.26447
- Published
- 2026-11-19
- Authors
- Chenyang Jin, Susanne F. Yelin, Andi Gu
AI summary
Overview
- Research area: Quantum error correction and fault-tolerant quantum computing, specifically the classical decoding hardware that sits alongside a quantum processor (FPGA and custom-silicon implementations of neural-network decoders).
- Technical level: Advanced. The paper assumes familiarity with stabilizer codes, syndrome extraction, logical error rates, and neural-network architecture, though the main argument is stated in accessible terms.
- One-sentence scope: The paper introduces Rapids, a streaming neural decoder co-designed with an FPGA that decodes the distance-19 surface code in under a microsecond per round with far lower logical error rates than prior real-time decoders, and shows that adding classical hardware can buy speed, accuracy, or larger code support.
What This Paper Is About
A fault-tolerant quantum computer needs a classical decoder that keeps up with the rate at which error syndromes are produced, returns its answer with low delay, and is accurate enough that the code does not have to be made larger than necessary. Superconducting processors complete a syndrome round roughly every microsecond, and existing real-time decoders have met that rate only by giving up substantial accuracy. The paper's goal is to build a decoder that is simultaneously fast enough for superconducting hardware, low-latency, and far more accurate than current real-time decoders — by designing the neural network and the FPGA circuit together rather than separately.
Key Contributions
- A streaming neural decoder called Rapids. It extends Cascade, a convolutional neural decoder with near-optimal accuracy, by adding a small gated recurrent unit (GRU). Because each convolutional block in the surface-code decoder reads only the round before and after, after L blocks the features of round t depend only on rounds t−L to t+L, making the network a parallel-window decoder over an unbounded syndrome stream.
- Hardware co-design of every layer. Depthwise convolutions replace standard 3×3×3 convolutions (27C products per site instead of 27C², using 32 to 128 times fewer DSP slices), Monarch matrices replace dense multilayer-perceptron maps (3 to 5 times fewer products), weights and activations are quantized to 8-bit and 4-bit integers with quantization-aware training, and 4-bit Monarch weights are compiled into shift-and-add logic (5 times fewer LUTs than general multipliers). A leaky ReLU with negative slope 1/8 needs only a comparison and a shift.
- Real-time decoding of three different codes on AMD Versal Premium VP1802 FPGAs. The surface code at d = 19, the ⟦144,12,12⟧ bivariate-bicycle (Gross) code, and the superdense color code up to d = 15 are each placed, routed, and characterized for speed, accuracy, and hardware footprint.
- A demonstration that classical hardware is a scalable resource. The pipeline can be cut at any block boundary and spread over multiple FPGAs, mapped to custom silicon, or divided along space for modular codes assembled from small planar modules.
Main Findings
- Surface code speed: At d = 19 the compact single-FPGA build runs at a 423.7 MHz clock with 0.944 μs per round, processing over one million syndrome rounds per second and keeping pace with a 1 μs syndrome period. The original d = 19 network of the prior Cascade work would have needed about 50 times the DSP slices of a VP1802 for its convolutions alone.
- Surface code accuracy: At p = 0.15%, the logical error rate is 240 times below that of union-find — described as, to the authors' knowledge, the only decoder previously shown to run in real time at this distance — and nearly 10 times below MWPM.
- Error suppression: Rapids suppresses errors by a factor of Λ = 4.4 for every two units of distance, versus 3.5 for MWPM and about 2.5 for union-find.
- Qubit savings: Union-find would need about d = 31 to match the logical error rate of Rapids at d = 19, so Rapids reaches the same error rate with 62% fewer physical qubits (721 instead of 1,921 per logical qubit).
- Latency: The compact d = 19 build has a 20.36 μs decision latency, of which 16.05 μs is the buffer and 4.31 μs is the pipeline of CNN, pool and GRU. A fast build processing two sites per clock cycle runs at 0.49 μs per round and cuts latency to 13 μs. Latency falls only until chip-to-chip communication dominates, setting a floor of about 8 μs at d = 19.
- Throughput is independent of network depth: In the pipelined implementation, each added block costs hardware but does not change throughput, because blocks work simultaneously on different rounds.
- Custom silicon estimate: Mapping the d = 19 decoder to the ASAP7 predictive 7 nm process with OpenROAD gives 0.30 μs per round and 6.5 μs latency, drawing about 10 W in 7.4 mm² — against 250 W for the FPGA build and 1,341 mm² for the four dies of the VP1802.
- Gross code: At p = 0.1%, the most accurate build (C = 128) is 16 times more accurate than the real-time Relay-BP-1 decoder and exceeds even joint-basis Relay-BP, which has no real-time implementation. Its decision latency is 8.0 μs.
- Trading hardware for accuracy on the Gross code: Scaling the hardware fivefold lowers the logical error rate by a factor of 100; power rises from 28 to 111 W at one round per microsecond, so four times the power buys a hundred times fewer logical errors. A round takes 144 clock cycles at every width, so time per round grows only from 0.30 to 0.33 μs.
- Color code: At p = 0.15% and d = 15, the decoder is over 20 times more accurate than Chromobius. Compact builds fit on one FPGA up to d = 15; fast builds spanning two FPGAs take 0.17 μs per round with a 6.3 μs decision latency. For comparison, the real-time AQ2-RT keeps pace with a 1 μs round only up to d = 9 and has latencies up to 1 ms.
- Sparsity pays off: At d = 9 in the color code, the sparsest model of width 128 makes 1.5 times fewer errors than a model of width 64 that is three times as dense, at roughly the same 8 million floating-point operations per round. The models recover AQ2-RT performance with about an eighth of its FLOPs per round, and are twice as accurate at the same FLOP budget.
- Modular decoding: For codes built from small planar modules, a block next to a seam needs only the sites within one step of the seam, so communication traffic grows with seam length rather than module area.
- Power at scale: One VP1802 per logical qubit at d = 19 would mean thousands of FPGAs and several hundred kilowatts. The largest Gross-code decoder draws about 9 W per logical qubit, and the authors estimate that high-rate codes plus custom silicon could bring this to about 0.4 W per logical qubit, under a kilowatt for thousands of logical qubits.
Methodology in Plain English
The team started from an existing convolutional neural decoder known for high accuracy and reshaped it so that it could run continuously on incoming data, with a small recurrent network at the end remembering cumulative logical flips. They then chose network components specifically for how cheaply they map onto FPGA resources: convolutions that treat each channel separately, sparse matrix mixes built from two block-diagonal steps joined by a fixed permutation, and fixed 4-bit weights turned into shift-and-add operations in configurable logic. They trained the networks in simulation (Stim, with SI1000 noise for surface and color codes and standard depolarizing noise for the Gross code) while the integer arithmetic was already in place, starting at a low physical error rate and raising it to the target. Each decoder was then placed and routed on a VP1802 FPGA, with layers arranged so that different network blocks process different rounds at the same time, and its throughput, latency, logical error rate, resource usage, and power were measured. A separate design-flow estimate (OpenROAD, ASAP7 7 nm) was used for the custom-silicon projection, and a calibrated analytical model was used to extrapolate latency beyond the built designs.
Why This Matters
The paper reframes decoding hardware as a design variable rather than a fixed overhead: rather than accepting a speed–accuracy trade-off, an architect can spend classical silicon to buy accuracy, speed, or support for larger codes, and the cost in qubits falls accordingly (62% fewer physical qubits for the same error rate at d = 19 in the surface-code comparison). It also shows a structural advantage of feedforward convolutional decoders over matching and belief-propagation decoders, which cannot be split across devices because they iterate over a whole decoding graph — the paper estimates a single chip-to-chip round trip at about 0.5 μs, so a hundred-iteration window would take at least 50 μs, too slow for superconducting hardware.
Real-world applications:
- Superconducting quantum processors with microsecond syndrome cycles, where the decoder must keep pace and low latency directly limits the runtime of compiled algorithms.
- Architecture and resource planning for fault-tolerant machines, since decoder power and cost (hundreds of kilowatts and thousands of FPGAs in one scenario, versus the authors' ~0.4 W per logical qubit target with high-rate codes and custom silicon) become first-order design constraints alongside qubit count.
- Quantum LDPC and other high-rate codes, where the decoder's lack of a planar-layout requirement allows it to handle codes such as the ⟦144,12,12⟧ Gross code whose checks connect distant qubits.
- Modular quantum computers, where many identical small decoders joined by short fixed links decode a large code while keeping the throughput of a single module.
Industry relevance: the work connects quantum hardware developers, FPGA and EDA vendors (the builds use Vivado 2025.2.1 on the xcvp1802-vsva5601-3HP-e-S part, and AMD donated the licenses), and ASIC teams, since the same circuit maps to a 7.4 mm² 7 nm design drawing about 10 W. It also gives a concrete benchmark target for machine-learning accelerator approaches, whose latencies have been two orders of magnitude above the 10 μs reaction time assumed in typical resource estimates.
Future Directions
- Closing the residual accuracy gap with AQ2-RT. The authors note that their models are twice as accurate at the same FLOP budget and suggest more hardware would recover the remaining gap in the color code.
- Replacing estimates with silicon. The 7 nm figures (0.30 μs per round, 6.5 μs latency, about 10 W, 7.4 mm²) come from an OpenROAD flow in a predictive process, not a fabricated chip; whether the projected savings carry over to high-rate codes, giving about 0.4 W per logical qubit, is stated as an open projection.
- Scaling to machines with thousands of logical qubits and to modular codes. The modular scheme is drawn schematically for a modular hyperbolic surface code, and the latency extrapolations beyond the routed d = 19 builds (to d = 27) come from a calibrated model rather than measurement.
- Extending the approach to other codes and joint-basis decoding. The authors point out that no clear path exists to scale the real-time Relay-BP decoder from one basis to joint-basis decoding or to larger codes, which leaves that regime open for decoder designs like theirs.
Target Audience
This paper is most useful to researchers and engineers working on quantum error correction and fault-tolerant system architecture, to hardware engineers designing classical control and decoding electronics for quantum processors (FPGA and ASIC), and to machine-learning researchers interested in hardware-aware neural network design. It is also valuable to readers who already know the basics of stabilizer codes and want a concrete, quantified picture of what real-time decoding costs in speed, latency, power, and silicon area.
Authors’ abstract
Fault-tolerant quantum computation requires a classical decoder fast enough to process syndrome measurements at the rate at which they are generated, and to return its decisions with low latency. This is most demanding for superconducting processors, whose fast syndrome cycles force a trade-off between decoding speed and accuracy. Decoders fast enough to keep up sacrifice accuracy, which must be compensated for with larger codes and thus additional physical qubits. Here we…
The full abstract on arXiv