Approximate Degenerate OSD for Quantum Codes

• ADOSD is a decoding method that integrates belief propagation with ordered statistics decoding to efficiently target degenerate error cosets in quantum LDPC codes.
• The methodology employs both hard-decision and soft-reliability metrics, followed by reliability sorting and highly reliable subset reduction to manage complexity.
• Empirical results demonstrate significant improvements in logical error rates and runtime performance, with nearly 99.8% reduction in higher-order decoding due to degeneracy conditions.

Approximate Degenerate OSD (ADOSD) refers to a class of algorithmic techniques for efficiently decoding quantum error-correcting codes—especially degenerate quantum LDPC codes—by integrating soft-information preprocessing (such as belief propagation) with reliability-aware, degeneracy-exploiting ordered statistics decoding. The “degenerate” aspect emphasizes the quantum setting, where multiple distinct error patterns can have the same physical effect due to stabilizer code structure, necessitating decoding strategies tailored to error cosets rather than unique representatives. The “approximate” qualifier indicates algorithmic relaxations or subset reductions that yield high performance with tractable complexity, distinguishing ADOSD from brute-force or fully optimal maximum-likelihood decoding.

1. Degeneracy in Quantum Coding and Motivation

Degeneracy is a central feature of stabilizer quantum codes, where the code subspace is invariant under a group of Pauli operators (the stabilizer group $\mathcal S$). Two error patterns $E$ and $E'$ are degenerate if $E' = E S$ for some $S \in \mathcal S$, resulting in identical effects on logical qubits. In practical decoding, especially in medium- to large-scale LDPC codes, many low-weight errors are degenerate, rendering classical, unique-instance-based decoding suboptimal. Quantum decoding thus aims not merely for the most likely error but for the most likely equivalence class (coset) of errors modulo $\mathcal S$ (“degenerate maximum-likelihood decoding”).

Exact coset enumeration is generally exponential in code length $n$, motivating approximate algorithms—parametrized by neglected high-weight stabilizers or other tractable reductions—that still capture degeneracy’s core advantage. ADOSD formalizes such an approach by tightly integrating quantum degeneracy awareness into ordered-statistics list decoders (Panteleev et al., 2019, Kung et al., 2024).

2. Core Methodology: Belief Propagation Preprocessing and Ordered Statistics Decoding

Modern ADOSD frameworks operate in two principal stages. First, soft-decision belief propagation (BP), typically in the quaternary setting for Pauli channels, is performed over the code’s Tanner or factor graph to acquire marginal error probabilities $P_i^E$ for each qubit $i$ and error type $E \in \{I,X,Y,Z\}$. The BP output is used to form:

• Hard decisions: $\hat e_i = \arg\max_E P_i^E$.
• Soft reliabilities: $r_i = \max_E P_i^E$ (or related metrics, see Section 3).

If the BP-produced error pattern exactly reproduces the observed syndrome, decoding terminates. If not, the algorithm enters the OSD phase. Columns of the check matrix (or the symplectic matrix in the quantum case) are permuted so that the least reliable bits/qubits are examined first. An OSD-w candidate search is performed: order-0 OSD corresponds to solving the binary syndrome equations under the hard-decision estimate; higher-order OSD-w searches flip $w$ of the least reliable bits to form a candidate list, selecting the minimal symplectic weight solution that satisfies the syndrome constraint (Panteleev et al., 2019).

This structure essentially maps quantum soft-decision decoding onto powerful classical ordered-statistics list decoding frameworks, with exact handling of quantum degeneracy in the search space and coset representatives (Kung et al., 2024).

3. Reliability Metrics and Highly Reliable Subset Reduction

Efficient ADOSD requires reliability metrics for qubit error bits that leverage both the persistent consistency in their BP hard-decision history and the final BP marginal distributions. A composite metric is introduced (Kung et al., 2024):

• Hard-decision stability: $\eta_i$ is the length of the final run of identical symbols in the hard-decision sequence for qubit $i$ across BP iterations.
• Soft-decision reliability:

$$\phi^X(i) = \max\{q_i^X + q_i^Y,\, q_i^I + q_i^Z\}, \quad \phi^Z(i) = \max\{q_i^Z + q_i^Y,\, q_i^I + q_i^X\}$$

where $\mathbf{q}_i = (q_i^I, q_i^X, q_i^Y, q_i^Z)$ is the BP output.

The combined order—first by $\eta_i$, then $\phi^a(i)$—ranks the bits for OSD candidate search, prioritizing those with less ambiguity.

To further reduce computational cost, the highly reliable subset reduction (HRSR) method removes bits (columns) corresponding to “highly reliable” variables—those with $\eta_i$ at its maximum and $\phi^a(i)$ above a threshold—from the OSD system. This shrinks the size of the subsequent Gaussian elimination and candidate enumeration, allowing higher effective OSD order $w$ within a fixed computational budget. For surface codes at moderate error rates, HRSR frequently reduces the problem size by $\geq 70\%$, with negligible impact on decoding performance (Kung et al., 2024).

4. Degeneracy Condition and Order Reduction

A central observation is that, after system reduction by HRSR and bringing the reduced matrix into row-echelon form, many column-flips in the “reliable” set correspond only to multiplications by low-weight stabilizers, i.e., degenerate moves that do not change the logical coset. Lemma 4 of (Kung et al., 2024) formalizes that if every column in the reliable subset has weight $< d-1$, then any flip in this set is logically degenerate, and thus OSD-0 suffices to reach maximum-likelihood performance within the used degeneracy cutoff ($\delta$-ADD). In simulated instances (surface code $d=11$ at $\epsilon=1.7\%$), this condition forced OSD order to zero in $99.8\%$ of trials. This is a leading reason for the high efficiency of ADOSD in realistic quantum code families.

5. Complexity Analysis

ADOSD achieves significant reductions in expected computational cost compared to standard OSD. The dominant steps and their complexities are:

Step	Complexity (typical)
BP (quaternary, $T$ iterations)	$O(n\gamma T)$ (often $O(n)$ for sparse codes)
Reliability sorting ($2n$ bits)	$O(n\log n)$
HRSR Gaussian elimination	$O((n-v)^3)$ on reduced system (often $v \gtrsim 0.7n$)
OSD-w search	$O(n^3 + n^{w+1})$ (with $w \leq 2$ in practice)
Degeneracy check	$O((n-k)(n+k))$

The average cost is as little as two to three BP iterations (e.g., for $n \approx 300$, $\epsilon \approx 1.7\%$ on surface codes), far outperforming classical OSD variants that lack subset reduction or degeneracy-aware order dropping (Kung et al., 2024).

6. Empirical Performance and Error Thresholds

Experiments across diverse code families—generalized hypergraph-product (GHP), bivariate bicycle, rotated toric/surface, color, XZZX, and lift-connected surface codes—demonstrate ADOSD’s competitiveness:

• On 2D topological codes, BP+ADOSD decoders attain threshold physical error rates ($\epsilon_{\rm th}$) up to $17.7\%$ (rotated surface, XZZX), significantly exceeding prior BP-OSD variants (~$14.8\%$).
• For $[[882,48,16]]$ GHP codes at $\epsilon = 0.05$, logical error rates (LER) decrease from $10^{-2}$ (BP) to $<10^{-4}$ (ADOSD); deeper OSD ($w=2$) or degeneracy-aware pruning achieves diminishing returns beyond this.
• Practical runtime is reduced by an order of magnitude: at LER $\sim 2\times10^{-6}$ in $[[289,1,17]]$ surface codes, ADOSD-4 is $2.8\%$ the runtime of OSD-4-2 (Kung et al., 2024).

7. Connections to Graph Pattern Counting and Degenerate Subgraph Counting

In combinatorial settings, the term “Approximate Degenerate OSD” also appears as the Approximate Degenerate Ordinary Subgraph Counting problem, where the task is to estimate, with $(1\pm\epsilon)$ relative error, the frequency of a fixed pattern $H$ in a $d$-degenerate host graph $G$. The leading techniques employ colour-coding and dynamic programming over tree or DAG decompositions, with runtime scaling as $$O(f(k,d)\epsilon^{-2}n^{\tau_1(H)+o(1)}\ln(1/\delta))$$, where $\tau_1(H)$ is the dag-treewidth of $H$ (Bressan et al., 2021). For common patterns (paths, cliques, matchings), this yields nearly linear or quadratic complexity, and these results delineate the fine-grained fixed-parameter tractability boundaries for approximate pattern counting in sparse graphs. No substantially better approximation algorithms exist under ETH for patterns with unbounded induced matching number.

8. Limitations and Future Directions

ADOSD’s efficiency relies on the prevalence of highly reliable bits post-BP and the ability to prune OSD search space via syndrome and degeneracy structure. In high-noise or adversarial cases, the worst-case complexity remains $O(n^3)$, and parameter tuning (e.g., reliability threshold $\theta$, BP schedule, OSD order cap) must be tailored per code class. The $\delta$-ADD approximation, which neglects very high-weight stabilizer multipliers, is empirically reliable at target error rates, though extreme tail events at very low logical rates may warrant deeper analysis.

Future research directions include extending ADOSD to circuit-level noise models (simultaneous data and syndrome decoding), integrating with ambiguity clustering and localized statistics, algorithmic pruning improvements, and automating parameter selection via machine learning across code families (Kung et al., 2024).

---

Key references:

• "Degenerate Quantum LDPC Codes With Good Finite Length Performance" (Panteleev et al., 2019)
• "Efficient Approximate Degenerate Ordered Statistics Decoding for Quantum Codes via Reliable Subset Reduction" (Kung et al., 2024)
• "Exact and Approximate Pattern Counting in Degenerate Graphs: New Algorithms, Hardness Results, and Complexity Dichotomies" (Bressan et al., 2021)