Randomized Quantum LDPC Codes

• Randomized Quantum LDPC Codes are quantum error-correcting protocols that incorporate stochastic modifications to suppress short cycles and trapping sets.
• They leverage local randomization methods like cross-swap operations and affine permutation matrix lifts to preserve belief propagation thresholds and extend code girth.
• These techniques carefully balance randomness with global algebraic structure, leading to lower error floors and improved minimum distance under efficient decoding.

Randomized quantum low-density parity-check (LDPC) codes are a broad class of quantum error-correcting codes whose structure derives from introducing randomness—either in the Tanner graph connectivity, the matrix permutations composing their parity-checks, or their local algebraic ingredients. These codes leverage stochasticity in their construction to suppress trapping sets, increase code girth, and, in certain paradigms, maintain or optimize the spectral and expansion properties critical for belief propagation decoding. However, the interplay between randomness and structural constraints such as minimum distance, encoding rate, and local check weight is highly nontrivial and has been the subject of intense theoretical investigation.

1. Fundamental Principles and Construction Approaches

Quantum LDPC codes encode quantum information using two binary (or nonbinary) sparse parity-check matrices $H_X,H_Z$ subject to the CSS orthogonality constraint $H_X H_Z^T = 0$ over $\mathbb{F}_2$. In classical LDPC parlance, "girth" refers to the length of the shortest cycle in the Tanner graph of the code. The minimum-weight codewords arising from short cycles frequently dominate the error floor of iterative decoders and thus suppressing such cycles is essential for high-performance quantum error correction.

Randomization strategies can be categorized by:

• Randomized Matrix Modification: Okada & Kasai (Okada et al., 6 Nov 2025) introduce ensembles by local $2\times 2$ cross-swap ("switch") operations on $H_X$ or $H_Z$ followed by integer-linear-program-based local repairs to reestablish CSS orthogonality. Each step preserves row and column weight distributions, maintaining BP decoding thresholds while genuinely randomizing graph structure and suppressing harmful cycles.
• Affine Permutation Matrix Lifts: Recent works (Kasai, 24 Apr 2025) lift small protographs using sequences of affine, noncommuting permutation matrices to escape conventional girth-12 limitations, achieving explicit girth-16 quantum LDPC codes. Randomized sequential selection imposes combinatorial constraints to preempt short cycles throughout assembly.
• Random Code Ingredients: In chain complex constructions (Dinur et al., 2022), base codes $C_A,C_B$ are sampled randomly to guarantee desirable distance and robustness properties, with nontrivial tensor product codeword decomposition ensuring macroscopic code distance and efficient local decoding.

2. Local Versus Global Randomness: Consequences for Code Properties

The spectrum and location of short cycles, trapping sets, and low-weight codewords in a quantum LDPC code are strongly affected by the nature of randomness involved:

• Local Randomness (e.g., cross-swaps and local repairs): Produces ensembles whose degree distributions are exactly preserved, maintaining the statistical BP-decoding threshold (density evolution) but breaking up short cycles and reducing the error-floor. Computational localization ensures scalability to large blocklengths since repairs operate on small submatrices ($O(d_c^2 d_r)$ variables).
• Global Randomness (e.g., completely random Tanner graphs): As shown by Kaufman, Lubotzky, and collaborators (Eldar et al., 2016), high-dimensional expanders with small discrepancy (pseudo-randomness) yield quantum codes with only polylogarithmic minimum distance. This phenomenon is a consequence of "Markov mixing" in the code's combinatorial shells, which impedes the formation of macroscopic cycles required for high distance. Merely random-like graphs/pseudorandom complexes cannot achieve linear minimum distance; structured (manifold-like, algebraic) ingredients are essential.

3. Girth-Optimized Random Ensemble Methods

Quantum LDPC codes constructed with maximum allowable girth are favored for their error floor suppression. Conventional models leveraging circulant permutation matrices (CPMs) are restricted to girth 12 due to commutativity properties. The affine permutation construction (Kasai, 24 Apr 2025) achieves girth 16 by randomized sequential selection of noncommuting affine permutations $f_i(j) = a_i j + b_i \pmod P$, verified against three criteria at every step:

1. CSS orthogonality constraint,
2. Non-commutativity, forbidding any $2\times 3$ commuting subarray,
3. Exhaustive exclusion of closed block-cycles of length $\leq12$.

Pseudocode for sequential randomized generation enforces these constraints, producing codes where the minimum weight observed $d \leq 14$ compared to conventional $d \leq 9$ for girth-12 constructions, as established through enumeration of block-cycles and kernel analysis. This suppression of low-weight codewords directly translates to lower error floors.

4. Matrix Randomization Algorithms and Complexity Analysis

In the randomized cross-swap ensemble approach (Okada et al., 6 Nov 2025), after each $2\times2$ swap, violation of CSS orthogonality is locally repaired by solving an ILP with variables and constraints proportional only to maximum degree parameters, and independent of overall code size:

• ILP variables: $v = O(d_c^2d_r)$,
• Constraints: $m = O(d_c^2d_r)$.

This ensures practical scalability: e.g., $d_c = 3$, $d_r = 8$ yields $v \lesssim 288$, $m \lesssim 1000$. Typical CP-SAT or MILP solvers resolve such instances in milliseconds for large-scale codes.

Practical pseudocode involves repeatedly choosing which matrix to mutate, identifying eligible $2\times2$ submatrices, performing a swap, extracting affected indices, solving the local ILP, committing the repair if feasible, and repeating for $T=O(n)$ rounds. In simulation, this randomization increases average girth, reduces error floors, but leaves BP threshold unchanged.

Property	Structured LDPC	Randomized Ensemble (cross-swap+ILP)
BP threshold (waterfall)	≈ unchanged	≈ unchanged
Error floor	Higher	Lower
Girth	Lower	Increased average
Degree distribution	Fixed	Fixed
Computational cost/step	O(1)	O(d_c^2 d_r) (size fixed, not n)

5. Distance Bounds: Limitations and Necessity of Structure

Analysis of chain complexes and expander-based codes reveals that purely random high-dimensional constructions are fundamentally limited: minimum distance $d_{\min}$ is strictly sublinear unless global topological or algebraic structure is imposed (Eldar et al., 2016). In pseudo-random expander complexes, CSS codes suffer from a Markov mixing argument, which flattens the code's weight enumerator and precludes the existence of large cycles. Only those complexes that are "far" from random (e.g., manifold cellulations, Ramanujan skeletons with large co-systole, or LDA lattice constructions) support codes with $d = \Omega(n)$.

Illustrative examples:

Construction	Discrepancy $\varepsilon$	Minimum Distance
Uniform $d$-hypergraph	$\varepsilon=0$	$O(1)$
Truly random $d$-graph	$\varepsilon=O(1/\sqrt{n})$	$O(\log^2 n) n^{-1/(2d)}$
LDA lattice (Hastings)	Large	$n^{1-\delta}$ ($\delta>0$)
Ramanujan complex skeleton	$\varepsilon\geq\Omega(1)$	Linear (for co-systole)

A plausible implication is that any attempt to "improve" quantum LDPC distances by simply randomizing Tanner graph edges or check matrix layout will, in the absence of added global structure, hit the limitations identified by the discrepancy theory.

6. Explicit Randomized Constructions with Robust Decoding

Not all randomness is detrimental: there exist explicit randomized quantum LDPC constructions with constant rate, linear minimum distance, and efficient decoders (Dinur et al., 2022). The left-right Cayley complex chain construction samples random base codes $C_A, C_B$ to maximize both code distance and a critical robustness property for their tensor product. The resulting CSS code:

• Has $n=\Theta(|G|)$ qubits,
• Dimension $k$ satisfying $r=k/n\in(0,1/2)$,
• LDPC property: local check weight $w=O(\Delta)$ (constant),
• Minimum distance $d=\Omega(n)$ for sufficiently large base-code length.

The linear-time decoder operates via local-flip strategies along the chain complex, exploiting the randomness-induced robustness at the chain level to ensure global correction up to linear-weight errors.

7. Implications and Future Research Directions

Randomization in quantum LDPC code construction requires a careful balance: while local randomization (cross-swaps, affine permutation selection) effectively suppresses short cycles and error floors, it cannot overcome the global distance barrier without additional structure. Recent work emphasizes constructing ensembles with preserved BP performance but improved finite-length behavior, and developing spatially coupled or cycle-aware belief propagation algorithms tailored to high-girth graphs (Kasai, 24 Apr 2025).

Active research directions include:

• Extending explicit girth-16 affine permutation constructions to larger protographs and arbitrary code parameters,
• Spatial graph coupling to compensate for waterfall degradation without sacrificing cycle suppression,
• Designing robust, structure-preserving randomizing transformations suited to density-evolution-guided quantum LDPC design.

In summary, randomized quantum LDPC codes are most effective when structure and stochasticity are engineered in tandem: randomization suppresses local error mechanisms, while global algebraic and topological structure is necessary for scaling minimum distance and overall code performance.