High-Rate Quantum LDPC Codes

• High-rate quantum LDPC codes are stabilizer codes with sparse parity-check matrices that maintain high encoding rates as system size grows.
• They combine innovative constructions like hypergraph products, expander graphs, and geometric tessellations to optimize distance and decoding efficiency.
• Designed for platforms like neutral atoms and ion traps, these codes promise low overhead and scalable fault tolerance with efficient decoding methods.

High-rate quantum low-density parity-check (LDPC) codes are quantum stabilizer codes characterized by sparse parity-check matrices and encoding rates that remain appreciable as system size increases. These codes address the dual challenge of minimizing overhead in logical-to-physical qubit ratio and enabling scalable quantum error correction with efficient decoding algorithms. High-rate quantum LDPC code families include constructions based on hypergraph products, generalized bicycle/hyperbicycle frameworks, expander graphs, and topological tessellations, as well as advanced post-quantum design paradigms that partially relax stabilizer orthogonality. High-rate constructions have seen recent acceleration motivated by neutral atom, ion-trap, and superconducting qubit platforms, where rapid logical processing and qubit efficiency are paramount. This article surveys the principal mathematical structures, decoding algorithms, performance benchmarks, and implementation considerations relevant to high-rate quantum LDPC codes.

1. Structural Foundations and Code Families

Quantum LDPC codes are defined by stabilizer check matrices with bounded weight, meaning each row (stabilizer) acts nontrivially on $O(1)$ qubits and each qubit participates in $O(1)$ stabilizers. High-rate codes achieve an encoding rate $R = k / n$ (with $k$ logical qubits, $n$ physical) that remains constant or decreases only slowly with increasing $n$.

Hypergraph-product codes (Tillich-Zémor): Constructed from a pair of classical LDPC codes, these yield CSS quantum codes with parameters $N = n^2 + m^2$, $K = k^2 + \tilde{k}^2$, with code rate $R = K / N$ scaling as $\Theta[(k/n)^2 + (\tilde{k}/m)^2]$, and minimum distance $D = \min(d, \tilde{d})$ ($d,\tilde{d}$ the classical distances) (Krishna et al., 2023).

Hyperbicycle codes: Interpolating between bicycle and hypergraph-product constructions, these codes introduce a "tile" and "shift" parameter $c, \chi$, and provide closed-form expressions for block length, rate, and distance bounds. Rates up to $R = 2 R_c^2 / c$ can be achieved (with $R_c$ the seed classical code rate) while maintaining minimum distance scaling as $\sqrt{N}$ (Kovalev et al., 2012).

Expander-based codes: Quantum LDPC code families based on balanced products of two-sided lossless expanders achieve parameters $[[n, k, d]]$ with $k = \Theta(n)$, $d = \Omega(n)$, constant-weight stabilizers, and provable linear-time decoders—assuming suitable expander graph existence (Lin et al., 2022).

Manifold and geometric codes: Tessellations of higher-dimensional hyperbolic manifolds can yield LDPC codes with $k/n \sim 0.18$, stabilizer weights $\{3,12\}$, $d = n^{\epsilon}$ for $\epsilon > 0$, and efficient "single-shot" decoders (Breuckmann et al., 2020).

Symmetry- and assistance-augmented designs: Codes leveraging partial qubit reliability (e.g., phase-only errors) or entanglement assistance can achieve quantum rates $k_Q/(2n-k_Q) > k/n$ for seed classical codes, importing classical LDPC performance nearly intact (Fujiwara et al., 2013).

Orthogonality-barrier–breaking codes: Newer constructions relax stabilizer orthogonality only where required, breaking structural trade-offs between girth, regularity, and distance, and enable high rate and improved minimum distance at fixed girth (Kasai, 13 Jan 2026).

2. Decoding Algorithms and Complexity

Decoding efficiency is crucial for high-rate LDPC codes. Key approaches include:

• Envelope-finding and erasure reduction: Viderman-style algorithms generalize erasure-conversion methods from classical LDPC codes. Given syndrome information, an $O(|E|)$-time algorithm finds an "envelope" $L$ guaranteed to contain all error positions; the residual error is converted to an erasure decoding problem, which (for current algorithms) is solved in $O(N^{1.5})$ time because the size of $L$ is $O(\sqrt{N})$ (Krishna et al., 2023).
• Combinatorial flipping and majority voting: For expander-based and topological codes, iterative greedy decoders flip sets of qubits within small neighborhoods to reduce syndrome weight whenever possible. With appropriate local testability properties, linear-time decoding up to a linear fraction of errors is possible (Lin et al., 2022, Breuckmann et al., 2020).
• Belief propagation (BP) and ordered statistics decoding (OSD): For codes with Tanner graphs of small degree and moderate cycle lengths, BP augmented with OSD provides high efficiency and no observable error floor at simulated logical-error rates $\sim 10^{-7}$, especially when regular girth-8 constructions are exploited (Pecorari et al., 2024, Kasai, 13 Jan 2026).
• Batched gadgets and parallel logical operation: Shared ancilla blocks and transversal circuits allow batched syndrome extraction, code switching, and fault-tolerant logical Clifford/non-Clifford gates across multiple code blocks with constant or polylogarithmic space–time overhead, as detailed for Bivariate Bicycle codes in high-rate batched architectures (Xu et al., 7 Oct 2025).

3. Minimum Distance, Girth, and Performance Trade-offs

Top-performing high-rate families empirically and analytically exhibit the following properties:

• Minimum distance: Hypergraph-product and hyperbicycle codes yield $d = O(\sqrt{n})$ scaling. Expander-based balanced product codes theoretically achieve $d = \Omega(n)$, as do codes derived from bespoke geometric constructions, subject to favorable group action and expansion properties (Lin et al., 2022, Breuckmann et al., 2020).
• Girth: Regular constructions are often limited by the orthogonality requirement, which traditionally imposes short cycles (e.g., 4-cycles) in Tanner graphs and upper bounds the minimal distance. By limiting commutativity constraints only to necessary blocks (active orthogonality), one can achieve girth 8 and lift the "row-weight" distance upper bound, demonstrated in explicit $(3,12)$-regular $[[9216, 4612, \leq 48]]$ codes (Kasai, 13 Jan 2026).
• Code rate: Rates $R = \Omega(0.1)$ are achievable in several code families (e.g., Bivariate Bicycle, La-cross, expander-based), while surface codes are restricted to $R \le O(1/d)$ (Xu et al., 7 Oct 2025, Pecorari et al., 2024).
• Error suppression and thresholds: Under circuit-level noise, high-rate LDPC codes such as La-cross and Bivariate Bicycle codes exhibit logical-error suppression $P_L(p) \sim (p/p_{th})^{D_{\text{eff}}}$ and outperform surface codes by more than an order of magnitude for equal code sizes and error rates $\leq 0.1\%$ (Pecorari et al., 2024). For erasure-biased channels, logical error rates show $P_L \sim A p^D$, vastly outpacing the thresholds and suppression properties of surface codes (Pecorari et al., 27 Feb 2025).

4. Practical Implementation: Neutral Atoms and Beyond

The experimental realization of high-rate LDPC codes is particularly promising in systems supporting modest nonlocality, such as neutral atom arrays:

• La-cross codes: Built as hypergraph-products of cyclic codes, these codes have stabilizers of weight 6—four nearest-neighbor and two long-range couplings—enabling implementation in 2D neutral atom grids using Rydberg blockade interactions with multiple laser wavelengths. For $k=3$ and $D=6$, a $[[225,9,6]]$ code is realized natively with order-of-magnitude lower overhead than equivalent surface code executions (Pecorari et al., 2024). Resource overheads and per-syndrome cycle depths are estimated, with block-scheduling ensuring minimal crosstalk.
• Bivariate Bicycle codes: Enable parallel logical operations, transversal Clifford gates, and efficient magic-state cultivation for universal computation through disjoint logical-operator supports (Xu et al., 7 Oct 2025). Experimental feasibility for neutral atom and other erasure-convertible platforms is optimized by moderate-weight stabilizers and local graph degree.
• Erasure conversion: Both code families leverage erasure detection mechanisms readily available in neutral atom devices (Rydberg leakage detection), trapped ions (metastable shelving), and superconducting circuits (leakage tracking via bosonic codes), optimizing the logical failure rate scaling to $P_L \sim p^D$ (Pecorari et al., 27 Feb 2025).

5. Benchmarks, Resource Scaling, and Performance

Table: Example parameters for high-rate quantum LDPC code families (curated from published code instances):

Code Type	$n$	$k$	$d$	Rate $R$	Syndrome Thresholds	Reference/Context
La-cross, $k=3$	225	9	6	$0.04$	$p_{th}\approx0.2\%$ (Pauli); up to $5-6\%$ (erasure)	(Pecorari et al., 2024, Pecorari et al., 27 Feb 2025)
Bivariate Bicycle	72	12	6	$0.167$	$p_{th}\approx1.2\%$ (erasure)	(Xu et al., 7 Oct 2025, Pecorari et al., 27 Feb 2025)
Expander Product	$~$	$~$	$\Omega(n)$	$\Theta(0.1)$	$O(n)$-time decoder	(Lin et al., 2022)
Hyperbicycle	90	10	7	$0.11$	$0.5-2\%$ (estimated)	(Kovalev et al., 2012)
Coxeter/Hyp4d	-	-	-	$0.18$	$4\%$ (single-shot)	(Breuckmann et al., 2020)
Girth-8 $(3,12)$	9216	4612	$\leq 48$	$0.5$	$4\%$ (BP+postproc, FER$<10^{-8}$)	(Kasai, 13 Jan 2026)
AG(4,3) assisted	1242	1080	$4$	$0.87$	$p \sim 0.03-0.04$ (BLER$=10^{-4}$)	(Fujiwara et al., 2013)

Scaling trends:

• For universal fault-tolerant quantum computation, batched logical gadgets on high-rate LDPC codes allow $O(1)$ overhead per Clifford gate and only polylogarithmic overhead for non-Clifford gates, enabling substantial reduction in resource requirements versus low-rate codes (Xu et al., 7 Oct 2025).
• High-rate LDPC codes can achieve logical error rates $P_L\lesssim10^{-4}$ at physical error $p=10^{-2}$ with order-of-magnitude fewer physical qubits than required for surface code tiling (Pecorari et al., 27 Feb 2025).

6. Open Problems, Limitations, and Future Directions

Key ongoing challenges in high-rate quantum LDPC research include:

• Developing linear-time erasure decoders for general LDPC code families—current “envelope-finding” or “small-set-find” algorithms are optimal in syndrome localization but bottlenecked by Gaussian elimination on large blocks (Krishna et al., 2023).
• Further improving minimum distance scaling at fixed rate and efficient logical-operator support, especially for codes aiming to simultaneously maximize girth and distance (Kasai, 13 Jan 2026).
• Exploiting degeneracy and cross-error correlations more fully, which current standard syndrome-based decoders do not address (Fujiwara et al., 2013).
• Optimizing hardware–code co-design in architectures with constrained connectivity or restricted measurement cycles, to maximize the logical capacity per physical resource (Pecorari et al., 2024, Pecorari et al., 27 Feb 2025).
• Understanding error suppression scaling under correlated or biased-noise models and adapting code families to such regimes, especially as erasure detection technologies mature (Pecorari et al., 27 Feb 2025).

A plausible implication is that as quantum hardware harnesses long-range interactions and erasure tracking, high-rate quantum LDPC codes will become increasingly advantageous both in terms of hardware efficiency and fault-tolerant logical gate implementation.

7. Summary and Outlook

High-rate quantum LDPC codes constitute a unifying paradigm for enabling scalable, hardware-efficient quantum computation and memory. Code families based on generalized product constructions, expander graphs, or assistance by reliable qubits or entanglement systematically overcome historical limitations in rate–distance scaling and resource overhead. Recent algorithmic advances—from linear-time syndrome localization, robust combinatorial and BP decoding, to batched logical gadgets—have closed key theoretical gaps between achievable error suppression and classical LDPC performance. As experimental platforms for quantum error correction continue to progress, high-rate LDPC codes and their descendants are positioned as central blueprints for high-throughput, low-overhead, and fully parallel quantum fault tolerance.

Key references: (Krishna et al., 2023, Kovalev et al., 2012, Pecorari et al., 2024, Lin et al., 2022, Xu et al., 7 Oct 2025, Kasai, 13 Jan 2026, Fujiwara et al., 2013, Breuckmann et al., 2020, Pecorari et al., 27 Feb 2025)