Evolutionary Discovery of Bivariate Bicycle Codes with LLM-Guided Search

This paper presents an LLM-guided evolutionary workflow that successfully discovers new high-performance bivariate-bicycle quantum LDPC codes by mutating Python programs and rigorously validating candidates through a multi-stage pipeline, yielding 465 distinct codes including indecomposable and high-distance variants.

The Gist

Imagine you are trying to build the perfect lock for a digital vault. In the world of quantum computing, this "lock" is called a quantum error-correcting code. Its job is to protect fragile quantum information from noise and errors. The better the lock, the more data you can store (high "rate") and the more damage it can withstand before breaking (high "distance").

For a long time, scientists have been trying to find the best designs for these locks, specifically a type called Bivariate Bicycle (BB) codes. Think of these as intricate, mathematical blueprints. The problem is that the number of possible blueprints is so vast it's like searching for a specific grain of sand on every beach on Earth, and checking if a blueprint works is incredibly slow and difficult.

This paper describes a new way to find these blueprints using Artificial Intelligence (specifically Large Language Models, or LLMs) acting as an evolutionary guide.

Here is the story of their discovery, broken down into simple concepts:

1. The "Evolutionary" Search Engine

Instead of a human trying to guess the perfect blueprint, the researchers built a system that mimics natural evolution.

• The "Organism": Instead of evolving a single code, they evolved a Python computer program (a recipe) that generates codes.
• The "Mutation": An AI (the LLM) looks at the current best recipe and suggests small changes, like "change this number" or "add a new step."
• The "Survival of the Fittest": The system generates thousands of new recipes. It tests them quickly to see if they produce a valid code. The best ones survive to be mutated again; the bad ones are discarded.

Over five "campaigns" (search rounds), this AI-driven system ran about 1,650 generations, screening roughly 200,000 candidate codes. The whole process cost about $400 in computer time and took about 140 hours.

2. The "Trap" and the "Referee"

Early in the search, the AI ran into a clever trap. It found recipes that produced codes with a huge amount of data storage (high "rate"), which looked amazing. However, these codes were actually useless because they had zero ability to correct errors (distance = 2). It was like finding a vault door that opens with a paperclip; it holds a lot of stuff, but it's not secure.

The researchers realized their initial "distance checker" (a standard tool called BP-OSD) was lying to them. It was overestimating how strong these codes were, sometimes by 12 times.

To fix this, they added a strict Referee (MILP) to the process.

• The Referee's Job: This is a heavy-duty mathematical solver that checks the distance of a code with 100% certainty.
• The Result: The Referee caught the "traps" immediately. It also revealed that many codes the AI thought were strong were actually weak. This forced the AI to stop looking at the "fake" high-performing codes and find genuinely strong ones.

3. The Discoveries

After refining their process, the system found 465 distinct, high-quality codes. Here are the highlights:

• The "Gold Standard" Match: They found a new type of code (called a "Perturbed Bivariate Bicycle") that matches the performance of the current best-known code (the "Gross Code") but uses a different, more complex structure. It's like finding a new engine design that gets the same mileage as the best car on the market but uses a different type of fuel.
• More Data, Same Protection: They found codes that can store more data (up to 54 logical qubits) than previous records while maintaining a decent level of protection.
• The "Decomposable" Discovery: The system found a code that looked like a super-advanced lock. However, the Referee's graph analysis revealed it was actually just two ordinary locks glued together. It wasn't a new invention; it was just two existing ones side-by-side. This showed the system's ability to spot "fake" complexity.

4. The "Rate vs. Distance" Trade-off

The researchers mapped out the landscape of all these codes and found a consistent rule, like a law of physics for these locks:

• The Envelope: You generally cannot have a lock that stores massive amounts of data AND is extremely tough at the same time.
• The Curve: If you want to store more data (higher rate), the lock becomes easier to break (lower distance). If you want a super-tough lock, you have to store less data.
• The Exception: They found some codes that push the limits of this curve (like a code with 50 data units and distance 8), but they still couldn't break the fundamental "envelope" of the trade-off.

5. Why This Matters

The paper concludes that using an AI to evolve computer programs is a practical, low-cost tool for discovering new quantum codes.

• It found codes that humans and traditional math searches had missed.
• It proved that standard testing tools can be dangerously inaccurate for high-performance codes, necessitating the use of the strict "Referee" (MILP).
• It demonstrated that AI can learn to avoid "traps" and discover complex algebraic patterns that generalize across different sizes of quantum computers.

In short, the researchers used an AI to evolve a "code generator," taught it to ignore fake results, and successfully discovered a new family of quantum locks that are stronger, more efficient, or simply different from anything we had before.

Technical Summary

Technical Summary: Evolutionary Discovery of Bivariate Bicycle Codes with LLM-Guided Search

Problem Statement

The discovery of Quantum Low-Density Parity-Check (qLDPC) codes, particularly Bivariate Bicycle (BB) codes, requires navigating vast combinatorial design spaces to find codes with favorable rate–distance–threshold tradeoffs. While BB codes offer weight-6 stabilizers and constant-depth syndrome extraction suitable for near-term hardware, the landscape of high-performance codes at practical block lengths ($n \lesssim 1000$) remains largely unexplored. Existing systematic enumerations are often restricted to specific polynomial forms or small block lengths, and the search space lacks a gradient structure amenable to continuous optimization. Furthermore, reliably certifying the parameters (specifically the minimum distance $d$) of candidate codes is computationally hard; standard heuristic methods like Belief Propagation with Ordered Statistics Decoding (BP-OSD) have been shown to systematically overestimate distance, particularly for high-rate codes, leading to unreliable fitness signals in evolutionary searches.

Methodology

The authors introduce an LLM-guided evolutionary workflow designed to discover and validate quantum codes. Rather than evolving individual code parameters, the system evolves generator ansätze—Python programs that produce candidate polynomial pairs (or 4-tuples for non-CSS codes) for arbitrary lattice dimensions.

Evolutionary Framework

• Algorithm: The system utilizes OpenEvolve, an implementation of the MAP-Elites algorithm, to guide a Large Language Model (LLM) in mutating code generators.
• Mutation Strategy: The LLM receives the current highest-fitness ansatz, domain knowledge, and evaluation feedback, proposing targeted code diffs (e.g., exponent adjustments, control-flow restructuring) rather than full rewrites.
• Population: The search is distributed across multiple "islands" with periodic migration to maintain diversity. The archive indexes ansätze based on behavioral dimensions such as the number of lattices yielding valid codes and the total count of high-quality codes.

Staged Validation Pipeline

To mitigate the unreliability of heuristic distance estimation, the authors employ a multi-stage cascade:

1. Stage 1 (Screening): Rapid evaluation on small lattices to compute the encoding dimension $k$ via $\text{GF}(2)$ rank. Ansätze failing to produce valid codes are discarded.
2. Stage 2 (Heuristic Estimation): Surviving ansätze are evaluated on larger lattices using BP-OSD with multiple decoder configurations (OSD0, OSD-CS10) to estimate distance $d$.
3. Stage 3 (Exact Verification): For top candidates (and in later campaigns, in-loop), Mixed-Integer Linear Programming (MILP) is used to compute exact distances or rigorous upper bounds. This stage is critical for correcting the systematic overestimation observed in BP-OSD.
4. Post-Campaign Analysis: Includes BLISS-based Tanner graph deduplication to identify permutation-equivalent codes, decomposability analysis (to detect direct sums), and Local-Clifford (LC) equivalence checks for non-CSS codes.

Code Families

• CSS BB Codes: Defined by two trinomials $A, B$ over $\mathbb{F}_2[x,y]/(x^\ell-1, y^m-1)$.
• Perturbed BB (PBB) Codes: A non-CSS ansatz introducing perturbation polynomials $C, D$ to create mixed stabilizers, allowing for non-CSS structures.

Key Contributions

1. Discovery of 465 Distinct Codes

Across five evolutionary campaigns, the system discovered 465 distinct codes at block lengths $n \le 360$:

• 97 CSS Codes: Including 97 distinct representatives (99 equivalence classes including rediscoveries). Notable findings include:
  • The [[288, 16, 12]] code: An indecomposable CSS code with $d=12$ (exact) and all shifts $\le 3$.
  • Higher-weight codes: Discovery of weight-8 codes achieving new $(k, d)$ combinations, such as [[288, 50, 8]] ($k=50, d=8$).
  • Recovery of known high-performing codes (e.g., the "gross code" [[144, 12, 12]]) and identification of new finite-length representatives.
• 368 Non-CSS PBB Codes: Codes using mixed stabilizers. The search found a [[144, 12, 12]] PBB code matching the gross code's Figure of Merit (FOM) and a [[360, 12, $\le$24]] code with a trusted FOM upper bound of 19.2.

2. Methodological Advances in Verification

• BP-OSD Overestimation: The study quantifies that BP-OSD systematically overestimates distance for high-rate codes ($k/n > 0.1$), with errors reaching up to 12$\times$. For example, a [[360, 40, 2]] code was estimated as $d \le 24$ by BP-OSD, while MILP confirmed $d=2$.
• Achievable-Syndrome Sampling: For non-CSS codes, standard random syndrome sampling fails because achievable logical cosets form a strict subspace. The authors introduce a method to sample only from the achievable subspace, restoring BP-OSD functionality.
• MILP Ground Truth: The use of MILP as a verification standard revealed that many high-$k$ candidates were actually low-distance or decomposable (e.g., the [[288, 24, 12]] code was identified as a direct sum of two gross codes).

3. Structural Characterization of the BB Landscape

The authors identify four algebraic families with distinct rate–distance profiles:

• Univariate/HGP: Codes equivalent to the hypergraph product of cyclic codes. These achieve the highest encoding dimensions ($k \propto \ell$) but suffer from a distance ceiling of $d \le 4$.
• x/y-swap: Codes with mixed variables in polynomials, achieving $d \ge 12$ but limited to $k \le 16$ for indecomposable codes.
• Mixed-Monomial/Higher-Weight: Codes with 4–6 term polynomials that access new $(k, d)$ points (e.g., $k=50$ at $d=8$) but do not escape the overall rate–distance envelope.
• Non-CSS PBB: Codes that match but do not exceed the FOM of the best CSS codes at $n=144$.

4. Empirical Rate–Distance Tradeoff

The search reveals a consistent empirical tradeoff: higher encoding rates generally accompany lower distances.

• Indecomposable weight-6 codes with $d=12$ are limited to $k \le 16$.
• Weight-6 codes with $k > 24$ universally have $d \le 4$.
• Higher-weight codes (weight-8) can access higher $k$ at moderate $d$ (e.g., $k=50$ at $d=8$) but do not break the observed envelope.

Results and Significance

Key Findings

• LLM Efficacy: The LLM-guided evolution successfully discovered algebraic patterns (e.g., univariate structures, x/y-swap) that generalize across lattice dimensions, outperforming random search and standard genetic algorithms in finding high-FOM codes with $d \ge 6$.
• Verification Necessity: The study demonstrates that heuristic distance estimation is insufficient for high-rate code discovery. The "A = B distance trap" (where $A=B$ yields $d=2$) was undetected by BP-OSD even at $1.5 \times 10^6$ trials but was immediately identified by the MILP pipeline.
• Hardware Relevance: The discovered codes, such as [[288, 16, 12]], offer improved logical qubit counts (up to 1.7$\times$ the gross code) while maintaining pseudo-thresholds comparable to the surface code. Non-CSS PBB codes show potential for improved error suppression under specific noise models (X-only), though this advantage diminishes under depolarizing noise with standard decoders.

Significance

The paper claims that LLM-guided program evolution, when paired with rigorous, multi-stage independent verification (specifically MILP), serves as a practical and cost-effective tool for structured quantum code discovery. The total computational cost of approximately $400 and 140 hours demonstrates the feasibility of this approach.

The work establishes a new verification standard for high-rate BB code claims, highlighting the critical gap between heuristic estimates and exact distance. It provides a reusable framework for exploring the combinatorial space of quantum codes, revealing that while the rate–distance envelope is robust, structured search can uncover new, high-performance representatives within it. The authors note that escaping this envelope likely requires moving beyond the bivariate bicycle family to more complex algebraic structures.