⚛️ quantum physics

Sequences of Bivariate Bicycle Codes from Covering Graphs

This paper introduces a method to generate infinite sequences of bivariate bicycle (BB) codes from a base code using covering graphs, establishing algebraic conditions for these "cover codes," defining induced maps for logical operators, and proving bounds on their parameters while demonstrating the discovery of new high-performance codes like the $[[144,12,12]]$ gross code.

Original authors: Benjamin C. B. Symons, Abhishek Rajput, Dan E. Browne

Published 2026-06-23

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Benjamin C. B. Symons, Abhishek Rajput, Dan E. Browne

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 secret message. In the world of quantum computing, this "fortress" is called a quantum error-correcting code. Its job is to stop tiny glitches (errors) from destroying the information.

For a long time, the best-known fortresses were "surface codes." They are easy to build because they only need neighbors to talk to each other, but they are very inefficient: they need a huge amount of space to protect just a little bit of information.

Recently, scientists discovered a new type of fortress called Bivariate Bicycle (BB) codes. These are much more efficient—they protect more data with less space—but they are harder to design because they require "long-distance" connections between parts of the fortress that aren't right next to each other.

This paper introduces a clever new way to design these efficient fortresses. Here is the simple breakdown:

1. The "Blueprint" and the "Copy-Paste" Trick

Think of a BB code as a complex architectural blueprint drawn on a grid. This blueprint tells you how to connect the "bricks" (qubits) and the "inspections" (checks) to keep the fortress secure.

The authors discovered that you don't need to draw a brand-new, giant blueprint from scratch. Instead, you can take a small, working blueprint (a "base code") and use a mathematical trick called a "covering graph" to generate a sequence of larger, more complex blueprints.

The Analogy: Imagine you have a small, perfect map of a neighborhood. You can create a "double map" where every street and house is duplicated, but they are connected in a way that looks exactly the same locally (neighbor to neighbor) but is twice as big globally.
The Result: By using this "copy-paste" method, the authors can generate an infinite sequence of new, larger codes starting from just one small, good example.

2. The "Magic Rules" for Copying

You can't just copy any blueprint; if you do it randomly, the fortress might collapse (the math won't work). The authors found simple algebraic rules (like a recipe) that guarantee the copy will be a valid fortress.

The Rule: If you want to make a "double-sized" fortress, you just need to make sure the new blueprint's grid is twice as big, and the connections follow a specific pattern relative to the original.
The Benefit: This shrinks the search space massively. Instead of looking through billions of random blueprints to find a good one, they only have to look at the specific ones that follow these "copy rules." This is like finding a needle in a haystack by only looking in the corner where the needle is guaranteed to be.

3. Finding the "Secret Keys" (Logical Operators)

A fortress is useless if you can't get inside to use the data. In quantum codes, these "keys" are called logical operators.

Projecting (Looking Down): If you have a giant fortress and a small one, you can "project" the keys from the giant one down to the small one to see if they match.
Lifting (Looking Up): More importantly, if you know the keys for the small, simple fortress, you can "lift" them up to the giant fortress.
The Analogy: Imagine you know the combination to a small safe. Because the big safe is just a "covered" version of the small one, you can use the small safe's combination to figure out how to open the big one, or at least know that the big one has a combination that works.

This allows scientists to find the "keys" for massive, complex codes by just studying the tiny, simple ones.

4. What They Found

Using this method, the authors did two main things:

Explained the Famous "Gross Code": There is a famous, highly efficient code called the "Gross code" (with parameters [[144, 12, 12]]). The authors showed that this code isn't a mystery; it's simply a "double cover" of a smaller, simpler code ([[72, 12, 6]]). It's like realizing a complex building is just two copies of a simpler building glued together.
Discovered New Fortresses: They used their method to search for codes with "heavier" checks (more connections per brick). They found several new, highly efficient codes, including:
- A [[64, 14, 8]] code.
- A [[144, 14, 14]] code.
  These new codes are even better at protecting data (higher "distance") than the previous best examples, though they are slightly more complex to build.

5. The "Odd vs. Even" Rule

The authors proved some mathematical guarantees about these new codes:

If you make a "double" (or any odd multiple) of a code, the new code will never have fewer logical keys (qubits) than the original.
If the number of copies is odd and the number of keys stays the same, the new code will be at least as strong (distance) as the original.

Summary

In short, this paper provides a mathematical assembly line for building better quantum error-correcting codes. Instead of guessing and checking random designs, you can take a small, proven design and use a specific set of rules to generate an infinite family of larger, stronger designs. This helps researchers find the "sweet spot" of codes that are both efficient and strong enough to build a future quantum computer.

Technical Summary: Sequences of Bivariate Bicycle Codes from Covering Graphs

Problem Statement
Quantum Low-Density Parity-Check (qLDPC) codes offer a promising alternative to surface codes by providing constant rates and improved distance scaling, potentially reducing the space overhead required for fault-tolerant quantum computation. However, identifying new, high-performance qLDPC codes remains a challenge due to the vast search space of possible parity check polynomials. Specifically, Bivariate Bicycle (BB) codes, which are group algebra codes defined over $\mathbb{F}_2[Z_l \times Z_m]$ , have shown potential with high-rate, high-distance instances (e.g., the [[144, 12, 12]] "gross" code), but a general method for generating infinite families of such codes with predictable parameters has been limited. Furthermore, understanding the relationship between logical operators and automorphisms across different code instances is crucial for implementing logical operations but is often difficult to analyze for large codes.

Methodology
The authors propose a framework for generating infinite sequences of BB codes using the mathematical concept of covering graphs (or graph lifts). The core methodology involves:

Algebraic Conditions for Covering: The paper establishes that a Tanner graph of a BB code $\tilde{Q}$ is a covering graph of a base BB code $Q$ if specific algebraic conditions are met regarding their lattice parameters and defining polynomials. Specifically, if $Q$ has parameters $(l, m)$ and polynomials $A, B$ , a cover code $\tilde{Q}$ with parameters $(\tilde{l}, \tilde{m})$ and polynomials $\tilde{A}, \tilde{B}$ is a valid $h$ -cover (where $h = \tilde{l}\tilde{m}/lm$ ) if:
- $\tilde{l} = ul$ and $\tilde{m} = tm$ for integers $u, t$ .
- The exponents of the monomials in $\tilde{A}$ and $\tilde{B}$ are congruent to those in $A$ and $B$ modulo $l$ and $m$ , respectively.
- The voltage assignment used to generate the derived graph corresponds to the "quotient" of the lattice parameters.
Reduced Search Space: By restricting the search to polynomials that satisfy these congruence conditions, the authors drastically reduce the search space for new codes. Instead of searching the full space of polynomials of length $n$ , the search is limited to variations of a base code's polynomials, reducing the complexity from $O(n^6)$ to roughly $O(h^4)$ for $h$ -covers.
Chain Maps and Homology: The graph covering map is extended to a chain map between the chain complexes of the base and cover codes. This induces maps on (co)homology:
- Projection Map ( $p$ ): Maps logical operators from the cover code to the base code.
- Lifting Map ( $\tau$ ): Maps logical operators from the base code to the cover code.
- Weight-Preserving Lift ( $\sigma$ ): A specific type of lift that selects a single pre-image for each vertex, used to upper-bound the distance of the cover code.
Automorphism Lifting: The framework is extended to show that graph automorphisms (and consequently CSS code automorphisms) can be lifted from the base to the cover code. Under specific conditions (odd $h$ and equal logical qubit counts), the logical action of these automorphisms is preserved.

Key Contributions and Results

Generation of Code Sequences: The authors demonstrate that known high-performance BB codes, such as the [[144, 12, 12]] gross code, can be viewed as double covers of smaller codes (e.g., [[72, 12, 6]]). They generate infinite sequences of new BB codes with fixed logical qubit counts ( $k$ ) and increasing block sizes ( $n$ ).
New Code Families:
- Weight 6 Codes: The method reproduces known families, including balanced product codes and generalized toric codes, and generates new sequences for $k=6, 8, 10, 12$ .
- Weight 8 Codes: The authors apply the method to search for BB codes with weight 8 checks (4 terms in defining polynomials). They find sequences with $k=8, 10, 12, 14$ that exhibit significantly higher $kd^2/n$ ratios than their weight 6 counterparts. Notable examples include the [[64, 14, 8]] and [[144, 14, 14]] codes.
- Qudit Codes: The methodology is generalized to qudit codes over $\mathbb{F}_q$ , successfully generating cover codes for base qudit BB codes.
Theoretical Bounds:
- Logical Qubits ( $k$ ): The authors prove that for an $h$ -cover code with odd $h$ , the number of logical qubits satisfies $k_h \ge k$ . They conjecture this holds for all $h$ .
- Distance ( $d$ ): For odd $h$ , they prove the upper bound $d_h \le hd$ . If $k_h = k$ and $h$ is odd, they prove the lower bound $d_h \ge d$ . They conjecture the general bound $d \le d_h \le hd$ holds for all $h$ .
- Weight-Preserving Lifts: They show that if a weight-preserving lift exists, it implies $d_h \le d$ , providing a numerical tool to rule out cover codes where the distance does not increase.
Logical Operator and Automorphism Analysis: The paper provides explicit constructions for lifting logical operators and automorphisms. It proves that when $h$ is odd and $k_h = k$ , the lifting map is an isomorphism on homology, ensuring that a logical basis of the base code lifts to a complete logical basis of the cover code, preserving the logical action of automorphisms (e.g., logical CNOT and Hadamard gates).

Significance
The paper claims significance in three main areas:

Efficient Code Discovery: By identifying a reduced search space based on covering graph theory, the authors provide a systematic and efficient method for discovering new BB codes with promising parameters, bypassing the need for brute-force searches over the full polynomial space.
Theoretical Unification: The work unifies various known BB code constructions (including the gross code, balanced product codes, and generalized toric codes) under a single framework of covering graphs, revealing structural relationships between them.
Logical Operator Management: The development of projection and lifting maps offers a practical tool for analyzing large codes. By deriving logical operators and automorphisms from smaller, well-understood base codes, the complexity of managing logical operations in large qLDPC codes is reduced.

The authors note that while the focus is on BB codes, the methods are expected to generalize to other group algebra codes and constructions involving hypergraphs or lifted products. They also highlight that while the search space is reduced, computing the exact distance of large cover codes remains a bottleneck, and their theoretical bounds serve as a guide rather than a complete solution for distance calculation.