Claude自主優化八類量子電路設計

ScienceDesigning more efficient quantum circuits with ClaudeOct 16, 2026Quantum computers will need carefully designed circuits to run useful algorithms on limited hardware.

We gave Claude plain-language specifications for eight such circuits, drawn from chemistry, optimization, physics simulation, and number theory, along with an automated evaluator that checks and scores each design.

Working largely on its own, Claude found designs that improve on the best published circuits, in some cases by an order of magnitude or more.

Such improvements substantially reduce the quantum resources that useful applications require, so practical quantum computers could arrive sooner than previously anticipated.

This work was led by Andi Gu as part of Anthropic’s STEM Fellows Program, with mentorship from Alek Kemeny, a quantum physicist at Anthropic, in collaboration with Susanne Yelin (Harvard University) and Mikhail Lukin (Harvard University and QuEra Computing).Read the full paper on arXiv.

Unlike classical computers, which store information in bits whose value is either 0 or 1, quantum computers store information in qubits, which can be built from single atoms, superconducting circuits, or particles of light.

These qubits make use of quantum phenomena such as superposition—which allows a quantum system to exist in a combination of states at once—in order to process information in ways that could make certain problems in fields like chemistry, materials science, and number theory tractable, even when they are too hard for traditional computers.

The quantum computers the field has built to date only have hundreds to thousands of qubits—too few to run many of the algorithms that promise practical advantages over classical computers.And these qubits are highly sensitive to environmental noise, such as heat, vibration, and even cosmic rays.

A tiny disturbance can nudge a qubit’s state, and these small errors pile up until the computer gives the wrong answer.

Given that both qubits and computing time are scarce resources, researchers have been working to redesign quantum algorithms to use fewer qubits and complete computations in less time.

An illustrative example is simulating FeMoco, the iron–sulfur cluster at the heart of nitrogenase, the enzyme that bacteria use to turn nitrogen from the air into ammonia.

Understanding how it works could help scientists design better industrial catalysts—the substances manufacturers use to speed up chemical reactions.

In 2017, researchers estimated that a quantum computer would need about 50 trillion Toffoli gates to compute FeMoco’s ground-state energy—the energy of its most stable configuration, which chemists need in order to predict how FeMoco reacts.

(Similar to ordinary computers, quantum computers work by applying a long sequence of simple operations, called gates, to their qubits.The Toffoli gate is one of the most expensive gates to run, so counting Toffoli gates is a standard way to estimate how long a computation will take.

)Through a series of algorithmic advances, the estimated number of gates has come down to about 340 million—a roughly 150,000-fold reduction, corresponding to a few hours of computation on a future machine with about three million physical qubits.

1 These reductions largely came from redesigning the circuits that carry out the computation, rather than from making better hardware.

Claude has proven particularly adept at optimizing classical algorithms, so we wanted to see whether it could do the same for quantum algorithms if it were given only a plain-language description of what each circuit must compute.Claude is unusually well suited to this task, for several reasons.

First, quantum algorithms are implemented as quantum circuits.These are composed of sequences of gates, like the Toffoli gates mentioned above.

Importantly, these circuits can be described in code, so we can make use of Claude’s coding capabilities to write, run, and revise circuit designs as ordinary programs.

Second, the (fairly common) class of quantum algorithms we were most interested in optimizing can be tested efficiently for correctness, as each input gives one definite output that an ordinary computer can check.This means we could have an external evaluator program validate Claude’s proposals.

Finally, we can give Claude a clear, objective score to improve: the number of qubits used, multiplied by the number of gates, which serves as a proxy for how long the circuit would take to run.

We found that Claude Mythos 5 could successfully work in a closed loop, proposing a circuit design, receiving feedback and a score from the evaluator program, and using that feedback to improve its next attempt, with no human input between rounds (see Figure 1).

Across eight computational primitives—the basic routines that larger quantum algorithms are built from—for chemistry, optimization, quantum simulation, number theory, and numerical computing, Claude discovered novel designs that used both fewer qubits and fewer gates than the best previously published algorithms (Figure 2).

In each case, the improvement resulted from uncovering new structural and mathematical insights about the problem, rather than from fine-tuning existing designs.

For example, when compiling a circuit for simulating an iron-sulfide molecule, Claude noticed that the molecule’s symmetries and repeating structure meant that some results could be calculated once and reused, rather than recomputed for every part of the system.

In other cases, it found that existing circuits included costly components that were needed to handle only extremely rare inputs, and it redesigned them without those components.Below, we describe two of Claude’s discoveries.

The first is a new way to perform modular inversion, a bit of arithmetic that is the most expensive step in elliptic-curve calculations.The second makes the costliest step of a leading quantum optimization algorithm about 12x cheaper.

These results suggest that AI can now help redesign quantum circuits, a key step in making quantum algorithms faster and easier to run.

Faster circuit design could bring the problems quantum computers are meant to solve—from designing new medicines and better batteries to finding cleaner ways of making fertilizer—within reach sooner.Figure 1: Closed-loop quantum circuit optimization.

Claude designs new implementations in Python, which are then sent to a programmatic evaluator.The evaluator checks whether the proposed implementation is correct, then scores it on the number of qubits and gates it requires.

This information is then sent to Claude, which uses it to improve its implementation.The code and values shown are illustrative.Figure 2: Claude designed smaller and faster circuits across eight different quantum-circuit design tasks.

Gray marks show the best previously published designs; orange marks and lines show Claude’s designs.Point addition, the eighth task, is compared in Table 1 below.A new reversible algorithmDesigning a quantum circuit involves two constraints that ordinary programming doesn’t have.

The first is that a quantum circuit can’t make “if-then” decisions the way an ordinary program can.An ordinary program can check a value and then run only one of two pieces of code.

But a quantum computer runs on a superposition of many inputs at once, some of which would run the first piece of code and some of which would run the second, so the circuit has to include the operations for both every time it runs.The second is that a quantum circuit can’t discard information.

An ordinary program can overwrite or delete its scratch work once it’s completed it; in a quantum computer, such intermediate information can’t simply be erased, because every step of a quantum circuit must be reversible.

Leaving that information in place isn’t an option, either, because leftover scratch work would corrupt the final result.The only way to discard information is to “uncompute” it by running the computation that created it in reverse, at the cost of additional gates.

Both of these constraints make quantum circuits far more expensive, in both runtime and qubits, than their classical counterparts.This constraint forces a difficult trade-off between space (i.e., qubits) and time.

At one extreme, a quantum circuit can uncompute intermediate results as soon as they have been used.This frees up qubits, but if those same results are needed again later, the circuit must recompute them, which adds gates and increases the runtime.

At the other extreme, the circuit can retain intermediate results until they’re no longer needed.This avoids repeating work, but it can require many more qubits.This is what makes quantum circuit design an especially interesting test of Claude’s capabilities.

The circuits can be written as ordinary code, but improving them requires the model to reason under a set of constraints quite unlike those of ordinary programming.

A hard first test: modular inversionThe first task we gave Claude was point addition, a rule for combining two points on a mathematical curve (an elliptic curve) to produce a third.

Point addition is the core step in quantum algorithms for the discrete logarithm problem on elliptic curves: given a starting point and the result of adding it to itself n times, find n.

For large curves, ordinary computers can’t solve this problem in any reasonable amount of time, but a sufficiently large quantum computer could.These algorithms perform point addition many times over, including in reverse, and these additions account for most of their qubit and runtime costs.

Problems like this—easy to compute, extremely hard to reverse—were among the first where quantum computers were shown to offer an exponential speedup over ordinary ones.For these reasons, point addition has become one of the field’s standard benchmarks.This made it a demanding test for Claude.

So, we asked it to map out how few qubits, as well as how few gates, point addition really needs.We gave Claude a one-paragraph brief.

It explained the mathematical rule for point addition, and how the evaluator would check each proposed circuit for correctness and score it on the number of qubits and gates it used.It also instructed Claude to explore several approaches in parallel.

After working for 53 hours with minimal human input (limited to the initial brief and occasional prompts to think more broadly), Claude arrived at a completely new approach to the problem.

The memory demands of divstepsMost of the cost of point addition comes from a single step, called modular inversion.Elliptic-curve arithmetic uses numbers that wrap back around when they reach a fixed limit.

Modular inversion is the wraparound version of division: given an integer a, find x such that ax ≡ 1 (mod p).Ordinary computers can perform this operation efficiently using a method called divsteps.Divsteps starts with a pair of numbers and repeatedly simplifies them over many rounds of iteration.

In each round, divsteps examines the current pair of numbers and conditionally swaps, adds, subtracts, or halves them.Along the way, it preserves just enough information to produce the modular inverse at the end.

Despite its success on ordinary computers, divsteps had not yet produced a practical quantum circuit, because of the reversibility constraint described above.

The record of which operation was chosen at each iteration, called branch information, is the kind of scratch work that a traditional program can simply discard.In contrast, a quantum circuit has to retain that record so the computation can be run backward.

A straightforward quantum version of divsteps is therefore forced to accumulate a long history of branch information, which requires an enormous number of additional qubits to store.

How Claude got around the memory problemClaude recognized that this divsteps approach could be promising for quantum circuits, but only if there were a way around needing to store the f