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

Ryabinkin et al. name two separate problems with the unitary coupled-cluster route, and the second is a hardware constraint rather than an accuracy one: the accuracy "depends on how many and what kind of terms are included", and there is "a growth of the number of simultaneously entangled qubits even at the fixed fermionic excitation rank", which "not all quantum computing architectures can cope with". Their method "starts directly in the qubit space and uses energy response estimates for ranking the importance of individual entanglers".

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.

  QCC hands this ingredient a fixed, shallow preparation and asks for one scalar back. The state is the QMF product $|\Omega\rangle$ built from one-qubit rotations, followed by the surviving entanglers $\exp(-i\tau_k\hat{P}_k/2)$ in order; the paper's only device-level instance is Fig. 2, a Rigetti circuit for $\mathrm{H}_2$ that reaches it with $R_x$, $R_z$ and Hadamard gates and exactly two CNOT gates for its single entangler. What is estimated is the qubit-space $\hat{H}$ on that state — the similarity-transformed $\hat{H}[\tau;\hat{P}]$ that ranks entanglers is a classical expansion, not something handed to the estimator — one estimate per energy evaluation of the joint $(\tau,\Omega)$ minimization, with no grouping of $\hat{H}$'s Pauli words into commuting sets prescribed. assumption: $E(\tau,\Omega)$ is treated as an exact expectation value; the paper raises the "inherent quantum uncertainty" of a quantum computer's expectation values only when contrasting its numbers with a hardware run, and no shot budget enters its accounting

  assumption

Ryabinkin, Yen, Genin and Izmaylov's own results are a classical numerical simulation, not a hardware run: ground-state potential energy curves for H2 and LiH in the STO-3G basis, with RHF orbitals from a modified GAMESS. H2 uses the Bravyi-Kitaev mapping with all 4 spin-orbitals kept as 4 qubits; screening the pool of two-qubit entanglers by the first-derivative test and, where that vanishes, the second-derivative test, only 6 of 54 candidates lower the energy at R = 1.0 angstrom, 2 caught by the first-order test and 4 only by the second. All 6 turn out to be related by a global frame rotation, so a single one suffices across the whole H-H curve, and its circuit needs only two CNOT gates. LiH is more revealing, and shows the screening's limit directly: near equilibrium (R about 1.5 angstrom) the same procedure readily finds 6-7 entanglers giving chemical accuracy there, but the paper states plainly that these entanglers do not give chemical accuracy over the full curve, R = 0.5 to 5.0 angstrom. Near R = 3.2 angstrom, where the QMF reference itself breaks spin symmetry, the same first- and second-derivative screening produces a candidate list that balloons instead of shrinking, so the authors rank by the energy gradient on a spin-singlet-constrained QMF state instead; the resulting 7 entanglers do reach chemical accuracy, at most 1 kcal/mol against the paper's complete-active-space CI reference, computed in the same hand-picked, frozen 3-orbital active space that the QCC/QMF calculation itself uses, across the entire curve, with 15 parameters (8 Bloch angles, 7 amplitudes) and, after factorizing every 3- and 4-qubit word among them into two-qubit exponentials, 31 two-qubit factors. What the run does not establish: no shot count, optimiser, iteration count or circuit depth is reported anywhere for either molecule; the two-CNOT circuit shown for H2 is a PyQuil compilation of one entangler into the Rigetti gate set, and no measured value from it, or from any device, is reported anywhere in the paper; every energy quoted, including the "Exact" reference curves, is a classical expectation value.

Classical simulation · Sec. III (Secs. III A-C, Tables I-II, Figs. 1-3, Eq. 33) of arXiv:1809.03827

given  H = sum_I C_I P_I  on N_q qubits,  the JW/BK-transformed
           electronic Hamiltonian, C_I numerical, P_I Pauli words     (Eq. 4-5)
       pool of Pauli-word entanglers P_k,  |P_k| = 2 ... N_q,
           pool size  4^N_q - 3N_q - 1                                (Sec. II A)

requires  each P_k involutory,  P_k^2 = I                            (Sec. II A)
    # true of any Pauli word; this is what lets H[tau;P_k] below close
    #   after exactly two extra terms, not a truncated series

# --- QMF reference state ---------------------------------------------
|Omega> = product_i ( cos(theta_i/2)|alpha_i> + e^(i phi_i) sin(theta_i/2)|beta_i> )   (Eq. 16)
    # 2 Bloch angles (theta_i, phi_i) per qubit -- 2 N_q parameters here  (Eq. 15)
E_QMF = min_Omega  <Omega| H |Omega>                                   (Sec. II B, Eq. 22)

# --- rank the pool: cheap derivative tests before the costly one -----
for each P_k in pool:
    d1_k = <Omega_min| -i/2 [H, P_k] |Omega_min>   # dE/dtau at tau=0   (Eq. 25)
    if d1_k != 0:
        tier1 += P_k
    else:
        d2_k = <Omega_min| (1/2) P_k[H,P_k] |Omega_min>  -  c_k^T D^-1 c_k   (Eq. A.12-13)
            # relaxation-corrected second derivative -- c, D are the
            #   Bloch-angle cross term and Hessian at Omega_min (Eq. A.8-A.9);
            #   the correction accounts for Omega_min moving as tau moves off 0
        if d2_k is significantly negative:
            tier2 += P_k   # "significant negative" -- no numeric cutoff given

shortlist = top-ranked of tier1 (by |d1_k|)  union  top-ranked of tier2 (by |d2_k|)
    # "top entanglers in both tiers" is the paper's own phrase for this cut --
    #   how many survive it is left to inspection of the ranked list, not a
    #   fixed rule                                                      (Sec. II B)

# --- full re-optimisation, but only on that shortlist -----------------
for each P_k in shortlist:
    H[tau; P_k] = H - i sin(tau)/2 [H,P_k] + (1-cos(tau))/2 P_k[H,P_k]  (Eq. 20)
    dE[P_k] = min_tau ( min_Omega <Omega| H[tau; P_k] |Omega> )  -  E_QMF   (Eq. 21-22)
    # dE[P_k] <= 0 by construction

select  {P_1, ..., P_Nent} = the entanglers kept from the dE[P_k] ranking
    # how many are kept is likewise not fixed by the theory above -- the
    #   paper settles it molecule by molecule, e.g. all 6 energy-lowering
    #   H2 entanglers turn out redundant and only 1 is used in the end;
    #   for LiH near equilibrium (R~1.5 A) a few (6-7) already reach
    #   chemical accuracy THERE, but do not hold over the whole 0.5-5.0 A
    #   curve -- that takes a different, specific 7, chosen below at the
    #   symmetry-breaking geometry R=3.2 A                        (Sec. III C)
    # at that symmetry-breaking geometry the same first-derivative gradient
    #   test (not the full two-tier test -- the paper writes out only this
    #   half at the constrained reference) is rerun on a spin-singlet
    #   CONSTRAINED QMF reference instead, whose gradient favours
    #   entanglers that restore the broken symmetry                  (Eq. 33)

# --- assemble the ansatz -----------------------------------------------
U(tau) = product_{k=1..N_ent}  exp( -i tau_k P_k / 2 )                    (Eq. 17)
Psi(tau, Omega) = U(tau) |Omega>                                          (Eq. 14)

# if hardware caps entanglement at two qubits, factor any |P_k| >= 3 term:
# split P = P_1 w_k P_2, use [w_k', w_k''] = 2i w_k on the shared qubit,
#   giving exp(-i t P) as a product of ~log2|P_k| two-qubit exponentials   (Eq. 26-32)
# gate count only -- Psi and the parameter count below are unaffected;
#   e.g. LiH's 7 entanglers factor into 31 such two-qubit terms            (Sec. III C)

return  Psi(tau, Omega) = U(tau)|Omega>,  jointly variational in tau, Omega
        -- 2 N_q + N_ent parameters total                                 (Sec. II A)
# feeds observable-estimation: E(tau,Omega) = <Psi|H|Psi> is minimized
#   jointly over both parameter sets, one estimate per energy evaluation   (Eq. 18-19)

Ryabinkin, Yen, Genin and Izmaylov price the QCC ansatz at $2N_q + N_{\mathrm{ent}}$ variational parameters, two Bloch angles per qubit plus one amplitude per entangler (Sec. II A), with $N_{\mathrm{ent}}$ bounded only by the pool of Pauli words of length $2$ to $N_q$, $4^{N_q} - 3N_q - 1$. Ranking is two-stage (Sec. II B): over the whole pool, one commutator expectation per entangler, $\langle \Omega_{\min}| -\tfrac{i}{2}[\hat{H},\hat{P}_k] |\Omega_{\min}\rangle$ (Eq. 25), and where that vanishes a second derivative (Eq. A.12); then full re-optimisation of $\tau$ and all $2N_q$ Bloch angles, but only for the top entanglers of both tiers. Eq. (20) expands the Hamiltonian into three terms per entangler, so the exactly transformed $\tilde{H}$ holds $\sim 3^{N_{\mathrm{ent}}}$ operators, a classical expansion and not a gate count. Measured, not proved: LiH in STO-3G, reduced to a $4$-qubit, $100$-Pauli-term effective Hamiltonian, reaches $\le 1$ kcal/mol with $7$ entanglers, $15$ parameters and $31$ two-qubit factors, those $7$ chosen at $R = 3.2$ angstrom by an added spin-singlet constrained-QMF gradient (Eq. 33). No shot count, iteration count, optimiser or circuit depth is given.

• QCC ansatz class in Tangelo

  • Tangelo: An Open-source Python Package for End-to-end Chemistry Workflows on Quantum Computers

  Tangelo is "an open-source Python package maintained by SandboxAQ, focusing on the development of quantum chemistry simulation workflows on quantum computers", released under Apache 2.0; the module's own statement of the problem it was written against is that the ansatz should "provide an improved alternative to classical unitary coupled cluster for describing the electron correlation of molecular systems". The module names its source: "This implementation is based on Ref. 1", and its Ref. 1 is "I. G. Ryabinkin, T.-C. Yen, S. N. Genin, and A. F. Izmaylov. J. Chem. Theory Comput. 2018, 14 (12), 6317-6326" — the paper this method is recorded from. The changelog dates "QMF, QCC and VSQS ansatze for VQE" to version 0.3.0 of 2022-02-15, the same release whose sole recorded change is the line "Naming (Good Chemistry, Tangelo, linq)".

  The class assembles the QCC operator as "QCC operator = -0.5 * SUM_k P_k * tau_k" and exponentiates it as "U = PROD_k exp(-0.5j * tau_k * P_k)", then builds the circuit under its own comment "Obtain quantum circuit through trivial trotterization of the qubit operator" — a CNOT-ladder-and-RZ construction that `ansatz_utils.py` credits to "Whitfield 2010". That is not the 2018 paper's factorisation of a Pauli word of length three or more into two-qubit exponentials, of which the paper says "In general, the decomposition overhead is logarithmic, but the exact figures depend on the set of entanglers": `exp_pauliword_to_gates` instead lays a single CNOT ladder across every index in the word, sorted, with one RZ at its end. Generator selection is delegated to `construct_dis`, whose module docstring credits not the 2018 QCC paper but "I. G. Ryabinkin, R. A. Lang, S. N. Genin, and A. F. Izmaylov. J. Chem. Theory Comput. 2020, 16, 2, 1055-1063", the iterative-QCC paper that introduced the direct interaction set. Only the first tier of the 2018 two-stage ranking is present: `get_idxs_deriv` evaluates "dEQCC_dtau = -i/2 <QMF|[H, gen]|QMF> = -i <QMF|H * gen|QMF>", terms are grouped by flip indices, group derivatives summed, and groups below `deqcc_dtau_thresh` (default 1e-3 a.u.) dropped. There is no second-derivative test for entanglers whose first derivative vanishes, and no per-candidate re-optimisation of the amplitude and the Bloch angles; one representative generator is taken per surviving group under the comment "for now just grab the first generator; eventually add capability to allow the user to select which generators to use", and `max_qcc_gens` truncates the list sorted by decreasing gradient magnitude. The parameter vector is `2 * n_qubits + n_qcc_params` long for the default Hartree-Fock reference, matching the paper's count, but only the entangler amplitudes reach the circuit: `update_var_params` writes into `self.qcc_circuit._variational_gates` and never into the mean-field half, so the Bloch angles stay at the values the circuit was first built with however an optimiser moves the leading `2 * n_qubits` entries, and the joint optimisation over amplitudes and Bloch angles that the paper specifies is not what this class performs. The class docstring says something different again — that a QMF circuit the class creates for itself carries "QMF parameters that are not variational" — and that is not what the code does either, since `prepare_reference_state` calls `get_qmf_circuit(self.qmf_var_params, True)` and every gate that function returns is built with `is_variational` set from that flag.

  Input is a Tangelo `SecondQuantizedMolecule` or `SecondQuantizedDMETFragment`, or a plain dict carrying `n_spinorbitals`, `n_electrons` and `spin` alongside a `qubit_ham`, so no molecule object is needed provided those three counts arrive with the Hamiltonian; a dict without a `qubit_ham` raises. Closed-shell and restricted open-shell are both handled — "the underlying fermionic mean-field state is treated differently depending on the spin" — with the mapping defaulting to `jw`, under which the class reorders the spin-orbitals itself and warns that it has done so: "Spin-orbital ordering shifted to all spin-up first then down to ensure efficient generator screening for the Jordan-Wigner mapping". The reference is Hartree-Fock: `init_qmf_from_hf` seeds the Bloch angles and `purify_qmf_state` runs before the direct interaction set is built. The molecules the shipped tests draw on are `mol_H2_sto3g`, `mol_H4_cation_sto3g`, `mol_H4_doublecation_minao` and `mol_H4_sto3g_uhf_a1_frozen` from `tangelo.molecule_library`.

  Apache-2.0, with file headers reading "Copyright SandboxAQ 2021-2024". Repository https://github.com/sandbox-quantum/Tangelo, which GitHub reports archived, latest release v0.4.3 published 2024-06-20; the README and the install instructions still name the old path goodchemistryco/Tangelo, which redirects. Distributed on PyPI as `tangelo-gc`. The class is `QCC` in `tangelo/toolboxes/ansatz_generator/qcc.py`; the screening is `construct_dis`, `get_dis_groups`, `get_idxs_deriv`, `get_gens_from_idxs` and `build_qcc_qubit_op` in `tangelo/toolboxes/ansatz_generator/_qubit_cc.py`; the mean-field machinery is `_qubit_mf.py` and the Trotterisation `exp_pauliword_to_gates` in `ansatz_utils.py`. Deliberately outside this entry: `tangelo/algorithms/variational/iqcc_solver.py` and `iqcc_ilc_solver.py`, and `_qubit_cc.qcc_op_dress`, which performs the canonical transformation of the Hamiltonian that the iterative method needs and which `qcc.py` does not import.

  No device run, and no test in the suite runs an optimiser: every energy is an expectation value at parameters fixed in advance, the QMF Bloch angles and the entangler amplitudes alike written into the test file as literal arrays and handed to `update_var_params` before the value is taken. The shipped tests in `tangelo/toolboxes/ansatz_generator/tests/test_qcc.py` evaluate energies through `get_backend()`, whose default target is Qulacs when installed among the statevector simulators and Cirq otherwise, called with `n_shots` left at `None`, so the figures are exact expectation values rather than sampled ones. Closed-shell H2 in STO-3G with the single generator `Y0 X1 X2 X3` returns -1.1372701746609022 hartree to a tolerance of 1e-6; restricted open-shell H4 cation in STO-3G under the symmetry-conserving Bravyi-Kitaev mapping with nine generators returns -1.6382913; the H4 double cation in MINAO under Bravyi-Kitaev with five generators returns -0.85465810. Four of the five energy-evaluating tests hand the generators in explicitly and so exercise the circuit construction rather than the screening, and the fifth, on a UHF reference, only asserts that the reference-state energy equals the mean-field energy. The automatic path is checked instead by parameter count: `test_qcc_set_var_params` constructs `QCC(mol_H2_sto3g, up_then_down=True)` with no generators supplied and expects nine variational parameters, eight Bloch angles on four qubits plus one entangler amplitude.

• DMET-QCC curve for a ring of ten hydrogen atoms on IonQ's trapped-ion computer

  • Optimizing Electronic Structure Simulations on a Trapped-ion Quantum Computer using Problem Decomposition

  The problem the pipeline was built against is fitting a molecule onto a device too small for it by shrinking the problem rather than the ansatz: "Using density matrix embedding theory as a problem decomposition technique, and an ion-trap quantum computer, we simulate a ring of 10 hydrogen atoms without freezing any electrons. The originally 20-qubit system is decomposed into 10 two-qubit problems, making it amenable to currently available hardware." QCC is the circuit that goes on the device inside that pipeline, cited to Ryabinkin, Yen, Genin and Izmaylov — "To estimate the expectation value of the fragment energy and the number of particles per fragment on a quantum device, we use VQE with the qubit coupled-cluster (QCC) ansatz" — with the screening procedure cited to the later iterative-QCC paper and the gradient that procedure rests on cited back to this one.

  Each embedding fragment is a two-qubit problem carrying two electrons. Entangler selection is the QCC first-derivative test alone, run classically: "We find which P_k to include in our ansatz by computing the derivative of the expectation value with respect to tau_k, which can be computed in a straightforward way when tau = 0. We remove P_k terms that have small derivative values", and for this molecule "we find that P_k of XY and YX have large, identical derivative values. Note that we carry out the computation of the derivatives on a classical computer." Two departures from the 2018 recipe are stated outright and are what this entry turns on. The Bloch angles are not co-optimised with the amplitudes: "We note that, in the present work, the optimal mean-field parameter set Gamma_opt is not relaxed during the minimization of Eq. (25)", and the final parameter set "is formed as the union of the separately optimized mean-field and QCC parameter sets". And no optimisation ran on the device at all: "Instead of variationally optimizing the energies, then running through the DMET cycles, here we focus on the evaluation of the total energy from the quantum simulation for the classically pre-computed optimal parameters." The hardware measured expectation values at fixed, classically obtained angles. Residual error is treated classically afterwards by McWeeny purification of the two-particle reduced density matrix, iterated to a trace criterion of 1.0e-2, which the paper says works here only because "our fragment only has two electrons - thus the 2-RDM happens to be the full density matrix".

  A ring of ten hydrogen atoms under symmetric expansion at ten bond lengths, "R = 0.7, 0.85, 1.0, 1.1, 1.3, 1.6, 1.8, 2.0, 2.5, and 5.0 A". Integrals and the classical references come from PySCF — "The evaluation of these integrals, as well as the Hartree-Fock (HF) and full CI calculations, are carried out using PySCF" — in the minimal basis MINAO. The fermion-to-qubit step is the symmetry-conserving Bravyi-Kitaev transformation, "performed using OpenFermion". Atomic coordinates are in the paper's Supplementary Data 1; "All other data that support the findings of this study are available from the corresponding author upon reasonable request."

  Not released: "The code is available from the corresponding author upon reasonable request." The only named third-party components are PySCF for the classical structure calculations and OpenFermion for the qubit transformation. Circuits were written in a standard gate set of controlled-NOT and the three single-qubit rotations, then transpiled so that "the output circuits are encoded in the trapped-ion gate set" — a single-qubit and a two-qubit rotation generated by a Pauli axis in the equatorial plane — with the two-qubit gate opened to a continuous angle rather than the fixed one of the native gate, "as has been used elsewhere for efficient and high-fidelity simulations". The author contributions record that one co-author "compiled and optimized the circuits for their execution on the hardware". Three optimised circuits, XX, ZZ and XZ, supply the XX, ZZ, XZ and ZX expectation values, the XZ circuit covering two of them because the two pre-optimisation circuits for XZ and ZX "reduce to the same circuit upon optimizing compilation", with the single-qubit terms recovered from the same statistics; a fourth circuit is run for YY, which "requires us to run an additional circuit, YY, on the trapped-ion quantum computer". What that fourth circuit is for the paper states two ways: Fig. 1's caption calls the YY circuits "required for the classical post-processing of our simulation data" and Supplementary Note 2 says the YY expectation value "is not needed to compute the total energies", while the main text lists YY among the values required "for the DMET cycles" and the Methods bootstrap builds its distribution of total energies from "each Pauli operator (XX, YY, ZZ, XZ, and ZX)".

  Executed on "IonQ's 11-qubit trapped-ion quantum computer", a linear crystal of fifteen ytterbium-171 ions "with spacing of about 4 micrometres ... suspended in a chip trap with a radial pseudopotential frequency of ~3.1 MHz", of which "the 11 ions in the middle" are qubits and "Two of these qubits are used in our experiment". Gate quality is quoted as calibration, not as a measurement made here: "Single- and two-qubit gate fidelities are nominally calibrated to greater than 99.5% and 96.5%, respectively." Table 1 reports total energies per atom in hartree; at R = 1.0 angstrom the classical DMET-QCC value is -0.536753, the device gives -0.536 +/- 0.007 and purification gives -0.538 +/- 0.007, against a full-CI -0.538093; at R = 5.00 the purified value is -0.49987 +/- 0.00008 against a full-CI -0.499810. The paper's own summary carries its exceptions: "All points are in agreement with the simulated DMET-QCC values, and, with the exception of the repulsive wall and the point R = 1.8 A, all values are within chemical accuracy." Uncertainties are bootstrap standard deviations over SPAM-corrected histograms, and the paper attributes their size to sampling — "We note that the error bars are quite large, which is a result of the limited sampling capacity" — without stating a shot count.

• Ryabinkin, Yen, Genin and Izmaylov's own QCC calculations on H2 and LiH

  • Qubit coupled-cluster method: A systematic approach to quantum chemistry on a quantum computer

  The implementation behind the method's own paper. It exists as a described procedure and a set of curves rather than as an artefact anyone else can run, which is itself the fact worth recording: the paper that defines QCC releases no code and names no solver.

  Canonical restricted Hartree-Fock orbitals in the STO-3G basis, computed "assuming D2h and C2v symmetry for H2 and LiH, respectively". For H2 all four spin-orbitals enter the second-quantised Hamiltonian and the Bravyi-Kitaev transformation is used with spin-orbitals "alternating in the order alpha, beta, alpha, ..."; the two stationary qubits are deliberately kept, so "all 4 qubits corresponding to 4 spin-orbitals were retained". For LiH an active space of three A1 orbitals is selected by hand after reordering the canonical orbitals, and the parity transformation is used with spin-orbitals arranged "first all alpha then all beta", giving a six-qubit Hamiltonian whose stationary third and sixth qubits are replaced by their eigenvalues to define four-qubit sector Hamiltonians. Every QCC calculation starts from an unconstrained QMF solution — "In all our QCC calculations we started with symmetry unconstraint QMF solutions" — and the spin-singlet constrained reference enters only where the LiH entanglers are picked at the symmetry-breaking geometry, Table II's energy lowerings there being "evaluated with respect to the symmetry constrained QMF energies".

  Orbitals and integrals came from a modified GAMESS: "To generate fermionic Hamiltonian spin-orbitals and one- and two-electron integrals, a locally modified gamess electronic structure package was used." The reference energies came from the same package: "Molecular integral transformation was carried out by the aldet module; this module was also used to generate reference complete active space configurational interaction (CASCI) energies." The number and square of the total spin operators were prepared from their second-quantised fermionic expressions and mapped alongside the Hamiltonian, the paper noting they "are extremely useful in analysis of both QMF and QCC solutions".

  No repository, package or module is named, and no code accompanies the paper. The only named tools are the modified GAMESS above and PyQuil, and PyQuil is used to decompose one entangler into gates the Rigetti machine could run rather than to run the method: the two CNOT gates in Fig. 2 appear, in the paper's words, "as a result of a decomposition (made by PyQuil) of the unitary transformation generated by the entangler" — a two-qubit Pauli word — "into elementary operations possible on the Rigetti machine". Whatever performs the QMF minimisation, the two-tier entangler ranking and the joint QCC optimisation is neither named nor deposited anywhere the paper points to.

  No device run. Fig. 2 is captioned "A sample quantum circuit representing the QCC ansatz for the H2 molecule on the Rigetti machine", but it is a compilation target: the paper reports no measured quantity from that machine or any other, and every energy in it is classical. For H2 at R = 1.0 angstrom the paper prints the outcome of the ranking and leaves the ranking itself elsewhere, "the full table can be found in Supplementary materials": "Out of total 54 two-qubit entanglers only 6 provide energy lowering; all of them were found by the combined first- and second-order screening", of which "Only 2 of them has non-zero energy gradient and, thus, are identified by the cheapest first-order test", so four were caught only by the second-order test. Those six turn out to be interchangeable — "all 6 energy-lowering entanglers are related by a simple global frame rotation (change of quantization axis)", so "it is possible to use any one of them for the whole range" of the H-H distance — and the circuit built from the chosen one "contains only two two-qubit CNOT gates". For LiH the six-qubit Hamiltonian carries 118 Pauli words at each geometry and the ground-state sector Hamiltonian 100.

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.

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

Narrower versions of this one

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

• Qubit coupled-cluster VQE

  Qubit coupled-cluster uses Pauli-word entanglers and a product-state reference directly in qubit space.

• Qubit coupled-cluster method: A systematic approach to quantum chemistry on a quantum computer↗Ilya G. Ryabinkin, Tzu-Ching Yen, Scott N. Genin, Artur F. Izmaylov · 2018theory yes · simulation yes · hardware no