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

Tang et al. name the gaps in the parent they are closing, and they are gaps in the specification rather than in the results: the original "did not provide a prescription for how to select the pool, how many operators it must contain, or whether the resulting ansatz will succeed in converging to the ground state". They also state the practical failure that motivates the qubit pool — the original pool "leads to state preparation circuits that are too deep for a practical application on near-term 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.

  Before any parameter is optimized, each growth step asks this ingredient for one commutator expectation per pool operator: $\langle\psi|[\hat H,\hat P_i]|\psi\rangle$ for each $\hat P_i$. The calls per step therefore number the pool size, and the qubit pool is larger than the fermionic one it replaces, which "leads to proportionally more measurements at each iteration." The relief is a smaller pool, not a cheaper estimator: for $n$ qubits a complete pool needs only $2n-2$ operators, so "the additional measurement overhead of qubit-ADAPT compared to fixed-ansatz variational algorithms scales only linearly with the number of qubits" assumption: that bound is for a minimal complete pool and against non-adaptive VQE, which screens no gradients; the reported energies used the larger fermionic-derived pool, and no per-step comparison with fermionic-ADAPT is given. Calls per run also carry the iteration count, which moves the other way: qubit-ADAPT "requires more variational parameters" than fermionic-ADAPT, each one a further pool sweep, and that trade is not quantified.

  assumption

Example

given  Hamiltonian H on n qubits,
       reference state  |psi_HF>,
       operator pool  P = { individual Pauli strings P_a = i * (p_1 (x) ... (x) p_q),
           p_j in {X,Y,Z}, that appear when the spin-adapted fermionic single-
           and double-excitation pool is Jordan-Wigner-decomposed for this system },
       P restricted to odd-Y strings, Jordan-Wigner Z-chains stripped so
           length(P_a) <= 4  --  the "qubit pool": much smaller than the full
           length<=4 Pauli set, since only strings already present in the
           fermionic pool survive                                    (Sec. III)
       convergence threshold  eps > 0

requires  H real, time-reversal symmetric
    # an even-Y P_a's gradient vanishes identically against such an H --
    #   that is why P excludes them outright, not a later screening step
    # P here is this fermionic-derived qubit pool, not the separate minimal
    #   complete pools {V_j}_n / {G_j}_n -- those are DEFINED in Sec. III B
    #   and proved complete there via a rank criterion (proofs in App. B/C);
    #   P's own completeness against that criterion is never established

# --- grow the ansatz: one Pauli-string term, one parameter, per iteration ---
|psi> <- |psi_HF>;   ansatz <- [ ];   k <- 0
loop
    for each  P_a in P:                                    # observable-estimation
        g_a <- <psi| [H, P_a] |psi>                                     (Eq. 2)
    ||g|| <- sqrt( sum_a g_a^2 )                                        (Eq. 3)
    if ||g|| < eps:  break
        # growth stops once the gradient norm drops below the threshold
    a_k <- argmax_a |g_a|
        # the pool operator causing the largest energy change is added next
    k <- k + 1;   theta_k <- 0;   ansatz <- ansatz ++ [ (theta_k, P_{a_k}) ]
    theta_1 .. theta_k <- classical optimizer minimizing  <psi(theta)| H |psi(theta)>
        # scope not spelled out by THIS paper -- inherited ADAPT-VQE protocol;
        #   text here only supports "more params cost more" (Sec. III A)
    |psi> <- exp(theta_k P_{a_k}) ... exp(theta_1 P_{a_1}) |psi_HF>          (Eq. 1)

return  the parameterised circuit family
        |psi^ADAPT(theta)> = exp(theta_k P_{a_k}) ... exp(theta_1 P_{a_1}) |psi_HF>   (Eq. 1)
# ansatz depth stays at the k found above; theta is left at its last
#   classically-optimized value

Cost, as the source states it

Tang, Shkolnikov, Barron, Grimsley, Mayhall, Barnes and Economou count $\bar{N}_{\mathrm{CNOT}} = 6$ CNOTs per variational parameter (Eq. A1), a figure they call a conservative estimate: exponentiating a Pauli string of length $q$ costs $2(q-1)$ CNOTs, and the qubit pool, with the Jordan-Wigner $Z$ chains stripped, has maximum length 4. One iteration adds one operator and one parameter. The generalized singles-doubles fermionic pool it replaces costs $\bar{N}_{\mathrm{CNOT}} = (6+2\bar{N}_Z)\bar{N}_{\mathrm{Pauli}}\bar{N}_{\mathrm{spin}}$ per spin-adapted doubles operator after first-order Trotterization (Eq. A2), roughly $64m$ for large $m$ spatial orbitals, and accurate only when all spin orbitals are evenly explored, i.e. no core orbitals - for LiH it overshoots the counted total by a third. Each step measures $\langle\psi|[\hat{H},\hat{\tau}_i]|\psi\rangle$ over the whole pool: additional measurements roughly pool size times Hamiltonian terms. Complete pools of size $2n-2$ are proved to exist constructively, but that minimum is numerical up to 7 qubits, and only 20-40% of random pools of that size are complete at $n=3,4,5$. Nothing bounds the iteration count, hence nothing bounds the total; the roughly order-of-magnitude CNOT reduction over fermionic-ADAPT is measured on H4, LiH and H6 in STO-3G, not proved.

Implementations

• qubit-ADAPT against fermionic-ADAPT on H4, LiH and H6

  • qubit-ADAPT-VQE: An adaptive algorithm for constructing hardware-efficient ansatze on a quantum processor

  The run the method was introduced for. Tang, Shkolnikov, Barron, Grimsley, Mayhall, Barnes and Economou set qubit-ADAPT against the fermionic-pool version of the same algorithm, and they name the thing they are measuring against in the introduction: "We term this algorithm qubit-Adaptive Derivative Assembled Problem-Tailored (qubit-ADAPT) VQE, in contrast with the implementation in Ref. [29], which we refer to as fermionic-ADAPT in this paper." Ref. 29 is Grimsley et al., the parent method. The claim under test is stated in the abstract: "Through numerical simulations on H4, LiH and H6, we show that our algorithm (“qubit-ADAPT”) reduces the circuit depth by an order of magnitude while maintaining the same accuracy as the original ADAPT-VQE." Two quantities are tracked per run, the number of variational parameters, which equals the ADAPT iteration count, and the number of CNOTs in the state preparation circuit; the outcome the paper reports is a trade between them rather than a win on both.

  Sec. III A runs both algorithms on each molecule and plots the energy error against FCI twice, once as a function of the iteration count and once as a function of the CNOT count of the corresponding state preparation circuit (Fig. 1, panels (a)-(c) and (d)-(f) respectively). The CNOTs behind those curves are counted from circuits rather than estimated from the formulas of Sec. II and Appendix A: "All CNOT gate counts are obtained using the qiskit command count ops, where we consider the case of all-to-all qubit connectivity for concreteness." For fermionic-ADAPT two curves are given, before and after transpilation, and the transpiled counts come from "qiskit.transpile [47] with heavy optimization, which includes canceling back-to-back CNOTs and “commutative cancellation”". The all-to-all assumption is acknowledged as favourable and left uncorrected: "Although these counts will increase as the connectivity is reduced, we do not expect the relative performance of the two algorithms to change significantly." Two controls sit on top of the head-to-head comparison inside Sec. III A. Fig. 2 replaces the gradient selection with random operator orderings drawn from the same qubit pool, on H4 and LiH, to test whether the gradient is what does the work. Fig. 3 repeats LiH at bond distances from 1Å to 3Å, to test sensitivity to the amount of correlation in the ground state. A third control belongs to the section after it: Sec. III B opens by thinning the qubit pool, removing randomly selected operators and keeping 1/4, 1/16 and 1/32 of it, on H4 at "The orbital basis and bond distance ... chosen as in Fig. 1" (Fig. 4). Qiskit is the only software the paper names, and it names it only for the gate counts and the transpilation: no simulator, no classical optimizer and no shot count is given anywhere for the energy evaluations themselves.

  Three molecules at geometries chosen for strong correlation: "In each case, we choose a bond distance such that correlation effects are significant: r = 1.5Å for H4 and H6, and r = 2Å for LiH." The orbital treatment is stated once for all of them: "All the calculations are performed using an STO-3G basis and start from restricted Hartree-Fock orbitals without using a frozen-core approximation such that we have 8 spin-orbitals for H4 and 12 spin-orbitals for each of the other two molecules." The fermion-to-qubit map is Jordan-Wigner throughout - "In this paper, we employ the Jordan-Wigner (JW) mapping" - with the others deferred: "Adapting the methods we develop here to other mappings [44-46] will be the subject of future work." Beyond the bond distance, the H4 and H6 geometries are given only by the atom strings drawn above the panels of Fig. 1, and the source of the one- and two-electron integrals is not stated.

  Fig. 1 reports the energy difference from the exact (FCI) result for H4 at 1.5Å, LiH at 2Å and H6 at 1.5Å, with qubit-ADAPT, fermionic-ADAPT and transpiled fermionic-ADAPT on the same axes. The outcome is a trade, and the paper states both halves of it: "It is evident from Fig. 1 that in the case of the qubit pool, more parameters are used compared to the fermionic pool. On the other hand, the number of CNOTs is reduced significantly, by about an order of magnitude in the case of H6." The abstract and the introduction state the order of magnitude for the three molecules together; in the body the only molecule the phrase is attached to by name is H6. On these runs the gradient selection is what keeps the parameter count down: on H4, "convergence to the ground state requires 46-78 parameters, compared to only 30 parameters for qubit-ADAPT", and on LiH the random orderings "require more than three times as many parameters as qubit-ADAPT to converge" - a figure the authors mark as incomplete, since "We can only provide a lower bound on the number of parameters needed to converge the random ordering results in Fig. 2(b) due to the long computational times needed in this case." They put the conclusion no more strongly than the runs allow: these findings "suggest that the role of the gradient selection in qubit-ADAPT is crucial for larger problems." Across LiH bond distances from 1Å to 3Å the curves largely overlap, and Fig. 3(c) plots "The final energies obtained by qubit-ADAPT (points marked by ×) for each bond distance considered" alongside "the exact ground state energies (solid curve)". Thinning the pool costs little at first and then costs accuracy: removing 3/4 of the operators leaves performance "similar to that with the original pool", and by Fig. 4's caption, "For the 1/4 and 1/16 pools, the algorithm can converge for almost every run. For the 1/32 pool, most of the runs can only reach an energy error of $10^{-3}$." Every number here comes from classical simulation - the paper calls them "classical simulations of several different molecules" - and it names no simulator, no classical optimizer and no shot count for them. No hardware run is reported.

• Minimal complete pools on random 3-, 4- and 5-qubit Hamiltonians

  • qubit-ADAPT-VQE: An adaptive algorithm for constructing hardware-efficient ansatze on a quantum processor

  The completeness study that closes Sec. III B of the same paper, and the one that answers the specification gap the paper opens with: what makes a pool good enough, and how small it can be. Sec. III B opens on the molecular pool-thinning of Fig. 4, recorded in the entry above, and then leaves chemistry behind. It fixes the test - "For a given pool, we define the overlap matrix as $M_{ij} = \langle\psi| A_i^\dagger A_j |\psi\rangle$ where $|\psi\rangle$ is an arbitrary real state. If the rank of $M$ satisfies $r(M) \geq 2^n - 1$, this pool is called complete." The $A_i$ are not the pool operators alone: they "include all the pool operators and their commutators", which is what lets a pool far smaller than the Hilbert space span it. Nothing chemical enters the completeness study - the Hamiltonians are random, and the energy axes of Fig. 6 are labelled in arbitrary units.

  Two things are run in it. First a search for the smallest complete pool: "To determine the smallest complete pools, we randomly generate many different pools of increasing size and compute $r(M)$ in each case to test for completeness. We did this for up to 7 qubits." Second, qubit-ADAPT itself is run with pools at that minimal size, to check that the rank criterion actually predicts convergence: "we run qubit-ADAPT for random real Hamiltonians of 3, 4 and 5 qubits with random initial states and for pools consisting of $2n-2$ operators randomly chosen from the set of odd Pauli strings. We also run simulations using the minimal complete pools $\{V_j\}_n$ and $\{G_j\}_n$." Those two families are the constructive proof of Appendices B and C made concrete: $\{V_j\}_n = \{Z_n\{V_k\}_{n-1}, iY_n, iY_{n-1}\}$ defined recursively from $\{V_j\}_2 = \{iZ_2Y_1, iY_2\}$, and $\{G_j\}_n$ holding "all two-qubit operators of the form $iZ_{k+1}Y_k$ that act on two neighboring qubits labeled by $k$ and $k+1$" together with "all single-qubit Pauli $iY$ operators except on the first qubit". Appendix C closes by naming the hardware $\{G_j\}_n$ was shaped for, and it names it as a target rather than as a machine anything here ran on: the pool "is particularly useful for quantum processors containing a linear array of qubits with nearest-neighbor coupling only", and "the entangling operators in the $G_i$ pool are similar to the cross-resonance interaction in fixed-frequency superconducting qubits, such as those in the IBM quantum processors" - a resemblance that "could be exploited to implement qubit-ADAPT with native hardware operations", in some future implementation and not in this one. The pools tested here are not the fermionic-derived qubit pool that produced the molecular curves of Fig. 1; they are random draws from the odd Pauli strings plus these two families. As in the molecular study, the paper names no simulator, no optimizer and no shot count.

  Random real symmetric Hamiltonians on 3, 4 and 5 qubits, with random initial states: "The operator coefficients in each Hamiltonian (which is taken to be real and symmetric) are obtained by sampling uniformly in the range $[-2, 2]$ with 10 samples for each of these 3 cases." No molecule, basis set or integral source enters, and Fig. 6's vertical axes read "energy (arbitrary units)". The completeness search that precedes it takes randomly generated pools of increasing size, tested up to 7 qubits, with Fig. 5 reporting the fraction complete for "two (blue circles), three (yellow squares), four (green diamonds), and five (red triangles) qubits".

  The minimal size comes out linear, and smaller than the authors expected: "Our numerical investigations reveal that, surprisingly, the minimal pool size required for the overlap matrix to have the required rank of $2^n - 1$ is only $2n-2$." Fig. 5 shows the fraction of random pools that are complete as a function of pool size, and "In each case, complete pools are found for pool sizes that contain at least $2n-2$ operators." At exactly that size most random pools still fail: "For the cases considered, we find that 20-40% of pools containing $2n-2$ operators are complete." On the runs that were made, the criterion separates the two outcomes without exception: "All of the curves that fail to converge correspond to incomplete pools. For these cases, even though the gradient goes to zero the ground state is not reached because important operators are never generated. On the other hand, the runs with complete pools always converge, highlighting the importance of this criterion." The search is what stops the sweep, and it is why existence is proved analytically in Appendix B rather than measured further: "Randomly selecting pools of size $2n - 2$ and testing for completeness by computing $r(M)$ is a numerically intensive process that quickly becomes infeasible as the number of qubits increases." The verdict returned on the parent's pool is that it was bigger than it had to be - the findings "suggest that the fermionic pool used in that work is overcomplete." All of it is classical simulation on random Hamiltonians: no molecule, no simulator, no classical optimizer and no shot count is named, and no hardware run is reported. The one device the paper names anywhere - the IBM quantum processors of Appendix C - is named as a target for a future implementation of $\{G_j\}_n$, not as a machine these runs used.

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.

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

• Qubit-ADAPT-VQE

  Qubit-space Pauli generators replace fermionic excitation operators to seek shorter adaptive circuits.

Sources

• qubit-ADAPT-VQE: An adaptive algorithm for constructing hardware-efficient ansatze on a quantum processor↗Ho Lun Tang, V. O. Shkolnikov, George S. Barron, Harper R. Grimsley, Nicholas J. Mayhall, Edwin Barnes, Sophia E. Economou · 2019theory yes · simulation yes · hardware no