⚛️ quantum physics

Logical Operator Decomposition for Distance Analysis of Bivariate Bicycle Codes

This paper introduces a logical operator decomposition framework for bivariate bicycle quantum codes that establishes an explicit distance identity, proves uniform rank properties, and enables the precise enumeration of minimum-weight logical operators to determine the exact distances of standard code instances.

Original authors: Mohammad Rowshan, Simon Devitt

Published 2026-10-01

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Mohammad Rowshan, Simon Devitt

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

Quantum computers hold the promise of solving problems that would take today's machines millennia to crack, but they are incredibly fragile. The slightest whisper of heat or a stray magnetic field can scramble the delicate information they hold. To protect this data, scientists use quantum error correction, a method that spreads a single piece of information across many physical particles, much like copying a secret message across a hundred different notebooks so that if a few are lost or damaged, the story can still be read. The strength of this protection depends on a property called distance: the minimum number of particles that must be disturbed before the message is corrupted. The larger the distance, the more robust the computer.

For years, researchers have been designing a specific family of codes known as bivariate bicycle codes. These are attractive because they are efficient and can be built on flat, two-dimensional surfaces, making them practical for real-world hardware. However, while scientists knew how to build these codes, they struggled to predict exactly how strong they were. Usually, they had to build a code and then run massive, time-consuming computer searches to find its distance, rather than being able to read the strength directly from the code's design. This meant that designing better codes was a process of trial and error, building first and measuring later.

A team of researchers has now changed this approach by developing a new way to look inside these codes. Instead of treating the code as a single, solid block, they discovered that the logical operators—the patterns of errors that could corrupt the data—can be split into two distinct categories. One category consists of errors that live entirely on one side of the system, while the other consists of errors that span both sides. By separating the problem this way, the researchers could analyze the strength of each part independently. They proved that the overall strength of the code is simply the weaker of these two parts, allowing them to calculate the distance with mathematical certainty rather than relying on guesswork or incomplete searches.

Using this new framework, the team examined six standard examples of these codes, ranging from small systems with 18 particles to larger ones with 288. In every case, they were able to prove the exact distance, confirming values that had previously been only estimated or known as upper limits. For instance, they confirmed that a code with 288 particles can withstand up to 18 simultaneous errors before failing. More importantly, their method revealed the hidden shape of the weakest errors. In some codes, the most dangerous errors were found to be one-sided, affecting only one part of the system, while in others, the errors were balanced, spreading evenly across both sides. In one specific case, a code with 108 particles, they found that the weakest errors were entirely balanced, a detail that previous methods had missed.

The researchers also showed that the old way of thinking about these codes was incomplete. They demonstrated that an error pattern that looks simple on paper might actually be heavier when fully realized, and conversely, a pattern that looks complex might hide a lighter version. By mapping out every possible minimum-weight error for these six codes, they created a complete census of the threats each system faces. This work does not just provide a list of numbers; it offers a clear, structural understanding of why these codes are strong or weak. It transforms the design process from a blind search into a precise engineering task, where the strength of a code can be understood and verified by looking at its fundamental algebraic parts. This clarity is a crucial step toward building the reliable, large-scale quantum computers needed for the future.

Technical Summary: Logical Operator Decomposition for Distance Analysis of Bivariate Bicycle Codes

Problem Statement
Bivariate bicycle (BB) codes are a prominent family of finite-length quantum low-density parity-check (LDPC) codes, offering high rates and planar-friendly layouts compared to surface codes. While the dimension and check weights of BB codes can be determined directly from their defining polynomials $a$ and $b$ via algebraic inspection, the minimum distance $d$ remains elusive. Currently, distance is established numerically using mixed-integer programming, randomized window methods, or decoder-assisted sampling. These methods treat the code as a fixed object to be probed rather than deriving the distance from the algebraic structure of the defining polynomials. Consequently, finite-length code design often proceeds by construction followed by post-hoc measurement, rather than by algebraic prediction.

Methodology
The paper introduces an algebraic framework to decompose the logical operator space of BB codes, separating the distance analysis into structurally distinct components.

Logical Quotient Decomposition:
The authors analyze the Z-logical quotient $K/S$ over the group algebra $R = \mathbb{F}_2[x, y]/(x^\ell-1, y^m-1)$ , where $K$ is the syzygy module $\{(u, v) : au + bv = 0\}$ and $S$ is the stabilizer submodule. They establish a short exact sequence:
$0 \longrightarrow \text{ann}(a)/b\,\text{ann}(a) \xrightarrow{\iota} K/S \xrightarrow{\pi} (a:b)/(a) \longrightarrow 0$
Here, the kernel corresponds to the annihilator component (classes admitting a left-only representative), and the cokernel corresponds to the colon component (classes where the right block is not in the ideal generated by $a$ ).
Dimension and Symmetry:
Using the Frobenius pairing of the finite group algebra, the authors prove that for every BB code, the dimensions of the annihilator and colon components are equal: $r_A = r_C = k/2$ . This holds even for repeated-root cases where the algebra is not semisimple.
Componentwise Distance Formula:
The distance $d_Z$ is shown to be the minimum of the distances within the two components: $d_Z = \min(d_A, d_C)$ .
- Crucial Distinction: The paper emphasizes that the algebraic component (annihilator vs. colon) is distinct from the representative shape (one-sided, lopsided, or balanced). An annihilator class may have a minimum-weight representative that occupies both blocks (lopsided), and a colon class may have a one-sided minimum.
Exact Lower Bounds via Cluster Search:
To establish lower bounds without exhaustive search, the authors prove that every proper subset of a minimum-weight logical operator has a non-zero syndrome. Leveraging this "syndrome connectivity," they develop a translation-anchored cluster search (Algorithm 1). This algorithm grows clusters from a fixed anchor qubit, pruning branches where the syndrome becomes zero or where the weight exceeds the target radius.
- A key theoretical result (Corollary 3) shows that this cluster search computes the colon distance $d_C$ exactly because the syndrome connectivity property holds for colon classes.
- For the annihilator component, the property does not always hold; thus, $d_A$ is determined either by the full census of minimum-weight operators or by combining a one-sided witness with a lower bound derived from the minimum weight of the syzygy module $K$ .

Key Contributions

Structural Decomposition: The paper provides the first exact sequence decomposition of the BB logical quotient, explicitly labeling logical classes as annihilator or colon types.
Distance Identity: It establishes the identity $d_Z = \min(d_A, d_C)$ and proves the dimension balance $r_A = r_C = k/2$ for all BB codes.
Shape vs. Component: It rigorously decouples the algebraic classification of logical classes from the geometric shape of their minimum-weight representatives, demonstrating that "annihilator" does not imply "one-sided."
Exact Verification Algorithm: The authors present a cluster search method that provides exact lower bounds for finite-length codes, avoiding the floating-point approximations of integer programming.
Complete Census: The method enumerates all minimum-weight logical operators for six standard BB codes, providing a detailed census of their component types and shapes.

Results
The authors apply their framework to six standard BB codes with lengths ranging from 18 to 288. The results confirm the distances for all six codes, resolving previous numerical upper bounds:

[[18, 4, 4]]: $d=4$ (attained in both components; lopsided shapes).
[[72, 12, 6]]: $d=6$ (attained in both components; one-sided shapes exist).
[[90, 8, 10]]: $d=10$ (attained in both components; mix of one-sided and balanced).
[[108, 8, 10]]: $d=10$ (attained only in the colon component; all minimum-weight classes are balanced).
[[144, 12, 12]]: $d=12$ (attained in both components; mix of shapes).
[[288, 12, 18]]: $d=18$ (attained in both components; confirms the numerical upper bound from prior work).

The census reveals that for five of the six codes, the minimum distance is attained in both the annihilator and colon components. Only the [[108, 8, 10]] code attains its distance exclusively in the colon component. Furthermore, the study shows that minimum-weight representatives can be one-sided, lopsided, or balanced, regardless of their algebraic component.

Significance and Claims
The paper claims to provide a structural understanding of BB code distances that was previously lacking. By separating the distance problem into componentwise coset-leader problems, it offers a more granular view of code performance than a single scalar distance value.

The authors state that their method allows for the exact verification of distances for finite-length codes, moving beyond numerical heuristics.
They highlight that the algebraic decomposition is a tool for "screening" candidate codes: cheap structural tests (Gaussian elimination) can identify weak candidates (e.g., those with sparse annihilators or colon shortcuts) before expensive cluster searches are run.
The paper modestly notes that while it provides the minimum Hamming weight of logical operators, it does not predict logical error rates under specific noise models or decoders. The significance lies in identifying the specific qubit sets that constitute the code's weakest points (the minimum-weight logicals) and understanding their structural origin.
The decomposition is presented as a general tool for two-block group algebra codes, potentially applicable to decoder design and code search strategies, though these applications are flagged as future work rather than immediate results of this study.

Technical Summary: Logical Operator Decomposition for Distance Analysis of Bivariate Bicycle Codes

More like this