Large-Language-Model Discovery of Quantum LDPC Codes through Structured Concept Evolution

Technical Summary: Large-Language-Model Discovery of Quantum LDPC Codes through Structured Concept Evolution

Problem Statement
Quantum error correction (QEC) is a prerequisite for scalable quantum computing. While the surface code has been the standard due to its high threshold and planar geometry, it suffers from a vanishing encoding rate ($\Theta(d^{-2})$), requiring a quadratic overhead of physical qubits per logical qubit. Quantum low-density parity-check (qLDPC) codes offer a promising alternative by combining sparse parity checks with finite encoding rates and growing distance, potentially enabling fault-tolerant computation with constant overhead. However, constructing high-performing qLDPC codes is a challenging discrete design problem. Existing families (e.g., hypergraph product, generalized bicycle, lifted product) rely on algebraic product constructions parametrized by group-algebra elements or protograph polynomials. The performance of these codes depends critically on the specific choice of these parameters, yet the viable region within the exponentially large search space is vanishingly small. Current discovery methods rely heavily on expert intuition, exhaustive enumeration of small instances, or random sampling, which do not scale to the block lengths required for practical applications.

Methodology: Structured Concept Evolution (SCE)
The authors introduce Structured Concept Evolution (SCE), a search framework that leverages Large Language Models (LLMs) not to design codes from first principles, but to evolve structured concepts. In this framework, an "individual" is not a specific parity-check matrix but a higher-level structured concept $\Sigma$ paired with an executable program $P_\Sigma$. The concept $\Sigma$ specifies the algebraic construction (e.g., base group, protograph shape, local seed matrices), while $P_\Sigma$ generates the CSS parity-check matrices ($H_X, H_Z$) for any admissible block length.

The SCE process operates as follows:

1. Search Space: The search is confined to Lifted-Product (LP) CSS codes, a generalization of the hypergraph product that yields some of the most powerful modern qLDPC codes.
2. Hierarchical Mutation: An LLM acts as a mutation operator, proposing edits to the structured concept at three distinct levels:
   • Level 1 (Local): Modifies the group-algebra entries (seeds) of the base matrices $A$ and $B$ while keeping the group family and protograph shape fixed.
   • Level 2 (Shape/Scaling): Changes the protograph dimensions ($m_A \times n_A, m_B \times n_B$) and the scaling rule, altering the block length and structure while keeping the group family fixed.
   • Level 3 (Algebraic): Replaces the base group family (e.g., transitioning from abelian to non-abelian groups), requiring a rewrite of the protograph shape and local entries to maintain validity.
3. Quality-Diversity Archive: Instead of converging to a single optimum, SCE maintains a quality-diversity archive (using a MAP-Elites algorithm) that stores competitive constructions across different base groups, encoding rates, and decoding performances.
4. Evaluation: Candidates are evaluated under code-capacity depolarizing noise using Belief Propagation with Ordered Statistics Decoding (BP+OSD). A fitness score $S$ is calculated based on the encoding rate $k/n$ and the error suppression exponent $\alpha(p)$, penalized by a novelty factor to avoid rediscovering structurally similar codes.
5. Implementation: The framework runs on lightweight models (GPT-5.4-mini and GPT-5.4-nano) using the OpenEvolve infrastructure.

Key Contributions

• Framework: The introduction of SCE, which pairs LLMs with a structured algebraic mutation grammar to discover lifted-product code families. This approach moves the search from raw matrix entries to coherent algebraic concepts.
• Discovery of Diverse Families: The method successfully discovers competitive code families ranging from abelian constructions to non-abelian groups that extend beyond standard designs like bivariate-bicycle (BB) codes.
• Performance Benchmarking: The authors characterize the discovered codes under depolarizing noise, demonstrating that they achieve high encoding rates (up to $k/n \approx 0.13$) at block lengths around $n \approx 1500$.
• Efficiency: The entire discovery process is achieved using lightweight LLMs, demonstrating that complex algebraic design problems can be tackled without massive computational resources.

Results

• Code Families: After three rounds of 1000 iterations, the search generated 3000 candidate constructions. Representative elite codes include:
  • Abelian: Codes based on groups like $Z_3 \times Z_{14}$ and $Z_2 \times Z_2 \times Z_{11}$.
  • Non-Abelian: Codes based on dicyclic groups ($Dic_{11}$) and dihedral groups ($D_{22}$), as well as semi-direct products like $(Z_2 \times Z_2) \rtimes Z_{10}$.
• Performance Metrics:
  • The best discovered codes reach an encoding rate of $k/n \approx 0.13$ with block lengths near 1500.
  • Under BP+OSD decoding at physical error rate $p=0.06$, the logical error rate per logical qubit ($\epsilon_L$) for the top candidates is comparable to or lower than baseline bivariate-bicycle codes (e.g., BB [[756, 16, 34]]), despite encoding roughly five times as many logical qubits.
  • The $k d^2 / n$ metric (a proxy for code quality) reaches values up to 51.9 for the discovered non-abelian codes.
• Evolutionary Dynamics: The hierarchical mutation strategy allows for both local refinement (Level 1) and broad structural exploration (Levels 2 and 3). The score evolution shows a steady improvement from an initial score of 0.17 to 0.62 over the search rounds.

Significance and Claims
The paper claims that SCE provides a viable route to discovering high-performance qLDPC codes by automating the exploration of complex algebraic design spaces. By evolving structured concepts rather than raw matrices, the method overcomes the limitations of previous machine learning approaches that searched over explicit, finite-size stabilizers. The results demonstrate that LLM-guided search can identify competitive code families, including non-abelian constructions that were previously difficult to find via exhaustive enumeration. The authors position this work as a step toward hardware-compatible code discovery, noting that the framework is extensible to other code families (e.g., balanced product, fiber-bundle) and could be adapted for co-designing codes with specific hardware connectivity constraints. The work is modest in its claims, presenting the discovery of competitive constructions rather than a definitive solution to all qLDPC design challenges, and acknowledges that exact minimum-distance computation remains NP-hard.