Grimsley et al. state the problem they are solving as a property of every fixed ansatz: VQE "typically relies on a pre-selected wavefunction ansatz that results in approximate wavefunctions and energies". Theirs instead "grows it systematically one operator at a time in a way dictated by the molecule being simulated", which "generates an ansatz with a small number of parameters, leading to shallow-depth circuits". The comparison they report is against unitary coupled cluster, on numerical simulations "including for a prototypical strongly correlated molecule", and it is better "in terms of both circuit depth and chemical accuracy" — a numerical result on chosen molecules, not a bound.

The Hamiltonian whose ground state is wanted, together with whatever structure is to be respected — particle number, spin, point-group symmetry, a reference determinant — and the connectivity and native gate set of the device the family has to run on.

1. Hamiltonian whose eigenvalues are wanted → Parameterised circuit familymeasure gradients, add largest to ansatz

   The ansatz is grown one factor at a time: $|\psi^{(n)}\rangle = e^{\hat\tau_n}\cdots e^{\hat\tau_1}|\psi^{HF}\rangle$, where each $\hat\tau$ is an anti-Hermitian one- or two-body excitation operator, $\hat\tau_{ij}^{ab} = \hat t_{ij}^{ab} - \hat t_{ab}^{ij}$, drawn from assumption: a fixed pool defined in advance, here "the set of all unique spin-complemented one- and two-body operators". To pick $\hat\tau_{n+1}$, the Hamiltonian's commutator with every pool operator is measured on the current state to get the gradient of the energy with respect to that operator's coefficient, and the operator with the largest gradient is appended with a fresh parameter. approximation: this replaces the exact result that FCI is an arbitrarily long product of such exponentials, Eq. 7, with a short sequence chosen greedily rather than fixed a priori, stopping once the norm of the gradient vector drops below a threshold $\epsilon$ (the paper uses the $L^2$ norm in its own numerical examples but notes this is just one choice among alternative convergence indicators for this step).

   approximationassumption

A circuit family with a fixed structure and free real parameters, together with the number of those parameters — which is the size of the classical search problem handed to the next layer.

• Estimate an observable

  Given the ability to prepare $|ψ⟩$ and a description of an observable $O$, return a classical scalar within $\varepsilon$ of $⟨O⟩$ at confidence $1−δ$. The state is never returned; only the number is.

  Two kinds of call, at two rates. Per iteration ADAPT-VQE hands the estimator its trial state and, for each pool operator $\hat A_m$, its commutator with the Hamiltonian, $[\hat H, \hat A_m]$; what comes back is used only in aggregate, ranked to pick one operator and normed against the exit threshold $\varepsilon$. approximation: each number is a finite average — "Repeating this multiple times and averaging gives the gradient" — with no shot count attached to the accuracy needed to rank the pool or resolve its norm assumption: preparation runs "on all devices simultaneously" only when "multiple quantum computers are available" The second kind is $\langle \hat H \rangle$, once per parameter setting the classical optimizer requests, inside a re-optimization the authors call "distinct from the gradient computed in step 5". Neither is budgeted: measurements only "will likely" rise against UCCSD-based VQE "due to the necessary gradient measurements", and the shot count "also depends on the number of iterations required for the classical optimization".

  approximationassumption

given  qubit Hamiltonian  H   (from a prior integral / qubit-mapping step)             (Step 1)
       reference state  |psi_HF>,  ideally one with the correct electron number        (Step 3)
       operator pool  {A_m},  here the set of all unique spin-complemented
           one- and two-body operators                                                (Step 2)
               A = tau_ij^ab = t_ij^ab - t_ab^ij   -- the anti-Hermitized
                   excitation-operator notation defined earlier in the paper           (Eq. 4)
       convergence threshold  eps > 0   (paper's own examples use  eps_m = 10^-m)       (Eq. 9)

requires  nothing beyond  eps > 0  -- no bound on the number of rounds is proven:
    #  "determining resource requirements for adaptive procedures is rather difficult"

ansatz = identity,   |psi^(0)> = |psi_HF>,   n = 0                                      (Step 3)

# --- grow the ansatz one operator at a time ----------------------------------
repeat
    for each  A_m  in pool:
        g_m  =  < psi^(n) | [H, A_m] | psi^(n) >   # via observable-estimation          (Step 5)
    # g_m is the gradient of <H> w.r.t. a not-yet-added coefficient on A_m;
    #   "repeating this multiple times and averaging" gives each g_m, and this
    #   whole pass "can be done in parallel"
    if  ||g||_2 < eps:  exit repeat                                                     (Step 6)
        # the L2 norm is the paper's own choice for its numerical examples --
        #   it states this is "just one possibility" among alternative
        #   convergence indicators for this step
    m*  =  argmax_m  |g_m|   # main text says only "largest gradient"; the SI is
        #   explicit -- "largest magnitude gradient"      (Step 7; SI Sec. I.C)
    tau_{n+1} := A_{m*}   # choosing A_m* does not remove it from the pool --            (Step 7)
                          #   it can recur in a later round
    |psi^(n+1)>  =  e^tau_{n+1}  |psi^(n)>,   with one new variational parameter
    n = n + 1

    # --- re-optimize every parameter placed so far --------------------------
    theta^(n)  =  argmin_theta   < psi(theta) | H | psi(theta) >                        (Step 8)
        # a full VQE run over all n parameters -- "distinct from the gradient
        #   computed in step 5 of the algorithm"
    |psi^(n)>  =  |psi(theta^(n))>

return  |psi_ADAPT(eps)>  =  e^tau_N ... e^tau_2 e^tau_1  |psi_HF>,   N = n at exit      (Eq. 8)
# stands in place of the exact FCI state, itself an arbitrarily long product of
#   the same one- and two-body exponentials, one replica per k (Eq. 7) -- here a
#   short sequence chosen greedily round by round, not fixed a priori and not
#   shown equal to FCI at finite N
# number of nonzero parameters = number of iterations = number of VQE
#   re-optimizations run in the loop above (Sec. II B)

Grimsley, Economou, Barnes and Mayhall cost ADAPT-VQE per iteration only. Each iteration measures one commutator expectation value $\langle \psi^{(i)} | [\hat{H}, \hat{A}_m] | \psi^{(i)} \rangle$ per pool operator to choose the next operator — parallelisable across uncoupled devices, with no shot count attached — then adds exactly one operator and one parameter, grows the circuit by that single one- or two-body operator, and re-runs VQE over every parameter so far. Because the number of non-zero parameters equals the number of iterations, iterations, parameters and VQE re-optimisations are one number, and nothing bounds it: the exit is a user-chosen gradient-norm threshold $\varepsilon_m = 10^{-m}$, and the authors give no resource bound — "Determining resource requirements for adaptive procedures is rather difficult". Neither the size of the screened pool nor any gate or CNOT count appears. Parameter counts are measured, not derived: for LiH/STO-3G (6 spatial orbitals) the $\varepsilon_1$ ansatz holds fewer than 10 parameters across the dissociation curve against UCCSD's 92 (64 spin-complemented), with all three thresholds under half of UCCSD's.

• TETRIS-ADAPT-VQE ansatz

  Keep ADAPT's habit of growing the ansatz from measured gradients, and stop adding one operator per round. Several operators acting on disjoint qubits can go in together, filling the same layer instead of stacking — the same circuit, packed rather than piled.

  What would earn it a path of its own: Drawing this apart from ADAPT needs the map to represent a SCHEDULE — how many operators a round admits, and therefore how often the gradient measurement is paid — where today a repeat is a count on one hop and nothing expresses "fewer rounds, more per round". The paper's own claim is precisely a trade between those two, so the moment the map can say it, this refinement has a drawable difference and stops being folded.

• Grimsley et al.'s in-house ADAPT-VQE simulation code

  • An adaptive variational algorithm for exact molecular simulations on a quantum computer

    Harper R. Grimsley, Sophia E. Economou, Edwin Barnes, Nicholas J. Mayhall · 2018

  About

  ADAPT-VQE was introduced by Harper R. Grimsley, Sophia E. Economou, Edwin Barnes and Nicholas J. Mayhall at Virginia Tech to take the fixed ansatz out of VQE, which they state “typically relies on a pre-selected wavefunction ansatz that results in approximate wavefunctions and energies”. What they built and ran is the numerical evidence for that claim: an algorithm which “instead of fixing an ansatz upfront … grows it systematically one operator at a time in a way dictated by the molecule being simulated”, measured against a unitary coupled cluster approach “in terms of both circuit depth and chemical accuracy” and “including for a prototypical strongly correlated molecule”. The published version records the division of labour as “H.R.G. wrote the code. H.R.G. and N.J.M. performed the calculations.”

  Methods

  Everything reported is a classical simulation of the algorithm, not a device run. Psi4 supplied the one- and two-electron integrals through the OpenFermion-Psi4 interface, and OpenFermion performed the Jordan–Wigner transformation. The pool was “the set of all unique spin-complemented one- and two-body operators” and the reference state was Hartree–Fock. Each iteration measured the commutator of the Hamiltonian with every operator in the pool to get the gradient, added the single largest-gradient operator “to the left end of the ansatz, with a new variational parameter”, and re-ran VQE over every parameter so far with the Broyden–Fletcher–Goldfarb–Shannon minimiser in SciPy. Selecting an operator does not drain the pool, so an operator can be chosen again. The exit was the L2 norm of the gradient vector falling below $\varepsilon_m = 10^{-m}$, run at $m = 1, 2, 3$. Instead of numerical gradients for the re-optimisation the authors “derived and implemented an efficient analytic gradient function” which returns the whole gradient vector “at a cost which is only roughly 2x that of the base energy evaluation”. As a control on the gradient-based ordering they grew the same ansatz by four other rules — Random (ijab), Random (pqrs), Lexical (ijab) and Lexical (pqrs) — where the ijab pools are restricted to indices “which do not annihilate the HF reference state” and the pqrs pools are not.

  Data

  Three molecules, each scanned along a dissociation coordinate, with the integrals computed by Psi4. LiH is computed by FCI, un-Trotterized UCCSD, Hartree–Fock and the three ADAPT thresholds, “all with the STO-3G basis set”; “In this basis set, LiH has 6 spatial orbitals and a Hilbert space of dimension 4096”, the occupied orbitals being {1,2} and the virtual {3,4,5,6}; starting from the Hartree–Fock state with two alpha and two beta electrons and using only number-conserving operators, “the relevant subspace to explore has a dimension of” 225. “In the STO-3G basis, BeH2 has 7 spatial orbitals, for a total Hilbert space dimension of 16384, and a neutral molecule subspace of dimension” 1225. The paper states no basis set for the third system, the simultaneous stretching of linear H6, included as “a prototypical strongly correlated molecule, which allows us to test the ADAPT-VQE approach for systems which are not well described with unitary coupled cluster”. FCI and un-Trotterized UCCSD are the baselines for all three systems — Table I averages each method's error across the scan, and Fig. 2's caption records that “the FCI curve lies directly underneath the ADAPT($\varepsilon_3$) curve, and so is not visible” — while Hartree–Fock is discussed as a plotted curve only for LiH, where chemical accuracy “is achieved in all cases other than HF”. The published article's data availability statement reads “The data for the numerical simulations is available upon reasonable request.”

  Code

  The paper says only that “an in-house code was written”, and the published article's code availability statement is “The code for the numerical simulations is available upon reasonable request.” A Python package that names this article does sit in the group's GitHub organisation, at https://github.com/mayhallgroup/adapt-vqe: a fork, taken into that organisation on 2019-11-21, of nmayhall-vt/adapt-vqe, itself forked from hrgrimsl/OF_VQE, and the commit history it carries begins on 2018-11-13 with “Basic OpenFermion VQE”, 45 days before the 28 December 2018 preprint. Its README reads “This is the simulation code for performing ADAPT-VQE calculations. Method detailed in Nature Communications, 10, 3007, (2019)”. Its setup.py names the distribution of-adapt-vqe, describes it as “Run ADAPT-VQE with Psi4 and Openfermion”, gives the authors as “Harper R. Grimsley, Nick Mayhall”, points its url at https://github.com/hrgrimsl/OF_VQE.git and declares license='Apache 2' beneath a full Apache License 2.0 header block, though no LICENSE file is present in the repository. Nothing published identifies the revision that produced Fig. 2 and Table I. The simulation is sparse-matrix, not gate-level: src/tVQE.py carries the trial state as a scipy.sparse vector, src/operator_pools.py supplies singlet_GSD, singlet_SD, spin_complement_GSD and spin_complement_GSD2 pools, and src/vqe_methods.py holds adapt_vqe next to test_random and test_lexical — the two selection procedures behind the four alternative orderings of Fig. 3, each taking the pool as an argument, with operator_pools.singlet_GSD() as the keyword default. requirements.txt pins openfermion==0.9.0, openfermionpsi4==0.4, pyscf==1.6.1.post1 and scipy==1.1.0. Three examples ship, all of them linear H6 at spacing r = 1.5 with basis = 'sto-3g' through PySCF and all calling vqe_methods.adapt_vqe(fermi_ham, pool, reference_ket, theta_thresh=1e-9); they differ by pool, examples/h6_gsd.py selecting singlet_GSD, examples/h6_sd.py singlet_SD, and examples/h6_sc_gsd.py the spin_complement_GSD pool that matches the paper's description.

  Results

  Every number is from the classical in-house simulation; no quantum processor was used, and the discussion says outright that “Further classical simulations and device implementations are needed to provide better insight into the numerical behavior.” Table I gives the average error across the PES scan in kcal/mol. LiH: UCCSD 0.0480, against ADAPT($\varepsilon_1$) 0.3000, ADAPT($\varepsilon_2$) 0.0058 and ADAPT($\varepsilon_3$) 0.0002. BeH2: UCCSD 2.2384, against 0.8023, 0.0907 and 0.0041. H6: UCCSD 3.7387, against 4.5297, 0.3023 and 0.0047 — so at the loosest threshold ADAPT is the worse of the two on the strongly correlated molecule. On parameter count, for LiH “UCCSD has 92 parameters, which can be reduced to 64 by combining spin-complements”, while “in all three ADAPT calculations, fewer than half of the parameters are needed compared to UCCSD” and the ADAPT($\varepsilon_1$) ansatz consists of “fewer than 10 parameters across the curve”; it is written out at LiH bond distance 2.39 Å as Eq. (10), a product of eight exponentials which “includes a mixture of both double excitations and correlated single excitations” and in which the HOMO-LUMO double excitation “is not the first operator, but instead the third”. Against the four alternative growth rules on BeH2 at a Be-H distance of 2.39 Å (Fig. 3), “the ADAPT ansatz converges dramatically faster than the other four cases considered”. The paper also reports its own failure mode. Because the algorithm is adaptive, the parameter count “can change abruptly, leading to discontinuous potential energy curves”, and “Two notable examples of this can be seen in Fig. 2(h), first at R(H-H) = 1.8 Å where ADAPT($\varepsilon_1$) experiences a large jump in energy, and second at 2.5 Å where ADAPT($\varepsilon_2$) increases in energy.” The cause of both is referred to convergence data “provided in the Supplement (see Supplement Fig. 1)”, and the mechanism is named for one of them: at larger bond lengths the energy “flattens out before dropping substantially again”, and “In the ADAPT($\varepsilon_2$) data of Fig. 2(h) and 2(i), the jump in energy error and drop in parameter number, respectively, are caused by the 2.5 A optimization aborting at a false gradient trough, while the optimizations at other bond lengths do not.” The remedy is stated: “if a tighter threshold is used (such as 0.001), the ADAPT-VQE algorithm does not prematurely abort”.

• AdaptVQE in qiskit-algorithms

  About

  ADAPT-VQE is shipped as a general minimum eigensolver rather than a chemistry program by qiskit-algorithms — a community package in the qiskit-community organisation, installed with pip install qiskit-algorithms and not part of the Qiskit SDK, whose README carries the warning “Qiskit Algorithms is no longer officially supported by IBM”. The class takes any qubit Hamiltonian and any pool of evolution operators, and its docstring points at this method's paper — “AdaptVQE <https://arxiv.org/abs/1812.11173> is a quantum algorithm which creates a compact ansatz from a set of evolution operators.” Where the paper's pool is fermionic excitations fixed by the molecule, here the pool is supplied by the caller and the chemistry is optional: “In chemistry, this is usually a list of orbital excitations.”

  Methods

  The loop is the paper's. Gradients are commutators, built in one line as commutators = [1j * (operator @ exc - exc @ operator) for exc in self._excitation_pool] and evaluated through Qiskit's Estimator primitive; the largest is appended to the ansatz and an inner VQE instance re-optimises every parameter. Three exits are the implementation's own rather than the paper's: an eigenvalue_threshold, default 1e-5, which stops “once the eigenvalue has changed by less than this threshold from one iteration to the next” and discards that last iteration; a TerminationCriterion.CYCLICITY abort, “Aborted due to a cyclic selection of evolution operators”; and a max_iterations cap reported as TerminationCriterion.MAXIMUM, “Maximum number of iterations reached”, which defaults to None, in which case “the algorithm is not bound in its number of iterations”. The convergence test also differs in kind from the paper's: gradient_threshold, default 1e-5, fires “once all gradients have an absolute value smaller than this threshold”, which is a bound on the largest component, where Grimsley et al. threshold the L2 norm of the whole gradient vector.

  Data

  The pool and the Hamiltonian are arguments, so the artefact itself carries no chemistry. What its test suite runs on is a four-qubit Hamiltonian written out literally in test/minimum_eigensolvers/test_adapt_vqe.py as a 15-term SparsePauliOp named h2_op (identity coefficient -0.8105479805373266), a pool of three SparsePauliOp excitations, and a reference state prepared by X gates on qubits 0 and 1. The file names no geometry, bond length or basis set for that Hamiltonian.

  Code

  The class is AdaptVQE in qiskit_algorithms/minimum_eigensolvers/adapt_vqe.py in the Python package qiskit-algorithms, https://github.com/qiskit-community/qiskit-algorithms, under the Apache License 2.0 with the header “(C) Copyright IBM 2022, 2026”. It is used as “from qiskit_algorithms.minimum_eigensolvers import AdaptVQE, VQE”, is constructed around a supplied VQE instance, and returns its answer from adapt_vqe.compute_minimum_eigenvalue(hamiltonian).

  Results

  The evidence that it runs is the repository's own test, not a published study. test_default asserts that AdaptVQE over that three-operator pool, with SLSQP as the optimiser and Qiskit's StatevectorEstimator — a noiseless statevector estimator, not a device — reproduces expected_eigenvalue = -1.85727503 to six decimal places, and that the whole eigenvalue_history matches it to rtol=1e-6; test_converged asserts the run ends on TerminationCriterion.CONVERGED at gradient_threshold=1e-3. The only backend in the suite is GenericBackendV2(num_qubits=5, coupling_map=[[0, 1], [1, 2], [2, 3], [3, 4]], seed=54), and it is used to build a transpiler pass manager, never to execute the circuits.

• ADAPT-VQE · Qiskit

  From the repository — run, not written up from a paper · unsupported

  About

  An adaptive ansatz grows one operator at a time using measured energy gradients from a predefined pool.

  Methods

  None found yet.

  Data

  None found yet.

  Code

  Qiskit

  Results

  Literature-backed method record; algorithmic scope and evidence boundary reviewed, with no benchmark run claimed.

• ADAPT-VQE

  An adaptive ansatz grows one operator at a time using measured energy gradients from a predefined pool.