ADAPT-VQE Algorithm

Grow the ansatz adaptively: at each step add the operator from a pool with the largest energy gradient, building a compact, problem-tailored shallow circuit. Understand first why it works this way, then see how qalgora-Q runs the whole loop in a single call.

The problem it solves — fixed ansätze are either too big or too small

A fixed ansatz like UCCSD crams every single and double excitation into the circuit, whether or not they actually matter for the molecule in front of you. The result is usually a circuit that is far too deep — many of those parameters contribute almost nothing, yet they still burn through precious coherence time. But pruning excitations by hand is hard, because you have no way of knowing in advance which ones to keep and which to throw away. ADAPT-VQE takes a different tack: instead of building the ansatz all at once, it grows it on demand, adding only the single most useful operator at each step.

The intuition — lay one brick at a time, always downhill

Lay out a pool of candidate excitation operators and ask one question: if I were to wire a given operator into the circuit right now, how fast could it push the energy down? The answer is that operator's energy gradient. Each round, ADAPT-VQE picks the operator with the largest gradient — the steepest available descent direction — adds it, re-optimizes all the parameters, and asks the question again. Building up brick by brick this way, the circuit contains only operators that genuinely drive the energy downward, which keeps it both shallow and accurate.

The math — measuring the gradient with a commutator

In the current state |ψ⟩, wiring in operator Ai with a parameter θ_i, the derivative of the energy with respect to that parameter (evaluated at θ_i=0) is given by the expectation value of a commutator:

∂E/∂θi|0 = ⟨ψ| [H, Ai] |ψ⟩

This formula assumes a specific generator convention. If the candidate unitary is written e(θ Ai) with Ai an anti-Hermitian excitation generator, then ∂E/∂θi|0 = ⟨ψ|[H, Ai]|ψ⟩. If instead a Hermitian generator Gi is used with e(−iθ Gi), the gradient is −i⟨ψ|[H, Gi]|ψ⟩. Different packages adopt different generator conventions, so follow the specific ansatz definition.

This quantity tells us directly which direction, and how fast, the energy would move if we added Ai. The larger its absolute value, the more "valuable" that operator is right now. When the gradients of every operator in the pool have dropped below some threshold, adding any further operator would barely help — that is convergence, and the loop stops.

The mechanism — the adaptive growth loop

1. For every operator Ai in the pool, measure the gradient ⟨[H, A_i]⟩.
2. Pick the operator with the largest gradient magnitude and append it to the circuit ansatz.
3. Re-optimize all parameters so far together with VQE.
4. Return to step one, until the largest gradient falls below the threshold.

Each additional round grows the circuit by exactly one operator and one parameter. What you end up with is not a generic template, but a compact circuit custom-built for this particular Hamiltonian.

Honest boundaries — the measurement cost of gradient screening

• Screening isn't free. Every round you have to measure the gradient of each operator in the pool before you can crown a winner. The larger the pool, the more expensive this screening becomes — it buys you a shallower circuit, but at the price of more measurements.
• It is a greedy strategy. Taking the steepest direction at every step does not guarantee the globally shortest circuit, and it can stall in a local minimum.
• Re-optimization gets pricier as the circuit grows. Every added operator means re-optimizing all the parameters again, so each round's optimization cost keeps rising late in the run.
• The choice of operator pool is critical. Too small a pool lacks expressive power; too large a pool makes screening explode — designing the pool is itself a trade-off.

Reading the code against the theory

Read the code below against the discussion above. get_operator_pool("uccsd", ...) pulls out the pool of candidate excitation operators — exactly the batch whose gradients get evaluated one by one. solvers.adapt_vqe(...) wraps the entire loop: internally gradient="parameter_shift" estimates each candidate's energy gradient via the parameter-shift rule; in ADAPT-VQE's theory this same gradient can equivalently be expressed through the commutator expectation ⟨[H, A_i]⟩. Both target the same selection criterion, but the measurement implementation need not be identical. It then picks the largest to wire in, re-optimizes with LBFGS, and stops only once the largest gradient drops below threshold=1e-3. The returned len(ops) is the number of operators ultimately selected and actually used — usually far fewer than the whole pool, which is precisely why the circuit stays compact.

Using the Solvers library

import qalgora
import qalgora_solvers as solvers
from qalgora import spin

hamiltonian = spin.z(0) + spin.z(1) - 0.5 * spin.x(0) * spin.x(1)
pool = solvers.get_operator_pool("uccsd", num_qubits=2, num_electrons=2)

energy, params, ops = solvers.adapt_vqe(
    hamiltonian, pool,
    optimizer=qalgora.optimizers.LBFGS(),
    gradient="parameter_shift",
    threshold=1e-3,
)
print("ground-state energy:", energy)
print("operators selected:", len(ops))

This UCCSD pool is a teaching-interface example; a real molecular calculation also needs the orbitals, electron count, fermion-to-qubit mapping, and Hamiltonian-generation pipeline specified.

References

• H. R. Grimsley, S. E. Economou, E. Barnes, N. J. Mayhall, "An adaptive variational algorithm for exact molecular simulations on a quantum computer," Nat. Commun. 10, 3007 (2019). doi:10.1038/s41467-019-10988-2
• A. Peruzzo, J. McClean, P. Shadbolt, M.-H. Yung, X.-Q. Zhou, P. J. Love, A. Aspuru-Guzik, J. L. O'Brien, "A variational eigenvalue solver on a photonic quantum processor," Nat. Commun. 5, 4213 (2014). doi:10.1038/ncomms5213