Symmetry-preserving state-preparation 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.

Gard et al. put the argument for the family before the family itself: "the efficiency of this algorithm depends crucially on the ability to prepare multi-qubit trial states ... that either include, or at least closely approximate, the actual energy eigenstates of the problem being simulated while avoiding states that have little overlap with them", and "symmetries play a central role in determining the best trial states". Their circuits "respect particle number, total spin, spin projection, and time-reversal symmetries" and "contain the minimal number of variational parameters needed to fully span the appropriate symmetry subspace dictated by the chemistry problem while avoiding all irrelevant sectors of Hilbert space" — minimality OVER THE SUBSPACE, which is a stronger claim than a small parameter count. The construction is general rather than tabulated: they "show how to construct these circuits for arbitrary numbers of orbitals, electrons, and spin quantum numbers" and "provide explicit decompositions and gate counts in terms of standard gate sets in each case". The evidence is simulation and its scope is stated: they "test our circuits in quantum simulations of the $H_2$ and $LiH$ molecules and find that they outperform standard state preparation methods in terms of both accuracy and circuit depth".

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

Gard et al. report a numerical VQE simulation of $H_2$ and $LiH$, not a hardware run: the Methods section states, "Our VQE simulations were done using IBM's Qiskit software, coding in our own proposed ansätze, which enforce relevant symmetries," and separately, "Noisy simulations were simulated using the noise parameters of IBM's Poughkeepsie device" — a noise model plugged into the simulator, never an execution on the device itself. For $H_2$ in the STO-3G basis, mapped under Jordan-Wigner to 4 qubits (their own $A_{4,2}$ and $E_{4,2}$ labels denote 2 electrons in 4 spin-orbitals), an ideal noiseless simulation optimized with BFGS from several random starts compares their particle-number-and-spin-projection-conserving $A_{4,2,s_z=0}$ ansatz (6 CNOT gates, 3 parameters) and their fully spin-restricted $E_{4,2,s=0,s_z=0}$ ansatz (20 CNOT gates, 2 parameters) against Qiskit's UCCSD (56 CNOT, 3 parameters), SWAPRZ (34 CNOT, 72 parameters) and RY/RYRZ (18 CNOT, 16-32 parameters); all reach energy errors "well below chemical accuracy." Repeating the $H_2$ comparison with the Poughkeepsie noise model, both $E$-gate ansätze — the unrestricted $E_{4,2}$ and the fully spin-restricted $E_{4,2,s=0,s_z=0}$ — lose accuracy to their larger CNOT counts; the unrestricted $E_{4,2}$ ansatz further drifts onto a nearly degenerate triplet state at long $H_2$ bond length, where the singlet-triplet gap is only of order $10^{-2}$ Hartree near two Angstroms, a failure that the fully spin-restricted $E_{4,2,s=0,s_z=0}$ ansatz alone is reported to avoid, being "the only displayed ansätze which always attempts to find the true ground state" across the dissociation curve. Separately, for $LiH$ reduced from 12 to 6 qubits by freezing the core orbital and dropping two non-interacting orbitals, the low-CNOT $A_{6,2,s_z=0}$ ansatz "continues to perform well," while its fully spin-restricted $E_{6,2,s=0,s_z=0}$ counterpart — the only $E$-gate ansatz tested for $LiH$ — exactly minimizes parameter count yet likewise suffers from a large CNOT count. The underlying energy values appear only as points on these plotted curves, not as a table, and the paper states its supporting data are "available from the authors upon request"; no run on actual quantum hardware appears anywhere in these results.

Classical simulation · Sec. II B (VQE simulations); Figs. 8-10 and their accompanying tables; Sec. IV (Methods) of arXiv:1904.10910

given  n spin-orbitals from a Jordan-Wigner-mapped Hamiltonian, m electrons fixed
       reference register |0>^(x)n

       A(theta,phi):  two-qubit gate, identity on |00>,|11>; on {|01>,|10>}:
           [ cos theta                exp(i phi) sin theta  ]
           [ exp(-i phi) sin theta       -cos theta          ]        (Eq. 2)
       = 2 single-qubit rotations + 3 CNOTs, minimal in CNOT count    (Fig. 2)

requires  0 < m < n,  linear nearest-neighbor qubit connectivity
    # m=0 or m=n: H_{n,m} is one-dimensional, no ansatz needed

# --- place the reference in the m-excitation sector --------------------------
k = m                          # excitations actually placed by the cascade
if m > n/2:
    k = n - m                  # work in the hole picture, not the particle one
        # gate counts for m and n-m are identical by particle-hole symmetry, so
        #   this is w.l.o.g.; it is REQUIRED rather than an optimisation because
        #   'no two adjacent' below is unsatisfiable once k > ceil(n/2)
        #   (Sec. II A, p. 5)
    # the cascade then spans the (n-m)-hole sector, which is H_{n,m} relabelled;
    #   C(n,m) = C(n,n-m), so every count below is unchanged
apply X to k of the n qubits, no two adjacent

# --- cascade A gates to span H_{n,m} = {|s>: s_i in {0,1}, sum_i s_i = m} -----
#     dim(H_{n,m}) = C(n,m)                                            (Eq. 1)
repeat
    first layer:   A(theta,phi) on every adjacent pair with an X on one side
    second layer:  A(theta,phi) linking each newly-touched qubit to a free
                       neighbor, until all adjacent qubits are connected
until  C(n,m) A gates placed
    # arrangement is NOT proved for general n,m -- confirmed only by fidelity
    #   sweeps over n,m in {2..6}x{1..5}, stated as a conjecture beyond that
fix phi on the last two A gates placed
    # naive 2*C(n,m) -> minimal 2*C(n,m) - 2 = 2*dim(H_{n,m}) - 2 real parameters

# --- optional: restrict to real coefficients (time-reversal symmetry) --------
if time-reversal required:
    set phi = 0 in every A gate
    fix one theta to zero
    # strips every coefficient's phase, then halves the count to dim(H_{n,m}) - 1

# --- optional: fix s_z (qubits 1..n/2 spin-up, n/2+1..n spin-down) ------------
if s_z required:
    zero every A gate bridging qubit n/2 and n/2+1 across the whole cascade,
        theta = phi = 0
        # each repeat of the primitive pattern can place its own such gate --
        #   the paper's n=4,m=2 example needs four parameters zeroed this way
    keep all of them out of the first layer
        # swap the first/second layer order if one would otherwise land there

return  U(theta,phi) |0>^(x)n
# spans H_{n,m}, or its time-reversal / s_z-restricted subspace, exactly, at
#   the minimal parameter count for whichever symmetries are imposed
# a hand-tuned circuit for one specific small (n,m) can beat this on CNOTs,
#   at the cost of non-nearest-neighbor connectivity (Fig. 4 vs Fig. 3)

Gard, Zhu, Barron, Mayhall, Economou and Barnes cost this family in variational parameters and CNOT gates only. Under Jordan-Wigner, $n$ spin-orbitals with $m$ electrons give a particle-number sector of dimension $\binom{n}{m}$, and absent any other symmetry $2\binom{n}{m}-2$ real parameters is the minimum that spans it; time reversal — eigenstates choosable real, no applied magnetic field — halves that to $\binom{n}{m}-1$. Their linear nearest-neighbour circuit uses $\binom{n}{m}$ two-qubit $A$ gates of three CNOTs each, so at most $3\binom{n}{m}$; dropping gates made redundant by the fixed input $|0\rangle^{\otimes n}$, Eq. (3) gives $3\binom{n}{m}-3m+1$ for $0<m<n/2$, a separate branch at $m=n/2$ and its particle-hole mirror above. The $\binom{n}{m}$ arrangement is a conjecture verified numerically only for $n\le 6$, the authors call this CNOT count "neither unique nor optimal", and parameters still grow exponentially. Imposing $s$ and $s_z$ (even $n$ only) leaves $\dim(H_{n,m,s,s_z})-1$ free angles, with Eq. (4) the subspace size. No shot, measurement, Hamiltonian-term or optimiser-iteration count appears anywhere in the paper or its supplement.

• Gard et al.'s own Mathematica notebook

  • Efficient Symmetry-Preserving State Preparation Circuits for the Variational Quantum Eigensolver Algorithm

  The paper releases one artefact and says so in a single sentence: "A custom Mathematica code to reproduce our results is available on GitHub", pointing at github.com/bgard1/Efficient-Symmetry-Preserving-State-Preparation-Circuits-for-the-VQE-algorithm. Its README repeats the scope — "This notebook contains example cases of efficient circuits that span a chosen number and spin subspace. All examples contained in the referenced paper can be generated with this notebook (with only minor modifications)." What is released is the numerical verification, not the VQE: the Methods section says separately that "Our VQE simulations were done using IBM's Qiskit software, coding in our own proposed ansätze, which enforce relevant symmetries", and the repository holds exactly two files — `README.md` and `Efficent_Circuit_NB.nb`, the misspelling being the repository's own — with no Qiskit code and no licence file. The measured data is not released either: "The data that support the findings of this study are available from the authors upon request."

  The notebook builds each circuit symbolically, then maximises the overlap of its output with random states drawn from the target subspace. `AGateGen[n_, m_, \[Theta]_, \[Phi]_]` is the Fig. 2 decomposition written out: the Mathematica product composes `cnot2[m, n]`, an `Opqb`-wrapped `Rz` by `\[Phi] + \[Pi]`, an `Ry` by `\[Theta] + \[Pi]/2`, `cnot2[n, m]`, an `Ry` by `-\[Theta] - \[Pi]/2`, an `Rz` by `-\[Phi] - \[Pi]` and `cnot2[m, n]`, the four rotations all targeting qubit m — three `cnot2` factors and four single-qubit rotations — and its trailing comment reads "General A gate which can act on non-adjacent qubits", so the released gate is built from general controlled-NOTs, `cnot2` being itself commented "General cnot gate which acts with control qubit i and target qubit j", and can act on non-adjacent qubits; the notebook defines no separate nearest-neighbour variant, `AGateGen` occurring exactly twice and as the same definition both times. Each verification cell has the shape `maxs = ParallelTable[Module[{set1 = Circuit[4, 2]}, Module[{randstat = Normalize@Re@randomstate1[1], varlist = Variables[...]}, NMaximize[..., Method -> {"SimulatedAnnealing", "RandomSeed" -> RandomInteger[{10^3}]}, MaxIterations -> 500]` closed over `{p, 1, N}`, and each is followed by a `Mean` over a `Table` of the first component of every `maxs` entry. `N` is not the same in every cell — the eight committed cells use 2000, 2000, 2000, 200, 50, 200, 50 and 200, which `results` gives per cell, matching the Methods section's "we find that Mathematica's NMaximize method 'Simulated Annealing' performs best for our purposes, when run over many samples of a randomly chosen state in the Hilbert space".

  There is no dataset. The random target states are generated inside the notebook by normalising a sum of `RandomReal[{0, 1}]` amplitudes over the basis states of the chosen sector, under the comment "Generate a random state within the chosen excitation and spin projection subspace", and the reference register is `zerostate = SparseArray[{1, 1} -> 1, {2^qubits, 1}]` with the comment "Ground state".

  The committed notebook keeps its outputs, so its own fidelity numbers can be read without running it: eight verification cells, four under the subchapter "Calculations if n=4,m=2 (Examples below are configured for "Split" spins and Stot=0, Sz=0)" and four under "Calculations if n=6,m=3 (Examples below are configured for "Split" spins and Stot=1/2, Sz=1/2)", each subchapter split into sections titled "Calculations without spin symmetry", "Calculations with spin projection symmetry" and "Calculations with total spin symmetry". The sample counts are not uniform, and five of the eight fall below the N = 2000 the paper quotes for its Fig. S4 fidelity curve — a figure the supplement states for that one curve, the checks it reports for the other choices of n and m carrying no sample count at all: the n=4,m=2 cells average over 2000, 2000, 2000 and 200 states and store 0.9999999999999869, 0.9999999999999994, 0.9999999999999989 and 1., while the n=6,m=3 cells average over 50, 200, 50 and 200 and store 0.9993670206370281, 0.9999999999999974, 0.9972115740382482 and 0.9995987256030427. The notebook flags the fidelities short of unity itself and attributes them to the optimiser rather than the circuit: "Occasionally the optizmer may fail to find the true maximum and an average fidelity may only be close to one. Inspection of the 'maxs' list can reveal that most fidelities are 1, with typically only a few which fail to maximize properly. This is likely a failure of Mathematica's optimizer and not of the circuit itself."

• XACC's ASWAP circuit-generator plugin

  Eclipse XACC ships this construction as a circuit-generator plugin, and its documentation names the source: "The ``ASWAP`` circuit generator generates a state preparation (ansatz) circuit for the VQE Algorithm. (See `Gard, Bryan T., et al. <https://arxiv.org/abs/1904.10910>`_)". The name is not the paper's — the string ASWAP does not occur anywhere in arXiv:1904.10910, whose own released notebook comments call it "our A SWAP circuit". The plugin was added on 2020-01-07 by Thien Nguyen of Oak Ridge National Laboratory, under the commit message "Implement ASWAP circuit plugin - Implemented the generic ASwap algorithm to construct ansatz circuit. - Added some unit tests."

  `ASWAP::addAGate` emits the Fig. 2 decomposition gate for gate: `CNOT(in_q2, in_q1)`, `Rz(in_q2, -(phi + pi))`, `Ry(in_q2, -(theta + pi/2))`, `CNOT(in_q1, in_q2)`, `Ry(in_q2, theta + pi/2)`, `Rz(in_q2, phi + pi)`, `CNOT(in_q2, in_q1)`, its declaration commented "Add an A gate (see FIG. 2) between two arbitrary qubits" — three CNOTs and four single-qubit rotations, the same seven factors the authors' Mathematica `AGateGen` composes. `initializeParamList` reproduces the paper's parameter counts rather than approximating them: it sizes its parameter list at `binomialCoefficient(m_nbQubits, m_nbParticles)` A blocks and declares `binomialCoefficient(m_nbQubits, m_nbParticles) - 1` free angles when `timeReversalSymmetry` is on, `2 * (binomialCoefficient(m_nbQubits, m_nbParticles) - 1)` when it is off, with two qubits special-cased to 1 and 2; the surplus angle is written as the literal `"0.0"` under the comment "Fix the free theta paramter to zero: Note: an A block with both theta and phi are zero ==> CZ gate", which is also what the paper states, that zeroing both parameters reduces the gate to a CZ rather than removing it. It places no gates: gates are placed by `constructCircuit`, which branches on `2 * m_nbParticles` against `m_nbQubits`, builds a fixed list of adjacent control-target pairs, and emits one A gate per pair until the parameter list runs out — so the A-block count matches the paper's only where the pair list is long enough. In the two branches at or below half filling it places the opening X gates on alternating qubits (`X(2*i + 1)` and `X(2*i)`). Of the four documented keys, `szSymmetry` is the one that does nothing: it is read and logged in `expand` and never referenced again, so spin projection is not enforced by this plugin — only particle number and, optionally, time reversal. The file states the reason: "Note: we don't have a *generic* method to reduce param count for sz symmetry for arbitrary number of qubits. The paper did provide some special-case handlers for 6 and 8 qubit cases."

  `quantum/plugins/circuits/aswap/aswap.hpp` and `aswap.cpp` in https://github.com/eclipse-xacc/xacc define `class ASWAP : public xacc::quantum::Circuit`, and `quantum/plugins/circuits/GeneratorsActivator.cpp` registers it (`auto aswap = std::make_shared<xacc::circuits::ASWAP>();` then `context.RegisterService<xacc::Instruction>(aswap);`) so it resolves by name from XASM as `ASWAP(q, t0, {{"nbQubits", 2}, {"nbParticles", 1}});` and from C++ as `xacc::getService<Instruction>("ASWAP")`. `requiredKeys()` lists `nbQubits`, `nbParticles`, `timeReversalSymmetry` ("default = true") and `szSymmetry`, and comments that "This circuit requires qubit array is in the 0 initial state." Both files carry the header "Copyright (c) 2019 UT-Battelle, LLC" and are "made available under the terms of the Eclipse Public License v1.0 and Eclipse Distribution License v1.0"; the repository's licence file is `LICENSE.EDL`. A commit on 2021-02-01 tightened the parameterisation to the paper's minimum after the fact — "The current ASWAP impl didn't take advantage of free parameters from normalization condition. e.g. has one extra parameter in time reversal symmetry case, which should be set to zero => simplify the A block." — and a second commit the same day, whose message claims variable naming rather than parameterisation, fixed a bug in ASwap with respect to variable naming and updated the unit test.

  `quantum/plugins/circuits/aswap/tests/ASwapTester.cpp` asserts the structure and then runs VQE on a simulator. `checkSimple` expects the four-qubit, two-particle circuit to hold `nbInstrPerA * nbA + 2` instructions with `nbInstrPerA = 7` and `nbA = 6`, commented "See FIG3: for the 4 qubits/2 particles case, we have a total of 6 A blocks + 2 X gates", with 5 variables under time reversal ("Expect: C(4,2) - 1 = 5 params") and 10 without ("Expect: 2 * (C(4,2) - 1) = 10 params"). The end-to-end checks are nuclear rather than molecular: `checkDeuteron2` and `checkDeuteron3` minimise the N=2 and N=3 deuteron Pauli Hamiltonians with the `nlopt` optimizer on the `qpp` accelerator ("use our Qpp backend") and assert `EXPECT_NEAR((*buffer)["opt-val"].as<double>(), -1.74886, 1e-4)` and the same against -2.04482. The plugin directory holds only `aswap.cpp`, `aswap.hpp` and `tests/`, whose two files are `ASwapTester.cpp` and a `CMakeLists.txt`, and neither H2 nor LiH — the paper's two test molecules — appears in the tester; no hardware run is committed with the plugin, and nothing in the tester checks that the circuit spans the subspace.

• ASWAP ansatz in Quantum Brilliance's Qristal SDK

  Quantum Brilliance's Qristal SDK offers ASWAP as one of its three built-in VQE ansätze, alongside a hardware-efficient one and UCCSD. Its documentation links the paper — "[ASWAP](https://arxiv.org/abs/1904.10910) ansatz that is useful for quantum chemistry" — and describes the knob rather than the construction: "ASWAP is well-suited to the types of Hamiltonians generated by quantum chemistry problems and is parameterized by the number of particles to use." The circuit itself is not Qristal's: `ASWAP_Ansatz` resolves XACC's plugin, so this entry records where the construction ships, not a second implementation of it.

  The one packaged ASWAP job builds its own Hamiltonian rather than reading a file: `JobID::H2_ASWAP` sets `pauliString=pauliStringFromGeometry(hydrogenChainGeometry(2))`, where `hydrogenChainGeometry` "generates geometry string for hydrogen chain with 1.4 bohr distance between atoms" and `pauliStringFromGeometry` is documented as "generate Pauli string from molecule geometry using pyscf with sto-3g basis and Jordan Wigner transformation". Qristal's documentation attaches a warning to that pairing: "The built-in ASWAP and UCCSD ansätze in Qristal map all alpha (up) spins then all beta (down) spins. Thus, care must be taken to make sure that the input Pauli Hamiltonian follows the same mapping convention."

  `std::shared_ptr<xacc::CompositeInstruction> ASWAP_Ansatz(const int nQubits, const int nParticles, const bool timeReversalSymmetry)` in `src/optimization/vqee/case_generator.cpp` calls `auto tmp = xacc::getService<xacc::Instruction>("ASWAP");` and then `ansatz->expand({ {"nbQubits",nQubits}, {"nbParticles",nParticles}, {"timeReversalSymmetry",timeReversalSymmetry} })` — every structural decision is XACC's, and Qristal exposes no `szSymmetry` argument at all. It is declared in `include/qristal/core/optimization/vqee/case_generator.hpp` with `timeReversalSymmetry=true` as the default, reached through `enum class AnsatzID {HEA, UCCSD, ASWAP}` and `setAnsatz`, and bound to Python in `src/python/py_optimization_vqee.cpp` as `AnsatzID.ASWAP` and `JobID.H2_ASWAP`; the shipped C++ driver `examples/cpp/vqeeCalculator` takes it as a string, its flag documented "Ansatz type: must be \"UCCSD\", \"ASWAP\" or \"HEA\"". The repository is https://github.com/qbrilliance/qristal-core, whose licence file reads "Copyright 2022-2024 Quantum Brilliance" and "All files and subdirectories contained in the directory of this document are copyright Quantum Brilliance, and may not be used except in compliance with the Apache License Version 2.0."

  An ASWAP energy is committed, but as a worked example rather than a result: `examples/cpp/vqeeCalculator/README.md` pairs an input block reading "ansatz": "ASWAP" at "nQubits": 5, "nElectrons": 2, "maxIters": 1 and an explicit nine-angle "thetas" list with an output block over the same Pauli string reading "energy": -6.722747367844044e-05 and "iterations": 1 — one evaluation at the listed angles, not a minimisation. The packaged library job commits no energy at all: it is `ASWAP_Ansatz(4,2,true)` with `.nQubits=4` and `.maxIters=75`, and its commented-out header records only the size — "H-2 chain 4 Qbits, 5 parameters, 15 Pauli terms (ASWAP ansatz)" — where the 5 is $\binom{4}{2}-1$, the paper's time-reversal-symmetric minimum. What is asserted over an ASWAP run is not an energy either: `tests/misc_py/q_chemistry_test_cases.py` sets `"ansatz":"aswap"` alongside `"acc":"qpp"`, nine thetas and `"method":"nelder-mead"`, drives an ASE BFGS geometry optimisation of H2 and asserts `optimum_bond_len == pytest.approx(1.388, None, 0.001)` — but its `from vqe_calculator import VQE` names a module that GitHub code search finds nowhere else in the repository, so what that test asserts is on record and whether it runs is not. None of the six shipped Python VQE examples selects ASWAP: the only one that chooses an ansatz through `AnsatzID`, `examples/python/vqee_example_3.py`, sets `ansatzID = qbvqe.AnsatzID.UCCSD` and mentions ASWAP only in the comment on its `trs` flag: "time reversal symmetry only when ASWAP, else just a required dummy to conform to the signature".

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.

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

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

• Symmetry-preserving VQE ansatz

  The ansatz is constrained to preserve selected particle-number, parity, or spin symmetries.

• Efficient Symmetry-Preserving State Preparation Circuits for the Variational Quantum Eigensolver Algorithm↗Bryan T. Gard, Linghua Zhu, George S. Barron, Nicholas J. Mayhall, Sophia E. Economou, Edwin Barnes · 2019theory yes · simulation yes · hardware no