ADAPT-VQE adaptive ansatz

What it fills

• Choose a parameterised trial state

  Fix the gate structure of a circuit family and leave its rotation angles open. What comes back is not a circuit but the set of states the later optimisation is allowed to search — which is why this is a slot of its own and not a paragraph in one method's write-up.

When it applies

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.

Requires

These do not move the route along. The method needs each of them alongside its own work, and the cost of getting them is part of what the method costs.

• 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

Example

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)

Cost, as the source states it

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.

Implementations

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

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

  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.”

  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.

  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.”

  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.

  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

  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.”

  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.

  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.

  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).

  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.

What it needs

Every step this method names is listed under Requires above. It walks its own span in one hop and calls out to the rest — that is a fact about the recorded route, not a claim that the span is simple.

Other ways to fill the same slot

Different approaches

• Unitary coupled-cluster singles and doubles

  Build the trial state from single and double excitations out of a reference determinant, exponentiated as a unitary. The family is chosen for chemistry rather than for the machine: the state you want is in it by construction, and the circuit that reaches it is deep.

• Hardware-efficient ansatz

  Build the trial state out of the gates and couplings the machine already has, and accept whatever states that reaches. The circuit is shallow because nothing in it was chosen for the chemistry; there is correspondingly no argument that the state you want is inside the family.

• k-UpCCGSD ansatz

  Take k repetitions of paired double excitations together with generalized singles, instead of the full set of doubles. The point of the restriction is that the depth then grows linearly in the number of orbitals rather than polynomially, and k is the dial that buys accuracy back.

• Qubit coupled-cluster ansatz

  Skip the fermionic layer and build the ansatz directly in qubit space, ranking candidate entangling operators by how much each would move the energy and keeping the ones that earn their place.

• Particle-hole coupled-cluster circuits

  Rewrite the Hamiltonian around the reference determinant so that what the circuit has to describe is excitations out of it, then build the family from gates that move an electron without creating or destroying one. Staying inside the right particle-number sector is a property of the gates, not something the optimiser has to discover.

• Orbital-optimized coupled-cluster circuits

  Let the orbitals move too. The usual family fixes a basis and varies the amplitudes; this one varies the molecular orbital coefficients alongside them, so the same accuracy is reachable from a smaller active space and a shallower circuit — and the energy becomes fully variational, which is what makes forces available.

• Symmetry-preserving state-preparation circuits

  Build the circuit so that it cannot leave the symmetry sector the chemistry lives in. Particle number, total spin, spin projection and time reversal are respected by the gate structure itself, so the search never spends parameters on states the answer cannot be in.

• Iterative qubit coupled cluster a narrower version of Qubit coupled-cluster ansatz

  Stop growing the circuit and grow the Hamiltonian instead. Each round folds the entanglers found so far into the operator by a canonical transformation, so every round runs a circuit of the same size — the cost moves off the device and into the number of terms that have to be measured.

• Generalized singles and doubles ansatz

  Drop the rule that an excitation has to move an electron from an occupied orbital into an empty one. Every pair of orbitals may be coupled, so the circuit stops depending on which reference determinant it was built around — a wider variational manifold, paid for in parameters.

Narrower versions of this one

• qubit-ADAPT-VQE ansatz a narrower version of ADAPT-VQE adaptive ansatz

  The same grow-it-one-operator-at-a-time construction, with the pool rebuilt out of qubit operators rather than fermionic excitations so that the circuits it produces are shallow enough for near-term hardware.

• TETRIS-ADAPT-VQE ansatz a narrower version of ADAPT-VQE adaptive 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.

• Batched ADAPT-VQE ansatz a narrower version of ADAPT-VQE adaptive ansatz

  Keep ADAPT's habit of growing the ansatz from measured gradients, and stop adding exactly one operator per round. Every operator whose gradient is close to the largest goes in together, so the ansatz reaches the same size in far fewer rounds — and it is the rounds, not the operators, that cost measurements.

In the Atlas

• ADAPT-VQE

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

Sources

• An adaptive variational algorithm for exact molecular simulations on a quantum computer↗Harper R. Grimsley, Sophia E. Economou, Edwin Barnes, Nicholas J. Mayhall · 2018theory yes · simulation yes · hardware no