Discovering state-of-the-art quantum circuits with large language models

Abstract: Significant efforts are currently being directed toward the implementation of large-scale quantum information processors, but realizing useful quantum advantage also requires the development of efficient quantum algorithms. While for many practical problems the dominant resource costs are associated with a small set of computational primitives, optimizing them in the quantum setting presents unique challenges, including a reversibility constraint absent from ordinary classical computation. Here we introduce an evolutionary framework in which LLMs propose circuit designs and an independent evaluator verifies and scores them. We apply this framework to tasks spanning numerical computation, chemistry, optimization, quantum simulation, and number theory. In seven of the eight tasks, the discovered circuits significantly reduce both Toffoli and qubit counts relative to the state of the art. In the eighth, the search discovers a new reversible architecture for prime-field modular inversion. 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. These results open the door for evaluator-guided LLM co-design of new algorithmic structures for quantum computation.

• The paper presents an evaluator-guided evolutionary framework for discovering reversible quantum circuits.
• This framework uses a Large Language Model (LLM) to generate algorithmic designs for the circuits and evaluates their correctness and resource costs programmatically.
• The methodology results in improved Toffoli Count QuM Quotient ($TQ$)-cost for several tasks, with the most significant reduction of 39x for fixed point Gaussian function evaluation.

Problem formulation and methodological contribution

The paper presents an evaluator-guided evolutionary framework for discovering reversible quantum circuits in which a LLM generates algorithmic designs and an independent programmatic evaluator verifies correctness and computes resource costs (2610.22367). The central premise is that quantum compilation cannot be reduced to local gate rewriting. A useful circuit may require simultaneous changes to the classical algorithm, data representation, reversible control flow, workspace allocation, approximation strategy, and uncomputation schedule.

The target class consists primarily of reversible embeddings of classical functions,

$\ket{x}\ket{y}\mapsto\ket{x}\ket{y\oplus f(x)},$

possibly augmented by phase operations and measurement-based uncomputation. Candidate circuits are represented as Python programs using named registers, loops, reusable subroutines, allocation and deallocation operations, Toffoli gates, Clifford operations, and corrected $X$-basis measurements. This representation preserves algorithmic structure and allows a single conceptual modification to affect many circuit locations coherently.

Correctness is evaluated on computational-basis trajectories. Because the permitted operations preserve computational-basis states up to phase before measurement, the evaluator can track bit strings and phase bits rather than exponentially large amplitude vectors. It checks the output permutation, phase, preservation of input registers, ancilla cleanliness, and consistency across measurement records. The resulting guarantee is stronger than checking only classical outputs: a dirty ancilla or an incorrect phase can entangle with the logical state or corrupt later interference while leaving measured output bits apparently correct.

The resource objective is

$TQ = T\times Q,$

where $T$ is the Toffoli/CCZ count and $Q$ is peak logical-qubit usage. The authors explicitly treat this as a tunable objective rather than a universal hardware metric. To avoid convergence to a single local architecture, the search begins with LLM-generated ideation across distinct algorithm families. These families are evolved independently and periodically exchange strong candidates. MAP-Elites preserves candidates occupying different regions of the Toffoli–qubit resource plane, allowing a higher-$T$ but lower-$Q$ design to remain available for later recombination.

The framework therefore searches over algorithmic programs rather than flattened gate sequences. Its principal limitation is also methodological: the evaluator, task interface, objective, input distribution, and permitted representation determine the space of discoverable solutions. The reported results demonstrate the capability of the framework within those boundaries, not unrestricted quantum algorithm discovery.

Reversible co-design principles

Three design principles recur across the discovered circuits.

Conditional routing replaces controlled arithmetic. If different branches require equivalent expensive arithmetic on differently organized data, controlled swaps can route the relevant operands into a common arithmetic kernel. For a conditional multiply-add, two controlled multiply-adds can be replaced by a controlled swap, one uncontrolled multiply-add, and the inverse swap. Under the stated schoolbook model, this changes the Toffoli count from $3n^2+17n-2$ to approximately half that value.

Reachable-state invariants replace explicit history. Reversible computation often appears to require storing every branch decision. The paper instead identifies invariants that encode branch history in arithmetic registers. During uncomputation, a decision can be reconstructed from the current state and then erased. This is not a local property of an update rule: it depends on the initialization, the complete forward algorithm, and the set of reachable states.

Failure budgets localize worst-case resources. A circuit must normally support every branch in a coherent superposition, so rare inputs can determine its worst-case schedule and workspace. The discovered designs reorganize computation so that atypical behavior is confined to extra iterations, history entries, carry propagation, or arithmetic ranges. Those resources can then be truncated while assigning the resulting failure probability to an explicit budget. This is a substantive assumption in several results: the strongest resource reductions are distribution-dependent and are not worst-case exact circuits.

Reed–Solomon decoding for DQI

Decoded quantum interferometry requires a reversible Reed–Solomon decoder to remove an error word while retaining its syndrome. The baseline uses a synchronized reversible extended Euclidean algorithm (EEA). For the primary instance, 70 syndromes over $\mathbb F_{2^{12}}$ specify an error pattern of weight at most 35. The reconstructed baseline requires approximately $5.1$ million Toffolis and 1,938 qubits.

The search replaces the EEA locator solve with Berlekamp–Massey (BM), whose forward arithmetic is much cheaper but whose ordinary reversible implementation would retain a history of overwritten locator templates. The discovered circuit exploits the fact that the locator polynomial is needed only up to a nonzero scalar, since rescaling does not change its roots. It rescales the replace branch so that both retain and replace cases share one arithmetic update. It also derives the overwritten discrepancy from the constant coefficient of the updated locator, eliminating the need to store it on most branches.

The circuit further avoids materializing the full decoded error word. DQI requires only a phase parity, so the implementation contracts Forney’s formula directly into a trace-like phase computation. A precomputed reciprocal polynomial replaces a field inversion at every scan position. The evaluator also uses input-distribution-dependent coefficient cutoffs and allocates one discrepancy-stack entry rather than the worst-case 35 entries. The latter reduces the stack from 665 qubits to 19, while inputs requiring more history are allowed to fail.

Figure 1: The reversible Reed–Solomon decoder combines a lower-cost Berlekamp–Massey recurrence, shared updates, adaptive coefficient ranges, and phase-only error recovery.

The resulting decoder uses approximately 440,000 Toffolis and 1,837 qubits. Relative to the baseline, this is a $X$0 reduction in both $X$1-cost and Toffoli count, with a $X$2 reduction in qubits. Across 100,000 complete-circuit tests, seven produced the wrong sign; the paper reports a combined sampled failure probability of approximately $X$3 for the relevant decoder limitations. The implication is that reversible algorithm selection can restore the arithmetic advantage of BM only when its overwrite pattern and reverse computation are redesigned jointly.

The same strategy is applied to the Hermitian-code DQI decoder. A naive reversible Feng–Rao construction uses approximately $X$4 Toffolis and $X$5 qubits. The discovered design casts locator recovery as a null-space problem, applies a Lanczos/block-Lanczos walk without storing the full syndrome matrix, and computes phase contributions in stripes rather than materializing the evaluator globally. It uses approximately 930,000 Toffolis and 2,395 qubits. This corresponds to reductions of roughly $X$6 in Toffolis, $X$7 in qubits, and $X$8 in $X$9-cost relative to the naive reversible baseline. The comparison must be interpreted cautiously: the baseline is explicitly identified as a naive reversible implementation, and the paper states that no prior reversible compilation exists for this case.

Modular inversion and divstep reversibility

The modular-inversion case is the paper’s strongest architectural result. The benchmark is affine point addition on a 256-bit elliptic curve, where the dominant operation is inversion of $TQ = T\times Q,$0 modulo the secp256k1 prime. Existing constructions use binary gcd or packed Euclidean walks. The LLM search instead discovers a reversible architecture based on integer divsteps, a classical algorithm previously considered unsuitable for this reversible setting because its branch history is not naturally stored in space freed by shrinking operands.

The divstep state contains two remainders, two scaled coefficients, and a signed counter. Each step selects among swap, odd non-swap, and even cases. The key result is that branch decisions can be reconstructed from the post-step arithmetic state. Swaps are identified by the 2-adic valuation of one coefficient. Many parity decisions follow from the updated counter or from termination. The remaining ambiguous decisions occur in excursions after swaps.

The paper proves that the ambiguous bit at excursion depth $TQ = T\times Q,$1 is encoded in a low-order window of the coefficient registers. If $TQ = T\times Q,$2 with $TQ = T\times Q,$3 odd, the decision is obtained from a bit of $TQ = T\times Q,$4. This is an exact reachable-state invariant, not a probabilistic heuristic. The circuit compiles shallow decoders directly as Boolean functions and stores only decisions beyond a tunable depth cutoff.

Figure 2: Evolutionary search in the resource plane preserves distinct circuit lineages and discovers designs that move through nonmonotonic Toffoli–qubit trade-offs.

With cutoff $TQ = T\times Q,$5, only $TQ = T\times Q,$6 of ambiguous decisions are stored. A 60-bit history allocation replaces a worst-case requirement of 263 bits for the sampled schedule, saving 203 qubits. The circuit supports 533 divsteps, rather than the worst-case bound of 590, and begins termination testing only from step 499. The associated failure contributions include finite stopping-time, history, carry, comparison, and integer-width limits. The union-bound estimate for point addition is approximately $TQ = T\times Q,$7, consistent with the stated $TQ = T\times Q,$8 target. Four of 100,000 complete point-addition tests failed.

Figure 3: The Euclidean alternative specializes operand-width windows, removes counter tests on typical positions, merges scans, and reduces the complete point-addition construction from roughly 70 million to 21 million Toffolis.

The complete divstep point adder uses 4.0 million Toffolis and 935 qubits. It is not superior to every prior design in Toffoli count: a binary-gcd construction cited in the paper uses approximately 1.9 million Toffolis and 1,446 qubits. Its advantage is a different point on the resource frontier, with substantially lower qubit usage. The claim is therefore not that divsteps dominate universally, but that reversible divstep architecture substantially improves the achievable Toffoli–qubit trade-off and makes a previously impractical classical method viable.

A second search result specializes a packed EEA schedule to the same prime. It reduces a reconstructed 69.5-million-Toffoli baseline to 20.5 million Toffolis using 843 qubits, a $TQ = T\times Q,$9 Toffoli reduction for only five additional qubits. This design is less algorithmically novel but illustrates the value of distribution-specific schedule specialization: fitted operand windows, test-free positions, merged scans, measured carries, and sparse-prime reduction together account for most of the reduction.

Numerical function evaluation

Three fixed-point numerical circuits—HHL rotation angles, Coulomb potentials, and Gaussian functions—are derived from piecewise-polynomial approximation but are reorganized for reversible execution. The baseline is the Håner–Roetteler–Svore construction, which uses arbitrary interval boundaries, general Horner evaluation, wide multipliers, and explicit temporary registers.

Figure 4: The HHL circuit uses dyadic interval selection, a shared local coordinate, and direct quadratic accumulation to replace repeated wide polynomial multiplications.

For HHL, the baseline uses cubic fits on 35 arbitrary intervals, 44-bit arithmetic, 16,000 Toffolis, and 300 qubits. The discovered circuit uses 345 dyadic intervals, a shared 15-bit local coordinate obtained by cyclic bit shifts, and quadratic approximations. It accumulates the polynomial directly into the output and fits coefficients to the exact truncated integer computation. The worst-case angular error is $T$0 radians. The circuit uses 1,348 Toffolis and 115 qubits, yielding a $T$1 reduction in $T$2-cost.

For the Coulomb potential, the circuit directly accumulates the three coordinate squares, replaces 16 quadratic intervals with 128 linear intervals, and uses measurement-based uncomputation for the larger lookup. Its worst-case error is $T$3. It uses 1,140 Toffolis and 142 qubits, compared with 6,355 Toffolis and 252 qubits for the baseline, reducing $T$4-cost by $T$5.

For the Gaussian, the circuit folds the input onto the nonnegative axis without an explicit add-one operation, prunes constant and zero regions of the lookup, avoids forming $T$6, and accumulates a quadratic directly into the output. The worst-case error is $T$7. It uses 1,583 Toffolis and 139 qubits, compared with 24,000 Toffolis and 362 qubits, reducing $T$8-cost by $T$9.

The common implication is that approximation degree is not the only relevant optimization variable. A finer partition can reduce total cost when it eliminates wide reversible arithmetic, and a mathematically equivalent approximation can have very different cost depending on whether its intermediate values must be stored and uncomputed.

Chemistry and lattice-gauge circuits

For the $Q$0 alias-select circuit, the search exploits two independent freedoms: permutation of Hamiltonian terms and nonuniqueness of alias-table constructions. Pauli terms related by Clifford frames are grouped into blocks, while alias rows are reordered to create repeated QROM subtrees. The resulting circuit reduces the baseline from 55,000 Toffolis and 139 qubits to 15,000 Toffolis and 126 qubits, a $Q$1 reduction in $Q$2-cost.

Figure 5: Frame-based grouping compresses Select by representing many Pauli terms through shared Clifford transformations and block representatives.

The result depends strongly on structure in the particular Hamiltonian. Two frames arise from exact spin symmetries, while other frames exploit approximate spatial regularities in the molecular data. The optimization is exact for the supplied table, but its compression benefit is not a generic property of arbitrary QROM instances. The paper explicitly notes that spin–orbit or Zeeman terms could remove some of the symmetry-based opportunities.

For the nonabelian lattice-gauge circuit, the task is to accumulate plaquette and rectangle traces over a $Q$3 periodic lattice with 192 links and 576 loops. The baseline computes each loop independently using general group multiplication, inversion, and QROM trace lookup. The discovered circuit changes the representation of the running product, chooses factor orders adapted to repeated updates, reuses partial loop products, and reads the seven-valued trace directly from group coordinates.

Figure 6: Cyclicity and inversion invariance of the real trace allow loop representatives to be reordered so that neighboring products share long path segments.

These changes reduce each running-product update from 146 to 35 Toffolis and reduce the complete circuit from 1.3 million to 170,000 Toffolis. Peak qubits decrease from 1,927 to 1,859, and $Q$4-cost decreases by $Q$5. The result illustrates a broader point: in nonabelian circuits, representation and traversal order can matter more than local optimization of a fixed multiplication routine.

Cross-task results

The principal quantitative results are summarized below.

Task	Baseline $Q$6	Discovered $Q$7	Reported $Q$8 gain
Reed–Solomon DQI decoder	$Q$9	$T$0	$T$1
Hermitian DQI decoder	$T$2	$T$3	—
HHL rotation angle	$T$4	$T$5	$T$6
Coulomb potential	$T$7	$T$8	$T$9
Fixed-point Gaussian	$Q$0	$Q$1	$Q$2
$Q$3 alias–Select	$Q$4	$Q$5	$Q$6
Nonabelian lattice gauge	$Q$7	$Q$8	$Q$9
Prime-field point addition	no single baseline	$3n^2+17n-2$0	—

In seven of eight tasks, the discovered circuit reduces both Toffoli count and qubit count relative to the selected baseline. The eighth task—prime-field modular inversion—produces a new reversible architecture rather than a direct improvement against one baseline. The Hermitian-code comparison is numerically the most extreme, but it also has the weakest baseline status because the reference is a naive reversible compilation rather than an established prior circuit.

Limitations and open questions

The $3n^2+17n-2$1 objective weights Toffolis and qubits equally, although the relevant bottleneck may instead be Toffoli depth, magic-state throughput, active volume, routing, measurement latency, or fault-tolerant architecture. Several reported circuits use bounded failure probabilities and input distributions; their resource advantages therefore do not automatically transfer to worst-case exact computation or to a different application distribution.

The task interface fixes the computational-basis encoding and excludes transformations whose benefit comes from changing the representation itself, such as coset encodings for modular arithmetic. The evaluator’s statistical correctness guarantees also depend on candidates being fixed before test samples are drawn and on the specified distribution over inputs and measurement records. More generally, the paper leaves open how search quality changes when the evaluator includes depth, connectivity, logical error rates, code-deformation costs, or architecture-specific magic-state supply.

A further open question is whether the LLM can reliably discover and verify invariants of the kind used in the divstep and BM constructions outside domains with compact classical trajectory evaluators. The reported results establish that such discoveries can occur under the present interface; they do not establish that the search will scale to arbitrary reversible algorithms or that its output will remain interpretable without substantial mathematical reconstruction.

Conclusion

The paper demonstrates that evaluator-guided LLM evolution can discover reversible quantum circuits whose improvements arise from algorithmic redesign rather than gate-level simplification. Across decoding, modular arithmetic, numerical approximation, quantum chemistry, and lattice-gauge simulation, the strongest results combine conditional routing, reachable-state history recovery, distribution-aware resource truncation, and application-specific representations.

The quantitative evidence is substantial: $3n^2+17n-2$2–$3n^2+17n-2$3 reductions in $3n^2+17n-2$4-cost for seven benchmarked tasks, a $3n^2+17n-2$5 reduction for the Hermitian-code comparison against a naive reversible baseline, and a new divstep architecture using 935 qubits for a complete 256-bit point adder. The main contribution is consequently methodological and architectural: reversible quantum compilation can be treated as a constrained search over algorithms, representations, and uncomputation strategies, provided that correctness and resource usage are exposed through an independent evaluator.