Quick Take
- The finding: Teams of LLM agents at Google DeepMind and Google Quantum AI found new quantum programs whose correctness and cost are proven in the Lean theorem prover. They cut costs by more than 290× for a fixed-point arcsin routine and by 10.9×, 8.08× and 2.49× for simulations relevant to fusion, photochemistry and drug metabolism.
- Why proofs matter: Quantum programs at the scale of thousands of qubits cannot be tested on today’s classical or quantum computers. A machine-checked proof against a frozen specification replaces the test.
- What it means: Collaboration between agent teams mattered. Averaged over the three science problems, 39% of the cost reduction came from ideas shared between teams through a wiki or scheduled “conferences”.
LLM agents have started to produce new results in mathematics and classical algorithms, mostly where answers can be checked by running code. Quantum algorithms are harder: a program for a fault-tolerant machine with thousands of logical qubits cannot be run anywhere yet. In “Discovering formally verified quantum programs with AI,” 25 researchers from Google DeepMind and Google Quantum AI get around this. They have agents write the program and a Lean proof that it is correct and how much it costs.
What the study shows
Researchers write a Lean specification of what a circuit must do and how its cost is counted, with placeholders for the program and the proofs. Agent teams fill them in. Cost for fault-tolerant circuits is the spacetime volume Q·T: logical qubits multiplied by the number of T gates, the expensive operation on error-corrected hardware.
- Fixed-point arcsin: This subroutine loads numbers into a quantum state. The best published version costs more than 1.08 × 108. Agents first searched a restricted gate set that can be checked numerically in seconds and reached 4.15 × 105. They then used Lean to lift that restriction and got to 3.70 × 105 (3,698 T gates on 100 qubits), more than 290× below the baseline.
- Fusion stopping power: This simulates an alpha particle passing through hydrogen fuel with 218 electrons. Cost fell from 5.42 × 1015 to 4.98 × 1014 (10.9×) on 4,374 logical qubits, against 5,650 in the baseline. The main trick moves electrons onto a real-space grid, where the Pauli exclusion principle can be exploited. That cut the number of walk steps by 12.8×.
- Photochemistry (non-Born–Oppenheimer dynamics): For a 47-nucleus, 187-electron molecule, cost fell from 4.98 × 1015 to 6.16 × 1014 (8.08×).
- Drug metabolism (cytochrome P450): Against a conservative baseline of 1.09 × 1012 on 481 logical qubits, the agents reached 4.37 × 1011 (2.49×).
- Parallel Grover search: The agents matched the strongest published protocols at the edges of the grid and beat them on most multi-target settings, by up to 1.22× (find one) and 1.41× (find all).
| Problem | Application | Baseline Q·T | This work Q·T | Reduction |
|---|---|---|---|---|
| Fixed-point arcsin | State preparation | > 1.08 × 108 | 3.70 × 105 | > 290× |
| α + hydrogen stopping power | Fusion | 5.42 × 1015 | 4.98 × 1014 | 10.9× |
| C23H20N3O non-BO dynamics | Photochemistry | 4.98 × 1015 | 6.16 × 1014 | 8.08× |
| Cytochrome P450 | Drug metabolism | 1.09 × 1012 | 4.37 × 1011 | 2.49× |
The collaboration data is just as interesting. In the photochemistry problem, the leading record changed teams seven times, and the final circuit combines techniques from three teams. The single largest drop (−34%) started as one team’s conference proposal that another team refined and proved.
Why it matters: results that do not depend on trusting the agent
Agents can cheat. They can weaken a theorem, add an axiom or misreport a cost. Here, every submission is replayed in a clean sandbox and checked with the Lean Comparator against the frozen specification. Only standard Lean axioms are allowed, and the proved cost must match the claimed figure. Reviewers only need to check the specification, not thousands of lines of agent-written proof. Baselines are deliberately conservative: for P450, the authors folded later compilation improvements into the published estimate, which roughly halved the cost they had to beat.
Method in brief
- Library: A Lean library built on Mathlib and Physlib’s Lean-QuantumInfo. It combines a classical-quantum programming language, quantum Hoare logic for correctness, and proofs of resource bounds.
- Agents: Seven teams took part. Each researcher chose their own framework, models, prompts and team structure, from a single agent to hierarchical teams. The paper does not name the LLMs used.
- Sharing: A version-controlled wiki holds the best verified solution, reusable Lean lemmas and notes on dead ends; a new record must improve cost by at least 5%. Conferences every four hours let teams critique ideas that are not yet verified.
- Problems: Five tasks, from asymptotic search algorithms to application-scale simulations with thousands of qubits.
What remains open
- Still too big for early hardware: The end-to-end simulations remain far beyond the resources projected for the first fault-tolerant quantum computers. The authors say further orders-of-magnitude improvements are needed.
- Only as good as the spec: Agents cannot optimise beyond the specification. The photochemistry spec demands correctness even on unphysical states, and fixing the P450 factorisation excludes recent representation advances.
- Spec loopholes happened: One example was exploiting how Toffoli gates were counted. Researchers had to close it by revising the specification.
- Reproducibility pending: The Lean library, specifications and verified solutions “will be open sourced shortly”. The models and compute budget per team are not reported.
- Hardware details missing: Error-correcting codes, qubit routing and physical layout are not yet part of the specifications.
Context: from numerical checks to proofs
Earlier AI searches for quantum circuits could only produce what a classical computer could simulate. In the arcsin case that meant a restricted gate set. Concurrent LLM-assisted formalisation work has focused on verifying algorithms that are already known. This paper combines formal verification with open-ended discovery, close in spirit to recent LLM-driven math results such as OpenAI’s AI-generated proofs. Its multi-team setup adds a social layer on top of single-loop systems. For more agent research, see self-improving agent scaffolds and our Agents studies.
What it means for researchers and AI teams
- Verification unlocks autonomy: Where results can be machine-checked, many agent teams can build on each other without human code review. That pattern carries over to software, chip design and mathematics.
- Human work moves upstream: Experts choose problems, write faithful specifications and interpret the results. Spec quality becomes the bottleneck.
- Share negative results: Dead-end notes in the wiki stopped other teams from repeating failed ideas. That is a cheap lesson for any multi-agent setup.
- Quantum timelines: Cheaper algorithms shorten the path to useful quantum computing from the software side. These are resource estimates, though, not runs on hardware.
More from Google on i10X.
About the analysis
Researched and written with AI assistance under the editorial responsibility of the i10X News team. The title image is an AI-generated illustration. Read our AI Use Policy. Spotted an error? Request a correction.
This article is based on the full text of Shirobokov, Jaderberg, Hristova, Tsoukalas, Bausch et al. (2026), “Discovering formally verified quantum programs with AI,” arXiv:2611.09822v1 (quant-ph, submitted November 6, 2026), including the main results, the discussion and the appendices on verification and multi-agent orchestration. All numbers come from the paper; i10X did not rerun any proofs. The paper is licensed CC BY 4.0; the chart was redrawn by i10X from Figure 5b. The authors are with Google DeepMind and Google Quantum AI; three worked as research consultants on assignment at Google. No funding or conflict-of-interest statement is included. AI tools assisted with research and drafting; selection, fact-checking and final editing were done by the i10X editorial team.
i10x Perspective
The headline numbers are impressive, but the bigger idea is the workflow. Formal proofs turn agent output from “plausible” into “checked”, and that is what lets many agent teams share work safely at scale. The open question is who writes the specifications, because that is now where both the leverage and the risk sit. We will watch whether the Lean library ships as promised and whether outside groups can reproduce the gains.
