Subspace-search variational eigensolver

What it fills

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

When it applies

Nakanishi et al. state the construction and what it buys: the algorithm "searches a low energy subspace by supplying orthogonal input states to the variational ansatz and relies on the unitarity of transformations to ensure the orthogonality of output states", and "the k-th excited state is obtained as the highest energy state in the low energy subspace". The saving they claim is against the other near-term proposals rather than against classical methods: it "consists only of two parameter optimization procedures and does not employ any ancilla qubits. The disuse of the ancilla qubits is a great improvement from the existing proposals for excited states, which have utilized the swap test". A generalisation obtains "all excited states up to the k-th by only a single optimization procedure". Evidence is numerical — "from numerical simulations, we verify the proposed algorithms" — with no hardware run reported.

Requires

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

Example

given  Hamiltonian H on n qubits; eigenstates {|E_j>}_{j=0}^{2^n - 1} with
       E_i >= E_j when i >= j, the ground state counted as the 0-th
       excited state                                              (Sec. II A)
       target index k for the excited state wanted

requires  an ansatz U(theta) and a second circuit V(phi) able to represent
    the exact unitary mapping the chosen input states to the corresponding
    eigenstates of H -- the spectrum found is exact only then; the paper's
    own advantage list states the condition with "k" input states and "k"
    eigenstates, where the algorithm below supplies k+1 of each
                                                          (Sec. III, adv. 1)

# --- step 0: fix the search sense BEFORE either optimization ------------
if k < 2^(n-1):
    m       <- k+1                 # number of orthogonal inputs supplied
    sense1  <- minimize            # applied to L1 in step 2
    sense2  <- maximize            # applied to L2 in step 4
else:
    m       <- 2^n - k             # the paper's own count, written as printed
    sense1  <- maximize
    sense2  <- minimize
    # the paper's faster branch for the upper half of the spectrum: choose
    #   2^n - k orthogonal inputs, maximize L1 in step 2 instead of
    #   minimizing, then minimize L2 in the final step instead of
    #   maximizing. A speed choice, not a correctness one         (Sec. II A)
    # the count is printed as 2^n - k against k+1 in the k < 2^(n-1) case;
    #   the same off-by-one looseness as the requires-clause above

# --- step 1: orthogonal inputs, one ansatz ------------------------------
choose m input states {|phi_j>}  mutually orthogonal (<phi_i|phi_j> = delta_ij)
                                                        (Sec. II A, step 1)
    # in practice chosen from a set of easily preparable states, such as
    #   the computational basis -- not built specially per problem (Sec. II A)
construct ansatz circuit U(theta)
    # unitarity carries the orthogonality through to the outputs
    #   automatically -- nothing measures it, which is why the swap test
    #   used by earlier proposals is removed              (Abstract; Sec. II)

# --- step 2: pin the whole subspace, not one state ----------------------
L1(theta) = sum_j  <phi_j| U^dagger(theta) H U(theta) |phi_j>
                                                        (Sec. II A, step 2)
theta* <- arg sense1 over theta of L1(theta)
    # scores every supplied input at once; U(theta*) is the unitary that
    #   best approximates the map from span{phi_j} onto span{E_j}_{j=0}^{k}.
    #   Step 2 therefore finds a SUBSPACE containing |E_k> as its
    #   highest-energy state, not |E_k> itself                    (Sec. II A)

# --- step 3: a second circuit confined to that subspace -----------------
construct V(phi) acting only on span{|phi_j>}_{j=0}^{k}  (Sec. II A, step 3)
    # the weighted variants below have no step 3 -- phi is folded into
    #   theta instead                                        (Fig. 1 caption)

# --- step 4: pick the target state out of the pinned subspace -----------
choose arbitrary s in {0, ..., k}
L2(phi) = <phi_s| V^dagger(phi) U^dagger(theta*) H U(theta*) V(phi) |phi_s>
                                                        (Sec. II A, step 4)
phi* <- arg sense2 over phi of L2(phi)

return  preparation routine  U(theta*) V(phi*) |phi_s>  ~=  |E_k>
# exact only under the requires-clause above; the paper's own advantage
#   list makes this an "if", not a guarantee               (Sec. III, adv. 1)
# two optimizations for the SSVQE, one for either weighted variant
#                                                          (Sec. III, adv. 5)
# evidence for the construction working is numerical simulation only, on a
#   4-qubit fully connected transverse-Ising Hamiltonian and HeH+, BFGS via
#   SciPy, best of 10 random restarts drawn from [0, 2pi) -- no hardware
#   run, and no shot count appears anywhere in the paper             (Sec. V)

# --- variant: weighted SSVQE, single target k, ONE optimization ---------
# replaces steps 2-4 with:
#   minimize  Lw(theta) = w * h_k(theta) + sum_{j=0}^{k-1} h_j(theta)
#     where h_j(theta) = <phi_j| U^dagger(theta) H U(theta) |phi_j>
#     weight w is any single value in (0, 1)                     (Sec. II B)
#   at the global optimum, U(theta) maps |phi_k> to |E_k> and every other
#     |phi_j> into span{E_j}_{j=0}^{k-1} -- one optimization instead of
#     two, but the paper notes the more complicated cost landscape may
#     raise the overall optimization time                        (Sec. II B)

# --- variant: weighted SSVQE, ALL states up to k, ONE optimization ------
# replaces steps 2-4 with:
#   minimize  Lw(theta) = sum_{j=0}^{k} w_j * h_j(theta)
#     weight vector w chosen with  w_i > w_j  whenever  i < j    (Sec. II C)
#   # the paper states only this ordering condition on w; it does not also
#   #   state w_j > 0 for every j, though its own numerical choice
#   #   w = (4, 3, 2, 1) happens to satisfy it
#   at the global optimum, U(theta) maps |phi_j> to |E_j> for every
#     j in {0, ..., k}; the same optimization-time caveat applies (Sec. II C)

# --- optional extension: transition amplitudes off the SAME U(theta*) ---
# write M = U^dagger(theta*) A U(theta*); then <E_i|A|E_j> = <phi_i|M|phi_j>
#                                                                 (Sec. IV)
#   # A is ASSUMED Hermitian here. Sec. IV says only "an operator A", but
#   #   both expansions below need M = M^dagger to hold
#   |+x_ij> = (|phi_i> + |phi_j>) / sqrt(2)
#   |+y_ij> = (|phi_i> + i|phi_j>) / sqrt(2)                      (Sec. IV)
#   Re(<phi_i|M|phi_j>) = <+x_ij|M|+x_ij> - (1/2)<phi_i|M|phi_i>
#                                          - (1/2)<phi_j|M|phi_j>    (Eq. 1)
#   Im(<phi_i|M|phi_j>) = (1/2)<phi_i|M|phi_i> + (1/2)<phi_j|M|phi_j>
#                                          - <+y_ij|M|+y_ij>
#   # IMPLEMENT THE Im LINE AS WRITTEN ABOVE. The paper's Eq. 2 prints the
#   #   same three terms with the opposite overall sign (the mirror of
#   #   Eq. 1). Expanding the paper's own |+y_ij> with M Hermitian gives
#   #   <+y_ij|M|+y_ij> = (1/2)<phi_i|M|phi_i> + (1/2)<phi_j|M|phi_j>
#   #     - Im(<phi_i|M|phi_j>), so the printed Eq. 2 sign is inverted.
#   #   The identical expansion reproduces Eq. 1 exactly, so the technique
#   #   is sound and only Eq. 2 disagrees. Eq. 2 as printed is recovered
#   #   by defining |+y_ij> = (|phi_i> - i|phi_j>)/sqrt(2) instead
#   each of the three terms is measured separately on the NISQ device, and
#     the terms are then summed on a classical computer            (Sec. IV)

Cost, as the source states it

Nakanishi, Mitarai and Fujii: the SSVQE cost $L_1(\theta) = \sum_{j=0}^{k} \langle \phi_j | U^\dagger(\theta) H U(\theta) | \phi_j \rangle$ sums $k+1$ energy expectation values, one per mutually orthogonal input state, against one for plain VQE; the second optimisation's $L_2$ has one term, $V(\varphi)$ acting only on the $(k+1)$-dimensional subspace. For $k \geq 2^{n-1}$ they supply $2^n - k$ inputs and reverse both optimisations, capping the count near $2^{n-1}$. No ancilla, $n$ qubits, where Higgott, Wang and Brierley's swap test doubles the register. "Optimization runs only twice for the SSVQE and only once for the weighted SSVQE", which keeps the same $k+1$ terms per evaluation - but the conclusion says \"in principle\", and the spectrum is exact only if the ansatz can represent the exact map from the $k+1$ inputs to eigenstates and the cost reaches its global optimum. Nothing bounds the iterations: on one random 4-qubit transverse-Ising instance at $k=3$ (BFGS, best of 10 restarts) the weighted $k$-th-state run needed more than the two-step SSVQE, the all-states variant about as many as that weighted run. No shot count, no hardware run.

Implementations

• Proof-of-principle simulations on a four-qubit Ising model and HeH

  • Subspace-search variational quantum eigensolver for excited states

  The paper that introduces SSVQE ends with what it calls "the simple, proof-of-principle numerical simulations" (Sec. I, describing Sec. V). The question they put is narrow: does feeding mutually orthogonal inputs to one ansatz actually land the $k$-th excited state, and does the generalised weighted form return the whole low-lying spectrum from a single optimisation? The scope is set in the introduction - "We perform numerical simulations and show validity of proposed algorithms for fully connected random transverse Ising models and Helium hydride." The acknowledgement reads "This work was supported by QunaSys Inc."

  All three algorithms were run at $k = 3$ on the one ansatz of Fig. 1: the two-step SSVQE, the weighted SSVQE for the $k$-th state at weight $w = 0.5$, and the weighted SSVQE for every state up to the $k$-th at weight vector $w = (4, 3, 2, 1)$. The inputs were computational basis states - "We chose the input states as $\{|\phi_j\rangle\} = \{|0000\rangle, |0001\rangle, |0010\rangle, |0011\rangle\}$" - with the ansatz depths $D_1 = 2$ throughout, $D_2 = 6$ for the SSVQE and for the weighted $k$-th-state variant, and $D_2 = 8$ for the all-states variant. Parameters were "randomly sampled from a uniform distribution $[0, 2\pi)$" and optimised with "the BFGS method [20] implemented in the SciPy library [21]"; every simulation was run ten times from different initial values and the reported run is the one "which achieved the lowest value of the cost function among those 10 results". Each figure plots a fidelity beside the energy: for step 1 "the overlap between the space spanned by $\{|E_j\rangle\}_{j=0}^{3}$ and the output of the quantum circuit $\{U(\theta)|\phi_j\rangle\}_{j=0}^{3}$", for step 2 $|\langle E_3 | U(\theta^*) V(\varphi) | \phi_3 \rangle|^2$.

  Two four-qubit Hamiltonians. The first is the fully connected transverse Ising model $H = \sum_{i=1}^{N} a_i X_i + \sum_{i=1}^{N} \sum_{j=1}^{i-1} J_{ij} Z_i Z_j$ at $N = 4$, whose coefficients are "sampled randomly from a uniform distribution on $[0, 1)$"; one drawn instance is reused throughout Sec. V A - "we use one Hamiltonian with the same coefficients as an example". The second is HeH: "The molecular Hamiltonians are calculated with OpenFermion and OpenFermion-Psi4 [22, 23]. We used the STO-3G minimal basis set, and therefore, obtained the 4-qubit Hamiltonian. We calculated the Hamiltonians at the 24 different bond lengths and performed the VQE at each point." The prose gives only "the 24 different bond lengths"; the bond-length axes of Figs. 6-8 carry tick labels 0.5 to 2.5 under "Bond length (Angstrom)". The ansatz is not particle-number conserving, so "the calculated excited states can have the different number of them".

  A classical numerical simulation whose only named software is SciPy, for the BFGS optimiser, and OpenFermion with OpenFermion-Psi4, for the molecular integrals: no circuit-simulation package, no device and no shot count is named anywhere in the paper. On the transverse Ising instance the first SSVQE optimisation drives the subspace fidelity to one - "as the cost function gets close to its global minimum, the fidelity approaches unity as expected" (Fig. 2) - and of the second, over the $(k+1)$-dimensional subspace, they write "One can see the subspace-search approach works well from Fig. 3" (its iteration axis runs to 40, against 400 for step 1; both are axis readings, not stated numbers). The weighted $k$-th-state variant also reaches $E_3$, but "the number of iterations to the convergence is larger than the number of overall iterations of the simple SSVQE" (Fig. 4), and the all-states variant costs about as much as that: "The number of iterations to the convergence is almost equivalent to the one presented in the previous section" (Fig. 5). For HeH, the SSVQE and the weighted SSVQE third-excited-state curves "agree nicely with the exact values of the third excited state at each bond length" (Figs. 6 and 7), and for the all-states run "the energy eigenvalues are well approximated by the optimized output of the weighted SSVQE" (Fig. 8). Every energy axis in the paper, Figs. 2 through 8, is labelled "Energy (Ha)"; no table of numbers is given.

• SSVQE-BLFQ light-meson spectroscopy on IBM Nairobi

  • Solving hadron structures using the basis light-front quantization approach on quantum computers

  Qian, Basili, Pal, Luecke and Vary take the effective light-front Hamiltonian they had used for light unflavored mesons under basis light-front quantization (BLFQ), cut it to a basis a NISQ device can hold, and run the spectrum on hardware: "We implement and compare the variational quantum eigensolver (VQE) and the subspace-search variational quantum eigensolver (SSVQE) to find the low-lying mass spectrum of the light meson system and its corresponding light-front wave functions as quantum states from ideal simulators, noisy simulators, and IBM quantum computers." SSVQE is the excited-state half of that comparison - the VQE half returns only the ground state - and the eigenstates it produces are then used to read off meson decay constants and parton distribution functions on the same circuits.

  The weighted SSVQE of Nakanishi et al. with "the compact encoding according to the Hilbert-Schmidt decomposition", so an $N \times N$ Hamiltonian occupies $\log_2 N$ qubits: "In the case of $N_{\max} = L_{\max} = 1$, the 4-by-4 Hamiltonian matrix is mapped onto two qubits. We prepare the four orthogonal reference states $|00\rangle, |01\rangle, |10\rangle, |11\rangle$, and then evolve them via EfficientSU2 ansatz with two repetition layers (12 parameters in total)." The cost is Eq. (24), $C_\omega = 1.0 E_{|00\rangle} + 0.5 E_{|01\rangle} + 0.25 E_{|10\rangle} + 0.125 E_{|11\rangle}$, and the ordering of the weights fixes which reference state becomes which level - "the respective reference state will be evolved in the order of its specified weight factor, namely, $|00\rangle$ becomes the ground state ($E_0$), $|01\rangle$ becomes the first" excited state, and so on. The larger cases put the 16x16 and 32x32 Hamiltonians on four and five qubits: four references and a six-layer HEA (56 parameters) for $(N_{\max}, L_{\max}) = (4,1)$, two references $|00000\rangle, |00001\rangle$ and a five-layer HEA (60 parameters) for (4,3). The optimisers are "COBYLA ... LBFGSB ... and SLSQP ... from scipy.optimize library" together with "SPSA ... and the Quantum Natural SPSA (QNSPSA) ... from qiskit.algorithms.optimizers library"; readout error is mitigated by calibration, and on hardware "re-calibration at a fixed interval (90 minutes) was necessary for the simulation as SSVQE optimization sometimes took 3-4 days to finish on IBM quantum backends". Every non-statevector SSVQE run used 20,000 shots, "the maximum number of shots allowed by the backend Nairobi".

  The BLFQ effective light-front Hamiltonian for light unflavored mesons, taken from the group's earlier classical work and truncated to "the three smallest but physically significant choices of the basis sizes: $(N_{\max}, L_{\max}) = (1, 1)$, $(N_{\max}, L_{\max}) = (4, 1)$, and $(N_{\max}, L_{\max}) = (4, 3)$. Respectively, they correspond to matrix dimensions of 4, 16, and 32." The quark mass $m_q$ and confining strength $\kappa$ "are obtained by fitting the experimental mass of $\rho(770)$ meson from the Particle Data Group (PDG) [67] at their respective cutoffs"; the same PDG source supplies the experimental decay constants the results are judged against, 130 MeV for $\pi$ and 216 MeV for $\rho$. The released repository ships the corresponding matrices under H_data/N1L1, H_data/N4L1 and H_data/N4L3.

  SSVQE_BLFQ_public, a Python/Jupyter repository at https://github.com/wyqian1027/SSVQE_BLFQ_public under the MIT licence, whose README states it "contains source code implementation of SSVQE using Qiskit and application demos on using SSVQE to solve hadronic observables in nuclear physics" and links both this paper and, as the algorithm, the Nakanishi, Mitarai and Fujii paper. It is not demonstrably the code that produced the results below: the paper itself names no repository, the GitHub API reports the repository created 2023-07-16 - after the December 2021 preprint and the 2022 Phys. Rev. Research version - and the tie rests on the README, which is signed "WQ 06/26/2022", the initials of first author Wenyang Qian, on the wyqian1027 account. Its src/ directory holds solver_SSVQE.py alongside solver_VQE.py, ansatz.py, blfq.py, blfq_quantum.py, measurement.py, mitigation.py and simulator.py; the two demo notebooks, demo_ssvqe_basics.ipynb and demo_ssvqe_blfq_observables.ipynb, sit at the repository root. The library it builds on is Qiskit: the optimisers are imported from qiskit.algorithms.optimizers (COBYLA, L_BFGS_B, SLSQP, SPSA, QNSPSA) and the demo notebook drives Qiskit's EfficientSU2, while src/ansatz.py writes its own circuits - class HardwareEffAnsatz, "Hardware Efficient Ansatz implementation with CZ two-qubit gates and RX, RZ single-qubit gates", plus UCC builders - and EfficientSU2 appears nowhere in src/.

  SSVQE ran on IBM Nairobi, "a recently-released 7-qubit quantum computer", at $(N_{\max}, L_{\max}) = (1, 1)$ on two qubits with readout-error mitigation and 20,000 shots per measurement, under COBYLA and under QNSPSA. All four levels came out at once (Table V, in MeV$^2$, truncated to the nearest integer): exact 543059 against 570482 (COBYLA) and 571106 (QNSPSA); 593915 against 612433 and 613577; 1685209 against 1659565 and 1674709; 1716743 against 1698240 and 1692378. The same run on Qiskit Aer's QASM simulator gives 543661 $\pm$ 40 and on the noise-mitigated QASM simulator 555448 $\pm$ 795, while the statevector simulator reproduces the exact values. From the IBM Nairobi state the pion decay constant comes out as 164.20 $\pm$ 8.51 MeV against an exact 178.18 MeV, and the rho as 167.76 $\pm$ 8.21 MeV against the same 178.18 MeV (Table VI). The larger bases stayed on simulators - "we did not run the SSVQE optimization for the two larger Hamiltonians on IBM quantum computers" - and there the paper's own summary is "we find the results from ideal SV and QASM simulator agree with the exact energies, while the results from noise simulators are consistently greater than the exact energies due to quantum noises": the (4,1) QASM row reads 373554 $\pm$ 4133, 586963 $\pm$ 3981, 786290 $\pm$ 4195 and 979853 $\pm$ 4040 against exact 369016, 575707, 737759 and 976608, while the (4,3) noise-mitigated ground state is 721627 $\pm$ 7237 against an exact 336927. Parton distribution functions for $\pi$ and $\rho$ were evaluated on the QASM simulator at 19 evenly-spaced longitudinal momentum fractions, also at 20,000 shots. The VQE half of the paper used a different device and a different shot count: "IBM's 5-qubit superconducting processor, IBMQ Manila", driven through the Qiskit runtime VQEClient, with "8,192 shots at each step of the optimization".

• Quantum Native Dojo SSVQE notebook on Qulacs

  Chapter 6-3 of the Quantum Native Dojo, the open self-study text kept in the same GitHub organisation as the Qulacs simulator, is a worked SSVQE implementation: "Among them, I would like to introduce a new method proposed in 2018, Subspace-Search VQE (SSVQE) [1]", citing Nakanishi, Mitarai and Fujii. Its stated task is "Implement SSVQE to search the ground state and the first excited state of the hydrogen molecule." This is teaching code rather than a research result - the chapter offers it as "an example of simulating SSVQE using Qulacs" - but it runs end to end and it is committed with its outputs.

  The weighted form with two inputs. The cost cell reads get_exp(state0, theta_list) + 0.5 * get_exp(state1, theta_list), where state0 is $|0000\rangle$ and state1 is set by set_computational_basis(1) to $|0001\rangle$ - weights 1 and 0.5, satisfying the chapter's rule that "$w_i$ is chosen to be positive and $w_i < w_j$ for $i > j$". The ansatz is hardware-efficient, "modeled after those used in experiments with superconducting qubits" citing Kandala et al.: a leading RY/RZ pair on qubit 0 alone, then merged RY/RZ rotations on every qubit and a CZ ladder, repeated depth = n_qubit = 4 times, then a final rotation layer - $2 n (D+1) + 2 = 42$ parameters, the trailing $+2$ being that leading pair. Optimisation is scipy.optimize.minimize with method "BFGS" from parameters drawn as np.random.random(...) * 1e-1; a callback records both input energies at every iteration. The exact references it plots against come from scipy.sparse.linalg.eigsh(hamiltonian_matrix, k=2, which="SA") and molecule.fci_energy.

  One molecule: H$_2$ at a fixed internuclear separation written as the bare number distance = 0.977 - the unit is Angstrom, the default geometry unit of OpenFermion's MolecularData, but the notebook states none - with geometry [["H", [0,0,0]], ["H", [0,0,distance]]], multiplicity 1, charge 0, in the sto-3g minimal basis. Integrals come from PySCF through OpenFermion's MolecularData and openfermionpyscf.run_pyscf(molecule, run_scf=1, run_fci=1), and the fermionic operator is mapped by jordan_wigner to "a 4-qubit Hamiltonian". The chapter flags what the unconstrained particle number does to the answer: "the first excited state here refers to the first excited state of the Hamiltonian of the hydrogen molecule without considering the number of electrons, which in chemical terms is the ground state of the hydrogen molecule ion."

  The notebook notebooks/6.3_subspace_search_VQE.ipynb in https://github.com/qulacs/quantum-native-dojo-en (Jupyter/Python, BSD-3-Clause), importing qulacs, openfermion and openfermionpyscf; the Japanese original is qulacs/quantum-native-dojo. That notebook is rendered at https://dojo.qulacs.org/en/latest/notebooks/6.3_subspace_search_VQE.html, whose text reads "Below is an example of simulating SSVQE using Qulacs". The site also carries a QURI Parts rewrite of the same chapter at https://dojo.qulacs.org/en/qp_main/notebooks/6.3_subspace_search_VQE.html, which builds the Hamiltonian with quri_parts.pyscf and quri_parts.openfermion, takes the ansatz from quri_parts.algo.ansatz.HardwareEfficient and estimates with create_qulacs_vector_estimator; that is a different artefact from the one described here.

  A Qulacs statevector simulation: the Hamiltonian is loaded with create_observable_from_openfermion_text and each energy taken with qulacs_hamiltonian.get_expectation_value on a qulacs.QuantumState, so there are no shots and no device. The committed outputs are the initial cost value, 0.211562756558141, and one figure - the two input energies plotted per iteration against molecule.fci_energy and the second eigenvalue from eigsh - under the line "Plotting the execution result, we can see that it has converged to the correct solution." No converged energy is printed as a number, and the notebook expects the whole run to "finish in tens of seconds".

What it needs

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 methodsruns Once per input state in the subspace, per optimiser iteration. The paper's construction is a search over a subspace spanned by several orthogonal inputs, so the objective is a function of all of their energies and one evaluation of it is one energy estimate for each — the price of not needing the lower states in advance. The number of inputs is k+1 for the k-th excited state; nothing bounds the iteration count, for the same reason nothing bounds VQE's.

   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.

   The loop closes through a measurement: every turn ends in a readout and starts from a fresh preparation. The price is a count of runs, not a depth. Stated as what the construction forces rather than as a figure the abstract quotes: the abstract gives the orthogonal-inputs construction and the two-optimisation framing, and one estimate per input per iteration follows from it. Recorded here because it is the reason this route costs more per turn than the deflation route it competes with, which is otherwise invisible on a map that draws both as one loop.

Other ways to fill the same slot

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.

• 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 variational eigensolver

  Optimise one circuit for several states at once and read off the transitions between them — both the energy of each transition and the oscillator strength that says how strongly light drives it. The answer is a spectrum with intensities, which is what an absorption experiment actually produces.

In the Atlas

• Subspace-search VQE

  One shared unitary transforms several orthogonal inputs while a weighted objective orders multiple eigenstates.

Sources

• Subspace-search variational quantum eigensolver for excited states↗Ken M Nakanishi, Kosuke Mitarai, Keisuke Fujii · 2018theory yes · simulation yes · hardware no