k-UpCCGSD 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.

Lee et al. present it as "affordable and systematically improvable" — the second half is the role of $k$, and the first is what the pair restriction buys. They compare against the full generalized set (UCCGSD) and the standard one (UCCSD) on classical benchmarks, and report that "$k$-UpCCGSD is found to show the best scaling for quantum computing applications" of the three.

Every step this method names moves its route along, so there is nothing it needs alongside them.

Lee et al., in the paper introducing k-UpCCGSD, report a classical numerical simulation, not a hardware run. Full configuration interaction references come from Psi4 via its OpenFermion interface, and the ansatz energy is evaluated variationally with its analytic gradient passed to SciPy's BFGS, restarted between thirty and two hundred times from randomly chosen initial amplitudes because it is unclear in general whether UCC optimization reaches a global minimum; the paper reserves its in-house OpenFermion/TensorFlow code for UCCSD alone, and k-UpCCGSD itself, like UCCGSD, is run through the development version of Q-Chem instead. They test the k-fold paired product form on ground- and first-excited-state potential energy curves (excited states via the orthogonally constrained VQE, OC-VQE, penalty method) for H4 in STO-3G ($N=8,\eta=4$) and 6-31G, and for N2 in STO-3G ($N=16,\eta=10$), running $k=1$ through $3$ on H4 and up to $k=6$ on N2. Error falls fast but not smoothly with $k$, and the rate is strongly system-dependent: on H4, "1-UpCCGSD is much worse than all the rest of UCC methods and adding one more product (i.e. 2-UpCCGSD) makes the energy numerically exact," while N2 needs far more repetitions, its ground-state non-parallelity error only falling below 1 mEh once $k$ exceeds 4, and for the excited state "the best performing UCC method is 6-UpCCGSD with a NPE of 1.61 mEh" against 7.79 for UCCGSD. Three limits are worth stating plainly. 1-UpCCGSD's instability traces to the fact that, unlike full-doubles CC, "the energy of k-UpCCGSD is generally not invariant under unitary rotations among orbitals," so a small $k$ can land on an unphysical local minimum, not merely a less accurate one. The noiseless BFGS optimizer used throughout is explicitly called "unsuitable for use on a quantum device due to the stochastic error associated with the measurement of observables in the VQE framework." And Trotter steps, central to the circuit-depth estimates elsewhere in the paper, are never mentioned in this Computational Details section, so these benchmark numbers are exact evaluations of the UCC energy rather than the output of a Trotter-decomposed circuit, and carry no Trotter error at all.

Classical simulation · "Applications to Chemical Systems" section, pp. 19-29 (Fig. 1 and Table 2 for H4/STO-3G, pp. 20-21; Table 3-4 for H4/6-31G; Table 6-7 for N2/STO-3G, pp. 26-27), with the optimization protocol and software attribution in "Computational Details", pp. 18-19 of arXiv:1810.02327

given  Hamiltonian H on N spin-orbitals, mapped 1-1 onto N qubits (qubit count is
       linear in N),  eta electrons,  reference determinant |phi_0>
       (this paper's own benchmarks use a restricted-Hartree-Fock determinant),
       and an integer k >= 1 supplied by the caller

requires  each factor's amplitude set is independent of every other factor's --
    #   no amplitude is shared across l = 1 .. k
requires  k is not fixed here by a formula in N, eta or a target error -- the paper
    #   only reports, after the fact, that k must be taken large enough to reach
    #   sub-chemical accuracy, or the energy surface loses the smoothness that makes
    #   it usable for tasks like scanning it ("Summary of Chemical Applications")

# --- k-fold product of independent pair-restricted unitaries -----------------
for l = 1 .. k:
    draw amplitude set  { t_p^q }  over ALL spin-orbital pairs p, q       # generalized singles
    draw amplitude set  { t_(iup,idown)^(aup,adown) }  over occupied spatial orbitals i,
        virtual spatial orbitals a                                       # paired doubles
        # iup/idown and aup/adown are the two spin components of one spatial orbital,
        #   not the loop index l

    T1^l  =  (1/2) sum_pq  t_p^q  adag_q a_p                                    (Eq. 12)
        # p, q run over occupied AND virtual spin-orbitals alike -- 'generalized',
        #   not restricted to occupied-to-virtual as in ordinary UCCSD (Eq. 4)
    T2^l  =  sum_ia  t_(iup,idown)^(aup,adown)  adag_aup adag_adown a_idown a_iup   (Eq. 14)
        # moves both spins of spatial orbital i into spatial orbital a together --
        #   the pCCD-style restriction that drops the rest of the generalized-doubles
        #   manifold UCCGSD keeps
    T^l  =  T1^l + T2^l
    U^l  =  exp( T^l - (T^l)^dag )

return  |psi(theta)>  =  U^1 U^2 ... U^k |phi_0>                                (Eq. 15)
    # Eq. 15 itself is only written  Pi_(l=1)^k exp(T^l - (T^l)^dag) |phi_0>  --
    #   no time-ordering symbol, no stated convention for which factor acts first;
    #   since each U^l carries an independent amplitude set the U^l's do not
    #   commute in general, so operator order is a real degree of freedom the
    #   source leaves open, not a resolved detail. Expanded here the way a Sigma
    #   would be read -- left to right in l -- so U^k acts on |phi_0> first and
    #   U^1 last; this ordering is this listing's reading, not a claim the paper
    #   itself makes
    # theta is the full stack of k independent {singles, paired-doubles} amplitude
    #   sets; k is supplied here, not derived -- it is the caller's dial, not this
    #   construction's output

# --- circuit realization, at a fixed number of Trotter steps per U^l (Table 1) --
gate count  =  O(k N^2)
    # total gate count is lower-bounded by the number of cluster amplitudes, and
    #   each factor's singles + paired-doubles amplitudes number O(N^2)   (Table 1)
group each U^l's paired-doubles terms into O(N) sets of O(N) terms acting on disjoint
    spin-orbitals;  execute every set in parallel on a linearly-connected qubit array
    # this is what reduces the O(kN^2) gate count to a shallower circuit -- it assumes
    #   maximal parallelization of terms on distinct spin-orbitals and neglects
    #   Jordan-Wigner overhead (the derivation's own stated assumption, not a
    #   general-purpose compiler guarantee)

Circuit depth $\mathcal{O}(kN)$ in the number $N$ of spin orbitals and the number $k$ of repetitions, as stated in the abstract, against $\mathcal{O}(N^3)$ for UCCGSD and $\mathcal{O}((N-\eta)^2\eta)$ for UCCSD with $\eta$ electrons. A depth for the family, not a complexity for solving the problem.

• PennyLane's qml.kUpCCGSD template

  Xanadu's PennyLane ships this ansatz as a built-in template, and its changelog is where the attribution lives. The v0.19.0 entry reads "Added a new template `kUpCCGSD`, which implements a unitary coupled cluster ansatz with generalized singles and pair doubles excitation operators, proposed by Joonho Lee *et al.* in [arXiv:1810.02327](https://arxiv.org/abs/1810.02327).", crediting pull request 1743; that release reached PyPI on 2021-11-09. The module file itself carries no citation — counted over the downloaded file, "Lee", "arXiv", "doi" and "1810" occur zero times against seven occurrences of "kUpCCGSD" as a live-instrument control — so a reader who opens only the docstring never meets the source paper.

  `kUpCCGSD(weights, wires, k=1, delta_sz=0, init_state=None)`, where the `init_state` default is nominal: `__init__` raises "Requires `init_state` to be provided." when it is left None. `compute_decomposition` first appends `BasisState(init_state, wires=wires)`, then runs `for layer in range(k)` and inside each layer emits every paired double as `FermionicDoubleExcitation(weights[layer][len(s_wires) + i], wires1=w1, wires2=w2)` and afterwards every generalized single as `FermionicSingleExcitation(weights[layer][j], wires=s_wires_)` — doubles before singles within a repetition, an ordering the paper's Eq. 15 does not fix. The two index sets come from two module-level helpers. `generalized_pair_doubles(wires)` returns, for `r, p in product(range(0, len(wires) - 1, 2), repeat=2) if p != r`, the pair of two-wire slices `wires[r : r + 2]` and `wires[p : p + 2]`, both directions of each pair kept, so a pair moves between any two spatial orbitals rather than only occupied to virtual. `generalized_singles(wires, delta_sz)` keeps a pair only when `sz[p] - sz[r] == delta_sz` for `sz = 0.5 * (-1) ** np.arange(n)`, and `delta_sz` is a single number per call restricted to 0 or ±1 — one instance therefore cannot carry both spin-conserving and spin-flipping singles, whereas the paper's Eq. 12 writes the singles operator as a sum over spin-orbital indices $p, q$ with no spin restriction stated, and this module's own class docstring says the same of the operator it implements, "The indices :math:`p, q` run over the spin orbitals and :math:`i, j` run over the spatial orbitals." Validation rejects fewer than four wires, an odd number of wires, `k < 1`, any other `delta_sz`, and a missing `init_state`. The weight tensor's shape is `(k, len(s_wires) + len(d_wires))`, one free amplitude per excitation per repetition, which is the paper's stipulation that each factor hold "an independent set of variational parameters". Recomputing the helpers gives four generalized singles and two paired doubles on four wires at `delta_sz=0`, six amplitudes per layer, and twelve plus six on six wires.

  Nothing molecular ships with the module; the inputs are the docstring's own example and the test suite's. The docstring builds H2 through `qp.qchem.molecular_hamiltonian` from `symbols = ["H", "H"]` and `coordinates = np.array([0.0, 0.0, -0.6614, 0.0, 0.0, 0.6614])`, and the device-suite test reuses an H2 fixture built the same way at ±0.66140414. The template's own test file fixes states rather than molecules: `test_k_layers_upccgsd` sets every weight to `np.pi / 2`, prepares the state on `default.qubit`, and compares it against a hard-coded amplitude vector at two sizes, four wires with $k = 4$ and six wires with $k = 6$.

  `pennylane/templates/subroutines/qchem/kupccgsd.py` in https://github.com/PennyLaneAI/pennylane — Python, Apache License 2.0, the file header reading "Copyright 2018-2021 Xanadu Quantum Technologies Inc.". One module holds `class kUpCCGSD(Operation)` and the two helpers `generalized_singles` and `generalized_pair_doubles`, re-exported through `pennylane/templates/subroutines/qchem/__init__.py` and `pennylane/templates/subroutines/__init__.py` as `qml.kUpCCGSD`. The file read here is master on 2026-09-02, 415 lines; 0.45.1 is the release then on PyPI. Three later changelogs touch it by name: v0.25.0 "Fixed a bug where the parameter-shift rule wasn't defined for `qml.kUpCCGSD`.", v0.27.0 "A redundant flipping of the initial state in the UCCSD and kUpCCGSD templates has been removed.", and v0.44.0, which lists the class among the templates covered by "The graph-based decompositions system enabled via :func:`~.decomposition.enable_graph` now additionally supports many existing templates." — that last is the `add_decomps(kUpCCGSD, _kupccgsd_decomposition)` registration at the foot of the same file, a second `for_loop`-based decomposition path beside `compute_decomposition` emitting the same gates in the same order. The v0.19.0 changelog's own worked example calls the template with `k=0`, which master rejects outright — `if k < 1: raise ValueError(f"Requires k to be at least 1; got {k}.")` — though that release's own source was not read.

  The docstring's run and the template test file's both use `default.qubit`, PennyLane's state-vector simulator; the device suite names no simulator at all, taking `dev` from a `device` fixture, so its hard-coded value is a reference whatever device is under test gets checked against. No example or test in the module, its test file or the device suite names a hardware device. The class docstring runs a gradient-descent VQE on H2 at $k = 1$ with `qp.GradientDescentOptimizer(stepsize=0.4)` and prints "Final value of the ground-state energy = -1.13618779 Ha" beside the six optimal angles of the single layer. The one assertion against a fixed energy is `test_kUpCCGSD` in `pennylane/devices/tests/test_templates.py`: on the H2 fixture with `k=1`, `delta_sz=0` and `weights = np.arange(np.prod(shape)).reshape(shape) / 10` it asserts `np.isclose(res, expected, atol=tol)` against `expected = -1.072648130451027`. That is an expectation value at one chosen parameter point, not a converged energy, and it is 63.5 mHa above the docstring's optimised figure.

• Tequila's make_upccgsd_ansatz

  • Tequila: A platform for rapid development of quantum algorithms

  Tequila builds this ansatz as a method on its molecule object rather than as a standalone circuit template, and the platform paper gives it a worked section of its own, "Example: 1-UpCCGSD", opening "As an explicit example we illustrate how to implement the 1-UpCCGSD ansatz of Ref. [62] for a Hydrogen-Flouride (HF) molecule in an active space with tequila" — Ref. 62 in that bibliography is "J. Lee, W. J. Huggins, M. Head-Gordon, and K. B. Whaley, Generalized unitary coupled cluster wave functions for quantum computation, J. Chem. Theory Comput. 15, 311 (2018)". The section spells the circuit out gate by gate and then points at the packaged route: "The ansatz herein is constructed explicitly, but note that the molecule structure already offers a convenient initialization of the k-UpCCGSD unitary through the make_upccgsd_ansatz function."

  `QuantumChemistryBase.make_upccgsd_ansatz(include_reference=True, name="UpCCGSD", label=None, order=None, hcb_optimization=None, spin_adapt_singles=True, mix_sd=False, ...)`, whose docstring opens "UpGCCSD Ansatz similar as described by Lee et. al." and documents `order` as "Order of the ansatz (default is 1) determines how often the ordering gets repeated parameters of repeating layers are independent" — that argument is the paper's $k$. It need not be passed: when `name` contains a hyphen the code reads it off the name, `order = int(name.split("-")[0])`, so `name="3-UpCCGSD"` means three repetitions. Which excitations a layer holds is decided by the same `name` string, through `make_upccgsd_indices`: with a "g" in the key every pair of spatial orbitals satisfying `n < m` becomes an index, so each unordered pair appears exactly once; without a "g" only reference-orbital to non-reference-orbital pairs survive. There are then two construction paths for the first layer, and the defaults take the second one. `hcb_optimization` is promoted from its `None` default to True whenever the encoding has an `hcb_to_me` and `include_reference` is left True — which covers Jordan-Wigner, defining its own `hcb_to_me`, and Bravyi-Kitaev, inheriting one — and the first layer's doubles then come from `make_hardcore_boson_upccgd_layer` in the hardcore-boson space, the circuit being mapped back by `hcb_to_me` before `make_upccgsd_singles` adds the singles. `make_upccgsd_layer` is reached only by `for k in range(1, order)`, so at the default `order` of 1 it is not called at all; it is the layer index entering the variable label there, `label=(label, k)`, that keeps the repetitions' amplitudes independent as the paper requires. Inside `make_upccgsd_layer`, which is what the second and later repetitions use, each pair's paired double is `make_excitation_gate(indices=((2 * idx[0], 2 * idx[1]), (2 * idx[0] + 1, 2 * idx[1] + 1)))` — both spin components of one spatial orbital moved together — except under plain Jordan-Wigner without `up_then_down`, where the code takes a `gates.QubitExcitation` on the four mapped wires instead. `make_upccgsd_singles` emits, over that same pair list, the two same-spin singles `[(2 * idx[0], 2 * idx[1])]` and `[(2 * idx[0] + 1, 2 * idx[1] + 1)]`. Two restrictions relative to the source follow from that indexing. The singles are enumerated by spatial-orbital pairs, so no spin-flipping single is generated, where the paper's Eq. 12 writes the singles operator as a sum over spin-orbital indices $p, q$ with no spin restriction stated. And under `spin_adapt_singles=True`, the default, a pair's two same-spin singles share one variable, `angle = (idx, "S", label)`; passing False splits them into separate "SU" and "SD" variables. Ordering inside a layer is all doubles then all singles unless `mix_sd=True`, documented as changing "the ordering from first all doubles and then all singles excitations (DDDDD....SSSS....) to a mixed order (DS-DS-DS-DS-...) where one DS pair acts on the same MOs" — but that switch is unavailable at the defaults just described, since the same method raises "Mixed SD can not be employed together with HCB Optimization" once `hcb_optimization` has been promoted.

  `src/tequila/quantumchemistry/qc_base.py` in https://github.com/tequilahub/tequila — Python, MIT licensed, `make_upccgsd_ansatz` a method of `class QuantumChemistryBase`, with `make_upccgsd_layer`, `make_upccgsd_singles`, `make_upccgsd_indices` and `make_hardcore_boson_upccgd_layer` beside it in the same file. `make_ansatz(name=...)` is the front door and routes here for any lowercased name containing "d" or "s" that is not "uccsd" and not a "spa" variant, so the README's `mol.make_ansatz(name="UpCCGSD")` and a direct `make_upccgsd_ansatz(order=k)` call reach the same construction. A second method of the same name lives in `src/tequila/quantumchemistry/madness_interface.py` for the basis-set-free backend. The distribution on PyPI is `tequila-basic`, 1.9.11 at the time of reading; the file read here is master on 2026-09-02.

  The repository's own evidence for this ansatz is two tests in `tests/test_chemistry.py`, both against FCI on a simulator and both on H2. `test_upccgsd` builds H2 at 0.7 Å in STO-3G, parametrized over `tq.quantumchemistry.encodings.known_encodings()` but returning early for any encoding whose `supports_ucc()` is false, optimises with BFGS and two-point numerical gradients from `initial_values=0.0`, and asserts `numpy.isclose(fci, energy, atol=1.0e-3)` first at the default order and then again for `order=2` — the only place in the suite where the $k$ dial is exercised against a reference, `order=` occurring exactly once in the file. `test_upccgsd_singles` repeats it in 6-31G and checks the ansatz energy and the Hamiltonian's own lowest eigenvalue against FCI at the same tolerance of 0.001 Hartree. Both are skipped unless psi4 or pyscf is installed. Neither of those two tests asserts a hardware run or a benchmark larger than H2; the rest of the repository's suite, and the separate tutorials, were not read.

• k-UpCCGSD across the chloromethane–chloride SN2 pathway

  • Quantum computational study of chloride ion attack on chloromethane for chemical accuracy and quantum noise effects with UCCSD and k-UpCCGSD ansatzes

  Lim, Jeon, Rhee, Oh and No run the ansatz along a whole reaction coordinate rather than at one geometry, which is what makes the study a use of $k$ rather than a demonstration of it. The problem they set is stated in the abstract: "we applied quantum computing to describe the PES of the bimolecular nucleophilic substitution (SN2) reaction between chloromethane and chloride ions. We performed noiseless and noise simulations using quantum algorithms and compared the accuracy and noise effects of the ansatzes." Tequila is the ansatz builder here, so this record is the study, not the library; the conclusion it reaches is about noise, "In noise simulations, UCCSD is more susceptible to quantum noise than k-UpCCGSD."

  "All the quantum algorithms were performed using tequila and qiskit", with "the active space to two electrons in four spin orbitals (four qubits), using the BK transformation, "cobyla" optimizer, and UCCSD or k-UpCCGSD ansatz (k=1,2,3,4,5)" — a HOMO/LUMO active space in STO-3G under a Bravyi–Kitaev encoding. The published script reproduces the noiseless half of that description exactly: it calls `molecule.make_upccgsd_ansatz(order=1)` through `order=5` on a `tq.chemistry.Molecule` built with `backend='psi4'`, `charge=-1`, `basis_set='sto-3g'`, `active_orbitals = {"A":[21,22]}` and `transformation="bravyi_kitaev"`, wraps each in `tq.ExpectationValue(H=H, U=UpCCGSDn, optimize_measurements=True)` and minimises with `tq.minimize(method="cobyla", ..., initial_values=0.0)`, alongside one `make_uccsd_ansatz(initial_amplitudes="mp2")` for the comparison. Three settings are reported. Noiseless simulation; a Qulacs arbitrary noise model "from bit flip, dephasing, depolarizing, two-qubit depolarizing, and amplitude damping noises", averaged over "262,144 shots from independent 32 calculations with 8,192 shots per iteration"; and a device-derived noise model where "we performed quantum noise simulations with 300,000 shots from three 100,000 shots using qasm simulators with the hardware-driven noise model (ibmq-bogota)". That third setting is a simulator carrying a model built from IBM's ibmq-bogota, not a run on that machine, and the paper says so in its own sentence.

  The reaction path is classical and predates the quantum part: "we created an intrinsic reaction pathway of 23 steps in the gas phase, from the initial complex to the final complex, using classical quantum mechanics and B3LYP/6-31+G*". Those 23 geometries are the repository's `xyz/` directory, `CH3CL_CL_01.xyz` through `CH3CL_CL_23.xyz`, one per step, and the script selects one by command-line index, `filename = 'xyz/CH3CL_CL_' + sys.argv[1] + '.xyz'`. The plotted numbers are published as tab-separated tables rather than only as figures: `Figure2/Figure2A.tsv` carries 23 rows under the columns HF/STO-3G, FCI/STO-3G, CCSD/cc-pVDZ, CCSD/cc-pV5Z, Active FCI/STO-3G, Active CCSD/STO-3G and Active UCCSD/STO-3G; `Figure3/Figure3AB.tsv` adds "Active 5-UpCCGSD/STO-3G" with and without noise and their up and down error bars; `Figure4/Figure4AB.tsv` carries 1-UpCCGSD and 5-UpCCGSD under the ibmq-bogota model with their up and down bounds, its column names lacking the "+noise" suffix Figure3AB uses; and `FigureS3/FigureS3.tsv` covers $k = 2, 3, 4$ the same way as Figure4AB.

  https://github.com/hclim0213/QC_SN2 — MIT licensed, described by its own README as "additional supplementary data" for the paper, and the only code in it is `example.py`, 50 lines of Python invoked as `python example.py 01`. The environment is pinned in the README: Python 3.8.10 with `tequila-basic==1.6.1 qiskit==0.29.0 qiskit-nature==0.2.1 qiskit-aer==0.8.2 qulacs==0.3.0 pyscf==1.7.6 openfermion==1.0.0`, plus psi4 from conda. What the repository does not contain is the noise half of the study: `example.py` builds and minimises the noiseless UCCSD and $k = 1$ through $5$ expectation values and prints their energies, and although it imports `qiskit` and `pickle` it uses neither; the paper places the shortest circuit elsewhere again, saying of 1-UpCCGSD that "its qiskit code is shown in the Supporting Information".

  Against the same active space, UCCSD was the more accurate of the two. Table 1 gives RMSE against Active-Space FCI/STO-3G as 0.000784 kcal/mol for UCCSD against 0.0293, 0.0255, 0.0320, 0.0204 and 0.0210 for $k = 1$ through $5$, and the text states it plainly — "Compared to the classical result with active space, k-UpCCGSD showed more inaccurate results than UCCSD". That sentence then gives only two numbers for a five-member family, 0.0210 and 0.0320 kcal/mol "respectively"; both appear in that Table 1 column, as the $k = 5$ and $k = 3$ rows, and the "respectively" has no antecedent, so the table's five values are the usable form and are what is quoted here. Chemical accuracy is claimed for both ansätze only against that same active space — "both UCCSD and k-UpCCGSD are also chemically accurate compared to FCI/STO-3G with the same active space". Measured instead against the classical results computed without an active space the two are indistinguishable at this resolution, 1.77, 1.21, 3.06 and 1.90 kcal/mol for 1-UpCCGSD against HF/STO-3G, FCI/STO-3G, CCSD/cc-pVDZ and CCSD/cc-pV5Z versus 1.77, 1.20, 3.05 and 1.89 for UCCSD, and of that comparison the paper says — writing about UCCSD, whose figures are the same size — that the results "cannot come close to those with chemical accuracy (less than 1 kcal/mol)". Ansatz against ansatz, the paper measures "the RMSE between the UCCSD/STO-3G and k-UpCCGSD ansatz (k=1,2,3,4,5) with active space" and reports 0.0287, 0.0254, 0.0317, 0.0198 and 0.0207 kcal/mol from 1-UpCCGSD to 5-UpCCGSD — a sequence it reads as showing "a decreasing tendency as the k value increased", which those five figures do not follow monotonically. Under the Qulacs noise model the order reverses, which is the study's point: "the upper bounds on the error were 0.889, 0.859, 0.752, 0.696, and 0.721 mHa, respectively, and the lower bounds on the error were 0.690, 0.643, 0.647, 0.708, and 0.589 mHa" for $k = 1$ through $5$, and "the quantum noise errors from k-UpCCGSD/STO-3G were smaller than those from UCCSD/STO-3G". Under the ibmq-bogota-derived model on the qasm simulator the shape of the curve survives but the absolute energies do not: "quantum noise resulted in an average error of 40.654 mHa in k-UpCCGSD compared to noiseless results", with a standard deviation of 0.436 mHa across the three independent simulations. The paper also declines to find a trend in $k$ under noise: there "was no clear tendency related to the k products and errors in the Qulacs-based noise simulations, and the ibmq-bogota-driven noise simulation".

Nobody has taken this apart yet. That is a gap in this graph, not a claim that the method has no parts.

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.

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

• k-UpCCGSD ansatz

  Repeated paired generalized doubles with generalized singles trade expressivity against shallower chemistry circuits.

• Generalized Unitary Coupled Cluster Wavefunctions for Quantum Computation↗Joonho Lee, William J. Huggins, Martin Head-Gordon, K. Birgitta Whaley · 2018theory yes · simulation yes · hardware no