Claude-Designed Quantum Circuits Need a Cost-to-Verification Ledger

Anthropic reports that Claude-designed circuits improved the logical resource frontier across eight quantum-computing primitives. Seven tasks reduced both Toffoli count and peak qubits; the eighth introduced a reversible modular-inversion architecture with new space-time trade-offs. The strongest lesson is the evaluator-guided discovery loop. The main caveat is equally important: a lower Toffoli × qubit score is one layer of evidence, not proof of faster useful computation on physical hardware. Every result needs a ledger connecting objective, correctness, failure budget, search cost, logical resources, and hardware consequences.

What the study actually did

The paper defines eight compilation tasks drawn from numerical computation, chemistry, optimization, quantum simulation, and number theory. Each search begins with a handwritten specification and a blank high-level Python program. Claude Mythos 5 proposes several algorithm families, revises candidate programs, and receives feedback from a programmatic evaluator.

The evaluator has two jobs:

• reject candidates that violate the functional contract;
• count executed Toffoli gates T and peak logical qubits Q, then rank valid candidates primarily by TQ.

This works for the selected class of circuits because they coherently compute a classical function. On a computational-basis input, the allowed operations can be simulated by tracking a bit string and phase instead of an exponentially large state vector. The evaluator checks output values, preservation of required inputs, return of every ancilla to zero, and exact phase behavior on sampled trajectories.

The search is evolutionary rather than one long conversation. Each iteration starts a new model session with a task specification, a parent program, evaluator feedback, selected alternatives, and compact notes from earlier attempts. MAP-Elites preserves candidates in different regions of the (T,Q) plane so a space-efficient design can survive even when its current product score is worse.

That architecture is the important system result: the model is free to make broad, unsafe proposals because an external-to-the-model evaluator filters completed designs. The evaluator is independent from the proposing model, but it was designed and operated by the same research project; this is not the same as independent external reproduction.

The reported gains are real logical-circuit gains

The paper's headline table reports substantial improvements. For the Reed-Solomon decoder used in decoded quantum interferometry, the baseline is about 5.1 million Toffoli gates and 1,938 qubits. The discovered design uses about 440,000 Toffolis and 1,837 qubits, a 12-fold improvement in TQ.

For prime-field modular inversion, the search found a new reversible use of divsteps. Rather than store every branch decision for later uncomputation, the circuit reconstructs many decisions from the current arithmetic state and stores only the hard cases. This yields a family of designs. One highlighted point uses 12% more qubits than the smallest prior point-addition design but 17 times fewer gates.

The improvements emerge from three recurring moves:

1. Route data through one shared expensive operation instead of controlling several duplicate arithmetic blocks.
2. Recover branch history from invariants in the current state instead of storing a full history stack.
3. Spend a declared failure budget to remove resources needed only by rare, expensive inputs.

These are algorithmic and representational changes, not minor gate deletion. They expand the logical Pareto frontier under the paper's circuit model.

Why TQ is useful and incomplete

Toffoli gates are costly in fault-tolerant architectures because they consume non-Clifford resources. Peak logical qubits approximate processor footprint. Their product rewards circuits that improve time and space together and discourages moving all cost from one axis to the other.

But TQ remains a proxy. Two circuits with the same product can have very different deployment implications. One may require more parallel magic-state factories; another may increase routing, measurement latency, classical feed-forward, or code-distance requirements. Hardware connectivity and architecture can change which design wins.

The paper handles this limitation partially by retaining a Pareto set rather than only one scalar winner. Decision-makers should continue that practice through the physical stack. A logical-circuit improvement becomes an application improvement only after resource estimation maps it to:

• physical qubits and code distance;
• magic-state production and scheduling;
• routing and connectivity overhead;
• measurement and feed-forward latency;
• total runtime and energy;
• end-to-end algorithm success probability.

The bottleneck can move after each optimization. A 12-fold cheaper decoder matters most when decoding dominates the target DQI instance. Once reduced, another stage may control total runtime.

Failure budgets are part of the price

Some gains deliberately exchange worst-case support for bounded error. This is legitimate quantum-algorithm engineering, but the failure allowance belongs next to the resource number.

For the Reed-Solomon decoder, a naive reversible Berlekamp-Massey implementation could require 35 stack entries, or 665 qubits, for rare update histories. The discovered circuit reserves one 19-qubit entry. Anthropic's article says roughly one in 10,000 sampled decodings needs more and fails. The paper reports a combined failure probability of 1.4 × 10^-4 across 400 million samples for two relevant decoder failure modes.

The modular-inversion design makes similar bounded choices. It reserves 60 history qubits instead of the observed worst-case 263 and supports a fixed stopping-time window. The paper estimates stack overflow around 2.4 × 10^-6 per inversion and a stopping-time assumption failure around 10^-5, within a total declared budget of 2 × 10^-4.

These probabilities are not hidden defects. They are explicit design parameters. Their system effect still depends on call count, dependence between events, amplification, retry behavior, and the larger algorithm's error budget. A per-call probability that looks small can become material when a subroutine runs many times.

Correctness evidence has multiple levels

The evaluator checks more than final classical output. Dirty ancillas can remain entangled with logical registers, and a wrong phase can corrupt later interference while leaving output bits unchanged. The tests therefore cover output, preserved input, ancilla cleanup, and phase.

For large domains, the evaluator samples trajectories rather than exhaustively testing every input. The paper derives statistical bounds that connect a fixed candidate's all-pass sample to an upper bound on defective probability. The phrase fixed candidate matters: repeated adaptation to a reused test set can leak validation information into search. A final holdout or separately generated test draw is needed to preserve the bound.

The divsteps branch-decoding result receives stronger treatment. The team reports large numerical simulations and a Lean formalization, with a public uncompute proof repository. That raises confidence in a core invariant, but it does not automatically formally verify every gate count, all eight complete circuit generators, the evaluator, or the end-to-end hardware claim.

As of the paper's October 15 arXiv v1, the public source cites OpenEvolve and the Lean repository. It does not present one complete release bundle containing all eight final programs, evaluator snapshots, search archives, prompts, model calls, and historical results. The paper is detailed enough for technical review, while exact independent reruns of the full search remain a separate milestone.

Search cost belongs in the ledger

Anthropic says the elliptic-curve point-addition result came from a 53-hour run with minimal human input after the initial specification and occasional prompts to broaden the search. That is useful timing evidence for one case, not a full cost report for all eight searches.

A scientific optimization system should record:

• model and API snapshot;
• total model tokens, calls, and failed iterations;
• wall-clock and parallelism;
• CPU, GPU, and simulator time;
• number of candidates evaluated;
• human design, intervention, and review time;
• formal-verification and independent-review cost.

Search compute is usually paid once while circuit savings may recur millions of times. This can make expensive discovery rational. The trade is measurable only when both sides share units and an amortization horizon.

The six-layer cost-to-verification ledger

A reusable ledger for AI-designed scientific artifacts should include six linked layers.

Each headline number should link to a row in this ledger. A 12-fold TQ gain can then remain a strong statement without being stretched into a 12-fold application speedup.

What the result changes

This study supports a precise conclusion: evaluator-guided LLM search can discover new logical circuit architectures when the task has an expressive program interface, cheap-enough correctness checks, and an objective that rewards relevant resource trade-offs.

It does not yet establish that useful fault-tolerant quantum computers will arrive on a particular schedule. Circuit design is one layer among error correction, logical operations, control, fabrication, calibration, and application-level economics. The research is valuable because it attacks a real layer with measurable gains and exposes a workflow that may generalize.

The correct response is neither dismissal nor timeline inflation. Freeze the task, publish the evaluator and artifacts, preserve the failure budget, map the Pareto frontier through a hardware model, and ask an independent team to rerun the result. That turns an impressive AI-generated candidate into cumulative scientific evidence.

Frequently asked questions

Did Claude design circuits for a real quantum computer?

Claude generated logical circuit programs under a specified circuit model. The paper evaluates logical correctness and resource proxies, not execution of the full designs on large fault-tolerant hardware.

What does a 12x improvement mean?

For the reported Reed-Solomon decoder, it is approximately a 12-fold reduction in the product of Toffoli count and peak logical qubits relative to the cited baseline. It is not automatically a 12-fold wall-clock speedup.

Were the circuits proved correct?

Candidates passed programmatic tests that include outputs, preserved inputs, ancilla cleanup, and phase. Large domains use statistical sampling. A central divsteps invariant also has a Lean formalization. The proof scope is narrower than complete formal verification of every final circuit and hardware mapping.

Why allow rare failures?

Worst-case inputs can dictate large qubit and gate reserves. If the parent algorithm permits a bounded error rate, omitting machinery for rare cases can reduce cost. The probability and amplification across repeated calls must remain explicit.

Can the full experiment be independently rerun?

The paper, arXiv source, OpenEvolve reference, and a Lean proof repository are public. A unified release of all final programs, evaluator snapshots, search histories, and model-call records is not linked in arXiv v1, so full historical reproduction remains incomplete.

References

• Gu et al.: Discovering state-of-the-art quantum circuits with large language models
• Anthropic: Designing more efficient quantum circuits with Claude
• Lean uncompute proof repository
• Schrottenloher: Optimized Point Addition Circuits for ECDLP
• Luo et al.: Space-Efficient Point Addition for ECDLP
• Jordan et al.: Optimization by Decoded Quantum Interferometry