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

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

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

Anastasiou et al. report a classical numerical simulation study, run with Python code the authors wrote themselves, comparing TETRIS-ADAPT-VQE against plain ADAPT-VQE on four molecules in a linear geometry and the STO-3G basis: H4 (8 qubits), LiH (12 qubits), H6 (12 qubits) and BeH2 (14 qubits), with both a Pauli-string qubit pool and a qubit-excitation (QE) pool tried for each molecule, optimized with SciPy's BFGS at a gradient-norm tolerance of $10^{-10}$ under a pool-gradient-norm convergence threshold of $10^{-7}$, with circuits compiled in Qiskit at optimization level 1 assuming all-to-all qubit connectivity throughout. Averaged over several bond lengths at ADAPT-VQE convergence, the ADAPT-VQE-to-TETRIS-ADAPT-VQE circuit-depth ratio runs from 1.58 (H4, QE pool) to 2.73 (BeH2, qubit pool) and grows with system size, while the number of pool-gradient measurements TETRIS needs falls by 53 percent (H4) to 70 percent (BeH2) relative to ADAPT-VQE. The gain sits specifically in depth: the paper's own conclusion states that this "results in significantly shallower circuits with roughly the same number of CNOT gates and variational parameters compared to the original ADAPT-VQE" — parity, not an additional reduction in either count. Both averages silently exclude, without stating how many, any bond-length geometry where either algorithm failed to reach the ground state, and the measurement-reduction figures are computed with no grouping of operators for simultaneous measurement assumed, a simplification the paper states without analyzing what a grouped measurement scheme would do to the comparison. Nowhere in this study is a physical qubit involved: every circuit is compiled in Qiskit to count gates and depth, never executed.

Classical simulation · Sec. III A-B, Table I, Table II of arXiv:2209.10562

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

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.

• adapt_vqe_tetris in the yzchen-phy/adapt-vqe fork

  This method's own paper names no repository for its numerics — it says only that "The results in this section were produced using python code written by the authors", and the arXiv version carries no code- or data-availability statement. A public repository, github.com/yzchen-phy/adapt-vqe, does carry a TETRIS implementation. It is a fork of virginia-tech-quantum/adapt-vqe, itself a fork of hrgrimsl/OF_VQE, and the parent tree contains no occurrence of the string tetris and defines adapt_vqe only, so adapt_vqe_tetris and the tetris/ directory are this fork's own additions. The GitHub account carries no name of its own; the only name the tree points at sits on the README's last line, under its ADAPT-QAOA heading, crediting that code to "How Much Entanglement Do Quantum Optimization Algorithms Require?", arXiv:2205.12283, whose first author is Yanzhu Chen — the method paper's second author. The README otherwise describes the package as code that "Includes simulation code for performing ADAPT-VQE and ADAPT-QAOA calculations" and never mentions TETRIS; the TETRIS work sits in a tetris/ directory of driver scripts and committed output that the README does not describe.

  The selection rule is the function adapt_vqe_tetris in src/vqe_methods.py, which takes a boolean Tetris argument. Each iteration measures one gradient per pool operator through pool.compute_gradient_i, accumulates the pool gradient norm, sorts grad_list descending by absolute gradient, and always appends the largest. When Tetris is True it then walks the rest of the sorted list, appending any operator for which pool.has_overlap returns false against every operator already added in that iteration. has_overlap, in src/operator_pools_pauli.py, is documented as "check qubit support of operator j and support of operator k", but it reads only the first Pauli term of each of the two operators — which is the whole support for these pools, since Pauli_QEB.double_exc builds an operator as a sum of eight terms all on the same four qubits. The packing loop applies no nonzero-gradient test, so an operator whose gradient has fallen to zero can still be packed when its support is disjoint, whereas the paper's step 4'(d) stops once "the list of operators with nonzero gradients and disjoint support with operators already added in the current ADAPT iteration has been exhausted". Convergence is the pool gradient norm against adapt_thresh, and the whole ansatz is then re-optimized by scipy.optimize.minimize with method 'BFGS' and gtol set to theta_thresh.

  The drivers build the molecule with PySCF through pyscf_helper.init in the sto-3g basis, obtain the qubit Hamiltonian as an OpenFermion sparse operator, and start from the Hartree-Fock determinant built by openfermion.jw_configuration_state. tetris/trial_tetris.py runs linear H4 at a bond length given on the command line with the QE pool, operator_pools_pauli.Pauli_QEB, the qubit-pool line Pauli_qubit left commented out beside it; trial_regular.py is the same script with Tetris set to False, and trial_tetris6.py and trial_regular6.py are the H6 pair. Committed output under tetris/data_QEB and tetris/data_qubit covers H4 and H6 only at bond lengths 1.0 through 5.0 Angstrom, twenty files in each directory as paired tetris and reg runs, of which twelve end at the drivers' own adapt_maxiter of 200 rather than at convergence and two end after two iterations; the paper reports H4, LiH, H6 and BeH2.

  Repository github.com/yzchen-phy/adapt-vqe, Python, installed with pip install ., default branch master, most recent commit dated 24 June 2024; there is no LICENSE file anywhere in the tree. The entry point is vqe_methods.adapt_vqe_tetris and the drivers call it as adapt_vqe_tetris(hamiltonian, pool, reference_ket, file_out, Tetris, adapt_maxiter=200, adapt_thresh=1e-7, theta_thresh=1e-10) — the same two thresholds the paper states, a pool gradient norm threshold of 10 to the minus 7 and a BFGS gradient norm tolerance of 10 to the minus 10.

  No paper links to this repository. What is committed is per-run output that predates the code now in the tree: the files carry three columns under a header reading n_iter, energy and index_op, where the committed adapt_vqe_tetris writes five and each driver writes an E_gs line before them. Each row gives an iteration number, an energy, and the list of operator indices added in that iteration, and in tetris/data_QEB/H4_3.0_tetris.txt seven of the eight rows carry two indices while one carries four — the packing the method is named for, visible in the data. Two files line up with the paper's own worked example, H4 at 3.0 Angstrom with the qubit pool: tetris/data_qubit/H4_3.0_tetris.txt runs to iteration 13 with its energy flat from iteration 12, against the paper's "TETRIS-qubit-ADAPT-VQE converges to the exact ground state within 13 iterations", and tetris/data_qubit/H4_3.0_reg.txt stops after two rows, against the paper's account of plain qubit-ADAPT reaching an eigenstate there so that "the ansatz growth stops, as the pool gradient vanishes". That is corroboration and not proof: neither the paper nor the repository says the two are the same runs. The runs are classical sparse-matrix simulation throughout, with the reference ground state taken from scipy.sparse.linalg.eigsh; no device and no simulator backend appears anywhere in the drivers.

• TETRIS mode in the adaptvqe package (ceo-adapt-vqe)

  • Reducing the Resources Required by ADAPT-VQE Using Coupled Exchange Operators and Improved Subroutines

  Ramôa, Anastasiou, Santos, Mayhall, Barnes and Economou wrote this package for a different question — a new operator pool they call the Coupled Exchange Operator pool — and treat this method as one of three transversal improvements folded in on top of it. Their own summary of it is that "multiple operators acting on disjoint qubit sets (i.e. with disjoint supports) are added to the ansatz in each iteration. Among all operators satisfying the disjoint support condition, priority is given to operators with higher gradient magnitudes." Their code-availability statement points at the repository: "The code used for the numerical simulations has been made publicly available at https://github.com/mafaldaramoa/ceo-adapt-vqe."

  TETRIS is a constructor flag on the AdaptVQE class, documented as "tetris (bool): Whether to do TETRIS-ADAPT". With it set, an iteration keeps growing while viable candidates remain, and after each addition update_viable_candidates calls tetris_screening, which unions the last operator's qubits into self.iteration_qubits and keeps a candidate only where op_qubits.isdisjoint(self.iteration_qubits). What screening filters is the whole pool rather than a shortlist: set_window sets window = self.pool.size when self.tetris is true, its docstring giving the reason as "On TETRIS mode, we might use all operators with nonzero gradient, hence the list should contain the whole pool." A companion flag progressive_opt decides whether the iteration's new parameters are optimized "at once or in a phased manner", and is refused outside TETRIS mode with ValueError("Progressive optimization is only defined by TETRIS mode.").

  Molecules come mostly from the package's own molecules submodule over PySCF and OpenFermion, with examples/Truncation/water.py and water_ov.py instead taking a PubChem geometry through OpenFermion directly. The example scripts that switch TETRIS on are small: examples/QE_Pool/QE.py runs H3 at r = 1.5 with the QE pool, examples/Qubit_Pool/Qubit.py runs H2 at r = 1.5 with NoZPauliPool, and further scripts passing tetris=True sit under examples/Truncation, examples/CEO and examples/Tensor_Networks. The paper's own runs are LiH, linear and triangular H6, and BeH2, on 12 to 14 qubits.

  Repository github.com/mafaldaramoa/ceo-adapt-vqe under the Apache License 2.0; the installed package is named adaptvqe, version 0.0.1 in pyproject.toml, authored by Mafalda Ramôa, requiring Python 3.10 or later and depending on scipy, openfermion, pyscf, openfermionpyscf, qiskit and quimb. The class is AdaptVQE in adaptvqe/algorithms/adapt_vqe.py and the screening method is tetris_screening in the same file. The QE-, qubit-, CEO- and truncation-pool examples drive the flag through the LinAlgAdapt subclass, whose docstring reads "Class for ADAPT-VQEs in which the energy and gradients are calculated using linear algebra. Expectation values are calculated exactly, with no sampling noise"; the two examples/Tensor_Networks scripts drive the same flag through TensorNetAdapt, a truncated-bond quimb path with max_mpo_bond and max_mps_bond arguments, and a third subclass SampledLinAlgAdapt exists alongside a shots argument.

  The paper's headline reductions — CNOT count, CNOT depth and measurement costs down by up to 88%, 96% and 99.6% against GSD-ADAPT-VQE on LiH, H6 and BeH2 — are for a combination the authors label CEO-ADAPT-VQE*, which stacks the CEO pool, this method, optimized gradient measurements and Hessian recycling, so no one of those numbers is this method's alone. Appendix B, which the paper's own cross-reference instead calls Sec. II of the Supplementary Information, does separate the three, and there this method is the only one that moves the iteration count: "only TETRIS relevantly affects the iteration count", the CNOT depth is "predictably lowered by TETRIS", and its effect on measurement cost is "a slight reduction in measurement costs by virtue of requiring a lower number of iterations". Every number is classical simulation with no device and no sampling: "we compute the expectation values via matrix algebra, without including shot noise or hardware noise".

• TETRISADAPT in ADAPT.jl

  Kyle Sherbert's Julia package is a general ADAPT framework — "There are many like it, but this one is mine" — written so that "different variants of ADAPT can usually be implemented by dropping in a single file, plus some very light changes to the main package". This method is one of those files. No paper documents the package: its README links the ADAPT-VQE article rather than any paper of its own and never mentions TETRIS, and a downstream package that requires it — TEPID-ADAPT, whose Project.toml pins ADAPT 1.0.0 — is described in its own paper only as "implemented with the Julia programming language", naming neither the package nor TETRIS.

  src/tetrisADAPT/TETRIS.jl defines struct TETRISADAPT{F} <: ADAPT.AdaptProtocol with a single field, gradient_threshold, and overrides ADAPT.adapt!. That method scores every pool operator, discards each candidate below the threshold with filter!(p-> p.second >= adapt_type.gradient_threshold, candidates), then loops: findmax takes the highest-scoring survivor, filter!(p-> isdisjoint(support(p.first), G_support), candidates) throws away everything overlapping it, and the winner is pushed onto ops_to_add, until the candidate dictionary is empty. The whole selection is then appended at once with every parameter set to zero. support is local to the file and collects the positions where the Pauli string is not the identity; the score itself is abs of the partial derivative of the observable with respect to the appended generator's parameter, computed in ADAPT.calculate_score. One thing differs from the paper: the convergence test inside adapt! compares every score against machine epsilon, eps(ADAPT.typeof_score(adapt_type)), rather than against a pool gradient norm, and the example script stops the run with a separate ADAPT.Callbacks.ScoreStopper callback instead.

  The only inputs in the tree are test fixtures. test/hubbard_tetris_qeb.jl builds a one-dimensional Hubbard Hamiltonian through ADAPT.Hamiltonians.hubbard_hamiltonian(L, U, -1.0, pbc=true) with L = 4 sites and U = 4u at u = 0.25, on 2L = 8 qubits, draws the pool from ADAPT.Pools.qubitexcitationpool(2L), and starts from a Néel reference bit string.

  Repository github.com/kmsherbertvt/ADAPT.jl under the MIT License; Project.toml names the package ADAPT, version 1.0.0-DEV, authors "Kyle Sherbert <kyle.sherbert@vt.edu> and contributors". The file is src/tetrisADAPT/TETRIS.jl and the type is addressed as ADAPT.TETRIS_ADAPT.TETRISADAPT. A second file, src/qaoa/TetrisQAOA.jl, carries the same packing over to ADAPT-QAOA through a TetrisQAOAAnsatz type.

  There are no published numbers. The evidence that it runs is the package's own suite: test/runtests.jl carries a testset named "TETRIS-ADAPT" that calls ADAPT.validate on ADAPT.TETRIS_ADAPT.TETRISADAPT(1e-4) with BFGS, a ScaledPauliVector pool, a PauliSum observable and a statevector reference, and test/hubbard_tetris_qeb.jl is a runnable script that ends by printing the relative energy error against a ground state obtained by dense eigendecomposition. Everything is in-memory Julia linear algebra; the package's dependency list carries no quantum-hardware or simulator package, and the strings qiskit, backend and shots appear nowhere in the tree.

• TETRIS selection reused for Gibbs states in TEPID-ADAPT

  • TEPID-ADAPT: Adaptive variational method for simultaneous preparation of low-temperature Gibbs and low-lying eigenstates

  This is the selection rule carried out of ground-state chemistry and into thermal-state preparation. The README describes the package as "implementing the TEPID-ADAPT algorithm" for "variationally preparing Gibbs states at low-temperatures", and its install instructions require ADAPT.jl by URL. The cited paper documents the algorithm, not this module: its only mention of the implementation is that the ADAPT subroutine was "implemented with the Julia programming language", and the strings TETRIS, disjoint and ADAPT.jl appear nowhere in it. So the module is code that exists without a write-up.

  src/TETRIS/TETRIS_Functions.jl reuses ADAPT.jl's type rather than redefining it: both functions it adds dispatch on adapt_type::ADAPT.TETRIS_ADAPT.TETRISADAPT, and the packing loop is the same one, a filter! on gradient_threshold followed by findmax and filter!(p-> isdisjoint(ADAPT.TETRIS_ADAPT.support(p.first), G_support), candidates) until the candidate dictionary is empty, with every selected parameter initialised to zero. What differs is the state acted on and how a score is computed: TEPID.calculate_scores evolves a TEPID_Ansatz over a chosen computational-basis subspace and scores each pool operator as abs of measure_commutator against the observable, and the adaptation pushes onto ansatz.generators and ansatz.parameters directly rather than through ADAPT.jl's push!. The convergence test is ADAPT.jl's, every score against machine epsilon.

  The one driver is scripts/examples/Heisenberg_fullPauli_TETRIS.jl, which builds a six-site XYZ chain through TEPID.Hamiltonians.xyz_model(L, Jx, Jy, Jz, PBCs) at L = 6, Jx = Jy = 1.0, Jz = -1.5 and open boundaries, runs at inverse temperature 2.0 over a six-element computational-basis subspace, and draws the pool from TEPID.Pools.fullpauli_sorted(L, mcut).

  Repository github.com/Bharatheon-vt/TEPID-ADAPT under the BSD 3-Clause License, not a fork, last pushed 9 April 2026. Project.toml names the package TEPID, version 0.1.0, author "Bharath Sambasivam <sbharath@vt.edu>", and pins ADAPT 1.0.0 among its dependencies. The file is src/TETRIS/TETRIS_Functions.jl, included as the nested module TEPID.TETRIS; a separate helper, load_TETRISansatz_from_trace in src/qiskit/qiskit_interface.jl, rebuilds a packed ansatz from a saved trace.

  There are no published numbers. The driver ends by printing a relative free-energy error against an exact Gibbs state built by dense eigendecomposition, together with a fidelity from QuantumInformation.fidelity, and it optimizes with Optim's BFGS under a BackTracking line search. That path is in-memory Julia linear algebra with no device and no backend. The package does carry a Qiskit path elsewhere — src/qiskit/qiskit_interface.jl transpiles an ansatz against a GenericBackendV2 to count CNOT depth and defines an Estimator with a default of 10000 shots — but the TETRIS driver never calls it.

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.

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

• TETRIS-ADAPT-VQE

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

• 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