Large Language Models Discover New Quantum Circuits, Outperforming State-of-the-Art on Seven of Eight Tasks

Quantum computing has long been stuck in a "hardware first, algorithms lagging" phase. Engineering investment in large-scale quantum processors keeps escalating, but achieving practically valuable quantum advantage hinges on one prerequisite: having sufficiently efficient quantum algorithms. Designing such algorithms is precisely one of the most labor-intensive parts of the quantum computing field.

A recent study proposes a new path—letting large language models directly participate in the design and optimization of quantum circuits, with an independent evaluator performing verification and scoring. This approach, called an "evolutionary framework," significantly outperformed current state-of-the-art solutions on seven out of eight cross-domain tasks.

Why Is Quantum Circuit Optimization So Hard?

To understand the value of this work, one must first grasp the unique predicament of quantum circuit design.

In many practical computational problems, resource overhead concentrates on a few computational primitives—Toffoli gates and qubits are the two most critical metrics. In classical computing, engineers can compress gate counts and reuse intermediate variables through various means; but quantum computing has an additional hard constraint: reversibility. Quantum gate operations must be reversible and cannot arbitrarily discard or overwrite intermediate states like classical circuits. This means a large set of classical optimization techniques directly fails, and circuit designers must rebuild algorithm structures within the reversibility framework.

For this reason, quantum circuit optimization has long relied on manual derivation by domain experts and small-scale heuristic search—inefficient, narrow in coverage, and difficult to transfer across domains.

Toffoli gate is a three-qubit controlled gate that flips the target qubit if and only if both control qubits are 1. Its status in quantum computing is analogous to the NAND gate in classical computing—a core building block for constructing universal reversible logic. It has become a focal point of resource optimization because the physical implementation of a Toffoli gate typically requires decomposition into multiple elementary gates (such as CNOT and single-qubit gates), and the resulting gate count and circuit depth directly determine error rates. In fault-tolerant quantum computing, Toffoli gates often involve expensive magic state distillation processes, and their count is a primary metric for assessing algorithm feasibility. Therefore, reducing Toffoli gate count is one of the core objectives of quantum circuit optimization.

Reversibility is a hard constraint of quantum computing: quantum gate operations must be described by unitary matrices, and unitary transformations are mathematically reversible. This means quantum circuits cannot freely use fan-out, overwrite operations, or discard intermediate results like classical circuits. Any intermediate computational state must be fully preserved or precisely reversed through inverse operations. This constraint renders techniques widely used in classical circuit optimization—such as constant propagation and dead code elimination—ineffective in quantum settings, forcing designers to rethink at the algorithmic structure level how to manage intermediate variables and ancillary qubits. It is precisely this constraint that makes quantum circuit optimization a highly non-trivial problem.

LLM as "Proposer," Evaluator as "Judge"

The core idea of this research is not complicated: split the circuit design problem into two independent stages—"generation" and "evaluation."

The large language model is responsible for proposing circuit design schemes. Its advantage lies in training data containing a wealth of algorithm descriptions, mathematical derivations, and engineering code, enabling the model to produce structural combinations that human experts might not think of, based on this cross-domain knowledge reserve.

An independent evaluator is responsible for verification and scoring. The evaluator does not participate in generation; it only performs simulation verification on the LLM's proposals, checking whether circuit functionality is correct while counting Toffoli gate and qubit numbers. High-scoring proposals enter the next round of iteration, forming an evolutionary search loop.

The key to this "generate-evaluate" separated architecture is the independence of the evaluator—it ensures that the LLM's "hallucinations" do not directly translate into erroneous results, as all adopted proposals undergo rigorous simulation verification.

Report Card on Eight Tasks

The research team applied this framework to five categories of tasks with enormous span: numerical computation, chemistry, optimization, quantum simulation, and number theory. This cross-domain choice itself demonstrates the method's ambition for generality—not customized optimization for a specific problem, but an attempt to verify whether LLMs can produce effective solutions across completely different algorithmic contexts.

The results are quite convincing. In eight tasks, seven simultaneously significantly reduced both Toffoli gate count and qubit count, with both key resource metrics outperforming previous state-of-the-art solutions. In quantum circuit design, Toffoli and qubit counts often have a trade-off relationship—reducing one may increase the other. Being able to reduce both indicates that what was discovered is not just parameter-level fine-tuning but improvements at the circuit structure level.

An Unexpected Gain from the Eighth Task

What truly elevates this work beyond "automated optimization" is the eighth task—prime-field modular inversion.

In this task, the search process did not stop at optimizing existing solutions but discovered a completely new reversible architecture. The key innovation of this architecture lies in a fundamental adjustment to how reversibility is handled, making a classical algorithm called divsteps feasible for the first time. divsteps was previously considered impractical in reversible integer arithmetic because its state transitions conflict with reversibility constraints. The new architecture bypasses this obstacle by reorganizing the implementation of reversibility, not only making divsteps usable but also greatly improving the trade-off between Toffoli gates and qubits in modular inversion.

In other words, the combination of LLM plus evaluator did not just find better parameter configurations—it discovered an algorithm structure that humans had not yet proposed.

The divsteps algorithm was originally proposed by Bernstein and Yang in 2019 as an iterative method for computing polynomial greatest common divisors and modular inverses. Its core idea is to progressively reduce the input through a series of simple linear transformations, with each step involving only addition, subtraction, and shift operations—naturally suited for reversible implementation. However, in quantum circuit design, the number of divsteps iterations depends on input data, leading to an uncertain number of intermediate states that is difficult to directly map to fixed-width reversible circuits. Previously, quantizing divsteps required introducing a large number of ancillary qubits to store branch states, with resource overhead far exceeding other approaches, so it was considered impractical. The architecture discovered in this study reorganizes the iterative process, transforming data-dependent branches into predictable sequences of state transitions, thereby bypassing this obstacle and making divsteps feasible in reversible quantum circuits for the first time.

What Does This Mean?

The significance of this work can be viewed at two levels.

At the methodological level, it demonstrates that "evaluator-guided LLM co-design" is a viable path for discovering new algorithm structures. Traditional quantum circuit optimization relies on expert intuition plus local search, whereas LLMs can extract structural patterns from cross-domain knowledge that human experts might overlook, while the evaluator provides a reliable screening mechanism. Together, they form a search paradigm that is both exploratory and controllable.

At the practical level, the significant reductions in Toffoli and qubit counts across seven tasks directly impact resource estimation for quantum algorithms. Under current noisy quantum hardware conditions, fewer gate operations and fewer qubits mean lower error rates and shorter circuit depths, which is crucial for running practical algorithms on near-term quantum devices.

Of course, this framework still depends on the evaluator's simulation capability—for large-scale quantum circuits, classical simulation itself becomes a bottleneck. Additionally, whether the LLM's proposals can maintain their advantages on larger-scale problems requires further verification. But at least, this work has opened a door: LLMs can become participants in quantum algorithm design, not merely code generation tools.

One-line Summary

An evolutionary framework where LLMs generate quantum circuits and an independent evaluator verifies them outperforms state-of-the-art on seven of eight tasks and discovers a novel reversible architecture.

Paragraph Summary

A new study proposes letting large language models directly participate in quantum circuit design, with an independent evaluator performing simulation verification and scoring, forming an evolutionary search framework. Across eight tasks spanning numerical computation, chemistry, optimization, quantum simulation, and number theory, the method significantly reduced both Toffoli gate and qubit counts on seven tasks, surpassing current state-of-the-art solutions. In the prime-field modular inversion task, the framework also discovered a novel reversible architecture that makes the previously impractical divsteps classical algorithm feasible for the first time and greatly improves the Toffoli-qubit trade-off. The separated generation-evaluation architecture ensures that LLM hallucinations do not directly translate into erroneous results. This work demonstrates that evaluator-guided LLM co-design is a viable path for discovering new algorithm structures, though the evaluator relies on classical simulation, which may pose bottlenecks for large-scale quantum circuit applications.