Researchers from Harvard Quantum Initiative for Science and Engineering, Anthropic, and QuEra Computing have developed an evolutionary framework using large language models to design quantum circuits. In seven of eight tested tasks, these LLM-designed circuits significantly reduced both Toffoli gate and qubit counts compared to existing designs.

The work also uncovered a new reversible architecture for prime-field modular inversion, enabling the use of the divsteps algorithm, previously impractical for reversible integer arithmetic, and improving the trade-off between Toffoli gates and qubit counts. These results open the door for evaluator-guided LLM co-design of new algorithmic structures for quantum computation.

LLMs Discover Circuits Reducing Qubit and Toffoli Counts

The efficiency of quantum circuits designed by large language models surpasses current methods in most tested scenarios, with circuits for seven of eight tasks exhibiting reductions in both Toffoli gate count and qubit requirements. This improvement is measured through a metric combining these two factors, the TQ-cost, which the framework uses to evaluate candidate circuit designs programmatically. The system’s evaluator verifies correctness and resource usage, enabling an iterative process where the LLM proposes designs and the evaluator scores them.

This approach allows for exploration of circuit designs beyond those traditionally considered, potentially unlocking new algorithmic structures for quantum computation. A key innovation lies in a newly discovered reversible architecture for prime-field modular inversion, a fundamental operation in number theory. The architecture addresses the challenges of reversibility, a constraint unique to quantum computation, by making the divsteps algorithm viable for reversible integer arithmetic.

The ability to handle reversibility in a novel way is central to this advancement, demonstrating the LLM’s capacity to generate more than just optimized versions of existing circuits. The framework’s resource accounting relies on tracking both Toffoli gate count and peak qubit count, with the latter approximating the logical processor footprint required for execution. Circuits implementing the same specification can vary significantly in their resource demands, and the system allows for exploration of these trade-offs.

For example, the modular inversion search generated a family of circuits along a Toffoli-qubit frontier, and an objective function prioritizing qubit reduction selected a lower-qubit member of that family. This flexibility highlights the potential for tailoring circuits to specific hardware constraints and algorithmic needs. The researchers note that the search is not tied to the specific form of the TQ-cost; it can run with any computable objective, emphasizing the adaptability of the approach. The system encodes each candidate circuit as Python code, allowing for efficient construction and evaluation.

Reversibility Constraints in Quantum Function Evaluation

The framework’s ability to optimize circuits extends to numerical functions used in quantum simulation, mirroring the role of established libraries like libm in classical computing. This suggests a pathway toward accelerating quantum algorithms that depend on these fundamental mathematical operations, potentially streamlining complex simulations. The system’s success in this area demonstrates its versatility beyond specialized number-theoretic problems. Decoding routines, essential for optimization problems, also benefited from the LLM-driven circuit designs.

This architecture addresses a key limitation in constructing efficient quantum circuits for certain types of calculations, opening possibilities for tackling previously intractable problems. The system achieved this by effectively handling the reversibility constraint inherent in quantum computation, a challenge absent in classical computing.

Evaluating Circuit Correctness via Basis-State Reduction

Circuit correctness verification relies on a principle of reduction to computational basis states, simplifying the evaluation process for proposed designs. This approach allows for programmatic assessment because each operation transforms a bit string and its phase without creating superpositions, eliminating the need to track exponentially scaling amplitudes. Instead, a candidate circuit’s action on any input can be simulated by monitoring a bit string and its phase, significantly reducing computational demands during testing.

This efficient evaluator can determine both the correctness and resource expenditure of any candidate circuit, streamlining the iterative design process. The system’s ability to assess circuits in this manner is fundamental to the overall framework, enabling the large language model to propose designs and the evaluator to objectively score them. A specialized optimization was implemented for coordinate arithmetic, bypassing the need for general multiplication, squaring, or reduction circuits. The discovered circuits directly integrate each term of coordinate formulas into the necessary register, streamlining calculations.

By handling reversibility differently, the architecture makes divsteps, a classical algorithm previously impractical for reversible integer arithmetic, viable and substantially improves the Toffoli-qubit trade-off for modular inversion.

LLM Ideation Stage: Exploring Diverse Algorithm Families

Exploring multiple algorithmic families in parallel benefits the search for efficient quantum algorithms, a strategy employed by the LLM in this work. Rather than focusing solely on variations of a single design, the system initially proposed up to five distinct circuit architectures for each task, allowing diverse approaches to mature independently before cross-pollination of ideas. This ideation stage, detailed in Extended Data, involved prompting the LLM to generate these families from the task specification alone, each with its own implementable datapath.

Well-performing candidates were then periodically shared between families, enabling successful concepts from one approach to inform another. This parallel exploration isn’t simply about finding the lowest initial Toffoli gate count. The system allowed circuits to temporarily worsen in certain metrics before ultimately achieving lower overall TQ-cost. The Gaussian lineage, for example, contained descendants that initially increased Toffoli or qubit counts, but eventually converged on more efficient solutions.

The lowest TQ-cost achieved across all families was reported at the end of the search, highlighting the value of maintaining diversity throughout the optimization process. This approach contrasts with traditional methods that might prematurely discard less promising paths. Computational primitives based on classical function evaluation play a central role in a wide range of quantum algorithms. Such primitives include decoding routines for optimization, numerical functions for quantum simulation, arithmetic routines for number theory and quantum read-only memory (QROM), which coherently loads classically specified data into quantum registers.

Conditional Routing Lowers Coherent Control Costs

Conditional routing within quantum circuits offers a pathway to reduce the resources needed for coherent control, as demonstrated by a new approach to circuit design. Rather than separately controlling arithmetic blocks for each branch in a computation, the system uses conditional routing, effectively transforming branch-dependent states into a standardized representation applicable to a single, efficient computation. This technique, reminiscent of bucket-brigade quantum random-access memory, allows expensive kernel computations to appear only once, minimizing control overhead.

The benefits of this approach are quantifiable; for the standard schoolbook construction, conditional routing reduces the Toffoli gate count from 3n² + 17n – 2 to (3n² + 17n – 2)/2. This optimization stems from a principle observed across circuits discovered by the search: replacing conditional arithmetic with conditional routing.

The system achieves this by identifying equivalences in required outputs, allowing seemingly different updates to become instances of the same computation, thereby streamlining the process. “Finding such a decomposition typically takes more than recognizing identical arithmetic in two branches: it exploits an equivalence in the required output so that apparently different updates become instances of the same computation,” the paper explains. This strategy addresses key challenges in coherent compilation, including expressing data-dependent control flow and achieving reversibility without retaining the entire computational history.

The work also reveals that some costs previously attributed to quantum arithmetic may stem from limitations in existing reversible constructions, rather than the algorithms themselves. By jointly choosing the algorithm, representation and uncomputation method, the system recovers efficiencies often lost in naïve reversible implementations. The Berlekamp-Massey and divstep constructions exemplify this, demonstrating how to reclaim advantages inherent in efficient classical methods. These results suggest a broader principle: that careful design can mitigate resource demands and unlock the potential of quantum algorithms.

Bounded Error Improves Modular Inversion Architectures

A newly designed circuit for prime-field modular inversion achieves a substantial reduction in quantum resource requirements by employing a different approach to reversibility, making previously impractical classical algorithms viable. This architecture, discovered through an evolutionary framework pairing large language models with an independent evaluator, allows for divsteps, a classical algorithm for integer arithmetic, to be used effectively in a reversible quantum setting. Beyond modular inversion, the framework demonstrated improvements in other areas of quantum computation.

New Reversible Architecture for Prime-Field Arithmetic

This advancement, achieved through a novel co-design approach, demonstrates a substantial improvement in resource efficiency for a key operation in quantum computation. The architecture’s viability stems from a different handling of reversibility constraints, unlocking a previously inaccessible pathway for this algorithm. This broad applicability suggests the framework can be applied to a range of quantum algorithms reliant on classical function evaluation.

👉 More information
🗞 Discovering state-of-the-art quantum circuits with large language models
✍️ Andi Gu, Susanne F. Yelin and Mikhail D. Lukin (Harvard Quantum Initiative for Science and Engineering, Cambridge, MA 02138, USA); Alek H. Kemeny (Anthropic)
🧠 ArXiv: https://arxiv.org/pdf/2610.22367

More like this