Iterative qubit coupled cluster

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 Qubit coupled-cluster ansatz

When it applies

Ryabinkin et al. state the trade in one sentence — "each iteration involves a canonical transformation of the Hamiltonian and employs constant-size quantum circuits at the expense of increasing the Hamiltonian size" — which is the whole point of the method: a NISQ device is bounded in circuit size, not in how many terms a classical computer can carry. The condition attached to convergence is the part not to skip: they "found that the exact ground-state energies can be systematically approached only if the generators of the QCC ansatz are sampled from a specific set of operators", so the generator pool is a correctness requirement here rather than a tuning choice, and the paper supplies an algorithm for constructing that set. Evidence is numerical, on LiH, H2O and N2; no hardware run is reported.

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.

  Each iteration asks the estimator for $\langle\hat H_d^{(k-1)}\rangle$ — the dressed operator carried in from prior rounds, not the bare $\hat H$ — on $\hat U(\tau)|\Omega\rangle$: a qubit mean-field product state under a fixed-size entangler. Eq. (7)'s minimization runs "with respect to $N_g$ amplitudes and $2n$ Bloch angles," repeated for "a small (usually 10) number of guesses," plus, whenever none beats the prior energy, a restart at $\tau=0$ and the previous Bloch angles — "guaranteed to lower energy because the chosen generators have non-zero energy gradients by construction." The operand grows, the circuit does not: dressing "increases the size of the Hamiltonian up to a factor of 3/2 at each step," hence "more measurements for a quantum one." Generator selection never comes back here: Eq. (9) scores each candidate $\hat P_i$ on the mean-field state $|\Omega_{\mathrm{min}}\rangle$ alone. The last return is "the ground-state energy estimate for the Hamiltonian $\hat H$."

Example

given  qubit Hamiltonian  H = sum_k C_k P_k,   M = O(n^4) Pauli terms on n qubits      (Eq. 3-4)
           C_k real, an even number of y-factors per P_k  (real electronic Hamiltonian)
       QMF reference  |Omega> = (x)_{j=1}^n |Omega_j>,
           |Omega_j> = cos(theta_j/2) |up>_j + e^(i phi_j) sin(theta_j/2) |down>_j      (Eq. 5-6)

requires  the optimum |Omega_min> -- or its "purified" state of maximum overlap with it --
    is a common eigenstate of every z_i,   prod_i z_i |Omega_min> = +/- |Omega_min>       (Eq. 10)
    # needed so the gradient below vanishes outside a flip-index partition of H;  the paper
    #   notes this condition frequently holds for the optimized QMF state as found, and
    #   supplies the purification only as a fallback when it does not
          Ng >= 1 generators per round,  N_steps rounds -- both are inputs, not derived
    # the authors "did not find rigorous conditions when such convergence was possible";
    #   only numerical evidence is offered, on LiH, H2O, N2 -- no hardware run

H_d^(0) = H       # base case for the round index k below            (Sec. II C, below Eq. 18)

# --- screen the CURRENT dressed Hamiltonian for its next Ng generators, classically ---
partition H_d^(k-1) into groups S_l by flip index  F(P_i) = {j : x_j or y_j in P_i}      (Eq. 12-15)
    # only P_i with odd y-parity and F(P_i) matching some group has  dE[P_i]/dtau != 0    (Eq. 8-11)
for each group S_l, build one representative P_l:  x on every flip index but one, y on the rest
    # this is the "direct interaction set" (DIS) -- O(M) representatives, one per group;
    #   the full set of generators satisfying the gradient condition is O(M 2^(n-1))
score each representative  |dE[P_l]/dtau|_0| = | <QMF| -i/2 [S_l, P_l] |QMF> |     (Eq. 8, S_l for H)
    # QMF = |Omega_min> is a product state with known Bloch angles -- computed classically,
    #   no device measurement;  Eq. 8's H is taken to be the LOCAL group S_l, not the full
    #   H_d^(k-1) -- that substitution is what makes the total screening cost O(M), summed
    #   over the O(M)-sized union of groups, rather than O(M) per representative
take the Ng representatives with largest |dE/dtau|
if max |dE/dtau| < threshold:  exit loop      # part of the base algorithm's step 1, same as
    #   the sampling step above it -- not an optional add-on (contrast the compression stretch
    #   below, which the paper itself does mark optional); no default numeric threshold is
    #   given in the main text

# --- optimize a FIXED-SIZE circuit against the dressed Hamiltonian, Eq. 7 ---
U(tau) = prod_{l=1}^{Ng} exp(-i tau_l P_l / 2)
    # circuit length is Ng exponentials -- independent of how many rounds have already run
minimize  E = <Omega| U(tau)^dagger H_d^(k-1) U(tau) |Omega>  over tau (Ng) and Bloch angles (2n)
    # <= 10 random-guess restarts (a reported typical count, not a fixed rule);
    #   if none beats the previous round's energy, retry once from tau=0 with the
    #   previous round's Bloch angles -- guaranteed not to raise the energy, since
    #   each P_l has dE/dtau|_0 != 0 by the screening step above

# --- dress: fold the optimized entanglers into the OPERATOR, not the circuit, Eq. 17-18 ---
H_d^(k) = H_d^(k-1)
        + sin(tau_l) ( -i/2 [H_d^(k-1), P_l] )
        + (1/2)(1 - cos tau_l) ( P_l H_d^(k-1) P_l - H_d^(k-1) )     # one P_l shown; apply Ng times
    # P_l H_d^(k-1) P_l only re-signs existing terms (Pauli anticommutation); all new terms
    #   come from the commutator, so a naive bound of 3^Ng tightens to ~ (3/2)^Ng M --
    #   an average-case estimate (Appendix A), not a worst-case bound

# --- optional: compress before the next round, Sec. II D ---
keep the J largest |C_j|,   sqrt( sum_{j>J} |C_j|^2 ) <= eps / 2^(n/2)                   (Eq. 21-23)
    # by Weyl's theorem this bounds every eigenvalue shift of the TRUNCATED operator:
    #   max_j |lambda_j(H_d) - lambda_j(H_c)| <= eps                                     (Eq. 20)
    #   -- a proved bound on the spectrum for a GIVEN J; nothing here bounds how large J must be

repeat from the screening step until round count reaches N_steps,
    or the gradient threshold above stops it first, whichever comes first  (Sec. II C, step 1)

return  the final round's QCC energy -- "the ground-state energy estimate for the Hamiltonian H"
# no total cost bound is given, since M grows per round with no proven ceiling: numerically,
#   14-qubit N2 (M = 825 at k=0) reached ~5x10^5 terms after 30 rounds and stayed more than
#   1 mEh from exact after 40 (Sec. III D) -- all evidence is numerical, no hardware run

Cost, as the source states it

Ryabinkin, Lang, Genin and Izmaylov give per-iteration counts and no total. The circuit stays fixed size: each iteration optimises $N_g$ amplitudes and $2n$ Bloch angles, then folds them into the Hamiltonian by Eq. (17)'s canonical transformation, with $N_g$ cut at run time to the number of distinct gradient groups. The Hamiltonian grows instead, from $M = O(n^4)$ Pauli terms to $\sim (3/2)^{N_g} M$ per dressing — an Appendix A average-case estimate, not a bound — and every retained term is one more to measure, with no shot count given. Screening generators costs $O(M)$, for a real electronic Hamiltonian and a mean-field reference that is an eigenstate of every $\hat z_i$. Nothing bounds the iterations: $N_{\text{steps}}$ is an input, and the authors "did not find rigorous conditions when such convergence was possible". Classically simulated, no hardware: 14-qubit $\mathrm{N}_2$ grew from 825 terms to $\sim 5 \times 10^5$ after 30 iterations, still over 1 $\mathrm{mE}_h$ from exact after 40. Keeping the $J$ largest coefficients with $\sqrt{\sum_{j>J} |C_j|^2} \le \varepsilon/2^{n/2}$ moves every eigenvalue by at most $\varepsilon$: a proved bound on the spectrum, not on $J$.

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.

• 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

• Iterative qubit coupled cluster

  Iterative QCC repeatedly dresses the Hamiltonian and selects new entanglers instead of fixing one deep circuit.

Sources

• Iterative Qubit Coupled Cluster approach with efficient screening of generators↗Ilya G. Ryabinkin, Robert A. Lang, Scott N. Genin, Artur F. Izmaylov · 2019theory yes · simulation yes · hardware no