Multi-agent discovery of practical quantum LDPC codes

The paper introduces a multi-agent framework for discovering practical quantum low-density parity-check (qLDPC) codes, addressing the challenge of finding useful finite-length instances that balance code performance with practical constraints. The framework combines specialist proposal and review, persistent scientific memory, long-horizon evolution of executable programs, and deterministic construction and evaluation within a closed-loop search. These programs instantiate coset-orbit balanced-product codes, a search space that includes bicycle and lifted-product constructions as well as non-normal subgroup actions.

The search is restricted to binary CSS codes with block length n at most 400 and overall weight w at most 10, where overall weight is defined as the larger of the maximum stabilizer weight and the maximum number of checks incident on any qubit. Within this regime, the framework discovers codes with leading or competitive rate–distance performance in every weight class considered. Representative instances include [[288, 16, 18]] at w = 7, [[288, 18, 18]] at w = 9, and [[234, 28, 18]] at w = 10. The search also uncovers structurally distinct, high-performing constructions, including a [[336, 12, ≤ 24]] candidate and a [[368, 18, 16]] code, both of which are genuine balanced-product constructions with non-normal subgroup actions.

The framework's architecture involves three agent roles: a researcher council that formulates hypotheses and proposes mathematical directions, a curator that combines proposals with accumulated evidence into persistent lessons and tasks, and workers that execute tasks by evolving executable code-family generators. The evaluator uses a proxy score Q proxy = k d ub squared / n, where d ub is a distance upper bound from QDistEvol, with adaptive allocation of computational effort to promising candidates. A MAP-Elites archive treats the underlying group family as an explicit niche dimension, along with subgroup type, code rate, and overall weight.

Results show that among codes with rigorously established distances, the [[288, 16, 18]], [[288, 18, 18]], and [[234, 28, 18]] codes attain the largest Q = k d squared / n values at w = 7, 9, 10, respectively. At w = 6, the [[336, 12, 20]] code attains Q = 14.29, within 7% of the leading exact code. At w = 8, the Heisenberg-group [[378, 32, 19]] code gives Q = 30.56. For candidates with high putative distances, upper-bound results include [[400, 16, ≤ 22]] with Q at most 19.36 at w = 6, [[384, 16, ≤ 24]] with Q at most 24.00 at w = 7, and [[390, 32, ≤ 32]] with Q at most 84.02 at w = 10.

The search also explores nontrivial group constructions, including lifted products over unusual groups like the central product (Dic 5 times Dic 5)/(z 1, z 2) and A 4 Z 16, as well as genuine balanced products with non-normal subgroup actions over groups such as A 6 times Z 2, PSL(2, q), and Frobenius constructions. The authors conjecture that lifted products are intrinsically favored for maximizing Q in the finite regime considered here, with genuine balanced products potentially showing advantages at larger block lengths.

Under code-capacity depolarizing noise with a common BP–OSD decoding protocol, the discovered codes exhibit low logical failure rates. The [[400, 16, ≤ 22]] code performs better than both bivariate-bicycle benchmarks across all sampled physical error rates. Pseudo-thresholds for leading codes range from 5.40% to 9.30%, with all ten reported codes having per-logical error rates epsilon L at most 1.68 times 10-5 at p = 0.03. The paper notes a systematic weight dependence, with pseudo-thresholds decreasing monotonically as weight increases, suggesting the decoder is better matched to lower-weight Tanner graphs.

The paper concludes with several future directions: incorporating decoder feedback directly into the search loop, adding structural constraints like girth requirements, extending the framework to other qLDPC construction languages, and applying the approach to other tasks in quantum error correction such as decoder discovery, distance estimation, and fault-tolerant gadget design.

Improvements to AI Systems:

1. Multi-Agent Scientific Discovery with Persistent Memory: Implement a role-based agent architecture (researcher, curator, worker) where a shared, evolving scientific memory stores validated hypotheses, failed approaches, and lessons. This allows the AI to accumulate domain knowledge across search iterations, avoiding redundant exploration and enabling long-horizon reasoning over thousands of code-generation attempts.

2. Closed-Loop Program Evolution with Deterministic Verification: Build an AI system that generates executable code (e.g., for code-family construction) and iteratively refines it via a deterministic evaluator (e.g., distance bounds, weight checks). The system should treat the program itself as the searchable object, enabling mutation, crossover, and selection based on exact metrics, not just neural predictions.

3. Adaptive Resource Allocation via Proxy Scoring: Use a computationally cheap proxy (e.g., Q proxy = k d ub squared / n) to prioritize candidates for expensive verification. The AI should dynamically allocate more compute to promising candidates while pruning low-potential ones, balancing exploration vs. exploitation in a finite-budget setting.

4. MAP-Elites with Explicit Niche Dimensions: Incorporate multi-dimensional quality-diversity search (e.g., MAP-Elites) where niches are defined by structural properties (group family, subgroup type, code rate, weight). This forces the AI to maintain a diverse archive of high-performing solutions across different design regimes, not just a single optimum.

5. Distance Upper-Bound Integration for Candidate Ranking: Train or design the AI to use rigorous upper bounds (e.g., from QDistEvol) alongside exact distances, allowing it to rank candidates with unverified distances and prioritize those with high potential, even when exact decoding is intractable.

6. Decoder-Aware Search Loop: Extend the framework to include a decoder (e.g., BP–OSD) as a feedback signal during search, not just post-hoc evaluation. The AI should optimize for pseudo-threshold or logical failure rate directly, adapting code structure to decoder strengths (e.g., favoring lower-weight Tanner graphs for better decoding performance).

What the Improved AI System Can Do:

• Discover novel, practically useful quantum error-correcting codes with optimized rate–distance–weight trade-offs, beyond human-designed constructions, within finite-length constraints (e.g., n at most 400, w at most 10).

• Automatically generate and evolve code families (e.g., balanced-product, lifted-product, bicycle) over non-trivial group actions, including non-normal subgroups, without manual mathematical derivation.

• Maintain a persistent, reusable knowledge base of successful construction patterns, failed hypotheses, and heuristic rules, enabling faster convergence on new problem instances.

• Balance exploration of diverse code architectures with exploitation of high-performing local optima, ensuring the discovery of structurally distinct solutions (e.g., genuine balanced products vs. lifted products).

• Provide rigorous performance guarantees by combining exact distance computations with upper bounds, allowing confident selection of codes for practical deployment.

• Adapt to decoder characteristics by co-optimizing code structure and decoding strategy, yielding codes with lower logical failure rates at finite physical error rates (e.g., pseudo-thresholds >5%).

• Transfer the framework to other quantum error correction tasks such as decoder design, distance estimation heuristics, and fault-tolerant gadget synthesis, by reusing the same agent-based, program-evolving, memory-augmented search loop.