Forced Gap Post-Selection for Quantum LDPC Codes and their Operations

This paper introduces a lightweight, decoder-agnostic post-selection strategy that significantly improves the logical error rate of high-rate quantum LDPC codes by re-running decoders with forced complementary outcomes to reject ambiguous shots, achieving over a fourfold improvement over previous methods on bivariate bicycle codes.

The Gist

Imagine you are trying to send a secret message across a noisy room. In the world of quantum computers, this "message" is a piece of information stored in a special code called a Quantum LDPC code. These codes are like high-tech safety nets designed to catch errors (noise) before they ruin your message.

However, sometimes the safety net is so good at catching small errors that it gets confused about whether a big mistake actually happened. It might say, "I fixed it!" when really, the message is still garbled. This is a logical error.

The Problem: How to Know if You're Safe?

In older, simpler codes (like the "surface code"), scientists had a clever trick to check their work. They would ask the decoder (the computer program fixing the errors): "What if the answer was the exact opposite of what you just gave me? How likely is that?"

If the "opposite answer" is almost as likely as the "real answer," the decoder is confused, and the result is suspicious. If the "real answer" is much more likely, the decoder is confident. This difference in likelihood is called a Gap. If the Gap is small, you throw the result away (this is called post-selection).

The Catch: This trick worked great for simple codes, but it broke when applied to the new, high-rate codes (like the 72-qubit and 144-qubit "bicycle" codes mentioned in the paper). These new codes have many different parts of the message (logical observables) all at once. Trying to check every possible "opposite" combination for all of them would take forever and require too much computing power.

The Solution: The "Forced Gap" Strategy

The authors of this paper came up with a new, simpler way to check for confusion, which they call Forced Gap Post-Selection.

Here is how it works, using a simple analogy:

1. The Baseline Run (The First Guess):
   Imagine you ask a detective (the decoder) to solve a mystery based on the clues (syndrome). The detective gives you their best guess: "The butler did it."

2. The Forced Runs (The "What If" Scenarios):
   Instead of asking the detective to guess every possible suspect, you force them to test specific "what if" scenarios, one by one.

   • Run 1: "Okay, Detective, pretend the butler is innocent. Who did it then?"
   • Run 2: "Now, pretend the gardener is innocent. Who did it?"
   • ...and so on for every key suspect.

   The decoder tries to find a solution where the answer is different from the first guess.

3. The Comparison (The Gap):
   You look at the detective's first guess and the best "forced" guess from the other runs.

   • If the first guess is much more likely than the forced guesses, the detective is confident. You keep the result.
   • If the first guess and a forced guess are almost equally likely, the detective is confused. The "Gap" between their confidence levels is small. You reject this result.

Why This is a Big Deal

The paper tested this strategy on two specific quantum codes (72-qubit and 144-qubit) and found some impressive results:

• Better Accuracy: By using this method, they reduced the rate of logical errors by more than 4 times compared to previous methods, using the exact same hardware and noise levels.
• Lightweight: Previous methods required heavy, slow, and complex computing steps to check for errors. This new method uses a "belief propagation" decoder (a type of fast, efficient algorithm) that is friendly to hardware chips (FPGAs). It's like switching from a heavy, slow truck to a nimble, fast sports car.
• Efficiency: Even though they have to run the decoder a few extra times (once for the baseline, and once for each "forced" scenario), the total work is manageable and can even be done in parallel (like having a team of detectives work on different "what if" scenarios at the same time).

The Bottom Line

The authors created a "suspicion meter" for quantum computers. It doesn't require super-computers to run; it just asks the decoder to try a few specific "what if" scenarios. If the decoder can't clearly distinguish between the right answer and a wrong one, the system says, "I'm not sure, let's throw this one out and try again."

This allows quantum computers to produce much cleaner, more reliable results, especially when they are being used to prepare special resources (like "magic states") needed for advanced quantum tasks. The paper specifically notes this is useful for offline resource state generation, such as distilling magic states for protocols like the 15-to-1 protocol.

Technical Summary

Technical Summary: Forced Gap Post-Selection for Quantum LDPC Codes and their Operations

Problem Statement
High-rate quantum low-density parity-check (LDPC) codes offer significant space overhead advantages over surface codes but face challenges in implementing effective post-selection strategies. In surface codes, a "complementary gap" is used to quantify decoding confidence by comparing the log-likelihood of the most-likely correction against a logically complementary correction. However, this technique does not directly extend to general quantum LDPC codes for two primary reasons:

1. Decoder Incompatibility: General quantum LDPC codes cannot be decoded using matching decoders, which are central to the surface code gap calculation.
2. Combinatorial Explosion: High-rate codes possess many logical observables ($k$ logical qubits imply $4k$ distinct logical classes). A naïve approach to post-selection would require decoding in every logical class to find the second most-likely outcome, rendering the process computationally infeasible (e.g., $2^{12}$ classes for a 72-qubit code with $k=12$).

Methodology: Forced Gap Post-Selection
The authors propose a "Forced Gap" strategy, a general post-selection method applicable to high-rate quantum LDPC codes with many logical observables. The approach is decoder-agnostic but relies on the ability to force a decoder to find a solution with a specific logical outcome.

The strategy proceeds in three phases:

1. Baseline Run: The decoder is run on the observed syndrome $\sigma$ to produce a baseline correction $e^{(0)}$ with logical class $L^{(0)}$. If the decoder fails to converge (an "erasure"), the shot is immediately rejected.
2. Forced Runs: For each of the $K$ logical observables, the decoder is re-run $K$ times. In the $i$-th run, the decoding problem is modified by appending the $i$-th row of the action matrix $A$ (with a flipped bit $1 \oplus L^{(0)}_i$) to the parity-check matrix $H$. This forces the decoder to find a correction $e^{(i)}$ where the $i$-th logical observable has the complementary outcome to the baseline.
3. Gap Calculation and Decision: The algorithm pools all converged solutions to identify the set of distinct logical classes found. It calculates the "Gap" as the difference in log-likelihoods between the most-likely logical class $\lambda^{(0)}$ and the second most-likely distinct logical class $\lambda^{(1)}$:
   $$\text{Gap} := \log P[\lambda^{(0)}] - \log P[\lambda^{(1)}]$$
   If all forced runs fail to converge, the Gap is set to $\infty$ (accepted). If the baseline fails, the Gap is 0 (rejected). A threshold $T$ is applied; shots with $\text{Gap} < T$ are rejected.

This method scales linearly with the number of logical observables ($K+1$ runs) rather than exponentially ($2^K$), making it computationally feasible.

Key Contributions

• Generalization of Complementary Gap: The work extends the concept of the complementary gap from surface codes to general high-rate quantum LDPC codes with multiple logical qubits.
• Efficient Algorithm: It introduces a strategy that avoids the infeasible enumeration of all logical classes by only forcing deviations in individual observables, reducing the computational burden from exponential to linear in $K$.
• Decoder Agnosticism: The strategy is designed to work with iterative decoders (like Belief Propagation) that may not converge, treating non-convergence as a specific signal (erasure or infinite gap) rather than a failure of the method.
• Lightweight Implementation: Unlike previous high-performance strategies that rely on high-latency Ordered Statistics Decoding (OSD), this method relies on FPGA-friendly Belief Propagation (specifically the Relay-BP decoder).

Results
The strategy was benchmarked using the Relay-BP decoder on:

• Idling Circuits: The 72-qubit [[72, 12, 6]] and 144-qubit [[144, 12, 12]] bivariate bicycle (BB) codes.
• Logical Operations: Surgery gadgets (in-module $X_1$, $Y_1$, and inter-module $X_1X_1$) for the 144-qubit code.

Key findings include:

• Error Rate Improvement: On the 72-qubit code at physical noise $p=10^{-3}$, the strategy achieves a logical error rate per round of $\approx 3.5 \times 10^{-8}$ at a 1% post-selection rate. This represents an improvement of over a factor of 4 compared to previous post-selection strategies (e.g., [LEB25] at $\approx 10^{-5}$ and [Xie+26] at $\approx 1.5 \times 10^{-7}$) under similar conditions.
• Post-Selection Rate: The performance gains are most pronounced at low post-selection rates (below 1%). The logical error rate curve flattens out after approximately 1% rejection, as the remaining shots either have infinite gaps (baseline converged, forced runs failed) or are erasures.
• Comparison to Prior Work: While other strategies (like those in [LEB25] and [Xie+26]) can continue to improve at higher post-selection rates (e.g., 5–30%), they often require more computationally intensive decoders (BP-OSD). The Forced Gap strategy offers superior performance in the low-rejection regime with significantly lower computational overhead.

Significance and Claims
The paper claims that the Forced Gap strategy provides a "simple and general" solution for post-selection in high-rate quantum LDPC codes, offering improved logical error rates with lightweight computation. The authors position this as a practical tool for scenarios where post-selection is available, particularly for offline resource state generation tasks such as magic state distillation, where operational noise often dominates.

The authors modestly note that the strategy does not improve significantly beyond a 1% post-selection rate for the tested idling circuits and that future work could address error floors caused by non-converging forced runs by combining the method with other decoding techniques (e.g., OSD or decimation). They also highlight that while the strategy is effective for current code sizes, its scaling to larger code distances and lower physical error rates requires further investigation, potentially via rare-events analysis rather than direct Monte Carlo simulation.