Multistate contracted variational eigensolver

• Estimate an excited-state energy

  Given a Hamiltonian you can query and a statement of which state above the lowest one is wanted, return an estimate of that state's energy — or of its distance from the ground state, which is the quantity an experiment usually measures. Whether the answer comes back as an absolute energy or as an excitation energy is a property of the method, and the two are not interchangeable.

Parrish et al. describe the extension by what it returns: MC-VQE "allows for the efficient computation of the transition energies between the ground state and several low-lying excited states of a molecule, as well as the oscillator strengths associated with these transitions". The oscillator strengths are the part no other route in this slot claims, and they are what turns a list of energies into a spectrum that can be compared with an experiment. Evidence is a simulation at a size worth stating: they "numerically simulate MC-VQE by computing the absorption spectrum of an ab initio exciton model of an 18-chromophore light-harvesting complex from purple photosynthetic bacteria". The abstract quantifies no circuit count, measurement count or scaling, and "efficient" is its word for the approach rather than a bound anyone proved here.

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

given  N chromophore monomers, each carrying two photoactive states |0_A>
       (ground) and |1_A> (excited) -- a restriction adopted "to facilitate
       ease of mapping to qubits", not a general limit of the method
       an ab initio exciton Hamiltonian H = E*I + H1 + H2 on N qubits,
       written in 1- and 2-body Pauli operators                       (Eq. 8)
       N_Theta = N+1 target states: the CIS manifold -- 1 ground
       configuration plus N singly-excited configurations, all allowed
       to mix                                            (Supp., CIS State Preparation)

requires  an efficient circuit to prepare each CIS reference state |Phi_Theta>
    and each interference state (|Phi_Theta> +/- |Phi_Theta'>)/sqrt(2) -- a
    condition specific to this construction, met here by a "matryoshka" ladder
    of one Ry pump gate on |0_A> and N-1 controlled Fy gates on the rest,
    with angles read recursively off the classical CIS coefficients
    mu, alpha, beta, ...                                    (Supp. Eqs. 42-55)

# --- stage 1: classical reference states ------------------------------------
solve CIS (or another polynomial-scaling classical method) for H
    -> N_Theta contracted, orthonormal reference states {|Phi_Theta>}
    # this only "sketches out" the shape of each state; nothing here is
    #   variational, and nothing here is proved accurate

# --- stage 2: state-averaged optimisation of the entangler ------------------
U(eta) = one SO(4) two-body entangler block per two-body interaction site
    of the exciton Hamiltonian, eta its 6 real angles              (Eq. 67, Supp.)
    # TWO separate restrictions here, and only the first is proved lossless:
    #   (a) restricting U to SO(2^N) is "without loss" -- the real exciton
    #       Hamiltonian's adiabatic eigenfunctions can be written as real,
    #       orthonormal vectors with only an overall +/-1 phase free
    #                                        (Supp., VQE Global Entangler Matrix)
    #   (b) building that SO(2^N) entangler out of ONE layer of local, per-site
    #       SO(4) blocks is a design choice, NOT covered by (a): the paper's
    #       own words are "we have elected to construct", with no completeness
    #       claim, and it offers further layers or entanglers extended "to the
    #       next layer(s) of nearest neighbors" when "additional variational
    #       flexibility in the ansatz is desired"          (Supp., after Eq. 60)

loop, varying eta, until the state-averaged energy stops decreasing:
    # the paper states no general stopping rule for this loop -- only what
    #   happened in its one demonstration; the phrasing here is a gloss
    for each Theta in [0, N_Theta):
        prepare |Phi_Theta>, apply U(eta)
        measure the diagonal element only
            H_ThetaTheta = <Phi_Theta| U(eta)^dagger H U(eta) |Phi_Theta>   (Eq. 4)
    Ebar(eta) = (1/N_Theta) * sum_Theta H_ThetaTheta                       (Eq. 6)
        # equals the trace of the contracted Hamiltonian in the {Phi_Theta}
        #   basis "from the definition of the trace" -- so minimising Ebar IS
        #   minimising the sum of these diagonal elements, nothing more
    step eta to reduce Ebar
        # demonstration: L-BFGS from an all-zero initial guess, second-order
        #   symmetric finite-difference gradients (delta_theta = 0.01),
        #   converged in 14 iterations on the N=18 system -- offered as an
        #   empirical route around barren plateaus (the minimum found lay
        #   "directly downhill" from the guess), not a proven one; a
        #   different logical SO(4) parametrisation of the same block took
        #   about twice as many L-BFGS iterations to the same solution
U_fixed <- U(eta) at the stopping point
    # one scalar objective covers every state, so all N_Theta states are
    #   "computed to approximately equal accuracy" -- no penalty term or
    #   projection singles out the ground state, unlike orthogonality-
    #   constrained VQE

# --- stage 3: off-diagonal elements, entangler now fixed --------------------
for each pair Theta, Theta' with Theta != Theta':
    prepare (|Phi_Theta> + |Phi_Theta'>)/sqrt(2), apply U_fixed, measure H
    prepare (|Phi_Theta> - |Phi_Theta'>)/sqrt(2), apply U_fixed, measure H
    H_ThetaTheta' = [ (sum-state expectation) - (difference-state expectation) ] / 2
                                                                           (Eq. 5)
    # two further circuits per off-diagonal element, this pair costed
    #   separately AFTER eta has converged -- not folded into stage 2
    # only 1- and 2-body Pauli expectation values are ever measured here;
    #   no 3- or 4-particle density matrix is required anywhere in MC-VQE

# --- stage 4: classical diagonalisation of the N_Theta x N_Theta problem ----
diagonalize H_ThetaTheta':
    H_Theta''Theta' V_Theta'Theta = V_Theta''Theta E_Theta,
    V_Theta'Theta V_Theta'Theta'' = delta(Theta, Theta'')                  (Eq. 2)
    # E_Theta are RITZ approximations to the exact eigenvalues, not the
    #   eigenvalues themselves
|Gamma_Theta> = sum_Theta'  |Phi_Theta'> V_Theta'Theta        # rotated references
|Psi_Theta>   = U_fixed |Gamma_Theta>                           # approximate eigenstates

# --- transition properties: stage 3's formula, mu_hat standing in for H ----
mu_hat = sum_A  mu_I^A * I_A + mu_Z^A * Z_A + mu_X^A * X_A
    # one-body Paulis only; obtained by substituting the desired operator
    #   for H in the stage-3 formula                                (Eq. 5, 77)
for each pair Theta, Theta':
    O_ThetaTheta' = (2/3) * (E_Theta' - E_Theta) * <Psi_Theta| mu_hat |Psi_Theta'>^2
        # sum over the Cartesian components of the vector-valued mu_hat  (Eq. 76)

return  {E_Theta} and {O_ThetaTheta'} over the CIS manifold
    -> an excitation-energy and oscillator-strength spectrum, e.g. an
       absorption spectrum built by broadening each transition
# demonstrated noiseless, at infinite shots: 1- and 2-body expectation values
#   were contractions of simulator wavefunction amplitudes, "equivalent to
#   infinite averaging of discrete Pauli measurements", with no noise or
#   error channel modelled and so no shot count charged; N=18, a SINGLE
#   entangler layer, 108 parameters, matched FCI to tens of microeV in
#   energy and well under 1% in oscillator strength -- one system, not proved
# depth linear and gate count quadratic in N is claimed only for exciton
#   models "with local Hamiltonian connectivity", in the Outlook, and without
#   derivation -- do not read it as proved or as general to other Hamiltonians

Parrish, Hohenstein, McMahon and Martínez count MC-VQE in contracted Hamiltonian elements: optimising the state-averaged entangler "requires only the measurement of $N_\Theta$ diagonal matrix elements $H_{\Theta\Theta}$", and the off-diagonal elements — written $N_\Theta^2$, though only $N_\Theta(N_\Theta-1)/2$ are distinct — are determined afterwards, two interference-state circuits each (Eq. 5), from 1- and 2-body Paulis alone: $2N$ one-body terms plus four per monomer pair (Eq. 8), truncated to $N$ nearest-neighbour pairs in the demonstration, where $N_\Theta = N+1$ on $N$ qubits. Nothing bounds the outer loop: the demonstration reports 108 parameters — six per $\mathrm{SO}(4)$ entangler, one entangler per interaction site, a single layer — converging in "14 L-BFGS iterations" of second-order symmetric finite differences, to within tens of $\mu$eV and $\ll 1\%$ oscillator strength of FCI on the $N=18$ LH2 B850 ring; one noiseless, infinite-shot simulation, not proved, and a different parametrisation "takes approximately twice as many iterations". The Outlook claims depth linear and gate count quadratic in $N$ for exciton models "with local Hamiltonian connectivity", without derivation.

• The Quasar simulation of the $N = 18$ LH2 B850 absorption spectrum

  • Quantum Computation of Electronic Transitions using a Variational Quantum Eigensolver

  The paper that introduces MC-VQE also carries its first artefact. The problem it was built against is stated as the absorption spectrum of a large photoactive complex at a fixed geometry: the authors "emphasize the accurate ab initio computation of the electronic absorption spectrum at a given nuclear configuration, as a prerequisite for direct non-adiabatic dynamics simulations". The demonstration system is an ab initio exciton model of the $N = 18$ cyclical LH2 B850 ring complex of purple photosynthetic bacteria, a Hilbert space of dimension $2^{18} = 262144$; a second, smaller case, an $N = 8$ linear stack of BChl-a chromophores, was added "at the request of a reviewer" because CIS is qualitatively wrong there.

  The authors state the artefact plainly: "MC-VQE circuits were implemented in our in-house quantum simulator package, Quasar. All aspects of state preparation, VQE entanglement, and casting of transition matrix elements as difference observables were performed in the simulator, though 1- and 2-body Pauli expectation values were evaluated through contractions of wavefunction amplitudes (equivalent to infinite averaging of discrete Pauli measurements), and noise/error channels were not modeled." CIS is solved classically over the reference and all singly-excited configurations. The $N = 18$ run used L-BFGS with finite-difference gradients from a zero-entanglement guess; the $N = 8$ run used "a slightly updated version of our Quasar code", a two-layer linear entangler circuit, and "the gradient-free Powell method" to a maximum state-averaged energy gradient of $1\times10^{-7}$. Two entangler layers rather than one, and a different optimiser, so the two runs are not the same configuration.

  The exciton-model parameters come from a classical program, not from the quantum part: "Monomer Hamiltonian matrix elements were computed in the GPU-accelerated TeraChem program for classical electronic structure theory, using TDA-TD-DFT at $\omega$PBE($\omega = 0.3$)/6-31G*." Dimer elements were approximated by the dipole/transition-dipole model and truncated after cyclical nearest-neighbour contacts. The supplemental data packet is split by system and the two halves must not be read as one deposit: for the $N = 18$ ring it carries the XYZ geometry, the classical TeraChem monomer outputs, per-monomer $S_0$ and $S_1$ total energies in a table published "to aid in replication of the results", "full numerical details of the ab initio exciton Hamiltonian", and "the L-BFGS iterative history, optimized MC-VQE parameter values, and other characteristics of the converged MC-VQE solution" in "the Quasar output file and .NPZ data file"; the separately listed ".NPZ file containing ab initio exciton model matrix elements" and ".NPZ file containing the output state energies and oscillator strengths" belong to the $N = 8$ case study, not to the ring.

  Quasar is named but was in-house at the time, and the run is pinned to a commit rather than a release: "All computational results for the B850 ring were run with Quasar GIT SHA 4ce64a05a0f5f63988cb68209d24e085d2de275f". Two public repositories now carry the name and neither is that code. `qcware/quasar`, Apache-2.0, with a committed `dist/qcware_quasar-1.0.0a2`, holds circuit, backend, Pauli, observable, measurement, Davidson, transpiler and optimizer modules, and across its whole listing no ab initio exciton model and no MC-VQE driver. `robparrish/quasar`, the first author's own, opened 2019-01-27 and licensed by its LICENSE file under the GNU LGPL v2.1, is a two-file statevector simulator whose README gives as its motivation "I went to run an 18-qubit MC-VQE job with a simple cyclical Ising model" and burned up a laptop doing it — the MC-VQE job is the reason for the simulator, not something the repository contains. The GitHub API answers that commit id with "No commit found for SHA" in both, and `qcware/forge_public_notebooks` carries no chemistry directory at all. So the artefact behind the published numbers is not, as far as could be checked, publicly readable.

  Both the energies and the oscillator strengths were reported, which is what makes this a spectrum rather than a list. On the $N = 18$ ring with a single entangler layer and 108 parameters, converged in 14 L-BFGS iterations, "MC-VQE with a single entangler layer is visually indistinguishable from FCI - the maximum deviations of excitation energies are on the order of tens of $\mu$eV, while the oscillator strengths generally deviate by $\ll 1\%$", against a CIS reference whose "oscillator strengths may deviate by 10% or more, particularly for the brightest states". The plotted absorption envelope is not an observable of the method: it is drawn "by broadening the contribution from each transition with a Lorentzian with width of $\delta = 0.05$ eV". No shot count, no noise model and no hardware; the simulator was the only backend.

• Orbital-optimized spin-adapted MC-VQE in SlowQuant, on ibm_marrakesh and ibm_aachen

  • Orbital-optimized spin-adapted multistate contracted VQE for excited states and properties on quantum hardware

  Kjellgren and co-authors extend MC-VQE in two directions at once — orbital optimisation and spin-adapted operators — and then run it on hardware, which the 2019 paper did not. Their stated problem is the price of the state average: "In multistate variational approaches, achieving a balanced description of an increasing number of electronic states places growing demands on the expressibility of the underlying ansatz, thereby introducing a fundamental trade-off between accuracy and circuit complexity." This is an extension named oo-MC-VQE, not a reproduction of the LH2 demonstration.

  Across every arm of the paper — statevector, Qiskit Aer, and device — "the wave function optimizations were performed using BFGS through the SciPy library"; the paper attaches no optimiser to the hardware runs specifically. The formaldehyde and $\mathrm{H}_3^+$ series, "both targeting real quantum hardware", used an oo-tUPS ansatz "with 1 layer, with the last layer of singles removed", on a (2e, 3o) active space. Reference states were selected classically: "All states included in the state-averaged wavefunction were picked on the basis of the diagonal elements of the singlet CSF basis CISD Hamiltonian. The chosen states were those that resulted in the lowest diagonal elements." Measurement budget is stated, unlike the 2019 simulation: "For both formaldehyde and $\mathrm{H}_3^+$, calculations used 50000 shots per measured Pauli-string, and the number of Pauli-strings was reduced using qubit-wise commutativity and using Pauli-saving." Error mitigation is the ansatz-based readout and gate mitigation $M_{\mathrm{ansatz}0}$ of Ziems et al., with post-selection on the correct number of $\alpha$ and $\beta$ electrons; the hardware runs "resorted to using the regular M0 error-mitigation instead of the M0+ error-mitigation, since the latter would be prohibitively expensive".

  Two molecules, both with the geometry written out: formaldehyde in cc-pVDZ ($R_{\mathrm{CO}} = 1.202$ Å, $R_{\mathrm{CH}} = 1.298$ Å, $\theta_{\mathrm{HCH}} = 116.44^\circ$) with four states in the state average on ibm_marrakesh, and $\mathrm{H}_3^+$ in aug-cc-pVTZ ($R_{\mathrm{HH}} = 0.900$ Å) with three states on ibm_aachen. Initial Hartree-Fock calculations came from PySCF. A separate statevector arm covered LiH, $\mathrm{H}_2\mathrm{O}$ and $\mathrm{NH}_3$ in STO-3G with ADAPT and oo-ADAPT, against state-averaged FCI references also computed in SlowQuant. Nothing is deposited: "The data that support the findings of this study are available from the corresponding author upon reasonable request."

  "All calculations were run using the SlowQuant package", cited to https://github.com/erikkjellgren/SlowQuant/tree/master — a branch, with no tag or commit, and the repository carries no releases and no tags, so the paper's runs are not pinned to a readable version. SlowQuant is BSD-3-Clause. The MC-VQE step is identifiable in the source: in `slowquant/qiskit_interface/sa_circuit_wavefunction.py`, class `WaveFunctionSACircuit`, the method `_do_state_ci` is documented as "Do subspace diagonalisation" citing "10.1103/PhysRevLett.122.230401, Eq. 2", which is the MC-VQE paper's own equation, and `get_oscillator_strenghts` implements $f_n = \frac{2}{3}\varepsilon_n|\langle 0|\hat{\boldsymbol{\mu}}|n\rangle|^2$ over the diagonalised states. A statevector twin, `WaveFunctionSAUPS`, lives in `slowquant/unitary_coupled_cluster/sa_ups_wavefunction.py` with the same citation. The off-diagonal elements come from `QuantumInterface.quantum_expectation_value_csfs` in `slowquant/qiskit_interface/interface.py`, whose docstring writes the identity in the sum-state-minus-half-each-diagonal form and cites "10.1103/PhysRevResearch.1.033062, Eq. (1)", the SSVQE paper — which is not a departure from MC-VQE, because the paper credits that superposition decomposition to "Parrish et al" and "Nakanishi et al" together and applies it determinant by determinant rather than state by state because doing so "reduces the number of needed CNOT gates" at the price of "more expectation value measurements". What differs from MC-VQE Eq. 5 is which circuits are run and which paper the docstring names, not the quantity computed.

  Absorption spectra for both molecules were computed on the two named devices, and the authors report the hardware as clearly worse than its own noise model: "It is clear that the error mitigated results from the real devices (blue dashed lines) are significantly worse than the error mitigated results using simulated noise", with $\mathrm{H}_3^+$ more affected than formaldehyde, though "the calculations on quantum hardware show the same trends as on the simulated devices". Their own conclusion is qualitative, not quantitative: "Molecular spectra are calculated with MC-VQE using real quantum hardware. It is found that molecular spectra can be calculated for some systems, but error-mitigation techniques are necessary to reduce the noise." From the statevector arm they report that "doubling the number of states roughly doubles the length of the required circuit", and that orbital optimisation alongside ADAPT "has a negligible effect on the number of required circuit parameters" — both measured on the small STO-3G systems, not proved.

• The MCVQE eigensolver in the electronic-structure-orbital-optimization package

  • Qubit Count Reduction by Orthogonally-Constrained Orbital Optimization for Variational Quantum Excited States Solvers

  MC-VQE here is not the subject but a component: Bierman, Li and Lu needed excited-state eigensolvers to sit inside an orbital-optimisation outer loop, and wrote one because Qiskit ships none. Their computational section says so directly: "The code used for our numerical simulations is an extension of the functionality provided by the open source package Qiskit. Qiskit provides an implementation of VQE, which we have modified to produce implementations of SSVQE and MCVQE." Their reference 36 for MCVQE is Parrish, Hohenstein, McMahon and Martínez, Phys. Rev. Lett. 122, 230401 — this method.

  `MCVQE` in `electronic_structure_algorithms/excited_states_eigensolvers/mcvqe.py` subclasses the package's own `SSVQE`. `initialize_mcvqe` builds the reference states classically through `get_CIS_states` or `get_CISD_states` depending on an `excitations` flag of `'s'` or `'sd'`, then precomputes the interference circuits as `(initial_states[i] + initial_states[j])/np.sqrt(2)` and `(initial_states[i] - initial_states[j])/np.sqrt(2)`, renormalised. After the optimiser stops, each off-diagonal element is `contracted_Hamiltonian[i,j] = 0.5*(matrix_element_result[0] - matrix_element_result[1])`, the plus-minus difference of MC-VQE Eq. 5, the diagonal elements are estimated separately, and the result is `np.linalg.eigh` of the contracted Hamiltonian. Two things the class does not do. It computes no transition dipole and no oscillator strength — grep finds neither word in the file — so it returns the energy half of MC-VQE and not the spectrum. And the equal weights that its own docstring calls "the primary difference" from SSVQE are not enforced: `MCVQE` defines no `_check_weight_vector`, so with `weight_vector=None` it inherits SSVQE's default `weight_vector = [self.k - n for n in range(self.k)]`, a descending vector, and the shipped example `examples/H2_OptOrbMCVQE.py` calls exactly that default at `mcvqe_instance.weight_vector = mcvqe_instance._check_weight_vector()`. The orbital-optimisation wrapper does not restore them either: `OptOrbMCVQE` sets no weights, and `opt_orb_eigensolver.py` takes the eigensolver's own vector when it has one, so the descending default reaches the outer objective as well.

  The shipped example is a small molecule driven entirely through Qiskit Nature: `examples/H2_OptOrbMCVQE.py` builds $\mathrm{H}_2$ at 0.735 Å in the 6-31G basis via `PySCFDriver`, maps with `JordanWignerMapper`, uses a `UCCSD` ansatz with `reps=2` compressed to four qubits, and optimises with `L_BFGS_B`. The paper's own integrals come the same way: "The 1 and 2-body integrals are obtained through the PySCF electronic structure driver in Qiskit".

  JoelHBierman/electronic-structure-orbital-optimization, Apache-2.0, named `orbital-optimization` version 0.2.0 by its own `setup.py` — but that is a name in a build file, not a channel: there is no distribution on PyPI, and the repository carries no release and no tag; last pushed 2024-10-09. Files: `electronic_structure_algorithms/excited_states_eigensolvers/mcvqe.py`, the outer-loop wrapper `electronic_structure_algorithms/orbital_optimization/opt_orb_mcvqe.py` exporting `OptOrbMCVQE`, the classical reference builder `electronic_structure_algorithms/initializations/configuration_interaction_states.py`, and tests `tests/test_mcvqe.py` (`class TestMCVQE`) and `tests/test_optorbmcvqe.py`. The paper pins the surrounding stack: "The Qiskit package versions used are Qiskit-Aer 0.12.0, Qiskit-Nature 0.4.5, and Qiskit-Terra 0.23.2." One provenance wrinkle: the source file's own docstring misnames and mis-cites the method, calling it "The multi-configuration Variational Quantum Eigensolver algorithm" and linking https://arxiv.org/abs/1810.09434, which is the SSVQE paper, not Parrish et al.; the paper that documents the code cites Parrish et al. correctly.

  Everything is simulated: "all orbital-optimized tests are run using Qiskit's AerSimulator in noiseless statevector mode unless stated otherwise", with L-BFGS-B as the classical optimiser and FCI reference values from CDFCI. What MCVQE buys over the SSVQE it subclasses is stated as a tendency, not a bound: "MCVQE often offers an improvement in accuracy over SSVQE for lower ansatz expressiveness. When higher expressiveness is used, the difference is often less significant." The one arm with sampling noise, Sec. 4.5's $\mathrm{H}_4$ binding curve at $10^6$ shots per observable evaluation under Qiskit's Gaussian approximation, reports a failure rather than a success: that surface "is difficult for state-averaged solvers such as MCVQE to accurately describe in the STO-3G basis, even when starting from CISD states", and at stretched geometries "MCVQE often converges to local minima". No hardware anywhere in the paper.

• The MC-VQE section of Tangelo's excited-states notebook

  Tangelo's own examples repository walks one small molecule through every excited-state route its table of contents lists, and arrives at MC-VQE, section 2.5, because state-averaged VQE alone does not separate the states: "The energies above are inaccurate, as the calculated states are restricted to linear combinations of the three lowest singlet states. We can use MC-VQE to generate the exact eigenvectors, as shown in the next section." The section is headed "Multistate, contracted VQE (MC-VQE)" and cites arXiv:1901.01234 by number, the Parrish, Hohenstein, McMahon and Martinez paper this method is recorded from. This is teaching code committed with its outputs rather than a research result, and the same notebook carries sections on VQE deflation, quantum subspace expansion and state-averaged VQE that belong to sibling methods rather than to this one.

  The state-averaged step is Tangelo's shipped `SA_VQESolver`: three orthogonal reference states given as the occupation lists `1,1,0,0`, `1,0,0,1` and `0,0,1,1` at equal `"weights": [1, 1, 1]`, an $\hat{S}^2$ penalty written `"penalty_terms": {"S^2": [2, 0]}` to hold the average on singlets, and the UpCCGSD ansatz under Jordan-Wigner. The contraction is then written out in the notebook rather than called from the library: a comment reads "Generate Equation (2) using equation (4) and (5) of arXiv:1901.01234", and the loop forms `sv_plus = (sv1 + sv2)/np.sqrt(2)` and `sv_minus = (sv1 - sv2)/np.sqrt(2)`, sets `h_theta_theta[i, j] = (exp_plus-exp_minus)/2` off the diagonal and `vqe_solver.state_energies[i]` on it, then diagonalises with `np.linalg.eigh`. A second route builds the same two interference states as circuits through `StateVector`, carrying the notebook's own warning that "the circuits created by StateVector are generally inefficient and one should try to create the circuits that generate these states by hand if running on a real quantum device". No transition dipole and no oscillator strength appear anywhere in the notebook, so this is the energy half of MC-VQE and not the spectrum.

  $\mathrm{Li}_2$, written in the input string as "Li 0. 0. 0." and "Li 3.0 0. 0." and described as "near its equilibrium geometry", in the 6-31g(d,p) basis, frozen to an active space the notebook describes as "2 electrons in 2 orbitals which involve 4 qubits when mapped to a qubit Hamiltonian using the Jordan-Wigner mapping". It is built through Tangelo's `SecondQuantizedMolecule` on a PySCF RHF reference with `symmetry=True`, and the classical references against which the run is judged are computed in the same notebook with PySCF `mcscf.CASCI`, one irreducible representation at a time.

  `sandbox-quantum/Tangelo-Examples`, Apache-2.0, file `examples/chemistry/excited_states.ipynb`, section 2.5. It stands on `SA_VQESolver` from `tangelo/algorithms/variational/sa_vqe_solver.py` in `sandbox-quantum/Tangelo`, whose LICENSE file is the Apache License 2.0. The qualifier is the point of the entry: Tangelo ships no MC-VQE solver class. `tangelo/algorithms/variational/` holds `vqe_solver.py`, `adapt_vqe_solver.py`, `tetris_adapt_vqe_solver.py`, `iqcc_solver.py`, `iqcc_ilc_solver.py`, `sa_vqe_solver.py` and `sa_oo_vqe_solver.py` and nothing else, and a case-insensitive search of `sa_vqe_solver.py` for MC-VQE, MCVQE, contracted, Parrish or the arXiv id returns nothing. Neither repository is pinned to a version by the notebook; its install cell fetches Tangelo from the `develop` branch.

  The notebook is committed with its cell outputs, so its numbers are readable without running it: MC-VQE returns $-14.869616815256682$, $-14.784034669938677$ and $-14.68019492913796$ for the three singlets, against CASCI references printed in the same notebook of $-14.8696203037798$ and $-14.6801959955889$ in $A_{1g}$ and $-14.7840383314395$ in $A_{1u}$. The notebook's own verdict is qualitative — "We can see that these singlet energies are all close to the exact answer" — and its two routes to the same contraction agree with each other to the fourteenth decimal place. This is a noiseless four-qubit statevector simulation with no shot count and no device named anywhere in the section.

1. Choose a parameterised trial state 13 methods

   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.

2. Minimise the objective over the parameters 6 methods

   Search the parameters of a fixed circuit family for the ones that minimise a chosen objective, given that every evaluation of that objective is a noisy estimate someone paid shots for. The output is a routine that prepares one particular state — the family collapsed to a member.

3. Estimate an observable 4 methods

   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.

Different approaches

• Variational quantum deflation

  Find the ground state first, then run the same variational search again with a term that punishes overlap with every state already found. Each state is reached by pushing the search off the ones below it, so they have to be found in order and each one costs another pass through the whole loop.

• Subspace-search variational eigensolver

  Send several mutually orthogonal input states through one parameterised circuit and minimise their energies together. A unitary keeps orthogonal inputs orthogonal, so the whole low-energy subspace comes out of a single optimisation — no earlier state to deflate, and no ancilla to test overlaps with.

• Quantum subspace expansion

  Stop optimising and start measuring: take the state the ground-state run already produced, measure matrix elements in a small space of operators applied to it, and let a classical solver diagonalise the little matrix that results. The extra accuracy is bought with classical work and more measurements, not with more coherence.

• Quantum equation of motion

  Ask for the gaps directly rather than for two energies to subtract. Measure the matrix elements the classical equation-of-motion formalism needs between excitation operators on the ground state, and solve its generalised eigenvalue problem classically; what comes back is an excitation energy, which is the quantity a spectrum is made of.

• Folded-spectrum variational eigensolver

  Point the same search somewhere other than the bottom. Minimising the variance around a chosen energy makes every eigenstate a minimum and the one nearest that energy the reachable one — so a state can be found without knowing its index, and the bill arrives as a squared Hamiltonian with far more terms to measure.

• Penalty-constrained variational eigensolver

  Add a term to the objective that punishes the trial state for leaving the symmetry sector you asked for, and the ordinary ground-state search returns that sector's lowest state — an excited state of the whole Hamiltonian whenever the sector is not the one the ground state lives in. Which penalty is used matters: one common form is proved not to work.

• Multistate contracted VQE

  A contracted reference subspace is jointly entangled before a small effective Hamiltonian is diagonalized.

• Quantum Computation of Electronic Transitions using a Variational Quantum Eigensolver↗Robert M. Parrish, Edward G. Hohenstein, Peter L. McMahon, Todd J. Martinez · 2019theory yes · simulation yes · hardware no