TETRIS-ADAPT-VQE 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.

A narrower version of ADAPT-VQE adaptive ansatz

When it applies

Anastasiou et al. describe the change as lifting exactly one rule: this is "a modified version of the ADAPT-VQE algorithm in which the one-operator-at-a-time rule is lifted to allow for the addition of multiple operators with disjoint supports in each iteration". What it buys is stated without a number and with its limits named — the result is "denser but significantly shallower circuits, without increasing the number of CNOT gates or variational parameters", and "its advantage over the original algorithm in terms of circuit depths increases with the system size". It also cuts the measurement overhead ADAPT pays between rounds: "the expensive step of measuring the energy gradient with respect to each candidate unitary at each iteration is performed only a fraction of the time compared to ADAPT-VQE", because fewer rounds are needed once a round may add more than one operator. The motivation is hardware rather than accuracy — adaptive algorithms "are not yet viable due, in large part, to the severe coherence time limitations on current devices".

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.

  What TETRIS hands down is a single state — the current ansatz $|\Psi^{(k)}\rangle$ at its optimized parameters — together with the whole operator pool; what comes back is one number per pool operator, and the quantity the selection actually uses is its norm, $|g_i^{(k)}| = |\langle\Psi^{(k)}|[H,P_i]|\Psi^{(k)}\rangle|$. ADAPT-VQE consumes only $\arg\max_i |g_i^{(k)}|$ from that returned vector; TETRIS's subroutine 4' consumes the ranking itself, descending past the maximum and keeping each entry whose qubit support is disjoint from those already kept, so estimates well below the largest decide what enters the layer. Reading deeper costs the layer no extra calls: the gradients "need only be measured once per iteration of the algorithm as usual". approximation: every operator packed into one iteration is ranked by a gradient estimated on $|\Psi^{(k)}\rangle$, the state before any of that iteration's operators were appended — none is re-estimated as the layer fills

  approximation

Example

given  Hamiltonian H on Q qubits (already qubit-mapped, e.g. Jordan-Wigner, Sec. II);
           operator pool P = {P_i}, antihermitian generators -- typically the qubit
           or QE pool (Eqs. 11-13), chosen over the fermionic one (Eqs. 7-8) because
           their operators touch fewer qubits each;  reference state |Psi_ref>,
           usually Hartree-Fock;  gradient-norm convergence threshold eps

requires  P_i^dagger = -P_i  for every pool operator P_i
    # antihermiticity is what turns the raw energy derivative into the
    #   commutator expectation value used below (Sec. II B, at Eq. 6)

# --- outer ADAPT loop: grow the ansatz one layer at a time (Sec. II B, steps 1-6) ---
Psi^(0) = |Psi_ref>;  ansatz = [ ]  (ordered list of (P_i, theta_i) pairs);  k = 0
loop
    # --- one gradient sweep, the whole pool handed to observable-estimation ---
    {g_i^(k)}_{P_i in P} = observable-estimation(H, Psi^(k), P)
        # g_i^(k) = <Psi^(k)| [H, P_i] |Psi^(k)>                          (Eq. 6)
        # measured once per iteration, however many operators this iteration
        #   goes on to pack below: 'this can be done without measuring any
        #   additional gradients compared to ordinary ADAPT-VQE since the
        #   gradient of each pool operator need only be measured once per
        #   iteration of the algorithm as usual'

    if sqrt(sum_i (g_i^(k))^2) < eps:                                    # step 3
        return ansatz
            # TETRIS's own text says only 'the pool gradient norm' -- this
            #   step is inherited unchanged from ADAPT-VQE (ref [15]), which
            #   resolves it explicitly as the L2 norm of the gradient
            #   VECTOR across the whole pool, not any single |g_i^(k)|
            # 'ADAPT-VQE has converged, and the algorithm terminates'
            #   (Sec. II B, step 3) -- TETRIS reuses this criterion as-is
            # the paper's own numerics used eps = 1e-7 (Sec. III, opening
            #   paragraph) -- a run choice, not part of the algorithm itself

    # --- subroutine 4': pack disjoint-support operators into one layer ---------
    order = pool operators sorted by |g_i^(k)|, descending            # step 4'(a)
    covered = {}                   # union of qubit supports used this iteration
    layer = [ ]
    loop
        pick the first P_i in order with support(P_i) disjoint from covered
                                 and g_i^(k) != 0                       # step 4'(b)
        if no such P_i exists:  break                                  # step 4'(d)
        append (P_i, theta_i = 0) to layer
        covered = covered union support(P_i)
        if covered = {all Q qubits}:  break                            # step 4'(c)
    # the order above is fixed by gradient magnitude alone -- greedy, NOT a
    #   joint search for the disjoint subset that would lower the energy most

    ansatz = ansatz ++ layer
        # every pair in layer sits on qubits none of the others touch, so
        #   the whole layer can be 'implemented simultaneously in the
        #   circuit' (Sec. IV, point a) -- one packed layer per iteration,
        #   in place of ADAPT-VQE's single operator

    (ansatz, Psi^(k)) = optimize(ansatz)
        # 'perform a VQE subroutine to update all parameters in the
        #   current ansatz' (Sec. II B, step 5) -- the optimum overwrites
        #   each theta_i stored in ansatz itself, not just Psi^(k), since
        #   the return line below reads theta_i off of ansatz directly
        # step 5 does not specify how the parameters are initialised;
        #   Sec. III D tests recycling the previous round's optimum for
        #   pre-existing operators ('warm start') against cold-start and
        #   300 random draws and reports it as the usual, effective choice
        #   -- an empirical finding, not part of the step-5 definition
    k = k + 1

return  ansatz, read as  prod_layers ( prod_{(P_i,theta_i) in layer} exp(theta_i P_i) )
        applied to |Psi_ref>  --  a parameterised circuit family, each layer's
        gates scheduled simultaneously, handed to the calling VQE loop

Cost, as the source states it

Anastasiou, Chen, Mayhall, Barnes and Economou price TETRIS-ADAPT-VQE only relative to ADAPT-VQE. Measured at ADAPT-VQE convergence, averaged over an unenumerated set of bond lengths with failed geometries excluded and never counted: the circuit-depth ratio runs $1.58$ to $2.73$ across H4, LiH, H6 and BeH2 on 8 to 14 qubits, reported separately for the qubit and QE pools and growing with system size (Table I), and pool-gradient measurements fall 53% to 70%, pools not resolved and no operator grouping for simultaneous measurement assumed (Table II). CNOT and variational-parameter counts are, in the authors' words, "roughly the same" as ADAPT-VQE's, not smaller. Depths assume all-to-all connectivity, Qiskit optimization level 1, and ADAPT-VQE given the same concurrency. Each iteration still measures $\langle \Psi|[H,P_i]|\Psi \rangle$ for every pool operator; packing adds no gradients. Nothing bounds the iteration count — the authors merely expect the round reduction to be "roughly $\lfloor Q/4 \rfloor$" for $Q$ qubits, assuming a Jordan-Wigner, double-excitation-dominated ansatz — and the running text's only iteration count is 13, for H4 at 3.0 Angstrom. Absolute depths and CNOT counts appear only in Figs. 4 and 5.

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.

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

• TETRIS-ADAPT-VQE

  Operators with disjoint support are packed into the same adaptive layer to reduce circuit depth.

Sources

• TETRIS-ADAPT-VQE: An adaptive algorithm that yields shallower, denser circuit ansätze↗Panagiotis G. Anastasiou, Yanzhu Chen, Nicholas J. Mayhall, Edwin Barnes, Sophia E. Economou · 2022theory no · simulation yes · hardware no