⚛️ quantum physics

Quantum Bicycle LDPC Codes with High $kd^2/n$ from Divisor-Driven Search

This paper introduces a polynomial-ring-based framework for constructing quantum bicycle LDPC codes that simplifies design verification and enables a systematic computer search, yielding new codes with competitive $kd^2/n$ figures of merit and establishing precise boundaries for their performance at small block lengths.

Original authors: Liangdong Lu, Guanmin Guo, Yang Liu, Ruipan Yang

Published 2026-08-11

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Liangdong Lu, Guanmin Guo, Yang Liu, Ruipan Yang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build a fortress to protect a tiny, fragile treasure: a piece of information stored in a quantum computer. The problem is that this treasure is incredibly sensitive; even a tiny breeze of noise can knock it over. To keep it safe, you need to build a shield made of "error-correcting codes." Think of these codes as a team of guards checking the treasure from different angles. If one guard gets confused by the noise, the others can figure out the truth and fix it.

The big challenge in building these shields is a trade-off. You want the shield to be strong enough to catch big mistakes (high "distance"), but you also want it to be efficient so you don't need a million guards just to protect one piece of data (high "dimension"). For a long time, the best shields were like a grid of tiny, local guards (called "surface codes"). They were reliable, but they were inefficient, requiring a huge number of physical qubits (the guards) for every single logical qubit (the treasure). Scientists have been hunting for a new type of shield called "Quantum LDPC codes." These are like a team of guards who can talk to each other from far away, allowing them to be much more efficient. One promising family of these shields is called "Bicycle codes," named because they are built using two spinning wheels of data that must stay perfectly synchronized.

However, designing these Bicycle codes has been like trying to find a needle in a haystack by feeling around in the dark. The old methods relied on complex group mathematics, which made it hard to know how good a code would be until you built the entire massive machine to test it. It was slow, indirect, and often missed the best designs.

This paper introduces a clever new way to design these Bicycle codes, turning the search from a blind feeling-in-the-dark into a precise algebraic recipe. The authors realized that when you look at these codes through the lens of polynomials (mathematical expressions with variables like $x$ ), the rules for making them work become surprisingly simple. They found that the "self-orthogonality" (the rule that keeps the guards from fighting each other) happens automatically if you just pick the right polynomials. Even better, they discovered that you can calculate exactly how many logical qubits the code will protect just by doing a simple math operation called a "greatest common divisor" on those polynomials. This means they can filter out bad designs instantly, before ever building the code.

Using this new "divisor-driven search," the team ran a computer program to test thousands of polynomial combinations. They found several new codes that are significantly better than previous records. For instance, they found a code with parameters $[[66, 20, 7]]_2$ . In plain English, this code uses 66 physical qubits to protect 20 logical qubits and can correct up to 7 errors. When they measured its efficiency using a standard score called $kd^2/n$ , this new code scored 14.85. This beats the previous star player, a famous code called the "bivariate bicycle code" ( $[[144, 12, 12]]_2$ ), which scored 12, even though the new code uses less than half the number of physical qubits. They also found a whole family of codes that work well for different sizes, including some that can protect just 2 logical qubits but correct up to 9 errors, which is a very high level of protection for such a small system.

The paper also did something very important: it drew a clear line in the sand about what this new method can and cannot do. By testing a specific case with 48 qubits, they proved that while their polynomial method is powerful, it has a limit. They showed that in this specific family of codes, it is mathematically impossible to have a code with 10 logical qubits and a distance of 5; the math forces the number of protected qubits to drop to 9 if the distance is 5. This "rank degeneracy" proves that some quantum phenomena are too complex for the simple polynomial recipe and require the more complicated group-theoretic methods.

In short, the authors didn't just find a few better codes; they built a new, faster, and more transparent way to design them. They turned a messy, trial-and-error search into a clean, algebraic process that finds high-performance codes quickly. While they proved that this method can't solve every possible puzzle (specifically ruling out certain combinations at 48 qubits), it opens up a vast new territory where scientists can efficiently discover the next generation of quantum error-correcting shields.

Technical Summary: Quantum Bicycle LDPC Codes with High $kd^2/n$ from Divisor-Driven Search

Problem Statement
Quantum low-density parity-check (LDPC) codes, particularly the bicycle family (two-block circulant codes), offer a promising alternative to surface codes by reducing qubit overhead while maintaining high error thresholds. However, the design of these codes has historically relied on group-algebra formulations (e.g., generalized bicycle codes, two-block group algebra codes). In these frameworks, the search space is indexed by group-subgroup pairs and support sets, which is indirect and difficult to prune. Crucially, key quantum parameters—dimension ( $k$ ) and distance ( $d$ )—cannot be determined algebraically before constructing large parity-check matrices. This necessitates computationally expensive matrix operations for every candidate, limiting the exploration of parameter regimes, particularly those with high dimension $k$ .

Methodology
The authors reformulate the bicycle code construction entirely within the symplectic polynomial domain, specifically for the cyclic case where the underlying group is $G = \mathbb{Z}_l$ . By mapping the group algebra $\mathbb{F}_2[\mathbb{Z}_l]$ to the quotient ring $R = \mathbb{F}_2[x]/(x^l - 1)$ , the authors establish an algebraic framework where:

Self-Orthogonality: The CSS orthogonality condition ( $H_X H_Z^T = 0$ ) becomes an automatic consequence of the commutativity of the polynomial ring, eliminating the need for explicit commutation checks.
Dimension Control: The quantum dimension $k$ is derived exactly as a polynomial greatest common divisor (gcd): $k = 2 \deg \gcd(a(x), b(x), x^l - 1)$ . This allows for pre-filtering candidates based on dimension before any matrix is built.
Distance Certification: The minimum distance is computed exactly using the Calderbank correspondence, which maps the stabilizer code to additive codes over $\mathbb{F}_4$ . The authors implement a "two-kernel" computation to exclude the stabilizer image, ensuring the distance reflects the true quantum distance rather than just the check weight.

The authors propose a divisor-driven search algorithm (Algorithm 1). Instead of random sampling, the search constructs polynomials $a(x)$ and $b(x)$ by multiplying a target divisor $g(x)$ of $x^l - 1$ with low-weight "lift" polynomials $u(x)$ and $v(x)$ . This structure guarantees a specific dimension range ( $k \approx 2 \deg g$ ) and keeps the stabilizer row weights low (LDPC property). The pipeline applies algebraic filters (gcd checks, involution symmetry checks) before resorting to exact distance computation.

Key Contributions

Polynomial Framework: The paper demonstrates that for cyclic groups, the bicycle construction collapses into a polynomial ring where self-orthogonality is automatic and dimension is a simple gcd calculation. This transforms code search from a matrix-based enumeration into an algebraically pre-filtered process.
High-Performance Code Discovery: Using this framework, the authors discovered a family of codes with competitive figures of merit ( $kd^2/n$ ). Notably, they found a $[[66, 20, 7]]_2$ code with $kd^2/n = 14.85$ . This outperforms the bivariate bicycle code $[[144, 12, 12]]_2$ ( $kd^2/n = 12$ ) despite having less than half the block length. Other notable discoveries include $[[46, 2, 8]]_2$ , $[[66, 2, 9]]_2$ , and codes at $n=90$ with dimensions up to $k=20$ .
Boundary Theorem: The authors extend their analysis beyond the cyclic case to the weight-8 symmetric coset-2BGA family at $n=48$ . They prove that in this specific family, a distance of $d=5$ forces a rank degeneracy ( $k=9$ ), thereby excluding the existence of a $[[48, 10, 5]]_2$ code within this family. Conversely, they construct a $[[48, 10, 6]]_2$ code using a minimal 48-element group, improving upon a previous realization that required a 72-element group.

Results

Code Parameters: The search recovered short codes $[[42, 12, 4]]_2$ and $[[62, 12, 4]]_2$ and generated a comprehensive table of codes for $n \in \{46, 50, 54, 66, 70, 78, 90, 170\}$ . The $[[66, 20, 7]]_2$ code represents a significant breakthrough in the high-dimension, moderate-distance regime, a region previously under-sampled by group-theoretic searches.
Decoding Performance: The authors benchmarked selected low-weight codes using Belief Propagation with Ordered Statistics Decoding (BP-OSD) under code-capacity noise. The results show clear waterfall regions. While the reference bivariate bicycle codes (e.g., $[[144, 12, 12]]_2$ ) exhibit steeper sub-threshold slopes due to lower check weights ( $w=6$ ), the new codes demonstrate competitive logical error rates, with some (e.g., $[[170, 10, 8]]_2$ ) showing no logical failures at physical error rates up to 2%.
Structural Insights: The paper identifies that the dimension formula based on polynomial gcd is the "defect-zero" case of a more general rank formula involving coset actions. The $n=48$ analysis reveals that rank degeneracy is tied specifically to distance $d=5$ in the symmetric coset family, distinguishing phenomena captured by the polynomial framework from those requiring genuine coset-theoretic analysis.

Significance
The paper claims to open a systematic route to bicycle-type quantum LDPC codes that extends beyond the reach of traditional group-theoretic searches. By shifting the search paradigm to the polynomial domain, the authors enable the efficient discovery of codes with high dimensions ( $k$ ) that were previously inaccessible. The framework precisely delineates its own boundaries: it successfully captures codes where the cyclic structure allows for algebraic pre-filtering, while explicitly identifying (via the $n=48$ case) where "genuinely coset-theoretic phenomena" (such as rank degeneracy) begin. The work provides both a practical tool for code discovery and a theoretical clarification of the relationship between group-algebra constructions and symplectic polynomial formulations.

Technical Summary: Quantum Bicycle LDPC Codes with High kd2/nkd^2/nkd2/n from Divisor-Driven Search

More like this

Technical Summary: Quantum Bicycle LDPC Codes with High $kd^2/n$ from Divisor-Driven Search