Machine-learning decoders for fusion-based quantum computing in real time

Daniel Barter, Jacob C. Bridgeman, Chris Dawson, Terry Farrelly, Shane Fleming, Mercedes Gimeno-Segovia, Paul Hartke, Timothy Hein, Sean Howell, Gregory Hyegang Jun, Siddhartha Kamalakara, Yehua Liu, Jose M. Monsalve Diaz, Eddie Richter, Sam RobertsarXiv 2026 · arXiv

TL;DR

Researchers have introduced PRISM, a transformer-based machine-learning decoder designed to handle the high erasure rates (photon loss) inherent in photonic fusion-based quantum computing. By leveraging sparse attention and aggressive hardware-software co-design, PRISM matches the accuracy of state-of-the-art algorithmic decoders while achieving the microsecond-scale latencies necessary for real-time quantum error correction on FPGAs.

What Problem Does This Paper Address?

Fault-tolerant quantum computing relies on Quantum Error Correction (QEC) to identify and fix physical errors before they corrupt logical information. The "brain" of this process is the decoder, a classical algorithm that must process measurement outcomes (syndromes) in real-time.

In photonic fusion-based quantum computing (FBQC), the dominant error mechanism is erasure—often caused by photon loss. While we know exactly where an erasure occurred, these "heralded" errors create irregular, large-scale inference problems that traditional decoders struggle to solve quickly. If a decoder is too slow, the quantum computer stalls; if it’s inaccurate, the logical error rate skyrockets. The challenge is finding a decoder that is simultaneously accurate, fast, and scalable.

FIG. 1: The decoding problem. (a) A schematic of a fault-tolerant protocol. A set of equivalent membranes is indicated by shaded sheets. A chain of errors (red) that flips a logical membrane without flipping any checks results in a logical error. (b) A Tanner graph example. Circle nodes are error mechanisms (fusion outcomes in FBQC) and square nodes are checks. The decoder observes which mechanisms are erased (crossed circles) and which checks are flipped (filled squares), but not the Pauli error itself (red circles). The highlighted mechanisms belong to the support of one membrane representative. (c) The decoding task: given the erasure pattern ε and the syndrome σ, infer for each membrane class whether it was flipped. Here, p(fµ | σ, ε) is the decoder; it predicts membrane flip probabilities based on the syndrome σ and erasure pattern ε for each logical representative indexed by µ.

Methods

The authors developed PRISM, a transformer-based architecture tailored for the graph-like structure of quantum codes. Key innovations include:

  • Sparse Cross-Attention: Instead of the standard "all-to-all" attention which scales poorly ($O(N^2)$), PRISM restricts attention to the edges of the Tanner graph (the physical connectivity of the code). This allows the computational cost to grow linearly with the size of the quantum system.
  • Erasure-Awareness: PRISM takes erasure flags as explicit inputs alongside syndromes, allowing the model to dynamically "re-weight" its confidence in different measurement outcomes.
  • Syndrome-Aligned Voting: The model predicts multiple equivalent representatives of a logical error. These representatives "vote" on the final correction, a technique that significantly improves robustness against local noise.
  • Hardware-Software Co-design (Q-PRISM): To enable real-time execution, the authors created a quantized version. They used ternary weights (values are restricted to $\{-s, 0, +s\}$) and 2-bit activations. This allows the entire neural network to be mapped onto the simple Lookup Table (LUT) fabric of an FPGA, avoiding the need for slower, specialized math blocks (DSPs).
FIG. 2: High level model structure. Refer to Figure C1 for a more detailed schematic. Components with learned parameters are shaded. From left to right: (a) Syndrome and erasure bits are embedded as check states and error-mechanism states, respectively. (b) Through a series of message-passing steps, check and error-mechanism states are updated by exchanging information on the Tanner graph. (c) A perceiver then updates membrane states for each membrane representative using the error-mechanism states. For the membranes, there are no observations that can be embedded, so these states are initially set to a single learned seed vector (see Appendix C). (d) A final learned linear layer maps each membrane state to a pair of logits. (e) Finally, predicted class flips are returned by combining representatives for each class in a syndrome- aware manner (Section III C 1).

Datasets

The study benchmarks PRISM using simulated data from four major families of fusion networks, all defined on a 3-torus:

  1. Six-ring network: A surface-code-like network that is "graphlike," allowing comparison with standard Minimum-Weight Perfect Matching (MWPM) decoders.
  2. Linked-loopy-diamond (LLD): A high-threshold topological network.
  3. Color-code network (CC8): Built from eight-qubit resource states.
  4. Bivariate Bicycle (BB) codes: A class of quantum Low-Density Parity-Check (qLDPC) codes known for high encoding rates.

The benchmarks covered code distances up to $d=24$, providing a rigorous test of the decoder's scalability.

Key Insights and Ideas

  • ML as a "Fixed-Time" Solution: Unlike algorithmic decoders (like Integer Linear Programming) whose runtime can vary wildly depending on the specific error pattern, PRISM has a deterministic inference time. This is a massive advantage for synchronous quantum control loops.
  • The "Erasure Stall": The authors found that training on high-noise models initially fails because erasures obscure too much information. They solved this using a curriculum learning strategy—starting with low noise and "annealing" up to the target operating point.
  • Quantization is Free (Almost): Aggressive quantization to ternary weights and 2-bit activations resulted in only a minor hit to accuracy while enabling a massive speedup on FPGA hardware.

Key Results

  • Accuracy: PRISM matched the logical error rates of state-of-the-art Integer Programming (ILP) decoders across all tested topological and qLDPC codes.
  • Latency: On an AMD VP1902 FPGA, a distance-8 LLD block was decoded with a full-block latency of just 6.59 $\mu$s.
  • Throughput: The system achieved an amortized decoding time of 1.56 $\mu$s per logical block.
  • Scalability: For the $d=24$ LLD code, the decoder returned zero logical errors after 30 billion trials at a 1.2% operating point, demonstrating its effectiveness at scales relevant to utility-scale quantum computing.

Limitations and Future Work

  • Modular Decoding: While the paper demonstrates high performance on individual logical blocks, a full-scale quantum computer will require "modular decoding"—stitching these block-level results together. The authors suggest PRISM is compatible with this but leave the implementation for future work.
  • FPGA Resource Scaling: The current implementation for $d=8$ fits comfortably on a single FPGA. Scaling to much larger distances ($d > 20$) in a single pass may require even more advanced hardware or further optimizations in model width.
  • Non-Periodic Blocks: The study focused on periodic decoding blocks (standard for benchmarking). Real-world applications with boundaries and non-periodic circuits will need specific training and architectural adjustments.

Summary updated

Abstract

Fault-tolerant quantum computation requires decoders that combine accuracy, throughput, low latency, and scalability to large numbers of physical qubits. In photonic fusion-based architectures, erasures from photon loss and probabilistic fusion measurements are a dominant error mechanism, motivating decoders that remain accurate at high erasure rates. We introduce PRISM, a transformer-based machine-learning decoder designed to exploit the known locations of erasures in protocols subject to both Pauli and erasure errors. We benchmark PRISM across a wide range of fault-tolerant protocols based on surface codes, color codes, and quantum low-density parity-check codes, with distances up to 24. Across these benchmarks, PRISM matches the logical error rates of integer-programming-based decoders while being significantly faster, including at error rates up to 50% of threshold. We further optimize the decoder and its real-time hardware implementation to reduce latency while maintaining accuracy. Our optimized implementation on an AMD VP1902 FPGA can decode logical blocks of distance 8 in both space and time, demonstrating a latency of 6.59 microseconds and an amortized decoding time of 1.56 microseconds per logical block is possible. These results show that machine-learning decoding can provide accurate, low-latency inference for erasure-dominated fault-tolerant quantum architectures.
BibTeX
@misc{barter2026machine,
  author = {Daniel Barter and Jacob C. Bridgeman and Chris Dawson and Terry Farrelly and Shane Fleming and Mercedes Gimeno-Segovia and Paul Hartke and Timothy Hein and Sean Howell and Gregory Hyegang Jun and Siddhartha Kamalakara and Yehua Liu and Jose M. Monsalve Diaz and Eddie Richter and Sam Roberts},
  title = {{Machine-learning decoders for fusion-based quantum computing in real time}},
  year = {2026},
  eprint = {2611.13630},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.13630},
}

Loading related content...

Figure