Claude cut a quantum circuit's gate count 17-fold by learning what it could uncompute

In classical computing, scratch memory is free. A program writes intermediate values to a stack, finishes, and the stack is discarded. Quantum circuits cannot do that: a qubit cannot be quietly deleted, because deleting a quantum state is itself an operation that has to be reversible.

That constraint is the quiet bottleneck in circuit design. Every temporary value a circuit needs must be stored in an extra qubit, and those qubits are the scarcest thing in the machine. The standard escape is to run the computation backwards at the end, restoring the scratch qubit to its original state — a technique called uncompute — but the circuit still has to know how.

A preprint posted to arXiv on 15 October by Andi Gu and three co-authors at Anthropic and Harvard handed that problem, and seven others, to Claude Mythos 5.

Eight problems, one evaluator loop

The setup was not a chat. The model wrote code describing a circuit; an automated evaluator checked it, counted qubits and Toffoli gates, and returned a score so the model could improve on the next attempt.

Seven of the eight resulting designs reduced both qubit count and Toffoli count against previously published constructions. The eighth produced a new way to make a computation reversible.

The headline case is point addition on an elliptic curve — the arithmetic underneath much of modern public-key cryptography. Storing the full history of that computation is expensive. Claude's approach was to infer the operation it had just performed from the state that remained, rather than record every step. Early rules worked on small numbers and failed at 256 bits; the model then worked through the algebraic relations to find rules that held at full width.

After 53 hours of search, seeded with a problem statement and a few human hints, it produced a family of designs rather than a single answer.

What the trade actually looks like

The comparison is the interesting part, because it shows that "better" depends on which resource you are short of.

Claude's design uses 935 qubits and about 4.01 million Toffoli gates. The Luo construction needs fewer qubits — 838 — but 69.53 million gates, roughly 17 times more. A third approach, by Schrottenloher, gets down to 1.9 million gates but spends 1,446 qubits to do it.

Read plainly: the model did not beat both alternatives on both axes. It found a different point on the same curve, and the point it found is the one that most existing hardware would prefer.

A second result, and its failure rate

The paper also reworks a Reed-Solomon decoder used inside a quantum optimisation algorithm. By recovering intermediate results from the current state instead of keeping them, the design reduces the number of spare qubits the algorithm must hold in reserve.

The authors report that across 403 million simulated runs, about one in 10,000 needed more than the 19-qubit allowance and could have failed. The revised design cuts Toffoli gates by roughly 12 times.

That failure rate is the honest part of the result. A design that is cheaper on average but fails occasionally is a different product from one that is more expensive and always works, and the paper does not hide the difference.

What has not happened yet

None of this has run on quantum hardware. The circuits were checked by program and by simulation. The Lean proof assistant verified some of the key mathematical claims, not the whole circuit. And the manuscript has not been peer reviewed.

Those caveats matter more than usual here, because the numbers are resource counts rather than measured performance. A gate count is a property of the design; whether the design survives noise, calibration drift and the compiler's own optimisations is a question only a machine can answer.

Why it is still worth noting

The interesting claim is not that a model designed a better circuit. It is that circuit design has a cheap, automatic scoring function — count the qubits, count the gates — and that a model can be dropped into that loop and left to search.

Where a field can score its own outputs, AI can iterate against the score. Quantum circuit synthesis is one of the few areas of physics where the score is unambiguous and the search space is enormous, which is close to the ideal case. Most of engineering is not like that, and the paper does not pretend otherwise.

What it shows is narrower and more useful: when the objective is countable, the model can spend 53 hours doing what a graduate student would spend a year on, and come back with a family of designs to check.

Source: preprint by Andi Gu and co-authors (Anthropic, Harvard), arXiv, 15 October 2026, as reported by Tuoi Tre.

Contact: [email protected]