OmniQEC: discovering practical quantum error-correcting codes by an AI scientist

AI summary

Overview

Research area: Quantum error correction (QEC) and AI-driven scientific discovery — specifically, using large language model (LLM) agents to design quantum low-density parity-check (qLDPC) codes that perform well at the circuit level on realistic hardware.

Technical level: Intermediate. The core ideas (code-level vs. circuit-level performance, logical error rate, syndrome extraction) are explained self-containedly, but the paper assumes some familiarity with stabilizer codes, qLDPC constructions, and decoders.

Scope: The paper presents OmniQEC, an LLM-orchestrated "AI scientist" that searches four qLDPC code families across 14 physical-qubit budgets and three LLM backends, optimizing directly for circuit-level logical error rate rather than algebraic code-level proxies.

What This Paper Is About

Most automated searches for quantum error-correcting codes rank candidates using purely algebraic quantities — block length, logical qubit count, distance, or a proxy such as Φ_code = kd²/n. But what a code looks like on paper does not determine how it performs once syndrome extraction circuits, native gate sets, ancilla budgets, and a real decoder are involved. OmniQEC closes that gap by treating code discovery as an autonomous generate–evaluate–refine loop in which an LLM orchestrator proposes construction programs, cheap code-level tools screen them, and expensive circuit-level simulation with decoders decides which candidates actually survive. The goal is codes that fit within a fixed total physical-qubit budget and deliver lower logical error rates than the standard bivariate-bicycle (BB) benchmarks.

Key Contributions

1. An AI-scientist architecture for QEC discovery. OmniQEC couples an LLM-based orchestrator to a code-search agent and three purpose-built modules (code characterization, circuit synthesis, circuit evaluation), with a self-evolving discovery memory that accumulates evidence across iterations and feeds it back into candidate generation.

2. A slow–fast dual-loop workflow. A fast loop screens large populations of candidates in seconds using code-level properties (validity, k, d, Φ_code), while a slow loop compiles selected codes into noisy Stim syndrome-extraction circuits and estimates circuit-level logical error rate via decoders such as BP+OSD, BP+LSD, and Relay-BP. This allocation makes direct circuit-level optimization computationally tractable.

3. A resource–performance frontier from direct LER optimization. Across four qLDPC families (BB, trivariate-bicycle, lifted-product, generalized lifted-product) and three LLM backends (Claude Opus 4.8, DeepSeek-V4-Pro, GPT-5.5), discovered codes show steadily improving logical-error suppression as the physical-qubit budget N grows from 20 to 288.

4. Evidence that code-level proxies mis-rank practical performance. The paper documents a systematic mismatch between Φ_code and circuit-level LER, and shows through ablation that removing circuit-level feedback substantially degrades both the quality and the stability of discovered codes.

Main Findings

• Beating the standard benchmarks at lower overhead. All three LLM backends surpass the BB [[72,12,6]] reference, with the first improvement appearing at N = 98 physical qubits — versus the N = 144 required by the BB implementation. GPT-5.5 and Claude Opus 4.8 additionally exceed the BB [[144,12,12]] reference at N = 240, whereas the BB implementation itself requires N = 288. DeepSeek-V4-Pro does not surpass the larger reference within the explored range.

• Approximately linear resource–performance trend. For all three backends, the best discovered codes form a clear frontier with p_LER decreasing approximately exponentially as N increases. The paper notes that the N = 98 crossover lies within the hardware scale of current reconfigurable processors such as Helios.

• The code-level proxy does not predict circuit-level ranking. Φ_code assigns 6 and 12 to the BB [[72,12,6]] and [[144,12,12]] references, yet only one OmniQEC-discovered code exceeds the larger reference on this metric. At N = 144 the best codes found by DeepSeek, Claude, and GPT have Φ_code = 2.25, 5.56, and 3.36 respectively, while all three beat the BB reference in circuit-level LER.

• Advantage persists across physical error rates. Twenty-one frontier codes (seven per backend) were swept over p ∈ [0.002, 0.01] under identical syndrome-extraction and decoding protocols. The strongest candidate achieves an LER 29.23-fold lower at p = 0.002 and 1.66-fold lower at p = 0.01 than the BB [[72,12,6]] reference. Fitted scaling p_LER ∝ p^Γ gives Γ = 5.20 for [[48,4,8]] (GPT), 5.60 for [[58,2,7]] (Claude), and 5.57 for [[48,4,8]] (DeepSeek), versus Γ = 3.79 for the BB reference.

• Both loops are necessary. At the final iteration, the top-five candidates from the full workflow reach mean error suppressions of 4.61 ± 0.54 (Claude), 5.17 ± 0.09 (GPT), and 4.07 ± 0.28 (DeepSeek). The fast-loop-only variant reaches only 2.14 ± 0.10, 3.20 ± 0.40, and 0.84 ± 0.16; the no-feedback variant reaches 3.86 ± 0.66, 4.25 ± 0.19, and 2.83 ± 1.50. Across all backends and checkpoints the full workflow achieves the highest mean suppression (4.27) and lowest variance (0.79), while removing feedback raises variance to 1.24–1.26.

• Exploration–exploitation differs by orchestrator. Claude and GPT converge on BB-dominated constructions, while DeepSeek retains greater diversity across code families but yields a weaker frontier — evidence that stronger reasoning converts circuit-level feedback into better proposals more effectively.

• Cost scales with the LLM backend, not the code size. API token usage varies only weakly with N; Claude offers the most favourable cost–performance balance, and DeepSeek is the least expensive but produces the weakest frontier.

Methodology in Plain English

The system works like a research lab run by an AI manager. A user states an objective — target code family, an optimization criterion, a total physical-qubit budget N, qubit connectivity, native gate set, and available ancillas. The LLM orchestrator turns this into a structured task and then runs 60 iterations per budget.

In each iteration, a code-search agent (a separate LLM) writes executable programs that generate candidate codes; each program is run with 20 random seeds, producing up to 480 candidate instances. Fast, seconds-scale checks throw out invalid codes and compute k, d, and Φ_code, with distance estimated using decoder-assisted tools such as BP+LSD and OSD. Only the top-ranked candidates advance.

Those survivors are compiled into full syndrome-extraction memory circuits: two-qubit interactions are scheduled by edge-colouring the Tanner graph, and the schedule is lowered into a Stim circuit with state preparation, native entangling gates, ancilla measurements, detector definitions, and logical observables. The circuit is converted to a detector error model, sampled under circuit-level depolarizing noise at physical error rate p = 0.005, and decoded (BP+OSD by default) to estimate p_LER, the logical error rate per syndrome-extraction round per logical qubit. This takes minutes to hours, so it is reserved for a small subset.

The resulting circuit-level rankings, together with synthesis and decoding records and the reasoning traces, are written into a discovery memory that shapes the next iteration's proposals. Hyperparameters are fixed across all budgets and backends; the run stops when the objective is met, the iteration limit is reached, or the compute budget runs out.

Why This Matters

Impact on research. The paper reframes QEC code discovery from a purely algebraic exercise into a hardware-grounded co-design problem over code, circuit, and decoder. Its demonstration that Φ_code = kd²/n — widely used in prior automated searches — can mis-rank codes by circuit-level performance is a caution for a whole line of work. It also shows a concrete, tool-grounded way to use LLMs as scientific optimizers where the ground truth is expensive simulation rather than text.

Real-world applications:

• Early fault-tolerant processors. Codes fitted to fixed physical-qubit budgets comparable to the BB [[144,12,12]] implementation (N = 288) are directly relevant to machines in the N ≈ 100–300 range, including reconfigurable platforms such as Helios.
• Memory experiments. The framework targets quantum-memory experiments specifically, producing codes with compiled syndrome-extraction circuits and decoding performance ready for benchmarking protocols.
• Hardware-constrained architecture planning. Because connectivity, native gate set, and ancilla resources are inputs, the search can inform which architectures make a desired code family realizable.
• Decoder-aware code selection. Codes are chosen with a specific decoder in the loop, so the output is a co-designed code–decoder pair rather than a code that must later be matched to a decoder.

Industry relevance. Quantum hardware companies must decide which codes to build into their roadmaps. A tool that ranks candidates by simulated implementation-level error rate, under explicit qubit budgets and gate sets, offers a cheaper alternative to expert intuition for that decision — and the modular interfaces mean new synthesis, simulation, and decoding tools can be dropped in as they improve.

Future Directions

• Faster circuit-level verification. Circuit-level evaluation is identified as the main computational bottleneck. Better syndrome-extraction synthesis, faster simulation and decoding, and more efficient statistical estimation of logical performance would let more candidates be judged on physical evidence rather than proxies.

• From assisted modules to a full multi-agent system. Currently only the orchestrator and code-search agent use LLMs; characterization, synthesis, and evaluation call predefined tools. Upgrading these into specialized agents — for circuit scheduling, flag-qubit placement, and decoder configuration — would enable more autonomous code–circuit–decoder co-design. The authors caution that LLM-as-a-judge biases motivate keeping evaluation grounded in executable tools and verifiable evidence.

• Calibration-aware search. Gate-error maps and disabled qubits or couplers from a specific processor could guide code selection, physical embedding, scheduling, and decoder tuning, moving from hardware-aware to calibration-aware design.

• Broader code families and platforms. Extending beyond BB, trivariate-bicycle, lifted-product, and generalized lifted-product to hypergraph-product codes, two-block group-algebra codes, balanced-product codes, and Floquet codes, and targeting neutral-atom arrays, trapped-ion processors, and other reconfigurable platforms.

Target Audience

Researchers and engineers working on fault-tolerant quantum computing who need codes that survive real circuit-level noise, not just algebraic scoring. It is particularly useful for quantum-architecture and QEC-hardware teams choosing codes under qubit budgets and connectivity constraints, for computer scientists applying LLM agents to scientific optimization with expensive black-box objectives, and for qLDPC theorists interested in why code-level figures of merit fail to predict decoding performance. Graduate students with introductory stabilizer-code background will follow most of it; the full construction details live in the Supplementary Information.

Authors’ abstract

Quantum error correction (QEC) is indispensable for scalable fault-tolerant quantum computing. However, discovering QEC codes that remain effective is challenging, as logical performance depends on the interplay between code structure, hardware, syndrome extraction, and decoding, which often impose competing requirements. Here we introduce OmniQEC, an efficient AI scientist for discovering QEC codes suited to deployment on modern quantum processors. OmniQEC formulates QEC design as an iterative discovery process in which an orchestrator, implemented by advanced large language models (LLMs), coordinates code generation, code-level screening, syndrome-extraction synthesis, and decoder-based circuit evaluation. At its core, OmniQEC combines a self-evolving reasoning mechanism with a slow--fast synergistic workflow: a fast loop explores candidates using inexpensive code-level proxies, whereas a slow loop performs physically grounded circuit-level evaluation and feeds the resulting evidence back into the search. We evaluate OmniQEC across four qLDPC construction families, three LLM backends, and $14$ total-physical-qubit budgets per backend. The discovered codes show steadily improving logical-error suppression with increasing physical-qubit budgets and outperform the BB codes with $[\![72,12,6]\!]$ and $[\![144,12,12]\!]$ under complete-implementation budgets of 98 and 240 physical qubits, respectively. The discovered codes are hardware-friendly and may be of independent interest for practical QEC implementation. These findings pave the way towards LLM-assisted QEC discovery grounded in physically informed code--circuit--decoder co-design.