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.

The Hamiltonian whose ground state is wanted, together with whatever structure is to be respected — particle number, spin, point-group symmetry, a reference determinant — and the connectivity and native gate set of the device the family has to run on.

1. Hamiltonian whose eigenvalues are wanted → Parameterised circuit familydress the Hamiltonian, screen by flip index

   At each outer round the previously found entangler is folded into the operator, not appended to the circuit, via the canonical transformation $\hat H_d^{(k)}=e^{i\tau_k\hat P_k/2}\hat H_d^{(k-1)}e^{-i\tau_k\hat P_k/2}$, closing exactly as $\hat H_d^{(k-1)}+\sin\tau_k\left(-\frac{i}{2}[\hat H_d^{(k-1)},\hat P_k]\right)+\frac12(1-\cos\tau_k)\left(\hat P_k\hat H_d^{(k-1)}\hat P_k-\hat H_d^{(k-1)}\right)$, a 3-term expression that would triple the operator count each round ($3^{N_g}$ after $N_g$ rounds) if terms stayed independent; since $\hat P_k\hat H_d^{(k-1)}\hat P_k$ adds no new terms, only re-signs old ones, the paper tightens this to $\sim M(3/2)^{N_g}$. The next $\hat P_k$ is not found by exhaustive search: assumption: the qubit mean-field reference is a common $\hat z_i$-eigenstate (or is purified to be one), and the Hamiltonian has real coefficients with an even number of $\hat y$ terms, so the gradient vanishes unless $\hat P_i$'s flip indices $F(\hat P_i)$ fall in one of the $O(M)$ classes the Hamiltonian's terms partition into, shrinking the pool to the "direct interaction set" ($O(M2^{n-1})$). approximation: the growing dressed Hamiltonian is periodically truncated to its $J$ largest-magnitude coefficients, with the ground-state shift bounded via Weyl's theorem, $\max_j|\lambda_j^\downarrow(\hat H)-\lambda_j^\downarrow(\hat H_c)|\le\|\hat H-\hat H_c\|$.

   approximationassumption

A circuit family with a fixed structure and free real parameters, together with the number of those parameters — which is the size of the classical search problem handed to the next layer.

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

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

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

• Iterative qubit coupled cluster · Qiskit

  From the repository — run, not written up from a paper · unsupported

  About

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

  Methods

  None found yet.

  Data

  None found yet.

  Code

  Qiskit

  Results

  Literature-backed method record; algorithmic scope and evidence boundary reviewed, with no benchmark run claimed.

• Iterative qubit coupled cluster

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