We present a real-time FPGA decoder for a high-rate $[[512,174,8]]$ 3D product qLDPC code. We construct a circuit-level detector-error model for a compact syndrome-extraction schedule and propose a small parallel ensemble of row-wise serial min-sum decoders with cumulative memory. The decoder matches $\text{BP+OSD-CS}_\text{10}$ accuracy with one core and Relay-BP accuracy with three cores. The FPGA implementation meets the latency budget of neutral-atom and trapped-ion systems. An ASIC implementation would improve the latency, enabling real time decoding even for superconducting systems. At a physical error rate of $p=10^{-3}$, three FPGA devices decode 174 logical qubits with a logical error rate of $5\times10^{-7}$ and effective distance 6. For $p=10^{-4}$, and assuming the number of BP iterations is capped to 30, the decoder's average latency is $5.1\,$\textmu s and its worst-case latency is $97.9\,$\textmu s.
AI Summary
The paper asks whether high-rate qLDPC codes can be decoded under circuit-level noise within real-time hardware budgets without OSD or integer-programming post-processing. It studies the $[[512,174,8]]$ 3D product code, with a 34% encoding rate, and constructs a compact syndrome-extraction schedule and detector-error model.
The decoder combines row-wise serial normalized min-sum updates with cumulative memory and a parallel ensemble using different check-processing orders and perturbed priors. Numerical comparisons show one core matching BP+OSD-CS$_{10}$ accuracy and three cores matching Relay-BP accuracy for this code. Eight-round simulations give a per-logical-qubit, per-round logical error rate of approximately $5\times10^{-7}$ at $p=10^{-3}$ and observed scaling corresponding to effective distance 6. Fixed-point quantization produces little accuracy loss in the tested single-round setting.
One core is implemented and timed on an FPGA, taking $3.264\,\mu\mathrm{s}$ per iteration. At $p=10^{-4}$, its average latency is $5.1\,\mu\mathrm{s}$; a 30-iteration cap bounds core latency at $97.9\,\mu\mathrm{s}$. Each core occupies more than half the device’s BRAM, so the ensemble requires three FPGAs.
The hardware implementation decodes a single round without idling noise, rather than a repeated-round sliding window. Reported core timings exclude communication; the tested Ethernet interface adds $34\,\mu\mathrm{s}$. Multi-FPGA integration, sliding-window decoding, control-system integration, and quantization–resource trade-offs remain future work. Sub-microsecond ASIC operation is projected, not demonstrated, and superconducting implementation also faces the code’s long-range interaction requirements.
Little sign of AI-generated textOverclaimsStrong assumptions
Central claim may not hold: The implemented decoder handles a one-round task, whereas the repeated-round accuracy study uses a different task and continuous sliding-window decoding remains future work.
Only individual FPGA-core timing is demonstrated, not the integrated three-device ensemble with its selection and communication overhead.
The Z-basis terminal-measurement experiments establish basis-specific logical performance rather than protection of both complementary logical observables.
Sub-microsecond superconducting decoding remains an unvalidated ASIC extrapolation, and faster communication cannot make the measured 5.1-microsecond FPGA computation sub-microsecond.
The reported 5.1-microsecond average permits approximately 196 ensemble-decoded batches per millisecond before overhead, not the claimed more than 250.
Written by gpt-6.1-sol from the paper's full text. Automated: it can be wrong.
We present a real-time FPGA decoder for a high-rate [[512,174,8]] 3D product qLDPC code. We construct a circuit-level detector-error model for a compact syndrome-extraction schedule and propose a small parallel ensemble of row-wise serial min-sum decoders with cumulative memory. The decoder matches BP+OSD-CS10 accuracy with one core and Relay-BP accuracy with three cores. The FPGA implementation meets the latency budget of neutral-atom and trapped-ion systems. An ASIC implementation would improve the latency, enabling real time decoding even for superconducting systems. At a physical error rate of p=10−3, three FPGA devices decode 174 logical qubits with a logical error rate of 5×10−7 and effective distance 6. For p=10−4, and assuming the number of BP iterations is capped to 30, the decoder's average latency is 5.1\textmu s and its worst-case latency is 97.9\textmu s.
The paper asks whether high-rate qLDPC codes can be decoded under circuit-level noise within real-time hardware budgets without OSD or integer-programming post-processing. It studies the [[512,174,8]] 3D product code, with a 34% encoding rate, and constructs a compact syndrome-extraction schedule and detector-error model.
The decoder combines row-wise serial normalized min-sum updates with cumulative memory and a parallel ensemble using different check-processing orders and perturbed priors. Numerical comparisons show one core matching BP+OSD-CS10 accuracy and three cores matching Relay-BP accuracy for this code. Eight-round simulations give a per-logical-qubit, per-round logical error rate of approximately 5×10−7 at p=10−3 and observed scaling corresponding to effective distance 6. Fixed-point quantization produces little accuracy loss in the tested single-round setting.
One core is implemented and timed on an FPGA, taking 3.264μs per iteration. At p=10−4, its average latency is 5.1μs; a 30-iteration cap bounds core latency at 97.9μs. Each core occupies more than half the device’s BRAM, so the ensemble requires three FPGAs.
The hardware implementation decodes a single round without idling noise, rather than a repeated-round sliding window. Reported core timings exclude communication; the tested Ethernet interface adds 34μs. Multi-FPGA integration, sliding-window decoding, control-system integration, and quantization–resource trade-offs remain future work. Sub-microsecond ASIC operation is projected, not demonstrated, and superconducting implementation also faces the code’s long-range interaction requirements.
Quantum computers can solve selected problems more efficiently than classical computers, but current devices are limited by high physical error rates. Quantum Error Correction (QEC) mitigates this by encoding many physical qubits into a logical qubit, with the surface code among the most widely studied approaches. Since syndrome measurements are produced continuously, the decoder must process them fast enough to avoid becoming a system bottleneck, making real-time decoding essential for fault-tolerant quantum computing. While most state-of-the-art real-time decoders rely on Minimum-Weight Perfect Matching (MWPM), we instead use a high-accuracy Graph Neural Network (GNN) that trades higher computational cost for lower logical error rates. To make this GNN practical for real-time decoding, we apply algorithm-hardware co-design. We reduce complexity through hardware-guided pruning and retraining, producing two hardware-friendly models that reduce parameter count by 3.1× and 6.5×. These target, respectively, an average decoding latency of one syndrome cycle and a worst-case latency within one syndrome cycle. We further reduce hardware cost using input-graph filtering and post-training quantization. Based on these optimized models, we propose an FPGA-based architecture for low-latency inference and real-time decoding. Evaluated on surface codes up to distance 7 under circuit-level noise at physical error rate p=10−3, our decoder outperforms MWPM in decoding accuracy for both average-latency and max-latency settings. It reduces logical error rate by 40% at 1μs average latency, and by 13% under a strict 1μs deadline.
Quantum processors need to improve their reliability to scale up the number of qubits and increase the number of algorithms that can execute. To reduce the logical error rate of the quantum systems, the use of error correction codes and decoders has been established as a low-cost and feasible approach, with good results from a theoretical perspective, for mid and long-term architectures. While most of the authors are focused on the algorithms to improve the correction capability of quantum computers, without taking into account a fundamental implementation aspect for their deployment in a real system, i.e., their latency must be bounded to avoid the qubit decoherence, only a few propose hardware architectures and they just include time estimations of their decoding latency. However, a real implementation has not been shown yet. In this work, we analyze from the point of view of hardware implementation two algorithmic options based on quantum low-density parity-check (QLDPC) codes: a) belief propagation min-sum decoders combined with codes with good error-floor behavior and b) belief propagation min-sum decoders concatenated with ordered statistics decoders (OSDs) for codes with early error-floor. The bounds for the maximum clock frequency required by the decoders to decode within the qubit coherence time are established as a parameter to show if a practical implementation is possible with the present or near future FPGA technology. Furthermore, real implementation results for a Xilinx FPGA device are provided, showing that some solutions can meet the timing constraints set up by the state-of-the-art quantum processors.
Real-time quantum error correction requires classical decoders to process growing syndrome workloads with low and predictable latency. For quantum low-density parity-check (qLDPC) codes, iterative belief propagation (BP) repeatedly updates messages over sparse Tanner graphs, creating substantial memory-access and data-movement demands. We map normalized Min-Sum BP decoding of the [[144,12,12]] Bivariate Bicycle qLDPC code onto a DPU-based Processing-in-Memory (PIM) architecture. Within each DPU, 11 tasklets cooperatively decode one syndrome, while multiple DPUs process independent syndrome instances in parallel. Using uPIMulator and a data-qubit Pauli error model with ideal syndrome measurements, we compare throughput, per-syndrome processing time, logical error rate (LER), and single-syndrome tail latency against a 16-logical-CPU baseline. At a component-wise physical error probability of p=0.001 and one BP iteration, the projected aggregate kernel throughput of 2,560 DPUs reaches 1.071 x 10^7 decodes/s, compared with 1.22 x 10^6 decodes/s for the CPU, an 8.8x improvement. From two iterations onward, the measured LER remains below the physical error probability for every evaluated value of p. For one to five iterations, the maximum sampled serialized X+Z DPU compute latency remains below the 1 ms decoder-side reference for trapped-ion QEC, reaching approximately 0.873 ms at five iterations. These results show that near-memory processing can provide high aggregate throughput and sub-millisecond compute latency for qLDPC BP decoding under the evaluated conditions.
Belief propagation (BP) combined with ordered statistics decoding (OSD) provides a good balance between accuracy and complexity for many quantum error correction (QEC) codes, making it nearly universal. However, the complexity of OSD can limit real-time decoding, particularly for superconducting qubits, and the limits of classical hardware decoders have not been fully explored. Therefore, it is important to assess the architecture of OSD for different code families, such as surface codes and bicycle bivariate codes, under realistic assumptions like the detector error model. This paper introduces a BP + OSD parallel architecture implemented on FPGA and ASIC for surface codes (distances 3–21) and bicycle bivariate codes (distances 6–24). Results show that for surface codes up to distance 9, the OSD post-processor fits into a single VCU129 FPGA, achieving a frequency of 200 MHz with a worst-case latency of 134 μ s. For bicycle bivariate codes, the limit is distance 12, with a frequency of 244 MHz and a worst-case latency of 84 μ s. In ASIC, with 45 nm technology, latency improves by 31%, but area resources grow significantly, making parallel implementation beyond distance 12 impractical on a single chip. The designs were verified using a hardware emulator, ensuring that the decoder’s behavior matches software simulations and revealing interesting results like potential error floors at low logical error rates.
Quantum error correction (QEC) is essential for realizing large-scale, fault-tolerant quantum computation, yet its practical implementation remains a major engineering challenge. In particular, QEC demands precise real-time control of a large number of qubits and low-latency, high-throughput and accurate decoding of error syndromes. While most prior work has focused primarily on decoder design, the overall performance of any QEC system depends critically on all its subsystems including control, communication, and decoding, as well as their integration.
To address this challenge, we present an open-source, fully integrated QEC system built on RISC-Q, a generator for RISC-V-based quantum control architectures. Implemented on RFSoC FPGAs, our system prototype integrates real-time qubit control, a scalable distributed multi-board architecture, and the state-of-the-art hardware QEC decoder within a low-latency, high-throughput decoding pipeline, forming a complete hardware platform ready for deployment with superconducting qubits.
Experimental evaluation on a three-board prototype based on AMD ZCU216 RFSoCs demonstrates an end-to-end QEC decoding-feedback latency of 446 ns for a distance-3 surface code, including syndrome aggregation, network communication, syndrome decoding, and error distribution. Extrapolating from measured subsystem performance and state-of-the-art decoder benchmarks, the architecture can achieve sub-microsecond decoding-feedback latency up to a distance-21 surface code ($\sim$881 physical qubits) when scaled to larger hardware configurations.
Quantum error correction (QEC) is essential for achieving low error rates required for fault-tolerant quantum computation. In stabilizer-based codes such as the surface code, errors are inferred from repeated syndrome measurements and corrected by a classical decoder. To prevent error accumulation, decoding must be performed with both high throughput and low latency to keep pace with the QEC cycle and enable real-time feedback for universal logical operations. Here we report a hardware-integrated control architecture featuring an FPGA-based neural-network (NN) decoder and experimentally demonstrate real-time surface-code (distance-3) QEC on a superconducting quantum processor. The system achieves a deterministic closed-loop latency of 550 ns, including 124 ns for NN decoding, enabling feedback corrections within a 1.25 us QEC cycle. We show that real-time decoding and feedback correction achieve logical performance comparable to offline decoding while maintaining robustness against varying error conditions. We further demonstrate mid-circuit feedback correction in non-Clifford logical circuits, where Pauli-frame updating alone becomes insufficient. Our results establish a low-latency hardware architecture for embedded QEC control and provide a pathway towards scalable fault-tolerant quantum computing systems.