Sharp Error-Rate Transitions in Quantum QC-LDPC Codes under Joint BP Decoding

Technical Summary: Sharp Error-Rate Transitions in Quantum QC-LDPC Codes under Joint BP Decoding

Problem Statement
While classical Low-Density Parity-Check (LDPC) codes are known for exhibiting steep error-rate reductions (threshold phenomena) and low error floors as code length increases, quantum LDPC codes with non-vanishing coding rates have historically lacked similar performance characteristics. Previous reports of steep transitions in quantum codes were largely restricted to codes decoded with non-binary Belief Propagation (BP) decoders or codes with vanishing rates. There remains a gap in understanding whether quantum codes with finite rates, decoded via simpler binary strategies, can achieve sharp error-rate transitions approaching the hashing bound. Furthermore, the mechanisms behind the "error floor"—the flattening of performance curves at low physical error rates—require elucidation, particularly regarding the specific error structures responsible.

Methodology
The authors investigate the performance of Quantum Quasi-Cyclic (QC-) LDPC codes decoded using a Joint Belief Propagation (BP) algorithm.

• Code Construction: The study employs quantum QC-LDPC codes constructed from a pair of orthogonal parity-check matrices ($H_X, H_Z$). These matrices are composed of $J \times L$ circulant permutation matrices (CPMs) of size $P$. The specific construction extends a previous method to column weight $J=3$ and $J=4$, with row weights $L=12$. The code length is defined as $n = PL$, and the coding rate is $R = 1 - (\text{rank}(H_X) + \text{rank}(H_Z))/n$.
• Decoding Algorithm: The decoder operates on a depolarizing channel with physical error rate $p_D$. It simultaneously estimates the noise vectors $\hat{x}$ and $\hat{z}$ to maximize the posterior probability $p(x, z | s, t)$ given the syndrome $(s, t)$. Decoding terminates when the syndrome condition $(H_Z\hat{x}, H_X\hat{z}) = (s, t)$ is met or the maximum iteration count is reached.
• Performance Metrics:
  • Frame Error Rate (FER): Defined as the fraction of trials failing the stabilizer-equivalence success condition (i.e., $\hat{x} + x \notin C_X^\perp$ or $\hat{z} + z \notin C_Z^\perp$).
  • Bit Error Rate (BER): Calculated as the average number of bit errors ($x_i \neq \hat{x}_i$ or $z_i \neq \hat{z}_i$) over all trials, divided by $n$. The authors note this metric quantifies residual support from a coding-theoretic perspective rather than exact physical equality.
• Simulation: Simulations were conducted for various parameters $(J, L, n)$, comparing performance against the theoretical hashing bound.

Key Contributions

1. Observation of Sharp Transitions: The primary contribution is the first reported observation of steep, threshold-like error-rate curves for quantum LDPC codes with non-vanishing coding rates decoded using a binary decoder (Joint BP), explicitly excluding those decoded with non-binary BP decoders. This challenges the notion that such sharp transitions are exclusive to high-complexity non-binary decoders or vanishing-rate codes.
2. Characterization of Error Floors: The study identifies that dominant error events contributing to the error floor involve a remarkably small number of bits. Specifically, for the $(4, 12, 1452)$ code, 97% of errors in the floor region involved no more than $3L$ bits; for the $(4, 12, 4500)$ code, 98% were confined to $2L$ bits or fewer.
3. Structural Attribution: These findings suggest that the error floor is caused by trapping sets—specific subgraph structures within the Tanner graph—rather than large-scale error propagation.

Results

• Steepness and Code Length: As the code length $n$ increases, both the FER and BER curves exhibit steeper transitions. This behavior was not observed in codes with small row weights, reinforcing the link between code structure and threshold behavior.
• Gap to Hashing Bound: A lower coding rate results in a larger performance gap from the hashing bound, a phenomenon consistent with classical binary LDPC codes.
• Error Floor Prominence: Contrary to some classical expectations where longer codes might suppress floors, the error floor becomes more prominent as code length increases in this specific quantum setting, likely due to the increased probability of encountering the specific small trapping sets.
• Decoder Capability: The results confirm that even with a binary Joint BP decoder, quantum QC-LDPC codes can achieve scalable waterfall behavior, suggesting that steep transitions are not solely a function of decoding complexity.

Significance and Future Directions
The paper posits that the identification of small trapping sets as the root cause of error floors provides a clear pathway for future code design. By understanding and avoiding these specific subgraph structures, it may be possible to further reduce the error floor.

The authors connect these findings to their recent work on column weight $J=2$, where they clarified trapping set structures and proposed post-processing techniques that significantly reduced error floors. They suggest that similar post-processing approaches could be extended to cases with $J \ge 3$ and large row weights $L$.

The authors outline two primary directions for future work:

1. Developing suitable post-processing algorithms to further reduce error floors for large $J$ and $L$.
2. Realizing quantum error correction with low error floors and performance approaching the hashing bound by leveraging spatially coupled code constructions.

The study concludes that the observed sharp transitions indicate that steep behavior is not exclusive to complex decoding strategies, offering a more accessible route to high-performance quantum error correction.