Discovering formally verified quantum programs with AI

Abstract: The timeline by which quantum computers can solve breakthrough problems in science depends on improved quantum algorithms as much as on better hardware. Such algorithmic advances are typically achieved through many years of expert human collaboration. In mathematics and computer science, LLMs have accelerated progress through automated discovery loops. However, quantum algorithms can only be evaluated by classical computers on restricted or small instances. Here we demonstrate automated discovery of quantum programs beyond these regimes including order-of-magnitude improvements on scientific applications. To achieve this, we build a quantum program library in the Lean theorem prover in which LLM agents synthesize novel programs against formal problem specifications and verify their correctness and cost. Agent teams collaborate, sharing results and knowledge through wikis and discussing ideas at organized conferences. Our results improve on prior baselines for parallel search (up to 1.4x), quantum arithmetic (290x), and simulations relevant to fusion, photochemistry and drug-metabolism by 11x, 8x and 2.5x respectively. Combining human and artificial intelligence at scale, under the rigor of mathematical proof, lets researchers design algorithms that today's classical and quantum computers cannot test, shortening the path to practical quantum computation.

• The paper introduces a framework that automates the discovery of quantum programs with formally verified correctness and resource bounds, achieving improvements up to 290× in fault-tolerant spacetime cost.
• The use of LLM-based search, a formal quantum programming language, and multi-agent collaboration enables the exploration of quantum programs beyond classical simulation.
• Cross-team interactions, via a shared wiki and scheduled conferences, contribute significantly to cost reductions in discovered quantum programs.

The paper presents a framework for automated discovery of quantum programs whose functional correctness and resource bounds are established by machine-checked proofs. Its central claim is that LLM-based search can be extended beyond classically simulable quantum circuits by combining a formal quantum programming language, quantum Hoare logic (QHL), explicit resource accounting, and multi-agent collaboration. The resulting system is evaluated on parallel Grover search, fixed-point $\arcsin$ evaluation, and three scientific simulation problems involving fusion, photochemistry, and drug metabolism. The reported improvements range from modest asymptotic gains in oracle complexity to a $290\times$ reduction in fault-tolerant spacetime cost.

Problem setting and contribution

Quantum-algorithm development is constrained by a verification asymmetry. Candidate circuits can often be tested numerically only for small instances, whereas the most consequential claims concern asymptotic behavior, thousands of logical qubits, and resource counts far beyond classical simulation. The paper therefore treats formal proof not merely as a post hoc correctness check but as the executable evaluation mechanism within the discovery loop.

The authors implement a Lean library for classical–quantum imperative programs. It supports unitary operations, measurement, reset, classical variables, conditionals, loops, and classical control flow. Specifications are expressed as Lean files containing target correctness theorems and cost bounds, with unfilled definitions and proofs represented by sorry. Agents must supply the program, its claimed resource cost, and the associated proofs. An independent verifier checks the resulting submission against a frozen specification, including the definitions, theorem statements, and allowed axioms. This prevents agents from obtaining apparent improvements by weakening the problem, modifying the cost model, or introducing axioms.

Correctness is formalized through total Hoare triples over classical–quantum states. The logic represents a state as a distribution over classical stores, with a partial density operator associated with each store. Assertions are quantum observables indexed by classical stores, and verification proceeds through weakest-precondition reasoning from postconditions backwards through the program. The framework also supports expected and worst-case resource bounds over measurement branches and loops. For fault-tolerant circuits, the principal metric is spacetime volume, $Q \cdot \mathcal{T}$, where $Q$ is the logical-qubit count and $\mathcal{T}$ is the number of $T$ gates.

This architecture establishes an important separation of responsibilities. Researchers define the semantics, correctness criterion, cost model, and physical assumptions; LLM agents search over programs, decompositions, representations, and proofs; Lean supplies the soundness boundary. The system does not eliminate specification design: it makes the specification the principal human-controlled interface to algorithm discovery.

Multi-agent discovery workflow

The workflow consists of heterogeneous agent teams operating against a common formal specification and verifier. Teams may contain a single iterative agent, hierarchical agents assigned to subroutines, or agents using numerical heuristics, symbolic derivations, circuit synthesis, and Lean proof search. The paper deliberately fixes neither the internal team topology nor the prompting strategy.

Two collaboration mechanisms connect teams. A shared wiki stores verified solutions, reusable Lean lemmas, partial results, and documented dead ends. Scheduled conferences provide a channel for exchanging unverified conjectures, critiques, and proposed mechanisms. Ideas become accepted results only after independent verification. The external comparator is essential because agents can otherwise exploit specification loopholes by altering definitions or cost accounting.

The reported collaboration data suggest that cross-team interaction contributes materially to the final reductions. Across the three scientific applications, $61\%$ of the logarithmic cost reduction after collaboration began is attributed to ideas generated within teams, $15\%$ to wiki or Lean-file reuse, and $24\%$ to conferences. The cross-team share varies substantially: it is $13\%$ for stopping power and $63\%$ for cytochrome P450. In the non-Born–Oppenheimer problem, the leading solution changed teams seven times and combined techniques originating in three teams. These measurements do not establish a causal comparison against isolated teams, but they do show that verified intermediate artifacts and informal critique can be integrated into a cumulative search process.

Main quantitative results

The principal results are summarized below.

Problem	Baseline cost or metric	Verified result	Improvement
Fixed-point $\arcsin$	$>1.08 \times 10^8$ in $Q \cdot \mathcal{T}$	$3.70 \times 10^5$	$>290\times$
Fusion stopping power	$5.42 \times 10^{15}$ in $Q \cdot \mathcal{T}$	$4.98 \times 10^{14}$	$10.9\times$
Non-Born–Oppenheimer dynamics	$4.98 \times 10^{15}$ in $Q \cdot \mathcal{T}$	$6.16 \times 10^{14}$	$8.08\times$
Cytochrome P450	$1.09 \times 10^{12}$ in $Q \cdot \mathcal{T}$	$4.37 \times 10^{11}$	$2.49\times$
Parallel Grover search, find one target	Published protocols	Verified circuits	Up to $1.22\times$
Parallel Grover search, find all targets	Published protocols	Verified circuits	Up to $1.41\times$

The comparisons use refined baselines in several cases. For the scientific simulations, the baselines incorporate methodological improvements published after the original estimates. The P450 comparison also expands the task from estimating only the ground-state energy to estimating every eigenstate within $0.1$ Ha of the ground state, increasing the baseline by $0.85\%$. These choices make the reported reductions more conservative, although they also mean that the comparison is against a constructed baseline rather than a single unchanged prior implementation.

Parallel Grover search

The first algorithmic case study concerns unstructured search with up to $m$ parallel oracle queries per round and $k$ marked items among $N$ candidates. The cost metric is expected oracle rounds in the large-$N$ limit, and the protocols are required to succeed with certainty. The evaluation covers powers of two up to $m,k=1024$.

The verified circuits match the strongest baseline on the $m=1$ and $k=1$ boundaries. They improve on the baseline at $100$ of $121$ grid points for finding one marked item, with a maximum reduction in expected rounds of $1.22\times$. For finding all marked items, they improve at all $110$ multi-target settings with $k \ge 2$, reaching a maximum speedup of $1.41\times$.

The gains result partly from composing known techniques through classical control. Examples include combining domain partitioning or parallel restarts with weak measurements, which reveal partial success information while retaining some coherence. The search also discovers new mechanisms, including coupling pairs of workspace registers so that parallel streams advance two finds simultaneously, and combining weak measurement with zero-query unmarking. The implication is that formal search can identify useful protocol compositions even when the underlying components are already known. However, the gain is measured in oracle rounds under an idealized oracle-dominated model; circuit synthesis, communication, measurement, and hardware costs are outside the stated objective.

Fixed-point $\arcsin$

The $\arcsin$ task evaluates the function on a 25-bit classical input represented in superposition, with uniform error at most $1.25 \times 10^{-7}$ over $[-1,1]$. The published piecewise-polynomial construction has a cost exceeding $1.08 \times 10^8$ in $Q \cdot \mathcal{T}$.

This problem permits a two-stage search. First, agents are restricted to the kickmix gate set, for which candidate circuits can be verified through fast classical simulation. That phase reduces the cost to approximately $4.15 \times 10^5$, using $4{,}152$ $T$ gates on $100$ qubits. Formal Lean search then removes the kickmix restriction and discovers a circuit with $3{,}698$ $T$ gates on the same number of qubits, corresponding to $3.70 \times 10^5$ spacetime cost. The final result is therefore more than $290\times$ below the baseline.

The mechanism responsible for the final improvement is localized: the coefficient-lookup component uses $33\%$ fewer gates, reducing the total cost by a further $11\%$ relative to the best kickmix solution. This case demonstrates a hybrid strategy in which numerical testing provides high-throughput exploration inside a simulable subspace, while formal verification permits subsequent escape from that subspace. It also supports the paper’s claim that classical simulation alone is not an adequate discovery criterion when useful circuits employ gate sets or structures that are difficult to simulate.

Fusion stopping power

The fusion application simulates an $\alpha$ particle and $218$ electrons moving among $216$ fixed protons. The specification requires approximation of the time-evolution operator $e^{-iHt}$ with error $10^{-2}$ on every antisymmetric same-spin electron state. The complete stopping-power estimate repeats the evolution $500$ times.

The baseline uses $5{,}650$ logical qubits and has a cost of $5.42 \times 10^{15}$ in $Q \cdot \mathcal{T}$. The discovered program uses $4{,}374$ logical qubits and reduces the cost to $4.98 \times 10^{14}$, a $10.9\times$ improvement. More than $90\%$ of the baseline normalization parameter $\lambda$ arises from electron–proton and electron–electron interactions. The central improvement is to apply these interactions in a real-space grid after a quantum Fourier transform rather than entirely in the momentum basis.

This representation exposes Pauli exclusion structure. At most two opposite-spin electrons can occupy a grid point, allowing a phase-kickback construction to prevent configurations with three or more electrons at one point from determining $\lambda$. The number of qubitized walk steps falls by $12.8\times$, while the $T$-gate cost per step increases by a factor of $1.52$. The net result is favorable because reducing the walk length dominates the per-step penalty.

A second improvement stores the total electron momentum in a $42$-qubit register between walk steps. Reusing this register halves the frequency of momentum recomputation and reduces the per-step $T$ count by an additional $10\%$. These improvements illustrate the importance of optimizing the algorithmic representation of the Hamiltonian rather than merely simplifying local arithmetic.

Non-Born–Oppenheimer molecular dynamics

The second scientific simulation treats both electrons and nuclei quantum mechanically for $\mathrm{C_{23}H_{20}N_3O}$. The system contains $187$ electrons and $47$ nuclei, corresponding to $5{,}616$ system qubits. The circuit must simulate $1$ fs of time evolution with error $10^{-2}$ for every input state.

Relative to a refined baseline of $4.98 \times 10^{15}$ in $Q \cdot \mathcal{T}$, the discovered circuit achieves $6.16 \times 10^{14}$, an $8.08\times$ reduction. Three mechanisms dominate the result.

First, interacting coordinates are loaded into ancilla registers rather than swapped into fixed locations and then restored. The ancillas are cleared by measurement-based uncomputation, avoiding the cost of reversibly reconstructing the original data. Second, the reciprocal distance $1/r$ is approximated through a piecewise Bernstein polynomial in $r^2$, implemented using comparisons and table lookup rather than multiplication. The approximation is realized in expectation through randomized sampling. Third, fixed nuclear charges are implemented by creating a uniform superposition and using reversible Boolean logic to assign $Z_n$ branches to a nucleus, replacing alias sampling for unequal charge weights.

The paper’s collaboration analysis is particularly detailed for this task. It reports that verified ideas propagated through seven team changes, and that the final circuit incorporates mechanisms originating from several independent groups. The result supports the claim that the wiki and conference layers can preserve algorithmic lineage while allowing successive teams to improve qubit, gate, and proof costs.

Cytochrome P450

The P450 task targets Compound I, a reactive intermediate whose closely spaced spin states are difficult to order reliably with approximate classical methods. The formal problem uses $63$ electrons in $58$ orbitals and requires estimating every eigenstate within $0.1$ Ha of the ground state to root-mean-square error at most $1$ mHa, including approximation errors.

The baseline is $1.09 \times 10^{12}$ in $Q \cdot \mathcal{T}$ on $481$ logical qubits. The verified program reduces this to $4.37 \times 10^{11}$, or $2.49\times$. More than $95\%$ of the per-step $T$-gate reduction comes from changing the representation of Hamiltonian terms. The baseline stores the selected term in a binary encoding and uses a $247$-qubit QROM register to retrieve rotation angles. The discovered implementation uses a one-hot register: each term has a dedicated qubit, and Clifford operations condition the relevant rotations directly on these qubits. A mixed binary/one-hot strategy supplies both term weights and rotation angles.

This result is notable because an earlier analysis had found one-hot encoding narrowly inferior due to its qubit overhead. The discovered construction reverses that conclusion under the present cost model by exploiting the encoding for multiple purposes simultaneously. The implication is not that one-hot representations are generally superior, but that their value depends jointly on the qubit budget, the compilation model, and the number of downstream operations that can reuse the representation.

Scientific and methodological significance

Across the scientific applications, the reductions are not produced by a single general-purpose circuit optimizer. They arise from changes in physical representation, Hamiltonian decomposition, probabilistic subroutines, ancilla management, and data encoding. The formal framework enables these heterogeneous changes to be evaluated under a single correctness contract.

The paper’s strongest methodological claim is that formal verification enlarges the searchable domain beyond circuits that can be tested by classical simulation. This is particularly relevant for asymptotic algorithms and applications involving thousands of qubits, where numerical validation cannot inspect the intended operating regime. The system also turns resource accounting into a theorem rather than an external estimate. A candidate is accepted only when its claimed qubit and gate bounds follow from the formal program and cost semantics.

The collaboration results provide a second contribution. Verified code, lemmas, and partial proofs can be reused by independent teams without relying entirely on manual code review. Informal conference suggestions remain useful because they generate hypotheses that are subsequently converted into formal artifacts. The distinction between unverified proposals and accepted verified results prevents speculative agent output from being conflated with algorithmic evidence.

Limitations and open questions

The paper explicitly identifies several limitations. The discovered programs remain substantially more expensive than projected early fault-tolerant machines, so the reported reductions do not by themselves establish near-term feasibility. The scientific estimates are resource projections under particular Hamiltonian encodings, error tolerances, repetition counts, and fault-tolerant cost models; changes to these assumptions can alter the ranking of algorithms.

The optimization is also bounded by the formal specification. In the non-Born–Oppenheimer task, requiring correctness for all input states includes unphysical states that violate exchange symmetry, potentially inflating the cost. In the P450 task, fixing the Hamiltonian factorization excludes representation improvements that are available in other formulations. Consequently, the measured gains should be interpreted as improvements conditional on the frozen problem definition, not as globally optimal resource requirements.

The current library does not fully model hardware-level constraints such as error-correcting-code choice, qubit routing, layout, correlated noise, or architecture-specific parallelism. Its primary cost metric, $Q \cdot \mathcal{T}$, may be inappropriate when qubits, $T$ depth, routing, or decoding dominate independently. The paper also does not provide a controlled ablation that isolates the contribution of LLM search from human-designed decomposition choices, nor does it establish how performance scales with the number of teams, agents, or verification budget. These leave open a specific empirical question: under a fixed specification and compute budget, what multi-agent architecture and collaboration protocol maximize the probability of discovering a better verified program?

Conclusion

The paper demonstrates a concrete integration of LLM search with formal quantum-program verification. Its Lean/QHL framework supports correctness proofs, resource accounting, and independent audit of agent-generated programs, while the multi-agent workflow enables verified ideas and partial results to accumulate across teams. The resulting programs improve parallel Grover search by up to $1.41\times$, fixed-point $\arcsin$ by more than $290\times$, and three scientific simulation workloads by factors of $10.9$, $8.08$, and $2.49$. The results establish formal verification as a practical discovery constraint for quantum algorithms whose behavior cannot be validated through classical simulation, while leaving specification quality, hardware-aware modeling, and controlled evaluation of agent collaboration as central unresolved issues.