Iterative qubit coupled cluster

• 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

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.

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

Ryabinkin et al. report a purely numerical simulation of the iQCC procedure on three molecules from Table I of their paper: LiH (4 qubits, STO-3G, bond length 1.7 angstrom), H2O (6 qubits, 6-31G, both at equilibrium and stretched to $R(\mathrm{OH})=2.35$ angstrom), and N2 (14 qubits, cc-pVDZ, a full-valence 10-electron/8-orbital active space). Each run starts from a qubit mean-field product-state reference and draws generators from the direct interaction set (DIS), with every iteration minimizing $N_g$ amplitudes and $2n$ Bloch angles from up to 10 random guesses; DIS gives systematic, near-geometric convergence to the exact energy where other generator pools saturate early. For LiH with $N_g=6$ generators per round, the energy reaches within $1\times10^{-8}$ $E_h$ of exact after only 5 iterations. N2 near equilibrium is the paper's stress test for the method's cost: the Hamiltonian starts at 825 Pauli terms and grows to roughly $5\times10^5$ terms after 30 iterations of a single-generator run, and even after 40 iterations the raw energy is still more than 1 $\mathrm{mE}_h$ from the exact $-109.0350$ $E_h$; extrapolating the near-geometric trend over the last 10 iterations instead gives $-109.0340$ $E_h$, itself only 1 $\mathrm{mE}_h$ above exact and a five-fold improvement in precision over the raw values, while compressing the Hamiltonian to its largest terms cuts the count by roughly $1.5\times$ for less than $3\times10^{-6}$ $E_h$ of energy error. The authors are explicit that this cost is not classical alone: dressing the Hamiltonian at each step also increases the number of terms a quantum device would need to measure, so the fixed circuit size is not free on the device side either. Two limits stand as reported: in the strongly correlated stretched-H2O geometry, the DIS pool needs three times as many iterations to reach comparable accuracy as in the weak-correlation cases, and the authors state plainly that they "did not find rigorous conditions when such convergence was possible" — every number here is numerical evidence for a fixed-size-circuit method, not a proof of convergence, and none of it involves a quantum device.

Classical simulation · Section III (Numerical Examples), Table I, and Figs. 1, 2, 4, 5, 6 of arXiv:1906.11192

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

• The iQCC-VQE solver in Tangelo

  • Iterative Qubit Coupled Cluster approach with efficient screening of generators
  • Tangelo: An Open-source Python Package for End-to-end Chemistry Workflows on Quantum Computers

  Tangelo is a Python package for end-to-end chemistry workflows on quantum computers. Its own paper is written from Good Chemistry Company, Dow Inc. and 1QB Information Technologies, and calls it "an open-source Python software package for the development of end-to-end chemistry workflows on quantum computers, released under Apache 2.0 license"; the repository's README now reads "an open-source Python package maintained by SandboxAQ", while the PyPI 0.4.3 description still says Good Chemistry Company. What it carries for this method is a solver rather than an ansatz, and the module says so itself: `tangelo/algorithms/variational/iqcc_solver.py` opens "This module implements the iterative qubit coupled cluster (iQCC)-VQE procedure of Ref. 1", and Ref. 1 in the same docstring is "I. G. Ryabinkin, R. A. Lang, S. N. Genin, and A. F. Izmaylov. J. Chem. Theory Comput. 2020, 16, 2, 1055–1063", the journal form of the paper this method is recorded from. It also states the trade in the corpus's own terms: the iterative procedure allows "a small number (1—10) of generators" per round, and "A caveat is that after each iteration, the qubit Hamiltonian is dressed with the generators and optimal parameters, the result of which is an exponential growth of the number of terms." One qualifier should not be lost: the Tangelo package paper is cited here for the package alone. The strings "iQCC" and "iterative qubit" occur nowhere in its text, checked by grep over `pdftotext` output on 2026-09-02, even though the solver had already shipped in v0.3.1 the week before that paper's v1.

  The docstring's numbered outline is the algorithm, and step (5) is the one that distinguishes this method from its neighbours: "If not terminated, dress the qubit Hamiltonian with the current QCC generators and optimal amplitudes", followed by "(6) Purify the QMF parameters, rebuild the DIS, and select generators for the next iteration; return to (1) and repeat until termination." The dressing is a single line of `qcc_op_dress` in `tangelo/toolboxes/ansatz_generator/_qubit_cc.py`, applied generator by generator: `qubit_op += .5 * ((1. - cos(taus[i])) * gen - 1j * sin(taus[i])) * commutator(qubit_op, gen)`, which is Eq. (17)'s canonical transformation with the anticommuting `P H P` piece folded into the same expression. Its docstring carries the paper's own growth estimate: "For an operator with M terms, each transformation results in exponential growth of the number terms. This growth can be approximated as M * (3 / 2) ^ n_g, where n_g is the number of QCC generators selected for the ansatz at the current iteration." The generator pool is the paper's direct interaction set and not a free choice: `construct_dis` groups Hamiltonian terms by flip index, keeps a group only "If |dEQCC/dtau| >= thresh", takes the first generator of each kept group, and raises `ValueError` when the set comes back empty. `iQCC_solver._update_iqcc_solver` re-dresses `self.qcc_ansatz.qubit_ham`, then sets `dis` and `var_params` to `None` and rebuilds the circuit, so each round screens the dressed operator rather than the original. The optional compression of Sec. II D is `QubitOperator.frobenius_norm_compression(epsilon, n_qubits)` in `tangelo/toolboxes/operators/operators.py`, off by default and cited to the same JCTC paper, promising that "The eigenspectrum of the compressed operator will not deviate more than epsilon". Its threshold is not quite Eq. (23): the code sets `frob_factor = 2**(n_qubits // 2)` where the paper divides by $2^{n/2}$, so for an odd qubit count the code may discard a tail whose norm is up to $2^{1/2}$ times what Eq. (23) permits, and the docstring's promise then holds only up to $2^{1/2}$ times epsilon. That last sentence is arithmetic on the two expressions, not a quotation from either.

  No dataset. The solver requires a `SecondQuantizedMolecule` — `__init__` raises `ValueError` without one, and the shipped `test_build_fail` asserts exactly that — and takes a `qubit_hamiltonian` only as an extra option handed through to `VQESolver` alongside the molecule, never as an alternative to it. The tests in `tangelo/algorithms/variational/tests/test_iqcc_solver.py` import four systems from `tangelo.molecule_library` — `mol_H2_sto3g`, `mol_H4_sto3g`, `mol_H4_sto3g_uhf_a1_frozen` and `mol_H4_doublecation_minao` — covering the closed-shell, restricted open-shell and double-cation cases, though `mol_H2_sto3g` is only instantiated and never simulated. Every test that supplies a molecule uses the "scbk" qubit mapping with `up_then_down=True`.

  https://github.com/sandbox-quantum/Tangelo, Python, distributed on PyPI as `tangelo-gc` by `setup.py` and live there at 0.4.3; `tangelo/_version.py` reads `__version__ = "0.4.3"` and v0.4.3 (2024-06-20) is the newest release the GitHub API lists. GitHub reports the licence as NOASSERTION, but only because the repository's `LICENSE` is a 577-byte grant notice — "Copyright SandboxAQ 2021-2024", "Licensed under the Apache License, Version 2.0" — rather than the full Apache text; every source file repeats that header. The repository is archived, 143 stars, last pushed 2026-08-05. The artefact is `tangelo/algorithms/variational/iqcc_solver.py` (14907 bytes on `main`, class `iQCC_solver`, exported by `tangelo/algorithms/variational/__init__.py`) together with `qcc_op_dress` in `tangelo/toolboxes/ansatz_generator/_qubit_cc.py` and `QubitOperator.frobenius_norm_compression` in `tangelo/toolboxes/operators/operators.py`. The direct interaction set it screens with is a dependency and not this artefact: `construct_dis`, `get_dis_groups` and `get_gens_from_idxs` sit in the same file, whose module docstring calls them functions "to create the direct interaction set (DIS) of generators for the qubit coupled cluster (QCC) ansatz", and their only caller in the package is the `QCC` class in `tangelo/toolboxes/ansatz_generator/qcc.py`, which is the qubit coupled-cluster ansatz's artefact rather than this one; `iQCC_solver` holds a `QCC` instance and keeps replacing the Hamiltonian that instance points at. The file exists at tag `v0.3.1` and 404s at `v0.3.0`, and `CHANGELOG.md` lists "QCC-ILC and iQCC solver" under "[0.3.1] - 2022-06-15". A sibling `iqcc_ilc_solver.py` (class `iQCC_ILC_solver`, added under "[0.3.3] - 2022-11-09") sits in the same directory and implements the involutory-linear-combination variant, which is a different ansatz and not recorded here. All read from `main` on 2026-09-02.

  Only the shipped unit tests, and they are short runs rather than convergence studies. `test_iqcc_h4` runs one iteration on `mol_H4_sto3g` with one generator taken from every DIS group (`max_qcc_gens: None`) and compression on at `compress_eps` 1e-4, asserting -1.96259 to four places; `test_iqcc_h4_uhf` runs three iterations of the restricted open-shell case with `max_qcc_gens` 8, asserting -1.95831 to three places; `test_iqcc_h4_double_cation` runs one iteration, asserting -0.854647 to four places. No device and no simulator is named anywhere: `backend_options` defaults to `{"target": None, "n_shots": None, "noise_model": None}`, so expectation values are exact and shot-free on whichever backend `get_backend` finds installed at run time, and nothing in the module touches hardware. The tests assert energies only — never the term count of the dressed Hamiltonian, which is the quantity this method trades circuit size for. That count is reachable, as `qubit_hamiltonian_terms` inside `get_resources()`, but the solver's own docstring limits what it returns to "the quantum resource estimates for the final iQCC-VQE iteration"; per-round values are only printed, and only when `verbose` is set.

• OTI Lumionics's parallel GPU iQCC on ruthenium carbon-fixation catalysts

  • Parallel iQCC Enables 200 Qubit Scale Quantum Chemistry on Accelerated Computing Platforms Surpassing Classical Benchmarks in Ruthenium Catalysts

  iQCC rewritten as a distributed, GPU-accelerated classical program, from OTI Lumionics Inc., the affiliation Ryabinkin and Genin carry on this method's defining paper. The problem statement is exactly the cost this method's own record names: the abstract offers "a parallel, GPU-accelerated implementation of the iterative qubit coupled cluster (iQCC) method that overcomes the exponential growth of the transformed Hamiltonian—the principal bottleneck for classical emulation of quantum chemistry circuits", and Sec. II E restates the growth as "each iteration can increase the term count by up to a factor of 3/2 [16], so that after n iterations the Hamiltonian may contain O((3/2)n M0) terms, where M0 is the initial count", where the exponent is a superscript in the PDF that plain-text extraction flattens. Two qualifiers matter and both are the authors' own. Nothing here runs on a quantum device: the point is that a classical machine keeps up, and the abstract says so — "These results effectively de-quantize a significant portion of the NISQ roadmap." And the barren plateau claim is about the generator pool, not about circuits: iQCC "confines the variational evolution to a classically simulable operator subspace by selecting entanglers exclusively from the Direct Interaction Space, which guarantees non-vanishing energy gradients at every iteration".

  Three pieces on top of the method as recorded. Terms are spread over MPI ranks by "a bit-wise partitioning strategy that distributes terms based on specific bits in their binary representation, ensuring that newly generated terms from the dressing procedure can be deterministically routed to their correct partitions, with communication required only in restricted, pairwise cases", with fine-grained partitioning and dynamic load balancing above it. Dressing and expectation values go to the GPU: "Pauli terms are encoded as binary strings of X and Z components, enabling efficient bit-wise operations in CUDA kernels", with "Sparse indexing and warp-synchronous reductions". Amplitude optimisation is not parallelised but replaced, and by borrowed machinery: "We employ a polynomial optimization scheme [19] that approximates the QCC unitary by a truncated symmetric-polynomial expansion", whose full form has $2^N$ terms for $N$ entanglers and which truncation at order $K$ reduces to $O(N^K)$, and "In practice, values of K = 2–6 recover sub-millihartree accuracy while allowing simultaneous optimization over hundreds of thousands of entanglers." That replacement is then itself distributed — "The expansion is parallelized across nodes: each core constructs its assigned portion of the polynomial expansion, evaluates local contributions to energy and gradients, and communicates only aggregated results to the optimizer" — so it is both replaced and parallelised, not one instead of the other. Generator selection is unchanged in kind and still runs off the direct interaction set. Fig. 1 lays the loop out as initialisation and MPI distribution, then gradient screening, optional polynomial optimisation on GPUs, GPU-accelerated dressing, and a convergence check.

  Eight ruthenium complexes from a carbon-dioxide fixation catalytic cycle, labelled I, II, II-III, V, VIII, VIII–IX, IX and XVIII, with integrals taken from earlier work rather than recomputed: "The 1 and 2 electron integral files were obtained from von Burg et al. [26] and as noted, the structures were first optimized using Density Functional Theory (DFT) with M06-L/def2-SVP." Hartree–Fock orbitals used ANO-RCC-VTZP on the non-metal atoms and ANO-RCC-VQZP on ruthenium, followed by CASSCF with a Cholesky decomposition threshold of 1e-4. Their active spaces, in Tables II and III, run from CAS(48e,52o) to CAS(76e,65o), and the abstract places the study "in the 100–124 qubit regime"; a ninth configuration, XVIII enlarged to CAS(100e,100o), appears only in the timing study and carries no energy in any table. A separate H2 benchmark precedes all of them, in STO-3G, cc-pVDZ, cc-pVTZ and aug-cc-pVTZ — "4, 20, 56, and 92 qubits in the four basis sets considered" — and it is the one place the polynomial optimiser is validated alone, with this method's distinguishing step switched off: "For these H2 benchmarks, no iterative dressing of the Hamiltonian was employed. Instead, the input qubit Hamiltonian was taken as is, and polynomial optimization was performed directly." The reference energies for the ruthenium set are DMRG-CI values from that same earlier work, and the authors flag their own comparison's soft edge: "the DMRG-CI energies could be lowered by using Fiedler ordering or by increasing the maximum bond order dimension and the number of sweeps".

  This is the weak half of the entry and the paper is the reason. The hardware is named exactly and the parallel iQCC software is not named at all: no repository, package name, licence, version or availability statement for it appears anywhere in the text, checked on 2026-09-02 by grep over the full `pdftotext` output, appendices included, for "availab", "repositor", "github", "zenodo", "licen", "open source" and "proprietary". The absence is of that software specifically — the paper does name one tool, the Azure Quantum Resource Estimator, and uses it for the fault-tolerant QPE comparison rather than for iQCC. What is stated is the machine: a "V100 node: 4× NVIDIA V100 GPUs (32 GB HBM2 each), 2× Intel Xeon Gold 6248 processors (40 cores total, 2.50 GHz), NVIDIA driver 535.183.01, CUDA 12.2", and "B200/B300 nodes: NVIDIA B200 or B300 GPUs provisioned via the NVIDIA Brev cloud platform, paired with AMD EPYC 9575F processors (64 cores, 2.0 GHz), NVIDIA driver 580.126.09", plus the note that "the term 'CPU' denotes individual physical processing cores rather than discrete multi-core processor sockets." The H2 benchmark ran somewhere else again, on "a workstation equipped with dual Intel® Xeon® E5-2650 v3 processors (40 physical cores, 80 threads, 2.30 GHz base frequency), using 16 cores for the calculations."

  The headline is a comparison against a classical reference, not against a device: "The results show that iQCC can exceed DMRG-CI energies variationally in 7 out of the 8 molecular systems", by "between 0.33-1.8 mHa" — a range the paper's own tables contradict at both ends, since the "Difference from DMRG (mHa)" entries for those seven read -1.965, -0.330, -0.718, -1.766, -1.019, -0.042 and -1.451, spanning 0.042 to 1.965 mHa. Table II gives, on four NVIDIA V100 GPUs, total times of 0.947, 3.799, 18.343 and 3.655 hours for I, II, II-III and V at maximum term counts of 1.0e8, 1.65e8, 5.0e8 and 1.65e8 and 2.0 to 2.5 million entanglers; Table III's largest total is 45.141 hours, and the abstract's overall range is "1.2 - 45 hrs". Table IV is the GPU claim in one row: complex XVIII at CAS(64e,56o) takes 1.20 hours on an NVIDIA Blackwell B200, 3.14 hours on four V100s and 109.01 hours on 32 AMD 7702 processes. The title's 200 qubits is a timed run and not only an extrapolation, since Fig. 3b is "XVIII CAS(100e,100o) with a Hamiltonian term limit of 1,000M and 1M entanglers in the final optimization step with 100 iQCC iterations" and "The wallclock times for the three different computational platforms using the CAS(100e,100o) XVIII system ranged from 38.78 hrs for the AMD 7702 CPU with 32 processes to 3.49 hrs on the NVIDIA Blackwell B300" — but no energy for that configuration appears in any table, and its 38.78 hours does not undercut Table IV's 109.01 on the same 32 processes, because the larger run is capped at 100 iterations and 1M entanglers against XVIII's 200 steps and 2.5M in Table III. The claim the title's phrasing invites, that advantage moves past 200 qubits, is offered as a projection: "potentially past 200 qubits". One more of the paper's own numbers disagrees, and a reader should know which to quote: the text says "The iQCC energy for system I was higher (6.8 mHa) compared to the DMRG-CI" while Table II's "Difference from DMRG (mHa)" row for system I reads 5.382 — which is what that column's own two energies, -7361.461381 and -7361.4559985 Ha, give, so 5.382 is the number the paper supports.

• Clifford-only iQCC, as a Tangelo notebook

  • Iterative Qubit Coupled Cluster using only Clifford circuits

  The iQCC loop kept intact but shrunk to one generator a round, so that every circuit simulated to choose that generator is Clifford. The restriction is stated plainly in the abstract the notebook reproduces for the reader — which is the v1 abstract of the note, not the v2 arXiv now serves: "In this variant of the iQCC method, the wave function ansatz at each iteration is restricted to a single exponentiated Pauli word operator and parameter. The Rotosolve algorithm utilizes Hamiltonian expectation values computed with Clifford circuits to optimize the single-parameter Pauli word ansatz." The v2 text says the same thing in the Fig. 2 caption, "a single generator was added at each iteration, which corresponds to Ng = 1 in Ref. 11", Ref. 11 being this method's defining paper, and it does not claim to escape this method's cost: "The algorithm still suffers from an exponential growth of the Hamiltonian, thus hindering its scalability." The purpose named is initial-state preparation for a later algorithm rather than a NISQ energy in its own right, and the v2 abstract keeps the route back open: "Since the iQCC method has been developed as a quantum algorithm firstly, our variant can be mapped naturally to quantum hardware."

  The notebook builds on two Tangelo classes rather than on `iQCC_solver`. `CirqCliffordSimulator` extends `CirqSimulator` and overrides `simulate_circuit` to "Perform state preparation corresponding to the input circuit using cirq.CliffordSimulator". The solver, `iQCConlyClifford`, "is defined as a child class of `ADAPTSolver` and replaces the `simulate` and `rank_pool` functions", with "A non-clifford backend" used "only to check that the full circuit obtains the same energy using the original qubit hamiltonian" — so the Clifford guarantee covers selection, not that verification step. Reusing `ADAPTSolver` is code sharing and not a claim about ADAPT-VQE: the pool is this method's direct interaction set, since the notebook imports `get_dis_groups` and `get_gens_from_idxs` from `tangelo.toolboxes.ansatz_generator._qubit_cc` and dresses with `qcc_op_dress` from that same file, and the note is about iQCC throughout. It is not, however, the pool `iQCC_solver` screens. The notebook's `full_qcc_pool` appends every generator of each DIS group and flattens the result, where `construct_dis` appends only `dis_group_gens[0]` under the comment "for now just grab the first generator"; it hard-codes the gradient threshold at 3.e-5 where the `QCC` ansatz defaults to 1e-3; and `rank_pool` chooses by running a Rotosolve over every pool operator and taking the lowest resulting energy rather than the largest gradient. The note names that last difference as its own, in the Fig. 2 caption: "One of the main difference lies in the generator selection... the refinement of the ground state benefits from the Clifford iQCC generator screening method, which selects the generator that minimizes the energy the most."

  The notebook's own run is a three-hydrogen chain — `xyz_H3` with atoms at 0, 0.7414 and 1.4828 angstrom on the z axis, `SecondQuantizedMolecule(xyz_H3, q=0, spin=1, basis="sto-3g")`, `mapping = "JKMN"`, `up_then_down=False`, `max_cycles = 4` — with an `FCISolver` energy as the reference. The note's own systems are larger, and its body and its abstract disagree about the smallest of them: the body studies "a linear chain of hydrogen atoms H4, lithium hydride LiH, and water H2O" at "respectively 8, 10 and 12" qubits, while the abstract writes H2 in place of H4, which the qubit count rules out, so the body's list is the usable one. Both agree on the largest, "the titanium-based compound Ti(C5H5)(CH3)3 with a (20, 20) active space, requiring 40 qubits". Integrals come from PySCF: "All calculations were performed using Tangelo, with PySCF as a backend quantum chemistry package to compute the molecular integrals."

  `examples/variational_methods/iqcc_using_clifford.ipynb` in https://github.com/sandbox-quantum/Tangelo-Examples, Apache-2.0 by the repository's licence field, archived, 28 stars, last pushed 2026-08-05, read 2026-09-02. The notebook is 17 cells and says of itself that it "shows how to implement iQCC using only Clifford circuits with Tangelo, and accompanies a note released at arXiv:2211.10501"; it installs Tangelo from the `develop` branch rather than from a release, so it is not pinned to a version. `CirqCliffordSimulator`, `iQCConlyClifford` and `full_qcc_pool` are all defined inside the notebook, not in the Tangelo package. Tangelo's own `CHANGELOG.md` lists "Notebook: iQCC using only Clifford circuits" under "[0.3.4] - 2023-02-15", from before the examples were split into their own repository.

  The notebook ships its stored outputs, and they show both halves of the trade. Four Clifford rounds on the hydrogen chain give -1.5146298806979668, -1.5218965900518353, -1.5244271035716803 and -1.5267582996827964, each re-checked on the non-Clifford backend against the original undressed Hamiltonian and agreeing with it to better than $10^{-13}$; the final line reads "The final energy is -1.526758299682792 with error 0.0001887054536875432", and a sweep of single-operator re-optimisations improves that to "error 0.00011503872016915828". Against those same four rounds the notebook prints "The number of H terms at each iteration is [62, 96, 125, 138]", which is the Hamiltonian growth this method pays for, measured. The largest run in the note is not pure Tangelo, and the sentence saying so is one line: "We perform 20 Clifford iQCC iterations using Tangelo along with an interfaced in-house C++ code", on a personal laptop, for the 40-qubit Ti(C5H5)(CH3)3 case — that C++ code is not published, so the 40-qubit result is not reproducible from the notebook alone. No quantum hardware appears in either the notebook or the note.

• OTI Lumionics's published iQCC Hamiltonians and simulation outputs

  • Iterative Qubit Coupled Cluster approach with efficient screening of generators

  A data release rather than a code release, from OTI Lumionics Inc., the company two of this method's four defining authors work for, and the only public artefact this search found that ships iQCC's own inputs and outputs for someone else to re-run. Its README states the scope: "This repository contains Hamiltonians of select systems generated from a modified version of GAMESS", and "Outputs from various iQCC simulations are also posted here, where additional files that contain energy and entangler information are available." It is not the data behind the parallel-GPU ruthenium study recorded beside this entry: it was created 2023-06-23, is never cited by that paper, and holds none of that paper's ruthenium systems.

  None of its own. What fixes the provenance is the repository's citation requirement — "When using any information from this repository the following publications must be cited as it describes the process in which the entanglers were generated" — naming DOI 10.1021/acs.jctc.8b00932, the qubit coupled-cluster paper, and DOI 10.1021/acs.jctc.9b01084, which resolves to "Iterative Qubit Coupled Cluster Approach with Efficient Screening of Generators", J. Chem. Theory Comput. 16, 1055-1063, the journal form of the paper this method is recorded from. The auxiliary number and spin operators are supplied to be used as in DOI 10.1021/acs.jctc.8b00943, the constrained variational quantum eigensolver paper.

  Four system families: nitrogen at CAS(12,28) and CAS(14,26), oxygen at CAS(12,28), ammonia at a 10-electron 32-orbital active space on a geometry from the NIST computational chemistry benchmark database, and two iridium complexes — Q1 in its triplet geometry, and Ir(F2ppy)3 in the singlet and triplet states. Each package holds the electronic Hamiltonian plus number, spin and penalty operators (`H_1.inp`, `N_1.inp`, `Npenalty_1.inp`, `S2_1.inp`, `Spenalty_1.inp`, `Sz_1.inp`) and a `reference_state.inp` "containing information about the Hamiltonian generation including coefficient cutoffs and the initial occupation reference vector", written "in right to left format" in the qubit basis. GAMESS input files are included for the ammonia and Q1 sets. The ammonia README flags its own reproducibility gap: "There could be some differences in the exact MO selection since the above publication does not report in detail the exact method for orbital selection."

  https://github.com/otilumionics/iqcc-hamiltonians, Apache-2.0, Zenodo DOI 10.5281/zenodo.10961200, created 2023-06-23 and last pushed 2026-01-07, read 2026-09-02. There is no iQCC source code in it. The Hamiltonians were "generated from a modified version of GAMESS", which is not released here, and nothing in the repository implements the method. Its four data directories are `N2-hamiltonians`, `O2-hamiltonians`, `ir-complexes` and `nh3-NIST-geometry`.

  The iQCC output files are the results, and they are deposited rather than summarised: each "shows the 'QMF' state for the iQCC iteration Hamiltonian, followed by the PT and DUC energy corrections, then followed by the list of the entanglers used for the iQCC iteration listed with their importance factor, then finally an array of the optimized amplitudes." The README warns that they are "occasionally updated when new publications are made available" and that "Simulation outputs can varry depending on the inputs to the iQCC algorithm", its own spelling, so no figure in the repository is quotable as a fixed benchmark without naming the file and the date it was read. No hardware and no simulator is named anywhere in 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.

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

• Iterative qubit coupled cluster

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

• 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