Batched ADAPT-VQE ansatz

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

A narrower version of ADAPT-VQE adaptive ansatz

Sapova and Fedorov introduce the variant by name — "we introduce batched ADAPT-VQE that adds multiple operators with the largest gradients simultaneously. This approach allows reducing the number of gradient computations while building a compact ansatz" — and state the selection rule as a ratio rather than a fixed count: "At each ADAPT-VQE iteration, we pick all the gradients that differ from the largest by a ratio less than r". What it buys is stated without a number: "Since batched ADAPT-VQE adds multiple operators at each step, it requires sizably fewer iterations to build an ansatz, which considerably reduces the cost of computing gradients". The saving is in iterations, not in the per-iteration measurement — the whole operator pool is still scanned each round, which is why this method carries the same `observable-estimation` step its parent does.

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.

  This method asks the estimator for two kinds of gradient, never an energy: the screen that ranks the pool operators, and the parameter gradients the gradient-based SLSQP optimiser consumes when the appended batch is re-optimised — "gradients in the VQE procedure and gradients with respect to the operators in the same way". Batching changes how many operators one screen yields, not what the screen asks for. The route depends on the pool: qubit operators take the parameter-shift rule directly, while "fermionic operators do not allow direct application" of it and go through fermionic-shift gradients, 4 circuit evaluations per gradient approximation: the cheaper fermionic-shift variant, 2 evaluations rather than 4, is bought by "introducing approximations" the paper does not spell out. assumption: the reported fermionic runs use neither, reading the gradient out numerically in one sweep over all $k$ circuit parameters — exact against analytic gradients only because these are noiseless statevector simulations, numerical ones being "less robust in the presence of noise".

  approximationassumption

Sapova and Fedorov ran a noiseless Qiskit statevector simulation of batched ADAPT-VQE on the carbon monoxide molecule at its equilibrium geometry in the minimal STO-3G basis, reduced by the paper's frozen-core and qubit-tapering procedure to 12 qubits, against a fermionic UCCSD-derived operator pool of 85 excitations. At each iteration every pool operator's gradient was screened, and instead of appending only the single largest, every operator whose gradient fell within a ratio $r = 2$ of the largest was appended together, so the batch size was not fixed but set by this ratio at each round; the growing parameter set was then re-optimized with a gradient-based SLSQP optimizer capped at 200 iterations. To first reach the same energy as VQE-UCCSD, the batched ansatz needed 75 parameters against 72 for the original one-operator-per-round ADAPT-VQE, three more, but cut the total number of one-parameter derivative evaluations by about 9 times, roughly 3,500 against 1,275 for VQE-UCCSD itself and about 30,100 for unbatched ADAPT-VQE; the paper attaches its one circuit-depth figure to this same first-match-VQE-UCCSD-energy point, reporting about 30% less circuit depth than VQE-UCCSD because 72 or 75 pool operators is fewer than the full 85-operator pool VQE-UCCSD draws on. At the later, stricter chemical-accuracy threshold the batched ansatz needed fewer parameters than the unbatched run, 128 against 134, with about 7 times fewer derivative evaluations there too, though no circuit-depth figure is reported at this second checkpoint. Pushed further toward the exact energy, both variants' derivative counts grow sharply, to about 75,000 for batched against 555,000 for unbatched: the roughly 9-fold derivative saving at the first-match point had already narrowed to about 7-fold by the chemical-accuracy point, and stays at roughly that level into this harder regime beyond it. This is a noiseless-simulator result only: no hardware run and no circuit-depth number specific to batching alone is reported for CO, and the saving in gradient measurements arrives with a small but real ansatz-compactness cost at the point where batching first matches VQE-UCCSD.

Classical simulation · Section II C 3 "CO molecule" and Figure 6b (batch rule set out in Section II A) of arXiv:2108.11167

given  Hamiltonian H (Jordan-Wigner mapped, qubit-tapered),  reference state |psi_ref>
       (e.g. the UHF state for an open-shell molecule such as O2, Sec. II C 2),
       fixed operator pool  {A_1, ..., A_M}  -- either fermionic UCCSD excitations
       or individual qubit Pauli strings, per which ADAPT-VQE variant is run

requires  r > 0,  a fixed ratio hyperparameter, not re-derived from the gradient
          distribution or re-tuned across rounds (the paper sets r = 2 for every
          molecule it simulates, Sec. II A)

k = 0,   psi_0 = psi_ref,   ansatz = identity,   theta = []

loop
    # --- pool screening, via observable-estimation ---------------------------
    for every A_i in the pool:
        g_i = <psi_k| [H, A_i] |psi_k>
            # the same commutator-gradient screen as plain ADAPT-VQE (Fig. 1,
            # Sec. II A); costed through observable-estimation -- parameter-shift
            # for qubit-pool operators; the paper's own statevector runs cost
            # fermionic-pool operators with numerical gradients (k+1 evaluations),
            # not the fermionic-shift analytic alternative it describes and sets
            # aside as too slow for the large fermionic gate counts (Sec. IV D)
    g_max = max_i |g_i|

    # --- batch selection & append ----------------------------------------------
    batch_k = { i : g_max / |g_i| < r }
        # "we pick all the gradients that differ from the largest by a ratio less
        #  than r" -- prose rule only, the paper gives no closed-form equation
        #  for it (Sec. II A, Fig. 1 caption)
    # every g_i above was read off the SAME state psi_k: an operator ranked later
    # within batch_k is screened before any operator ranked ahead of it in the
    # same batch has actually been appended to the ansatz or had its coefficient
    # optimized
    ansatz <- ansatz composed with  exp(theta_i A_i),  i in batch_k,
                  appended in gradient order
        # "we add the operators to the ansatz following the order of computed
        #  gradients" (Sec. II A) -- direction unstated; largest-first is the
        #  natural reading, since batch_k is already ranked by |g_i| and
        #  original ADAPT-VQE always adds the single largest-gradient operator,
        #  but the paper never writes "decreasing" or "descending"
    theta <- [ theta unchanged;  new entries for batch_k ]
        # "we set initial parameters to optimal values obtained at the previous
        #  iteration, as was done in the original work" (Sec. IV D) -- only the
        #  carry-over of the EXISTING entries is stated; the paper does not say
        #  what the newly appended entries are initialized to

    # --- re-optimize the whole ansatz, via observable-estimation ----------------
    theta = argmin_theta  <psi(theta)| H |psi(theta)>   via SLSQP
        # gradients for this optimization are the same observable-estimation
        # call used for screening, not a separate estimator: "we calculate
        # gradients in the VQE procedure and gradients with respect to the
        # operators in the same way" (Sec. IV D)
    psi_{k+1} = psi(theta)
    k = k + 1

    if  E_k has converged:   break
        # this paper's own reported runs stop "until the energy convergence"
        # (Sec. IV E) -- no numeric criterion is given for it. Sec. IV E goes on
        # to describe eps_m = 10^-m (Eq. 8) as what the original ADAPT-VQE work
        # [27] applies to the gradient-vector norm, and recommends applying it to
        # the max gradient component instead as "preferable ... in practical
        # simulation" -- a 10^-2 max-component threshold gave energies close to
        # VQE-UCCSD with fewer gates. Neither eps_m form is stated to be what
        # produced the results reported here.

return  U(theta) |psi_ref>,  built from  batch_0 (union) batch_1 (union) ... (union) batch_{k-1}
# k rounds in place of one operator per round -- each round still screens the
# full pool (see cost)

Sapova and Fedorov: batching cuts rounds, not the per-round measurement. "The number of computed energy derivatives at each step equals the operator pool size", and the rule picking every gradient within ratio $r = 2$ of the largest (selected from $2, 5, 10$) needs all of them. Pool size is $O(N^2 n^2)$ for $N$ spin-orbitals and $n$ electrons (fermionic UCCSD), or $O(n^4)$ in system size — a different $n$ — for Pauli-string pools, carrying an $O(n^8)$ measurement overhead they attribute to Shkolnikov et al. and Liu et al. rather than derive. Parameter-shift costs 2 circuit evaluations per derivative (their qubit runs); their fermionic runs used numerical gradients, $k+1$ evaluations for a whole $k$-parameter gradient. Each round's inner VQE is capped at 200 SLSQP iterations; nothing bounds the rounds, which stop on a tuned gradient threshold. Savings are measured on STO-3G statevector simulations: "up to an order reduction" in total 1-parameter derivatives, for fermionic and qubit polynomial pools — CO about 3,500 against 30,100, and 75,000 against 555,000 past UCCSD energy — while with a linear pool on H2O at $R = 2.0$ Å batching computed about 10% more.

• Batched ADAPT-VQE in PNNL's NWQ-Sim

  NWQ-Sim is Pacific Northwest National Laboratory's quantum system simulation environment, published as pnnl/NWQ-Sim and named in its own top-level README as NWQSim, the Northwest Quantum Circuit Simulation Environment; its vqe subdirectory carries a VQE and ADAPT-VQE driver written in C++ against NLopt, with CPU, NVIDIA and AMD GPU statevector backends. The batched selection is not part of the original driver: it arrived in commit af262952 of 2025-12-16, whose message is implement batched-adapt-vqe, and vqe/README.md documents it under the heading Example - Batched-ADAPT-VQE as including at most the number of operators given by -ak in each ADAPT iteration if their operator gradient norms are larger than tau times the largest gradient, tau being set by -at. Nothing on the default branch attributes the rule to anyone: a code search scoped to pnnl/NWQ-Sim for Sapova and for the arXiv identifier 2108.11167 returns no hit, and the top-level README, NOTICE, doc/user_manual.md, doc/python_vqe_api.md, vqe/README.md and the four source files carrying the feature name neither Sapova and Fedorov nor their paper — nor does the vqe_memory branch that the top-level README links for its VQE manual, though the repository carries twenty-two branches and only those two were read. So the repository carries a threshold rule of the same shape as the one Sapova and Fedorov describe, under the same name, with no citation to them and no claim to be a reimplementation.

  The selection sits in the ADAPT loop of vqe/src/execution/adapt_runner.cpp. Each round screens every pool operator that is not already in the ansatz — the loop skips an index whenever selected[idx] is true — by copying the current state, applying that pool operator at plus and at minus adapt_gradient_step, and taking a central difference of the energy, (energy_plus - energy_minus) / (2.0 * options.adapt_gradient_step). The screen therefore costs two energy evaluations per unselected pool operator per round, on top of the one spent on the current state before the loop begins, and it is a finite difference of the energy rather than the commutator expectation that original ADAPT-VQE measures. The batch is then cut by ratio: const double batch_threshold = options.adapt_batch_tau * max_gradient, and every operator whose gradient magnitude is at least batch_threshold and strictly positive becomes a candidate. Candidates are sorted by descending gradient magnitude, truncated to options.adapt_batch_max_operators, appended in that order by ansatz.add_operator(idx, 0.0), and the whole parameter vector is then handed to a single NLopt call. Two things the paper leaves open are settled here by the code: the batch is appended largest-gradient-first, and each newly appended parameter starts at exactly 0.0. What the ratio rule as Sapova and Fedorov write it does not carry is the hard cap on batch size, although the same section of their paper notes that restricting the operator batch size at each iteration can be useful for experiments on existing quantum devices, and credits Liu et al. with adding a fixed number of operators, so a cap is not foreign to its framing. The sharper departure is from original ADAPT-VQE rather than from this paper: an operator once selected is skipped by every later screen, so no pool operator can enter the ansatz twice and the per-round screening cost falls as the ansatz grows, where Grimsley et al. state that growing the ansatz does not drain the pool and so operators can show up multiple times if selected by the algorithm, and Sapova and Fedorov write that the number of computed energy derivatives at each step equals the operator pool size. Sapova and Fedorov say nothing either way about re-selection. With the shipped defaults, adapt_batch_max_operators = 1 and adapt_batch_tau = 1.0, the same code path is one-operator-per-round ADAPT-VQE, so batching is opt-in rather than the default behaviour.

  The input is a file of second-quantised fermionic operators — the CLI help calls it a sum of Fermionic operators — read under the XACC/Qiskit indexing scheme by default, or the DUCC scheme with --ducc, together with a particle count passed as -p; XACC and DUCC name indexing schemes in this repository, not file formats. Six Hamiltonian files ship under vqe/example_hamiltonians/, of which that directory's README documents four: linear H4 with 4 spatial orbitals and 4 particles at 1.5 Angstrom, LiH with 6 spatial orbitals and 4 particles at 3.4 Angstrom, and linear H6 with 6 spatial orbitals and 6 particles at 1.8 and at 2.2 Angstrom. The batched example in vqe/README.md uses one of the two files in that same directory which the README does not document, H4_4_0.9_xacc.hamil. The operator pool is not read from the input file: adapt_ansatz::build_pool() in vqe/src/ansatz/adapt.cpp constructs a uccsd_ansatz generator and takes its excitation list, and uccsd_ansatz::pool_name() in vqe/include/ansatz/ansatz.hpp returns UCCSD, so the batched selection runs over a fermionic singles-and-doubles pool whose excitations are grouped by the symmetry level set with --sym, which defaults to full.

  pnnl/NWQ-Sim on GitHub, MIT licence — the LICENSE file reads MIT License, Copyright (c) 2021 Ang Li — default branch main. Four files carry the feature. vqe/include/vqe_options.hpp declares it under the comment Batched ADAPT-VQE controls as two fields, std::size_t adapt_batch_max_operators = 1, commented Maximum operators appended per ADAPT iteration, and double adapt_batch_tau = 1.0, commented Gradient threshold fraction relative to max gradient. vqe/src/execution/adapt_runner.cpp holds the screen and the selection, and distributes the screen across MPI ranks by striding the pool loop from world_rank by world_size before an MPI_Allreduce over the gradient magnitudes. vqe/main.cpp exposes the two fields as -ak or --adapt-batch-k and -at or --adapt-tau, rejecting a zero batch size with adapt-batch-k must be positive and any tau outside the interval (0, 1] with adapt-tau must be in the interval (0, 1]; the Python front end vqe/python/module.cpp exposes both as properties on the options object and repeats both checks. Because the code keeps every gradient at or above tau times the largest, where the paper keeps every gradient differing from the largest by a ratio less than r, tau plays the part of the reciprocal of r — and the README's own batched example passes -at 0.5, which is the reciprocal of the r = 2 the paper sets for every molecule it simulates. The inner VQE solve is NLopt, defaulting to the derivative-free LN_COBYLA under a budget of 100 objective evaluations per inner solve (adapt_max_evaluations) and a default cap of 50 ADAPT rounds (adapt_max_iterations), where the paper's own runs used gradient-based SLSQP capped at 200 iterations — an iteration count, not an evaluation budget, so the two numbers are not directly comparable. The README's batched invocation is ./build/vqe/nwq_vqe -f vqe/example_hamiltonians/H4_4_0.9_xacc.hamil -p 4 --adapt -ak 10 -at 0.5. The repository has exactly one release, v1.0.0 of 2023-08-03, which predates the batched commit by more than two years while the top-level README declares Current version 2.0, so no tagged version of NWQ-Sim carries this feature and a user has to build from main.

  The repository publishes no result from a batched run. The table of energies in vqe/example_hamiltonians/README.md — ADAPT-VQE rows for H4 at 1.5 Angstrom, LiH at 3.4 Angstrom and H6 at 2.2 Angstrom, against eigendecomposition FCI values in the same table — is not one, and it is not clean provenance either: all four commands printed beneath it under the heading Example commands used for the table run LiH34.hamil, so the H4 and H6 columns cannot have come from them; one of the two ADAPT-VQE commands passes a --gsd flag that the current vqe/main.cpp no longer parses; and neither ADAPT-VQE command sets -ak or -at, which with the shipped defaults leaves batching off. The batched path appears in vqe/README.md only as a syntax example on H4, with no energy, no iteration count and no gradient-evaluation count reported beside it, and vqe/adapt_vqe_perlmutter.md, the only other document in the repository giving ADAPT-VQE run commands, sets neither flag and mentions batches only in its Slurm SBATCH directives. The saving that Sapova and Fedorov measure, a reduction in rounds and so in total derivative evaluations, is therefore implemented but not reproduced anywhere in this repository.

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.

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.

• ADAPT-VQE adaptive ansatz

  Refuse to fix the structure in advance. Start from nothing and add one operator at a time, choosing each from a pool according to what the molecule itself indicates, until the energy stops improving. The circuit ends up short because nothing was included that the problem did not ask for.

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

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

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

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

• Batched ADAPT-VQE

  Several high-gradient operators are appended per adaptive iteration to reduce optimization and measurement rounds.

• Variational quantum eigensolver techniques for simulating carbon monoxide oxidation↗M. D. Sapova, A. K. Fedorov · 2021theory no · simulation yes · hardware no