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.

A Hermitian H reachable as a sum of terms that can be measured separately; a statement of which state is wanted — an index k, a symmetry sector, or a target energy to sit nearest; for most of the methods here, the ground state already solved, and for the deflation route every lower state as well; a target additive error and a shot budget.

1. Hamiltonian whose excited state is wanted → Parameterised circuit familyChoose a parameterised trial state

   Step 1 constructs $U(\theta)$ and picks $k+1$ mutually orthogonal inputs $\{|\varphi_j\rangle\}_{j=0}^{k}$ with $\langle\varphi_i|\varphi_j\rangle = \delta_{ij}$, taken in practice from the computational basis. What the family must contain is a map, not a state. assumption: $U(\theta)$ and $V(\phi)$ can represent the exact unitary mapping the $k+1$ inputs to the corresponding eigenstates of $H$ — Sec. III states the spectrum is exact when they can, and writes $k$ there where the algorithm defines $k+1$ Step 3 builds a second circuit $V(\phi)$ acting only on the space those inputs span; the weighted variants have no step 3, and Fig. 1's caption notes that for them $\theta$ denotes both parameter sets, so the $\phi$ block belongs to $U(\theta)$. The simulated $U(\theta)$ is $D_2$ repetitions of $R_X(\theta_1^{(d)})\ldots R_X(\theta_4^{(d)})$, $R_Z(\theta_5^{(d)})\ldots R_Z(\theta_8^{(d)})$ and a nearest-neighbour CZ chain, closed by one $R_X, R_Z$ layer at index $D_2+1$; $V(\phi)$ is the same block on two wires, $D_1$ times. On the molecular Hamiltonian the ansatz is not built to conserve electron number, so the calculated excited states can differ in electron count.

   assumption

   Open this step

2. Parameterised circuit family → State you can prepareMinimise the objective over the parameters

   Eigenstates run $\{|E_j\rangle\}_{j=0}^{2^n-1}$ with $E_i \ge E_j$ when $i \ge j$, the ground state counted as the $0$-th excited state. Writing $h_j(\theta) = \langle\varphi_j|U^\dagger(\theta)HU(\theta)|\varphi_j\rangle$, step 2 minimises $L_1(\theta) = \sum_{j=0}^{k} h_j(\theta)$ — $k+1$ energies at once, not one state's — so $U(\theta^*)$ best approximates the map from $\mathrm{span}\{|\varphi_j\rangle\}_{j=0}^{k}$ onto $\mathrm{span}\{|E_j\rangle\}_{j=0}^{k}$: a subspace is pinned, not a state. Step 4 freezes $\theta^*$ and maximises $L_2(\phi) = \langle\varphi_s|V^\dagger(\phi)U^\dagger(\theta^*)HU(\theta^*)V(\phi)|\varphi_s\rangle$ for an arbitrary $s \in \{0,\ldots,k\}$, preparing $U(\theta^*)V(\phi)|\varphi_s\rangle$ — $V$ applied first — which is $|E_k\rangle$, the subspace's highest-energy state. For $k \ge 2^{n-1}$ the paper supplies $2^n-k$ inputs and reverses both directions. The weighted variants fold both into one: $L_w(\theta) = w\,h_k(\theta) + \sum_{j=0}^{k-1} h_j(\theta)$ with $w$ any value in $(0,1)$, whose optimum sends $|\varphi_k\rangle$ to $|E_k\rangle$ and the others into $\mathrm{span}\{|E_j\rangle\}_{j=0}^{k-1}$; and $L_{\mathbf{w}}(\theta) = \sum_{j=0}^{k} w_j h_j(\theta)$, whose optimum maps $|\varphi_j\rangle$ to $|E_j\rangle$ for every $j \le k$. assumption: both mappings are stated at the cost's global optimum, and the paper warns the weighted landscape may lengthen the run assumption: Sec. II C imposes only $w_i > w_j$ for $i < j$; the mapping also needs $w_j > 0$, which its own choice $\mathbf{w} = (4,3,2,1)$ satisfies and its stated condition does not require

   assumption

   Open this step

3. State you can prepare → Number with an error barEstimate an observable runs 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.

   One evaluation of $L_1$ is $k+1$ separate energy expectations $\langle\varphi_j|U^\dagger(\theta)HU(\theta)|\varphi_j\rangle$, $j = 0,\ldots,k$, on the same $n$-qubit register; the convergence figures plot exactly this quantity per input. Orthogonality is imposed at the input and carried by unitarity, so no measurement certifies it — the swap test Higgott, Wang and Brierley use, which doubles the number of qubits with additional gates, is removed, and no ancilla is used. The same $U(\theta^*)$ yields transition amplitudes, $\langle E_i|A|E_j\rangle = \langle\varphi_i|M|\varphi_j\rangle$ for $M = U^\dagger(\theta^*)AU(\theta^*)$. Eq. (1) gives $\mathrm{Re}(\langle\varphi_i|M|\varphi_j\rangle) = \langle {+^x_{ij}}|M|{+^x_{ij}}\rangle - \frac{1}{2}\langle\varphi_i|M|\varphi_i\rangle - \frac{1}{2}\langle\varphi_j|M|\varphi_j\rangle$ with $|{+^x_{ij}}\rangle = (|\varphi_i\rangle + |\varphi_j\rangle)/\sqrt{2}$. Eq. (2) prints those same three terms for the imaginary part from $|{+^y_{ij}}\rangle = (|\varphi_i\rangle + i|\varphi_j\rangle)/\sqrt{2}$; expanding that state instead gives $\mathrm{Im}(\langle\varphi_i|M|\varphi_j\rangle) = \frac{1}{2}\langle\varphi_i|M|\varphi_i\rangle + \frac{1}{2}\langle\varphi_j|M|\varphi_j\rangle - \langle {+^y_{ij}}|M|{+^y_{ij}}\rangle$, so the printed sign is inverted. Each term is measured separately and summed on a classical computer. assumption: $A$ is Hermitian — Sec. IV says only an operator $A$, but both expansions need $M = M^\dagger$ assumption: superpositions like $|{+^x_{ij}}\rangle$ can easily be prepared

   assumption

   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.

   Open this step

A scalar estimate — of that eigenvalue, or of the gap between it and the ground state — together with the run budget it consumed. Some methods return a whole low-energy subspace at once and others return one state per run, and that difference is a cost, not a convenience.

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)

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.

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

  • Subspace-search variational quantum eigensolver for excited states

    Ken M Nakanishi, Kosuke Mitarai, Keisuke Fujii · 2018

  About

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

  Methods

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

  Data

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

  Code

  None found yet.

  Results

  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

    Wenyang Qian, Robert Basili, Soham Pal, Glenn Luecke, James P. Vary · 2021

  About

  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.

  Methods

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

  Data

  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.

  Code

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

  Results

  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

  About

  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.

  Methods

  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.

  Data

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

  Code

  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.

  Results

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

• Subspace-search VQE · Qiskit

  From the repository — run, not written up from a paper · unsupported

  About

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

  Methods

  None found yet.

  Data

  None found yet.

  Code

  Qiskit

  Results

  Literature-backed method record; algorithmic scope and evidence boundary reviewed, with no benchmark run claimed.

• Subspace-search VQE

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