MethodLayer 1
Batched ADAPT-VQE 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.
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.
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.
Same contract as the slot it fills.
This one, drawn
From Hamiltonian whose eigenvalues are wanted to Parameterised circuit family
A circle is an object you are holding. This method is drawn heavier, opened into its own steps; the other lines between the same two ends are the alternatives recorded for the same slot. Circles are named on hover, and each one is a link.
Nothing drawn here has a recorded way through it that this figure leaves shut. See it on the map
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.
A narrower version of ADAPT-VQE adaptive ansatz
When it applies
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.
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 , return a classical scalar within of at confidence . 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 circuit parameters — exact against analytic gradients only because these are noiseless statevector simulations, numerical ones being "less robust in the presence of noise".
approximationassumption
Example
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)Cost, as the source states it
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 of the largest (selected from ) needs all of them. Pool size is for spin-orbitals and electrons (fermionic UCCSD), or in system size — a different — for Pauli-string pools, carrying an 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, evaluations for a whole -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 Å batching computed about 10% more.
Implementations
Nobody has written one up yet. That is a gap in this record, not a statement that the method has never been run — the paper register already records, per paper, which sources report numerics or a hardware run.
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.
- 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.
In the Atlas
- Batched ADAPT-VQE
Several high-gradient operators are appended per adaptive iteration to reduce optimization and measurement rounds.