⚛️ quantum physics

Soft decoding for quantum LDPC codes with experimental validation

This paper introduces a soft beam search decoder for quantum LDPC codes that leverages internal data for confidence scoring, demonstrating through simulations and experimental re-analysis that it significantly suppresses logical errors and extends qubit lifetimes to beyond-breakeven regimes with minimal shot rejection.

Original authors: Arda Aydin, Edwin Tham, Nicolas Delfosse, Min Ye

Published 2026-09-24

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Arda Aydin, Edwin Tham, Nicolas Delfosse, Min Ye

Original paper licensed under CC BY 4.0 (http://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

In the quest to build a computer that can solve problems beyond the reach of today's machines, scientists are turning to the strange rules of quantum mechanics. These machines, known as quantum computers, use tiny particles like atoms or ions to store information in a state called a qubit. Unlike the bits in a standard laptop, which are either a zero or a one, a qubit can exist in a mix of both states at once. This power comes with a fragile cost: the slightest disturbance from the environment can corrupt the information, causing the calculation to fail. To combat this, researchers use a method called quantum error correction. They spread the information of a single logical qubit across many physical particles, constantly checking for mistakes without looking at the data itself, which would destroy it. When an error is spotted, a decoder acts as a guide, figuring out what went wrong and how to fix it. However, these decoders often struggle with the sheer complexity of the data, and if they make a mistake in their own judgment, the entire calculation can collapse.

A team of researchers at IonQ and the University of Maryland has developed a new way to help these decoders make better decisions without slowing them down. They focused on a specific type of error-correcting code, known as a quantum low-density parity-check code, which is a leading candidate for building large-scale quantum computers. The challenge they addressed is that while these codes are powerful, the software used to fix errors often produces a result without telling the user how confident it is in that result. In the past, if a decoder was unsure, the only option was to discard the entire attempt and start over, which wastes valuable time and resources. The researchers realized that the decoder itself holds the secret to its own confidence. By watching how the decoder works internally, they found a way to measure its certainty without needing any extra calculations or complex new models.

The team introduced a method where the decoder keeps a running tally of how many steps it takes to find a solution. If the decoder finds the answer quickly, it is likely a reliable result. If it has to wander through many possibilities and take a long time to settle on an answer, that result is more likely to be shaky. The researchers set a simple rule: if the decoder takes too many steps, the system discards that specific attempt and tries again, but if it finishes within the limit, the result is kept. This approach, which they call a soft decoder, acts like a filter that removes the most uncertain outcomes while keeping the vast majority of successful ones. In their simulations, this simple filter proved incredibly effective. For certain types of quantum codes, the method reduced the rate of logical errors by a factor of up to 580, while rejecting fewer than one-tenth of one percent of the attempts. This means the computer could run for much longer without making a mistake, simply by ignoring the few times the decoder was unsure.

To test if this idea works in the real world, the team applied their method to data from actual experiments conducted on a trapped-ion quantum computer. These experiments involved storing information in a memory state for a period of time and checking if it survived. Under the old method, where the decoder made a decision without checking its own confidence, the logical memory lasted about as long as the physical particles themselves. This is a critical threshold known as the breakeven point; until a computer can protect information better than the raw hardware, it cannot be useful. By applying their new soft decoding rule to the existing experimental data, the researchers found that the logical memory life more than doubled. For five different types of codes tested, the memory lasted significantly longer than the physical particles, pushing the system firmly into the realm of beyond-breakeven performance. This improvement came at a small cost: the system had to restart about 2.6% to 5.6% of the time to discard the uncertain results, a price the researchers found well worth paying for the massive gain in stability.

The study also looked at how this method could work in real-time operations, such as measuring the state of a quantum computer while it is running. They simulated a process where the computer performs a series of measurements to check for errors, a technique essential for advanced architectures. Even in these fast-moving scenarios, the soft decoder managed to suppress errors by a factor of up to 210, while only slightly increasing the chance that a measurement would need to be repeated. The researchers noted that this method is particularly efficient because it does not require the computer to run the decoding process twice or use extra computing power to estimate confidence. Instead, it uses the data the decoder is already generating. This makes the technique ready to be integrated into current and future quantum systems, offering a straightforward path to more reliable quantum calculations. The work suggests that by paying close attention to the internal signals of the error-correcting software, scientists can unlock a higher level of performance without needing to build more complex hardware.

Technical Summary: Soft Decoding for Quantum LDPC Codes with Experimental Validation

Problem Statement
In fault-tolerant quantum computing, decoders are essential for computing corrections based on parity-check measurements. While hard decoders output a single correction, soft decoders supplement this with a confidence score. This confidence information enables post-selection, a strategy where low-confidence shots (quantum states or sub-circuits) are discarded to reduce the logical error rate of the accepted ensemble.

Existing soft-output decoders for quantum low-density parity-check (qLDPC) codes face limitations:

Surface codes: Confidence can be estimated from clustering (e.g., minimum-weight perfect matching), but these metrics do not directly apply to beam search decoders used for general qLDPC codes.
Alternative methods: Approaches using neural decoders, separate syndrome classifiers, or repeated decoding (e.g., the two-round logical-error criterion, 2R-LEC) often require additional computational overhead, extra decoder invocations, or trained models.
Efficiency: There is a need for a confidence metric that identifies unreliable outcomes with minimal computational cost and without requiring additional decoding passes.

Methodology
The authors introduce a soft beam search decoder that derives its confidence metric directly from the internal execution data of the standard beam search algorithm, eliminating the need for extra computation.

Convergence Iteration as a Confidence Metric:
The beam search decoder (controlled by parameters $I_0, I, R, B$ ) performs a bounded search over candidate error configurations. The authors observe that the cumulative number of Belief Propagation (BP) iterations executed across all visited search paths before a valid correction is found serves as an effective measure of reliability.
- Let $M(s)$ be the position in the sequence of BP iterations where the first valid correction is found for syndrome $s$ .
- Hypothesis: Earlier convergence (lower $M(s)$ ) correlates with higher decoding reliability.
Post-Selection Rules:
- Iteration-Cutoff Rule: A shot is accepted only if $M(s) \le M_{cut}$ . Shots that do not converge or exceed the cutoff are rejected. This rule requires no additional decoder invocation or likelihood calculation.
- Hybrid Rule: To improve performance on codes where the iteration cutoff alone is less effective, the authors combine the iteration cutoff with the 2R-LEC method (which tests agreement between logical predictions under original and reweighted priors).
  - If $M(s) \le M_{low}$ : Accept immediately.
  - If $M_{low} < M(s) < M_{high}$ : Apply 2R-LEC (requiring a second pass).
  - If $M(s) \ge M_{high}$ : Reject.
    This hybrid approach limits the use of the expensive 2R-LEC to an intermediate convergence range, reducing the mean number of decoder invocations to $1 + f_{mid}$ (where $f_{mid}$ is the fraction of shots in the intermediate range).
Sliding-Window Decoding:
The iteration-cutoff rule is extended to real-time error correction using a sliding-window approach. A shot is accepted only if every window required for that shot converges and the maximum cumulative iteration count across all windows satisfies the cutoff.

Key Results
The authors validated their approach through circuit-level simulations and re-analysis of experimental data.

Circuit-Level Simulations (Global Decoding):
- Tested on five qLDPC codes: BB90, BB144, Q70, Q102, and Q54.
- At a physical error rate of $p = 10^{-3}$ , the hybrid soft decoder achieved up to 580× logical-error suppression for the Q54 code while rejecting only 0.1% of shots.
- For BB90 and BB144, the iteration-cutoff rule achieved 124× and 78× suppression, respectively, with 0.1% rejection.
- The hybrid rule consistently provided the largest logical error suppression among compared algorithms while using only 32%–65% of the mean BP iterations required by the full 2R-LEC method.
Sliding-Window Decoding (Logical Measurements):
- Simulated error-detected measurements (EDM) for the "walking cat" architecture using Q54 and Q70 codes.
- Achieved up to 210× error suppression for Q54 while increasing the rejection probability by only 0.5 percentage points.
Experimental Validation (IonQ Trapped Ions):
- Re-analyzed experimental memory data from a trapped-ion quantum computer (previously reported in [48]) using the same beam search configuration but applying the iteration-cutoff post-selection.
- The post-selection strategy doubled the logical qubit lifetimes for all five tested codes (BB5 and GB4 families) at mean rejection rates of 2.6%–5.6% per syndrome round.
- This brought all five codes into the beyond-breakeven regime, where the logical lifetime exceeds the measured physical-qubit lifetime ( $3.84 \pm 0.48$ s).

Significance and Claims
The paper claims that the proposed soft beam search decoder offers a practical, low-overhead method to enhance the performance of qLDPC codes:

Zero Extra Computation: The confidence metric is derived from the standard decoder's execution, requiring no additional decoder invocations, explicit likelihood calculations, or trained models.
Efficiency: The hybrid approach achieves superior error suppression compared to 2R-LEC while significantly reducing computational cost (fewer BP iterations).
Experimental Impact: The method can be applied to existing experimental data without new quantum experiments, immediately improving logical lifetimes and enabling beyond-breakeven performance for current qLDPC memory experiments.
Architectural Integration: The approach is compatible with streaming implementations (e.g., walking cat architecture) and can improve the success probability of logical operations (such as magic state factories and Clifford gates) by filtering unreliable resource states.

The authors conclude that this soft decoding strategy is immediately applicable to current fault-tolerant architectures based on LDPC codes, offering a pathway to higher logical fidelity with minimal resource overhead.

More like this