💻 computer science

Sparse Mamba Decoder for Quantum Error Correction: Efficient Defect-Centric Processing of Surface Code Syndromes

The Sparse Mamba Decoder (SMD) is a defect-centric neural decoder that achieves superior accuracy and near-constant low latency by processing only active detection events with O(k) complexity, significantly outperforming existing decoders in speed and logical error rates across various quantum error correction benchmarks.

Original authors: Samira Sayedsalehi, Nader Bagherzadeh, Maxim Shcherbakov

Published 2026-10-22

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Samira Sayedsalehi, Nader Bagherzadeh, Maxim Shcherbakov

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Quantum computers promise to solve problems that would take today's machines thousands of years, but they are incredibly fragile. The tiny particles that hold their information, called qubits, are easily disturbed by heat, vibration, or even stray electromagnetic waves. When a qubit gets disturbed, it makes a mistake, and if these mistakes pile up, the entire calculation collapses. To build a useful quantum computer, scientists must build a system that can find and fix these mistakes as they happen, a process known as quantum error correction. The most popular method for doing this uses a grid of qubits where the system constantly checks its own health. These checks produce a stream of data called a syndrome, which acts like a map of where errors have occurred. The challenge is that a computer must read this map and decide how to fix the errors faster than new errors can appear, a race against time that requires immense speed and precision.

For years, the best tools for reading these error maps have been classical algorithms that treat the entire grid as a solid block of data, checking every single square regardless of whether anything is wrong. This approach is reliable but slow, because it wastes time processing empty space. In a new study, researchers at the University of California, Irvine, have introduced a different way of thinking. They built a decoder that ignores the empty parts of the grid and focuses only on the few spots where an error actually happened. By treating the error map not as a full picture but as a sparse list of active events, they created a system that is dramatically faster and just as accurate as the best existing methods.

The researchers, led by Samira Sayedsalehi, developed what they call the Sparse Mamba Decoder. To understand why this is a breakthrough, one must first understand the nature of the errors. In a quantum computer running a typical experiment, errors are rare. Out of thousands of possible places where a mistake could be recorded, usually only a tiny fraction, often less than five percent, actually show a problem. The old way of decoding was like a security guard walking through every single room of a massive, empty hotel to check for intruders, even though the guard knew that intruders only ever appeared in a few specific rooms. The new decoder skips the empty rooms entirely. It waits for the alarm to ring, identifies the specific room where the noise came from, and then analyzes only that room and its immediate neighbors.

This shift in strategy allowed the team to use a powerful new type of artificial intelligence architecture called a state-space model, specifically a version known as Mamba. This model is designed to process sequences of information efficiently. Instead of feeding the entire grid of data into the system, the researchers extracted only the active error signals, which they call defects. They then wrapped each defect in a detailed description containing its location, the type of error, and its relationship to nearby errors. This created a short, variable-length list of events rather than a giant, static block of data. The AI model then read this list to predict whether the computer had suffered a logical failure, which is a mistake that cannot be fixed and ruins the calculation.

The results of this approach were striking. When tested on simulated data that mimics the behavior of real quantum hardware, the new decoder reduced the rate of uncorrectable errors by up to 49 percent compared to the standard method used in the field. More importantly, it did so with incredible speed. In tests, the new system ran between 95 and 467 times faster than the current leading near-perfect decoder, known as Tesseract. While the Tesseract decoder took milliseconds to process a single error map, the new system completed the task in microseconds. This speed is critical because quantum computers operate on cycles that last only about one microsecond; if the decoder is too slow, the computer cannot keep up with its own mistakes.

The researchers also tested their system on real data collected from Google's Sycamore quantum processor. In these experiments, the new decoder matched or slightly surpassed the performance of a previous, more complex neural network that processed the full grid of data. This proved that the new method did not lose accuracy by ignoring the empty space; it simply found a more efficient way to see the signal. The system achieved this high performance on standard, commercially available graphics cards, without needing the specialized, expensive supercomputing hardware that other advanced decoders require.

One of the most significant findings was how the system handled the size of the quantum computer. As the grid of qubits grows larger to perform more complex calculations, the amount of data to process usually explodes, making decoding slower and slower. The new decoder, however, maintained a nearly constant speed regardless of the grid size. While other methods became hundreds of times slower as the grid grew, this system only slowed down by a small factor. This suggests that as quantum computers scale up to the massive sizes needed for practical use, this defect-focused approach will become not just faster, but essential.

The success of the Sparse Mamba Decoder relies on a clever way of describing the errors. Instead of just knowing where an error happened, the system was given a rich set of clues for each error event. It was told the exact coordinates of the error, whether it was a bit-flip or a phase-flip, and whether its neighbors were also firing alarms. It was also given a history of the error's state over time. By feeding this detailed context into the AI, the system learned to recognize complex patterns of mistakes that older methods missed. It learned to distinguish between a single measurement glitch and a chain of errors spreading across the chip, allowing it to make better decisions about how to fix the computer.

The study also highlighted a fundamental limitation of the old approach. By processing the entire grid, previous decoders were forced to treat the horizontal and vertical directions of the error map as separate problems. However, in the quantum world, certain types of errors affect both directions at once. The new decoder, by looking at the sequence of all errors together, could naturally see these connections. This allowed it to solve problems that the older, separated methods could not, leading to the significant drop in error rates observed in the tests.

While the system is not yet fast enough to run in real-time on the fastest superconducting quantum computers, which operate on a one-microsecond cycle, it represents a massive leap forward. The researchers noted that the current version processes data in batches, which adds a small delay. However, the underlying logic is so efficient that a future version, designed to stream data as it arrives, could potentially reach the speeds needed for real-time correction. The fact that this level of performance was achieved on a standard graphics card suggests that the barrier to entry for high-quality quantum error correction is lower than previously thought.

The work demonstrates that the inherent sparsity of quantum errors is a feature, not a bug. By designing an architecture that respects this sparsity, the researchers found a path to decoding that is both faster and more accurate. The study rules out the idea that processing the full, dense grid of data is necessary for high accuracy, showing instead that focusing on the active defects is a superior strategy. As quantum hardware continues to improve and grow larger, the ability to decode errors quickly and efficiently will be the key to unlocking the full potential of these machines. This new decoder provides a clear, practical path toward that future, proving that sometimes the best way to solve a complex problem is to ignore everything that isn't broken.

Technical Summary: Sparse Mamba Decoder for Quantum Error Correction

Problem Statement

Quantum error correction (QEC) is a prerequisite for fault-tolerant quantum computing, requiring decoders that balance accuracy, speed, and scalability. The surface code, a leading candidate for near-term implementation, generates a syndrome array of size $O(d^2 R)$ , where $d$ is the code distance and $R$ is the number of measurement rounds.

Existing state-of-the-art neural decoders, such as AlphaQubit and the Dense Mamba decoder, process this full dense syndrome array regardless of the actual error rate. However, at physically relevant error rates (e.g., $p \approx 0.1\%$ ), fewer than 5% of syndrome entries contain active detection events. Processing the entire dense volume is analogous to performing dense matrix multiplication on a 97%-sparse matrix, leading to unnecessary computational overhead. Furthermore, while matching-based decoders like Minimum-Weight Perfect Matching (MWPM) are fast, they are suboptimal as they fail to account for correlated errors (e.g., Y-errors triggering both X and Z stabilizers). Conversely, near-optimal decoders like Tesseract or AlphaQubit 2 often require specialized hardware (e.g., Trillium TPUs) or exhibit high latency that scales poorly with code distance.

Methodology: The Sparse Mamba Decoder (SMD)

The authors introduce the Sparse Mamba Decoder (SMD), a defect-centric architecture that fundamentally shifts the input representation from dense syndrome arrays to sparse sequences of active detection events.

1. Sparse Defect Representation

Instead of processing the full $(d^2-1) \times R$ syndrome volume, SMD extracts only the $k$ active detection events. Each defect is represented by a 13-dimensional feature vector ( $f_{i,t}$ ) encoding:

Spatial Coordinates: Normalized $(x, y)$ on the rotated lattice.
Temporal Context: Normalized round index $t/R$ .
Stabilizer Type: Binary flag for X-type or Z-type checks.
Connectivity Flags: Binary indicators for spatial neighbors (4 flags) and temporal neighbors (2 flags) that also fired.
Boundary Distances: Normalized distances to the Z and X logical boundaries ( $b_Z, b_X$ ).
Reconstructed Measurement: The cumulative XOR of the detection event history ( $m_{i,t}$ ), providing the current state of the stabilizer.

These features are sorted by time and stabilizer index to form a variable-length sequence of length $k$ , where $k \ll d^2 R$ at relevant error rates.

2. Architecture

The SMD utilizes a Mamba state-space model backbone, which processes the defect sequence in linear time without attention mechanisms.

Embedding: A two-layer MLP projects the 13-dimensional features into a model dimension ( $d_{model}$ ).
Mixer Layers: The core consists of $L$ layers, each containing a Mamba selective scan block (with state dimension $d_{state}=16$ and convolution width $d_{conv}=4$ ) followed by a Gated Dense block (using SiLU gating).
Readout: Variable-length sequences are aggregated via masked mean pooling and passed through a readout network (ResBlock or MLP) to predict the logical observable $\hat{\lambda}$ .
Dual-Head Variant: For depolarizing noise, a dual-head architecture predicts both $\lambda_Z$ and $\lambda_X$ jointly, allowing the model to capture correlations between error bases that independent matching decoders miss.

3. Training Protocols

The authors employ distinct training strategies based on the noise model:

Synthetic Benchmarks: Trained from scratch with fresh synthetic data using AdamW or Lion optimizers.
SI1000 Benchmark: Utilizes a three-stage curriculum over measurement rounds ( $r \le 9, 25, 120$ ) to handle long sequences.
Sycamore Experimental Data: Follows a two-stage protocol: pretraining on a Detector Error Model (DEM) calibrated to hardware via XEB data, followed by fine-tuning on real experimental data.
Ensembling: To maximize accuracy, the authors use multi-checkpoint ensembling (averaging logits from models at different training steps) and multi-seed ensembling.

Key Contributions

Sparse Defect-Centric Architecture: SMD processes only active defects ( $k$ ) rather than the full syndrome volume ( $d^2 R$ ), achieving $O(k)$ computational complexity. This contrasts with $O(d^2 R)$ for dense neural decoders and $O(d^4 R)$ for attention-based methods.
High Accuracy Across Benchmarks:
- Depolarizing Noise: SMD reduces logical error rates by 40–91% compared to MWPM, Tesseract, and Belief Matching at $d=5–11$ by exploiting Y-error correlations through joint decoding.
- SI1000 Noise: Reduces the MWPM logical error rate by up to 49% at $d \le 5$ . At $d=7$ , a three-checkpoint ensemble achieves a 16% reduction over MWPM.
- Sycamore Data: The SMD ensemble matches or slightly surpasses the dense Mamba decoder of Lee et al. on experimental data, despite using a sparse input without dilated 2D convolutions.
Computational Efficiency: SMD runs 95–467× faster than the Tesseract near-MLD decoder and 232–463× faster than Belief Matching under SI1000 noise. Under uniform circuit-level noise, latency remains nearly constant (24–57 $\mu$ s) as $d$ increases from 3 to 9, whereas Belief Matching latency increases by 773×.
Commodity Hardware Feasibility: All results are achieved on standard NVIDIA GPUs (RTX 4090 and H200 NVL) with model sizes of 7.5–16M parameters, avoiding the need for specialized TPUs required by AlphaQubit 2.

Results and Performance

Accuracy: On the Sycamore dataset ( $d=3, 5$ ), the SMD ensemble achieves logical error rates of $2.940 \times 10^{-2}$ and $3.001 \times 10^{-2}$ , respectively, outperforming the dense Mamba baseline ( $2.98 \times 10^{-2}$ and $3.03 \times 10^{-2}$ ) and tensor network decoders at $d=3$ .
Latency Scaling: For uniform circuit-level noise, SMD latency increases only 2.4× from $d=3$ to $d=9$ , compared to a 773× increase for Belief Matching.
Generalization: The model demonstrates strong generalization to out-of-distribution round counts (e.g., $r=140$ when trained up to $r=120$ ) and varying error rates, provided the defect density remains within the training distribution.

Significance and Claims

The paper claims that the inherent sparsity of quantum error syndromes at physically relevant error rates is a powerful structural prior that should be exploited by decoder architectures. The Sparse Mamba Decoder demonstrates that:

Sparse representation is sufficient: Accurate decoding does not require processing the full dense syndrome array; encoding spatial structure directly into feature vectors allows a 1D sequential model to capture necessary geometric correlations.
Scalability is achievable on commodity hardware: High-accuracy, near-MLD performance can be attained on consumer-grade GPUs without specialized accelerators, making advanced neural decoding more accessible.
Efficiency vs. Accuracy Trade-off: SMD offers a Pareto-optimal balance, closing a significant portion of the accuracy gap between MWPM and near-MLD decoders while operating at orders-of-magnitude lower latency.

The authors note that while SMD is optimized for batched throughput on current hardware, its $O(k)$ scaling is orthogonal to streaming architectures. Future work could combine SMD's sparse processing with streaming optimizations to achieve real-time decoding for superconducting qubits. The approach is also posited to be adaptable to other code families like color codes and quantum LDPC codes.