Particle-hole coupled-cluster circuits

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

Barkoutsos et al. put the transformation before the circuit: they "propose a transformation of the electronic structure Hamiltonian in the second quantization framework into the particle-hole (p/h) picture, which offers a better starting point for the expansion of the trial wavefunction", so that the state "is parametrized in a way to efficiently explore the sector of the molecular Fock space that contains the desired solution". The circuit family follows from that choice — "a new family of quantum circuits based on exchange-type gates that enable accurate calculations while keeping the gate count (i.e., the circuit depth) low" — and the resulting method is named in the paper: "the particle-hole implementation of the Unitary Coupled Cluster (UCC) method within the Variational Quantum Eigensolver approach ... named q-UCC". The claim to read carefully is the last one, because it is about Trotterisation rather than about accuracy in general: they "show how a single Trotter step can accurately and efficiently reproduce the ground state energies of simple molecular systems", and *simple* is the paper's own word. No hardware run is reported.

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

Barkoutsos et al. report this ansatz's own numerical simulation, not a hardware run, on molecular hydrogen in the 6-31G basis. Calculations use the full, unreduced set of 8 Hartree-Fock orbitals, 2 occupied and 6 virtual, which their Jordan-Wigner mapping puts one-to-one onto 8 qubits, because, to keep a one-to-one correspondence with the classical UCCSD algorithm, they "do not perform any additional reduction of the Hamiltonian as was done in previous studies." The circuit prepares the Hartree-Fock reference state and applies the exponentiated $\hat T_1+\hat T_2$ excitation operator of Fig. 1, with the amplitudes optimised by the BFGS algorithm; per Table I's own caption, every UCCSD figure it reports already assumes this exponential is truncated to a single Trotter step, a choice the authors elsewhere say cuts the gate count by "about a factor $10^3$" relative to a higher-order split. At that single step, rewriting the Hamiltonian into the particle-hole picture leaves the q-UCCSD circuit itself unchanged, 708 one-qubit gates, 608 two-qubit gates and 15 parameters under both the plain and the particle-hole Hamiltonian, but cuts the classical optimisation cost: BFGS iterations needed to reach $10^{-7}$ Ha convergence fall from 53 to 27, and the number of circuit measurements from $3383\times N_s$ to $1471\times N_s$, where $N_s$, the shot count per evaluation, is introduced but never assigned a number anywhere in the paper. That truncation's accuracy is checked separately, at a single H$_2$ geometry of bond length 0.592 angstrom, where even at $n=1$ the measured error stays below $10^{-10}$ Ha. The authors call this an explicitly surprising, empirical finding rather than a designed guarantee: they attribute it to the VQE optimiser's flexibility "absorbing" the Trotter error, and note that it breaks the exponential's one-to-one correspondence with the classical CCSD expansion, prompting them to rename the method q-UCCSD.

Classical simulation · Table I caption and Section IV.A (particle-hole vs. plain Hamiltonian, UCCSD column, all at a single Trotter step); Fig. 5, Section IV.B.2 and Section V (Trotter-step convergence and the resulting gate-count reduction) of arXiv:1805.04340

given  electronic Hamiltonian in second quantization, HF orbital basis
           H_el = sum_ij h_ij a_i^dag a_j + sum_ijkl g_ijkl a_i^dag a_j^dag a_l a_k    (Eq. 1)
       HF reference determinant  |Phi_0> = prod_{i=1}^N a_i^dag |vac>                    (Eq. 4)
           equivalently the bit-string ket |1...1 0...0>, N occupied orbitals set to 1
                                                        (unlabeled form, Sec. III, step iii)
       index convention:  i,j,k,l occupied;  m,n,p,q virtual;  r,s,t,u either
       fermion-to-qubit map: Jordan-Wigner                                    (Sec. III, step ii)

requires  cluster operator truncated at singles+doubles,  T = T1 + T2
    # higher T_n need only longer circuits, not new theory -- the paper restricts
    #   its own implementation to UCCSD as "unpractical" beyond that (Sec. II B 1)

# --- rewrite the Hamiltonian in the particle-hole picture ----------------------
redefine   b_i^dag = a_i,       b_i = a_i^dag      (hole creation / annihilation)    (Eqs. 5, 7)
           b_m^dag = a_m^dag,   b_m = a_m          (particle creation / annihilation) (Eqs. 6, 8)
    # b's still obey fermionic anti-commutation -- N_b[.] then defines a valid
    #   quasiparticle vacuum at |Phi_0>
normal-order  N_b[.]  against |Phi_0>  to get
    H_p/h = E_HF + sum_rs <r|F|s> N_b[a_r^dag a_s]
                  + (1/2) sum_rstu <rs|g|tu> N_b[a_r^dag a_s^dag a_u a_t]         (Eq. 9)
    # this is the operator the device measures -- the qubit register itself is
    #   not re-encoded, only the Hamiltonian is rewritten

# --- build the cluster operator --------------------------------------------------
T1 = sum_{i;m}           theta_i^m         a_m^dag a_i                              (Eq. 13)
T2 = (1/2) sum_{i,j;m,n} theta_{i,j}^{m,n} a_n^dag a_m^dag a_j a_i                  (Eq. 14)
    # sums run over ALL occupied/virtual pairs -- an active-space restriction to
    #   primed subsets i',m' shrinks them directly, same functional form (Eqs. 23-24)
|Psi(theta)> = exp( (T1 - T1^dag) + (T2 - T2^dag) ) |Phi_0>                         (Eq. 12)

# --- exponentiate by first-order Trotter splitting, n steps ----------------------
exp( (T1-T1^dag) + (T2-T2^dag) )
    ~=  [ exp((T1-T1^dag)/n)  exp((T2-T2^dag)/n) ]^n                                (Eq. 25)
    # exact only as n -> infinity, general two-term case  (Eq. 16)
    # each factor realised by the excitation circuits of Fig. 1;
    #   the underlying Pauli-string form is given in App. A (Eq. AA.6)

# --- optimise theta by VQE, at the chosen n --------------------------------------
loop
    prepare |Psi(theta)>  on the device via the n-step circuit above
    measure  <Psi(theta)| H_p/h |Psi(theta)>
    theta <- BFGS step on the measured energy                                       (Sec. III)
until convergence

return  |Psi(theta_min)>,   E_GS = E_HF + E_corr_UCCSD(theta_min)                    (Eq. 15)
# n=1, WITH theta fully re-optimised by VQE AT that n, measures error < 1e-10 Ha
#   at equilibrium H2 (Eq. 27; Fig. 5 red triangles) -- a DIFFERENT, larger
#   'Trotter error' (Eq. 26, amplitudes fixed at their exact-exponentiation
#   values) is plotted in the same figure for comparison and is NOT the
#   quantity claimed small here. The paper calls the n=1 result "surprising",
#   explained by VQE's flexibility 'absorbing' the error, and explicitly not
#   a proven bound                                          (Sec. IV B 2; Sec. V)

Barkoutsos et al. give one scaling: q-UCCSD circuit depth as $\mathcal{O}\left( \binom{N_{\mathrm{occ}}}{2} \times \binom{N_{\mathrm{virt}}}{2} \times N_{\mathrm{qubits}} \right)$ — binomial coefficients — for the cluster operator truncated at $\hat{T}=\hat{T}_1+\hat{T}_2$, where $N_{\mathrm{occ}}$ and $N_{\mathrm{virt}}$ count only orbitals taking part in the excitations, so an active space shrinks it directly. Everything else is measured on $\mathrm{H_2}$ in 6-31G (8 qubits, no Hamiltonian reduction), in simulation, with nearest-neighbour connectivity and exchange gates counted as one native two-qubit operation. q-UCCSD at a single Trotter step: 15 parameters, 708 one-qubit and 608 two-qubit gates, identical under both Hamiltonians — the particle-hole rewrite buys optimiser work, BFGS iterations falling 53 to 27 and Pauli-string evaluations $3383 \times N_s$ to $1471 \times N_s$ with $N_s$ never fixed, an overall speed-up of "about a factor 2 to 3". For the exchange-gate heuristic ansatz, reaching $10^{-7}$ Ha at equilibrium takes $D=6$ blocks (84 parameters, 42 two-qubit gates, no one-qubit gates) against $D=8$ (112, 56); demanding chemical accuracy ($0.5 \times 10^{-2}$ Ha) along the whole dissociation path erases that saving — $D=10$, 140, 70 under both. Nothing bounds the VQE iteration count; $D$ is fixed empirically. No hardware run.

• The particle-hole Hamiltonian transformation in Qiskit Aqua's chemistry stack

  • Quantum algorithms for electronic structure calculations: particle/hole Hamiltonian and optimized wavefunction expansions

  The paper's own UCCSD circuits were built on IBM's stack — "The circuits for the implementation of the UCCSD trial wavefunction (see Fig. 1) are constructed following the prescriptions in [3, 38, 40] and implemented in the IBM software package QISKit" — and the p/h rewrite of the Hamiltonian later shipped in that stack as library code naming this paper as its source. That sentence is scoped to those circuits and to nothing else: the paper names no simulator and no device anywhere for any of its runs. The docstring of FermionicOperator.particle_hole_transformation makes the same case the paper does, that the standard second quantized Hamiltonian can be transformed into the particle-hole picture "which makes the expansion of the trail wavefunction from the HF reference state more natural", and that "for both trail wavefunctions implemented in q-lib ('heuristic' hardware efficient and UCCSD) the p/h Hamiltonian improves the speed of convergence of the VQE algorithm for the calculation of the electronic ground state properties", pointing the reader to "P. Barkoutsos, arXiv:1805.04340". The misspelling of trial, twice, and the name q-lib, which nothing in the repository glosses, are the source's.

  The code does Eq. 9's normal-ordering numerically on integral arrays rather than symbolically. The wrapper first reorders the operator into the interleaved-spin convention; then the module-level function rescales the two-body array by -2 and transposes it, IJKL to IKLJ, before folding the occupied-orbital Coulomb and exchange contributions into the one-body integrals — h1_old_matrix[r][s] += h2_old_matrix[r][i][s][i] - h2_old_matrix[r][i][i][s], summed over the occupied list built from num_alpha and num_beta. Those two normalising lines have to be read with the fold-in or its sign and scale come out wrong: the -2 undoes the -0.5 that QMolecule.twoe_to_spin applies when it builds the spin-orbital two-body array, and after the transposition the subtracted pair is Coulomb minus exchange over the occupied index, so what accumulates is a Fock matrix — which is what the one-body term of Eq. 9 carries. The identification with Eq. 9 is a reading of the arithmetic; the code names no equation. It then loops over every one-body index pair and every two-body index quadruple of the register, handing each to normal_order_integrals with the operator string ['adag', 'a'] or ['adag', 'adag', 'a', 'a'], accumulating new one- and two-body arrays together with the constant terms that the reordering throws off, and converts back to the block-spin convention. Those constants are summed into one returned energy shift; the qubit register itself is untouched, only the operator is rewritten.

  No dataset. The inputs are one molecule's one- and two-body integral arrays, from whichever driver produced them, plus the electron count as a list holding the alpha count then the beta count: the wrapper's signature is particle_hole_transformation(self, num_particles) and the module-level function's is particle_hole_transformation(n_qubits, num_particles, h1_old_matrix, h2_old_matrix). The repository's own test feeds them from the PySCF driver.

  GitHub, qiskit-community/qiskit-aqua, archived, Apache-2.0, last pushed 2021-11-26, read 2026-09-02. The transformation is qiskit/chemistry/particle_hole.py, 2040 lines, whose entry point particle_hole_transformation begins at line 1958 and is supported by normal_order_integrals, sort and last_two_indices_swap in the same file; it is exposed as the method FermionicOperator.particle_hole_transformation of qiskit/chemistry/fermionic_operator.py, returning the pair (new_fer_op, energy_shift). Two enums select it from the layer above, TransformationType.PARTICLE_HOLE = 'particle_hole' in qiskit/chemistry/core/hamiltonian.py and FermionicTransformationType.PARTICLE_HOLE = 'particle_hole' in qiskit/chemistry/transformations/fermionic_transformation.py, and each branches to that same call. The file is present in every released tag from 0.6.0 through the final 0.9.5 and absent at 0.5.5. It did not survive the move to the successor package: no minor-series tag of qiskit-community/qiskit-nature from 0.1.0 through 0.8, and not its main branch either, contains any path matching particle_hole.

  No benchmark energies are reported and no hardware run. What the repository checks is algebra, plus one hard-coded number. test/chemistry/test_particle_hole.py asserts that the negated shift equals the electronic part of the Hartree-Fock energy, assertAlmostEqual(-ph_shift, molecule.hf_energy - molecule.nuclear_repulsion_energy), and that the Jordan-Wigner ground state of the transformed operator, with the shift added back, equals that of the untransformed one — both eigenvalues from NumPyMinimumEigensolver, that is exact diagonalisation rather than a variational run. It runs those two identities over ten rows: H2, LiH, H2O, OH and CH2, at sto3g and 6-31g, with RHF, ROHF and UHF references, and it skips itself when PySCF is not installed. The number is in the two tests that drive the p/h branch of the layer above, test_core_hamiltonian.py and test_fermionic_transformation.py, which both take H2 in sto3g through Jordan-Wigner without two-qubit reduction and assert a ph_energy_shift of -1.83696799 with a 4-qubit, 15-term Pauli operator out. None of the three asserts an iteration count or a timing, so nothing in the repository tests what the paper claims about convergence. A worked notebook, chemistry/ParticleHoleTransformation.ipynb in qiskit-community/qiskit-community-tutorials, calls the same method on H2 in sto3g and then runs VQE on the transformed operator on BasicAer's statevector_simulator, but with a TwoLocal ry/cz circuit rather than either ansatz of the paper.

• The q-UCCSD variational form in Qiskit Aqua's chemistry stack

  • Quantum algorithms for electronic structure calculations: particle/hole Hamiltonian and optimized wavefunction expansions

  Aqua's UCCSD class is a general singles-and-doubles variational form: it does not itself rewrite the Hamiltonian into the particle-hole picture, and it does not use the paper's exchange-type gates. It is recorded here for what its own documentation and its neighbours in the package say it is. Its module docstring names this paper first, the argument doc for excitation_type describes 'sd', 's' and 'd' as choosing between "q-UCCSD, q-UCCS, q-UCCD excitation lists" in the paper's own acronyms, and the particle-hole Hamiltonian it can be run against is produced by the same package and selected one layer up by TransformationType.PARTICLE_HOLE — the pairing the paper studies, and the pairing the transformation's own docstring names when it says the p/h Hamiltonian helps "both trail wavefunctions implemented in q-lib ('heuristic' hardware efficient and UCCSD)". What q-UCC names is stated two ways in the paper and neither is a slip: the abstract has "the particle-hole implementation of the Unitary Coupled Cluster (UCC) method within the Variational Quantum Eigensolver approach ... named q-UCC", while the Conclusions say "we introduced the q-UCC acronym to define the quantum version of the classical CC approach". On the second reading the acronym marks the variational character rather than the particle-hole rewrite, so the shipped name is weaker evidence of provenance than it first looks.

  UCCSD builds its circuit one excitation operator at a time. It takes num_orbitals, num_particles, a qubit mapping and an initial state, derives the singles and doubles excitation lists — optionally narrowed by active_occupied and active_unoccupied, which is the active-space restriction the paper names as the first of the two developments it investigates — and maps each excitation to a qubit operator. The static method _construct_circuit_for_one_excited_operator multiplies each by -1j and calls WeightedPauliOperator.evolve(state_in=None, evo_time=param, num_time_slices=num_time_slices), and parallel_map concatenates the resulting circuits in order. num_time_slices defaults to 1, documented only as "parameters for dynamics, has a min. value of 1", so the shipped default builds one Trotter slice per excitation operator; the splitting between operators is first-order regardless, because each is evolved separately. That default is not the paper prescribing one step: the paper reports its single-step accuracy as something to be explained, "This surprising result can be explained with the flexibility of the variational quantum algorithm".

  No dataset. What the class takes is a description of one molecule's register rather than its integrals — num_orbitals, num_particles, a qubit mapping, an initial state that is normally HartreeFock, and optional active_occupied and active_unoccupied lists; the integrals reach the calculation only through the qubit operator that the transformation layer has already produced. The repository's tests supply those counts from the PySCF driver.

  GitHub, qiskit-community/qiskit-aqua, archived, Apache-2.0, last pushed 2021-11-26, read 2026-09-02. The class is UCCSD in qiskit/chemistry/components/variational_forms/uccsd.py, 799 lines, reached from the layer above through VQEUCCSDFactory in qiskit/chemistry/algorithms/ground_state_solvers/minimum_eigensolver_factories/vqe_uccsd_factory.py. Its module docstring carries three references, not one: this paper, then https://arxiv.org/abs/1701.08213 for the tapering and https://arxiv.org/abs/1911.10864 for the singlet and pair q-UCCD variants; the class docstring repeats the first and the third and drops the tapering one. Those two other urls are quoted here as the docstring's content and are not cited by this entry. The successor package kept the citation and dropped the subject: Qiskit Nature's UCC, in qiskit_nature/second_q/circuit/library/ansatzes/ucc.py and at qiskit_nature/circuit/library/ansatzes/ucc.py in the first release 0.1.0, lists arXiv:1805.04340 as its only reference and still does on main, while implementing neither the particle-hole rewrite nor the exchange gates.

  test/chemistry/test_uccsd_advanced.py runs the class end to end on the paper's own system and basis — H2 in 6-31G, frozen core, parity mapping with two-qubit reduction — through VQE with SLSQP capped at 100 iterations on BasicAer's statevector_simulator, and checks the total energy to six places against hard-coded references: -1.1434447924298028 for paired q-UCCD, -1.1476045878481704 and -1.1515491334334347 for the two singlet variants, and -1.1516142309717594 for UCCSD. All four build their transformation with TransformationType.FULL, so what is exercised is UCCSD against the plain second-quantized Hamiltonian. Of the 66 Python files under test/chemistry, six name the particle-hole path at all, and all six are the transformation's own tests; no test in the repository runs a variational form against the particle-hole Hamiltonian, so the convergence comparison that is the paper's actual result is not reproduced in the package that ships both halves of it. No hardware run.

• The paper's two exchange-gate entangler blocks as PennyLane templates

  • Quantum algorithms for electronic structure calculations: particle/hole Hamiltonian and optimized wavefunction expansions

  The exchange-gate half of the paper is the half a third party picked up. PennyLane added both of the paper's particle-conserving entangler blocks in release 0.13.0, whose changelog records that "Two new hardware-efficient particle-conserving templates have been implemented to perform VQE-based quantum chemistry simulations" applying "several layers of the particle-conserving entanglers proposed in Figs. 2a and 2b of Barkoutsos et al., arXiv:1805.04340". Those are the paper's Eq. 19 and Eq. 20 gates, two of the three entangler blocks it investigates; the third is all-to-all CNOTs, which the paper says "does not conserve the particle number" and which PennyLane did not take. What the paper claims as new is the family and not the gates: the abstract proposes "a new family of quantum circuits based on exchange-type gates", while the two gates themselves are attributed in the text to its references 51 and 49, both hardware papers.

  ParticleConservingU1 is documented as implementing "the heuristic VQE ansatz for quantum chemistry simulations using the particle-conserving gate U_1,ex proposed by Barkoutsos et al.", applying D layers of an entangler block to a Hartree-Fock state, each layer holding N-1 two-parameter exchange gates acting on nearest-neighbour pairs; the matrix its docstring prints is the paper's Eq. 19, and the helper decompose_ua assembles the controlled U_A from CZ, CRot, PhaseShift and CNOT. ParticleConservingU2 is the single-parameter counterpart, D layers of N RZ rotations followed by N-1 exchange gates, with the exchange gate built in u2_ex_gate as CNOT, then CRX at twice the angle on the reversed wire pair, then CNOT, and with compute_decomposition laying the pairs out as the even-indexed neighbours first and the odd-indexed ones after. The weight shapes the templates require reproduce the paper's own parameter counts: 2D(N-1) at D=6 on N=8 wires gives the 84 that Table I reports for the first entangler block on H2 in 6-31G under the particle-hole Hamiltonian, and D(2N-1) at D=8 gives its 120 for the second. Neither template touches the Hamiltonian; the particle-hole rewrite is not part of what PennyLane took, and neither file mentions it.

  No dataset. Both usage examples build their input inside the library: the hydrogen molecule at coordinates 0., 0., -0.66140414, 0., 0., 0.66140414 through PennyLane's qchem.molecular_hamiltonian, with the reference state from qchem.hf_state for two electrons. The weights are random in both — a default_rng draw seeded 1234 for ParticleConservingU1, an unseeded uniform draw for ParticleConservingU2 — so neither example is a converged calculation, and the templates themselves take the Hartree-Fock occupation as init_state, defaulting to all zeros when none is given.

  GitHub, PennyLaneAI/pennylane, Apache-2.0, not archived, read 2026-09-02. The templates are class ParticleConservingU1 with the helpers decompose_ua and u1_ex_gate in pennylane/templates/layers/particle_conserving_u1.py, 466 lines, and class ParticleConservingU2 with the helper u2_ex_gate in the sibling particle_conserving_u2.py, 315 lines; both are re-exported from pennylane/templates/layers/__init__.py, which pennylane/templates/__init__.py takes in turn by star import. They arrived in release 0.13.0 through pull requests 875 and 876. Both are still live on main at version 0.46.0-dev91 — neither file contains the string deprecat — and both carry unit tests, at tests/templates/layers/test_particle_conserving_u1.py and test_particle_conserving_u2.py.

  No benchmark and no hardware run. The only energy either module prints is ParticleConservingU1's doctest, an expectation value of the hydrogen Hamiltonian at two layers on seeded random weights, -0.9686 to four places, evaluated on default.qubit, PennyLane's state-vector simulator; ParticleConservingU2's example calls its cost function without showing the output, and the doctest under its compute_decomposition prints an operator list rather than an energy. Nothing here reproduces the paper's convergence study, and nothing compares the two blocks against the plain and particle-hole Hamiltonians as Table I does.

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.

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

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

• Particle-conserving VQE circuits

  Givens-style or excitation-preserving blocks keep evolution inside a fixed-particle-number sector.

• Quantum algorithms for electronic structure calculations: particle/hole Hamiltonian and optimized wavefunction expansions↗Panagiotis Kl. Barkoutsos, Jerome F. Gonthier, Igor Sokolov, Nikolaj Moll, Gian Salis, Andreas Fuhrer, Marc Ganzhorn, Daniel J. Egger, Matthias Troyer, Antonio Mezzacapo, Stefan Filipp, Ivano Tavernelli · 2018theory yes · simulation yes · hardware no