A Hardware-Trained Generative Quantum Eigensolver for Sample-Based Quantum Diagonalization of Organotin Hydroxides up to 70 Qubits

Kunal Kumar, Kimberlee Keithley, Toshiya Iwamori, Shu Kanno, Ikko Hamamura, Takao Kobayashi, Akira Koseki, Qi Gao, Naoki Yamamoto, Hiroshi Horii, Yuri Kobayashi, Borja Peropadre, Kouhei Nakaji, Toru Imai, Takayuki Osogami

TL;DR

Researchers have successfully trained a transformer-based "Generative Quantum Eigensolver" (GQE) using real quantum hardware to design highly efficient circuits for molecular simulation. By putting an IBM Heron processor directly in the training loop, the team generated state-preparation circuits for 70-qubit systems that are up to 72 times shallower than standard methods while maintaining near-chemical accuracy.

What Problem Does This Paper Address?

Simulating the electronic structure of large, complex molecules is one of the "killer apps" for quantum computing. However, we are currently in the NISQ (Noisy Intermediate-Scale Quantum) era, where quantum bits are fragile and errors accumulate quickly.

Traditional approaches often rely on fixed circuit templates (ansätze) that are often too "deep"—meaning they contain too many operations for current hardware to execute reliably. While we can use classical computers to help design better circuits, exact classical simulation becomes impossible once we move beyond roughly 46 qubits. This creates a "catch-22": we need quantum computers to simulate large molecules, but we can't classically design the efficient circuits needed to run them on today's noisy hardware.

Methods

The authors propose a Hardware-Trained Generative Quantum Eigensolver (GQE). Instead of using a fixed template, they use a GPT-2 style transformer model to "write" the quantum circuit token by token.

The core of their approach is a two-stage curriculum:

  1. Stage 1 (Noiseless Warm-up): The transformer is trained on a classical simulator using small molecules (up to 32 qubits).
  2. Stage 2 (Hardware Continuation): Training continues with the IBM Heron processor (ibm_kobe) in the loop. The hardware provides the energy feedback (the "reward") used to update the transformer's weights. This allows the model to learn to navigate real-world device noise and connectivity constraints at scales (46 and 70 qubits) where classical simulation fails.

To calculate energies, they use Sample-Based Quantum Diagonalization (SQD). In this hybrid scheme, the quantum computer samples electronic configurations, and a classical supercomputer then performs a final diagonalization within that specific subspace to find the ground state energy.

Figure 1: Training control flow for one iteration. The size curriculum picks a molecule; its conditioning (A1 or A5) drives the transformer policy, which samples N = 20 circuits of L operator tokens each. In Stage 1 the circuits are evaluated with an exact statevector simulator (curriculum of at most 32 qubits; the transpilation only measures depth and two-qubit-gate count); in Stage 2 they are transpiled and run on ibm_kobe (10,000 shots for each of 20 circuits in one Runtime job) on the 23- and 35-orbital target molecules, initialized from the full Stage-1 policy checkpoint (every weight is carried over; Section 2.7). The SQD subspace build with self-consistent recovery and global merge gives each circuit’s energy and raw error; an admission gate then checks the best circuit of the batch (depth within the ceiling, raw error within the energy tolerance, at least one two-qubit gate). Admitted iterations drive a GRPO/GSPO policy-gradient update over all 20 circuits; for rejected iterations the counts are logged but nothing is back-propagated and the next iteration resamples.

Datasets

  • Training Set: A variety of small molecules ($H_2$, $CH_4$, etc.) and larger transition-metal complexes like ferrocene and $Fe(CN)_6$.
  • Evaluation Set (Zero-shot): The model was tested on methyltin trihydroxide ($Sn(OH)_3$-Me) and its hydrates. These molecules are critical "held-out" targets because they serve as minimal models for organotin photoresists used in extreme-ultraviolet (EUV) lithography—a cornerstone of modern semiconductor manufacturing.

Key Insights and Ideas

  • Hardware as the Ultimate Teacher: By training on actual hardware, the policy learns to favor circuits that perform well under noise. Interestingly, the authors noted that device noise actually helps "spread" the quantum state into useful configurations that the classical SQD step can then "repair" and optimize.
  • Amortization and Transfer Learning: A major "aha" moment was that a policy trained on transition metals could design excellent circuits for organotin compounds without any retraining. This suggests that the model is learning general principles of molecular electronic structure.
  • The Hartree-Fock Penalty: Without a specific penalty, the model tended to "cheat" by collapsing to the simplest possible circuit (the Hartree-Fock state). Adding a penalty forced the model to explore the more complex, correlated configurations necessary for high accuracy.
  • Efficiency over Depth: The generated circuits were remarkably shallow. At the 70-qubit level, the GQE circuits used 34–72 times fewer two-qubit gates than the standard Local Unitary Cluster Jastrow (LUCJ) ansatz.

Key Results

  • High Accuracy: In zero-shot tests on the organotin family (32 to 70 qubits), 27 out of 28 runs achieved energies within 15 mHa of the gold-standard DMRG reference, with a median error of only 4.5 mHa.
  • Superior to Baselines: The trained policy was more accurate than untrained controls in every single test case.
  • Extreme Gate Reduction: For the largest 70-qubit systems, the model selected circuits with only 64 to 160 two-qubit gates, compared to the ~7,000 gates required by standard transpiled LUCJ circuits.
  • Computational Cost: The four main training runs required approximately 120 million hardware shots and 648 QPU minutes.
Figure 2: Inference control flow. A frozen policy (trained, or randomly initialized for the untrained control) emits 10 circuits for an unseen molecule; they are sampled once on ibm_kobe (100,000 shots each) and the raw counts are cached. Below the dashed line everything runs locally on the cached counts: the circuits are ranked by a one-shot diagonalization (up to 200 alpha strings, net dimension 40,000; circuits without a valid shot are excluded); five results are selected: best and second (the two lowest ranking energies), merged (the shots pooled from all circuits with a finite energy), and E+D 1 and E+D 2 (the two circuits chosen by the E+D rule, which combines the rank by energy, E, with the rank by the number of distinct measured bitstrings, D); the same recovery step is then applied to each of the five, with D = 20,000 strings per spin sector and 25 iterations. The result per circuit is the energy, the raw-shot and subspace excitation histograms and the singles-injected energy.

Limitations and Future Work

While impressive, the authors acknowledge several hurdles:

  • Policy Collapse: During hardware training, the model's "vocabulary" often narrowed down to a single preferred operator sequence, limiting the diversity of the circuits it could propose.
  • Dependence on Classical References: The training process still requires an approximate classical reference energy (like CCSD(T)) to set the "admission gate" for updates. Finding a way to train without any classical reference remains a goal.
  • Sampling Overhead: The depth advantage is currently "paid for" by sampling 10 different candidate circuits to find the best one, which increases the total number of quantum measurements (shots) required.

Future work will likely focus on integrating error mitigation techniques and exploring even larger active spaces to see where the limits of this "hardware-taught" approach truly lie.

Summary updated

Abstract

Quantum hardware can provide feedback for training circuit generators beyond the reach of exact classical simulation. We train generative quantum eigensolver (GQE) policies, transformers conditioned on molecular descriptors, to generate the state-preparation circuits for sample-based quantum diagonalization (SQD). Training runs first on a noiseless simulator and then with the IBM Heron processor ibm_kobe inside the loop, at 46 and 70 qubits ($1.2 \times 10^8$ shots for the four main training runs). A classical CCSD(T) reference energy of the training molecules enters only an admission gate and two auxiliary reward terms. During hardware training, a reward penalty prevents collapse to circuits that sample only the Hartree-Fock determinant. Policies trained on transition-metal complexes are applied without retraining to Sn(OH)$_3$-Me and its hydrates, minimal models of organotin photoresists for extreme-ultraviolet lithography, from 32 to 70 qubits. After one round of hardware sampling, followed by classical ranking and recovery of the cached counts with the molecular Hamiltonian and no further QPU calls, 27 of 28 runs at 46-70 qubits are within 15 mHa of the density-matrix renormalization group (DMRG) reference (median 4.5 mHa), and in all eight runs with an untrained control the trained policy is more accurate. At 56-70 qubits the selected circuits use 34-72 times fewer two-qubit gates than the local unitary cluster Jastrow (LUCJ) circuit transpiled for the same device. These results demonstrate that circuit generators can be trained with quantum hardware at 70 qubits.
BibTeX
@misc{kumar2026hardware,
  author = {Kunal Kumar and Kimberlee Keithley and Toshiya Iwamori and Shu Kanno and Ikko Hamamura and Takao Kobayashi and Akira Koseki and Qi Gao and Naoki Yamamoto and Hiroshi Horii and Yuri Kobayashi and Borja Peropadre and Kouhei Nakaji and Toru Imai and Takayuki Osogami},
  title = {{A Hardware-Trained Generative Quantum Eigensolver for Sample-Based Quantum Diagonalization of Organotin Hydroxides up to 70 Qubits}},
  year = {2026},
  eprint = {2611.13755},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.13755},
}
Figure