Folded-spectrum 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.

Cadi Tazi and Thom state what it buys and what it costs in the same breath: the method "provides the possibility of directly computing excited states around a selected target energy, using the same ansatz as for the ground state calculation", and, "inspired by the variance-based methods from the Quantum Monte Carlo literature", it "minimizes the energy variance, thus requiring a computationally expensive squared Hamiltonian". The squared operator is the binding cost and they treat it as one: "we alleviate this potentially poor scaling by employing a Pauli grouping procedure, identifying sets of commuting Pauli strings that can be evaluated simultaneously". The target energy is an input, not an output — a state is reached because it is near a number the user chose. Results are "all electronic excited states with chemical accuracy on ideal quantum simulators" for H2 and LiH; no device run is reported.

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

given  Hamiltonian H, as a weighted sum of Pauli strings h_i P_i
       an arbitrary target energy omega, chosen by the user -- not returned,
           not fitted, an input like any other
       the same Trotterized UCCSD ansatz used for a ground-state VQE run,
           applied to a reference determinant |Phi_ref> chosen for the
           symmetry sector of the wanted excited state
       a shot-budget scheduler, and the SPSA classical optimizer for the
           QASM-simulator runs                                    (Sec. VI B)
           # the LiH potential curves were run on a statevector simulator
           #   instead; SPSA is named only for the QASM runs      (Sec. VII B)

requires  omega closer to the wanted eigenvalue E than to any other -- when it
    is not, the loop still converges, just onto the neighbouring state; the
    paper reports this as expected behaviour of the method, observed as
    jumps between electronic states along a potential energy surface when
    two states are close in energy or gradients are large       (Sec. VI A 1)

# --- fold the spectrum about omega -------------------------------------------
(H - omega)^2 |Psi> = (E - omega)^2 |Psi>                              (Eq. 13)
    # true for every eigenstate |Psi> of H, for every omega -- proved from
    #   linearity of the Schrodinger equation, not ansatz- or method-specific
    # the folded operator keeps H's eigenstates but reorders the eigenvalues
    #   around omega, so its LOWEST eigenstate is the one whose E sits
    #   nearest omega                                     (Sec. III, Fig. 4)
    #   -- Section III has no lettered subsections; this is body text there

F(theta) = <Psi(theta)| (H - omega)^2 |Psi(theta)>                     (Eq. 14)
    # minimised in place of <H>; this swap is the only change from a
    #   ground-state VQE -- same ansatz, same reference-state machinery

# --- build the squared operator, then cut it back down ------------------------
square H to form (H - omega)^2                       # ~ (#Pauli strings in H)^2
    # "the number of Pauli strings primarily obtained is approximately the
    #   square of the number of terms in H"                     (Sec. IV B 1)
    # e.g. H2O/STO-3G: 1578 strings in H square to about 1578^2 before any
    #   reduction is applied                        (Table II, Appendix 2)
reduce via Pauli commutation/anticommutation relations           (Sec. IV B 1)
    # H2O: down to 111615 strings this way            (Table II, Appendix 2)
    # the paper reports this reduction gives an EMPIRICAL scaling below
    #   O(N^6) against the expected O(N^8), a result imported from a
    #   separate study of a different set of systems and only asserted, not
    #   derived, to extend to the folded operator here; the paper's own next
    #   sentence asks for "more formal analyses"                 (Sec. IV B 1)
partition the reduced strings into simultaneously-diagonalizable groups
    # qubit-wise commutativity (QWC): H2O -> 20393 groups under Jordan-
    #   Wigner, one circuit evaluation each; H2's 24 folded strings -> 9 QWC
    #   groups                                        (Table II, Appendix 2)
    # the coarser general-commutativity (GC) partition used for the
    #   error-mitigated run cuts H2's 24 strings to just 2 groups,
    #   G1 (16 strings) and G2 (8 strings)                   (Eq. 30, Sec. V C)
    #   -- Sec. V C is "Zero Noise Extrapolation", not the VI C
    #      post-processing subsections cited further down

# --- VQE loop: minimise F, not <H> --------------------------------------------
repeat until the cost gradient falls below 1e-9:                (Sec. VIII A)
    prepare |Psi(theta)> = UCCSD(theta) |Phi_ref>
    for each Pauli group:
        take s shots, s = smax - (smax - smin) * exp(-k * iteration),
            smin = 1000, smax = 10000, k > 0                       (Eq. 36)
            # used for ALL computations in the paper; precision only tightens
            #   as the run approaches convergence -- early, imprecise
            #   evaluations are tolerated by design              (Sec. VI B 2)
        recover the group's Pauli expectation values from one set of counts
    sum weighted group expectation values to get F(theta)
    theta <- SPSA_step(theta, F)
        # perturbs every theta_i at once; F is evaluated only at
        #   theta+delta and theta-delta -- 2 evaluations per iteration
        #   REGARDLESS of dim(theta), which is why SPSA is used here (Sec. VI B)

# --- optional: carry a state across a potential-energy-surface scan -----------
if scanning a PES, warm-start point k+1 from point k's converged result:
    omega_{k+1} <- E_k  ;  theta_init_{k+1} <- theta_opt_k         (Eq. 32, 33)
    # a continuity heuristic added on top of the method, not part of a
    #   single-geometry FS-VQE run                                 (Sec. VI A)
    # requires continuous MO coefficients too: RHF phase jumps are detected
    #   via P_{k,k+1} = C_k^dagger S_k C_{k+1} and rectified        (Eq. 34)
    at geometries observed to jump between states, add a penalty to F:
        F <- F + eta * |theta_{k-1} - theta_k|, eta = 0.1              (Eq. 35)
        # eta = 0.1 is an empirically chosen constant, applied only to "some
        #   isolated points" in the curve -- not a standing part of the
        #   loop                                                 (Sec. VI A 1)

# --- refine theta after the loop exits ----------------------------------------
sample F at a few points near theta_opt and fit a parabola;
    replace theta_opt with its vertex if F improves               (Sec. VI C 1)
    # rests on UCCSD eigenstates sitting at parabola vertices in the energy
    #   landscape; the paper calls the gain "usually very low" because the
    #   optimizer already locates the vertex well, with "a few tenths of a
    #   percent" gained only in some cases
round any theta_i landing close to 0 or to a fraction of pi;
    keep the rounding only if F improves                         (Sec. VI C 2)
    # runs AFTER the quadratic fit, on its output; "usually only improves the
    #   result very slightly", up to a few hundredths of a percent

take a final measurement at 30000 shots                          (Sec. VI B 2)

return  the energy at theta_opt (nuclear repulsion plus <H> in the optimised
        state) and the prepared state |Psi(theta_opt)>
# the exact form of that final-energy expression is read off Figure 3's
#   flowchart, whose symbols pdftotext does not extract -- inferred from
#   step 1 ("compute nuclear repulsion energy") and Sec. II's <H>, NOT
#   quoted; worth a visual check of the figure
# one run returns ONE state near one omega, not a spectrum -- "all excited
#   states ... may be obtained by modifying the parameter omega over a wide
#   enough range of energies", i.e. scanned by hand              (Sec. III)
# nothing in this loop certifies that the converged E is really nearest
#   omega rather than a local minimum of F reached by a limited ansatz
# no quantum-device run is reported: NISQ hardware is called "too limited"
#   and every result is a simulator result                        (Sec. VII)

Cadi Tazi and Thom count the squared operator directly: forming $(\hat{H}-\omega)^2$ takes $\mathrm{H_2O}$ in STO-3G from $1578$ Pauli strings to $111615$, which qubit-wise-commuting grouping under Jordan-Wigner returns to $20393$ groups, one circuit evaluation each (Table II, section VIII B). That section calls the group count $O(N^6)$ in $N$ spin-orbitals, but the figure is their import of Suchsland et al.'s ungrouped string count: empirical, over molecules to $18$ qubits, no proved power law, and never established for groups. SPSA costs $2$ evaluations per iteration (QASM simulations); for $\mathrm{H_2}$, whose $24$ strings fall into two general-commuting groups, one evaluation is two circuits. Each string needs $O(1/\varepsilon^2)$ shots at fixed confidence and bounded variance, here $1000$ rising to $10000$. UCCSD depth is $O(N^4)$. Nothing bounds the iterations: the loop stops on a $10^{-9}$ gradient threshold (section VIII A). The classical Pauli reduction and grouping underneath is NP-hard and, the authors say, not yet scalable.

• The $\mathrm{H}_2$ and LiH excited-state curves on Qiskit simulators (Sec. VII)

  • Folded Spectrum VQE : A quantum computing method for the calculation of molecular excited states

  The authors' own runs, and Sec. VII opens by saying why there are no others: "The current capability of NISQ hardware (in terms of quantum volume and gate fidelity) is too limited for FS-VQE to obtain reasonable results on real quantum devices. Thus, we restricted our computations to small molecules and small active spaces that are tractable on simulators." What the runs settle is narrow and worth stating narrowly — whether folding the spectrum about a chosen $\omega$ returns the right excited states when nothing is in the way, the abstract's claim being "all electronic excited states with chemical accuracy on ideal quantum simulators" — and then, in Sec. VII C, whether the same loop still reaches chemical accuracy once a noise model is switched on and error mitigation is applied. No device is touched anywhere in the paper: no machine is named as a run target, the noise model is only "based on the models provided for IBM quantum devices", and even the SPAM confusion matrices "are directly extracted from the noise model's parameters" rather than measured on hardware.

  Three different instruments, and which one produced a number changes what the number means. $\mathrm{H}_2$: "The UCCSD circuit for this system of 4 spin-orbitals and 2 electrons is composed of 3 excitation operators that can be implemented in a compiled quantum circuit of depth 71 (with 44 CNOT gates). Computations were performed on Qiskit's QASM simulator acting like an ideal noiseless quantum computer, including finite sampling error. A shot scheduler between 1000 and 10000 shots was used during optimization (see section VI B 2)", with 30000 shots for the final evaluation. LiH: "the UCCSD gate includes 8 excitations, resulting in a circuit of depth of 311 with 212 CNOT gates. The computations were performed on Qiskit's Statevector simulator allowing the measurement of the qubits' exact state, thereby avoiding finite sampling error" — so the LiH curves carry no sampling error at all and no shot budget applies to them. The mitigated study of Sec. VII C is a third instrument again, the same algorithm run against a noise model. The classical optimizer is named only for the sampled runs: "We use the SPSA (Simultaneous Perturbation Stochastic Approximation) optimizer for QASM (Quantum Assembly Language) simulations." Scanning a curve is not a bare sequence of independent FS-VQE runs: Sec. VI A, inside the Computational details section, carries each geometry into the next, $\omega_{k+1}=E_k$ and $\theta^{\mathrm{init}}_{k+1}=\theta^{\mathrm{opt}}_k$, and "The MO coefficients are pre-computed for each geometry using the PySCF package" with restricted-Hartree-Fock phase jumps detected and rectified so the parameters stay continuous — though Sec. VII never restates this of the curves it reports, and the companion regularisation was applied only "for some isolated points in the PEC". The loop's stopping rule is a gradient threshold, "the optimization terminates when a threshold value ($10^{-9}$ in our implementation) is reached in the cost function gradient". The Pauli-grouping study of Table II is wider than the runs: it counts strings and qubit-wise-commuting groups for LiH/STO-3G, $\mathrm{BeH}_2$ and $\mathrm{H_2O}$ as well, and none of those three is ever put through FS-VQE.

  Two molecules, both tiny, both in bases chosen for tractability rather than physics. "$\mathrm{H}_2$ was described with the STO-3G basis including the 1s orbital for each atom, resulting in 4 spin-orbitals for the system and 4 qubits after Jordan-Wigner transformation", with three excited states targeted through their reference determinants, $T_1$, $S_1$ and $S_2$. LiH is "described with 6 spin-orbitals in a minimal basis (considering s orbitals only for both atoms)", six qubits under Jordan-Wigner, with eight excited states listed ($T_1$, $S_1$, $S_2$, $T_2$, $S_3$, $T_3$, $S_4$, $S_5$); the paper disclaims the chemistry itself rather than the numbers: "Note that the results LiH may differ greatly from the experimental data because the basis set only includes s orbitals, which is a poor approximation for the lithium atom. This minimal description allows us to put the FS-VQE to the test but does not aim for physically accurate results." The reference the errors are measured against is not experiment but "the FCI energies obtained by numerical diagonalisation of the Hamiltonian". The noisy study of Sec. VII C uses a synthetic device: a tunable model "based on the models provided for IBM quantum devices", whose Table I fixes gate errors, $T_1$, $T_2$ and SPAM error at a scale factor $\lambda$, where "$\lambda = 1$ corresponds to the order of magnitude of the experimental values in IBM machines" and $\lambda = 0$ is noiseless.

  Qiskit supplies the simulators and PySCF the molecular-orbital coefficients; those two packages, plus SPSA, are the whole named stack. No artefact is released with the paper, and the check that settles it is the PDF's link annotations rather than its text, because `pdftotext` silently drops every hyperlink: the arXiv v2 PDF carries exactly one URL in the whole document, IBM's quantum-computing portal, with no repository and no archive DOI, and no data- or code-availability statement in the prose. The accepted manuscript deposited in the University of Cambridge repository has neither an availability statement nor any link annotation at all. What is recorded here is therefore a study, not a package a reader can install — with one route left unchecked, since the published JCTC version was not read and ACS places data-availability statements on the article page rather than in the manuscript.

  For $\mathrm{H}_2$ on the sampled simulator, "FS-VQE allows recovering the complete potential energy curves for the 3 excited states of $\mathrm{H}_2$, at chemical accuracy", and Fig. 8's caption bounds only the points its rescaled error subplots do not show: "The error plots were rescaled for clarity, and all non-visible points are below $10^{-3}$ mHa for $\mathrm{H}_2$ and below $10^{-8}$ mHa for LiH." Sec. VIII A states the headline and qualifies it in the next sentence: "all points in figure 8 have an error within the range of chemical accuracy (1 kcal / mol) compared to FCI, as evidenced by the subplots. However, a wide range of errors (between 1.5 mHa and $10^{-16}$ mHa) and different patterns of error curves are observed" — sixteen orders of magnitude of spread, attributed not to the method but to where the gradient threshold happens to stop each run. The mitigated study is a single point, not a curve: "The mitigated FS-VQE algorithm was used to compute the highest excited state $S_2$ of the $\mathrm{H}_2$ molecule in STO-3G basis, at a fixed bond length of 0.74 Angstrom", 20000 shots per circuit evaluation, and "When using mitigation, the energy computation reaches chemical accuracy compared to FCI for $\lambda < 0.4$, while only $\lambda = 0$ is below 1 kcal/mol without mitigation." Two figures describe how far that is from a present machine and they are not the same size: the $\lambda = 0.4$ row of Table I is a factor of $2.5$ in the linearly scaled one- and two-qubit gate error rates, $4 \times 10^{-5}$ and $4 \times 10^{-4}$ against $10^{-4}$ and $10^{-3}$ at $\lambda = 1$, and about $3.2$ in the exponentially scaled $T_1$ and $T_2$, while the Discussion reads the same result as needing "quantum devices with improved performances of about an order of magnitude compared to those of the present machines" — a stricter target than the paper's own open bound $\lambda < 0.4$ requires, and one that bound admits rather than contradicts. The authors label the mitigated run themselves: "These experiments are a proof of concept that the FS-VQE algorithm can be combined with mitigation techniques to deal with noise in quantum computations. More detailed and extensive analysis of the use of mitigation techniques in FS-VQE is left for further studies."

• The `Folded_spectrum` class in MindQuantum's research tree

  A released module rather than a study, and it does not cite the method's home paper. It sits in the MindQuantum project's own `research` branch under `challenges/2023/General_module_of_excited_states_based_on_MindQuantum/`; the parent `challenges/2023/readme.md` names the contest as the second Ascend AI Innovation Competition and this module as its second-batch problem three, and requires prize-winners to submit their work to the MindQuantum repository within a week of the results being published, so the tree holds winning entries rather than open submissions. The module's README describes a general excited-state module implementing six methods, listing the folded spectrum method first alongside orthogonally constrained VQE, subspace expansion, subspace-search VQE, multistate contracted VQE and the orthogonal state reduction variational eigensolver. Its stated sources are MindQuantum itself, the review "Noisy intermediate-scale quantum (NISQ) algorithms", and a paper on the orthogonal state reduction eigensolver; Cadi Tazi and Thom are not among them, and the README attributes the folded-spectrum objective to none of the three. The constructor's docstring says what the class is in one line — "This is a implementation of folded spectrum method for VQE." — and the class statement itself carries no docstring.

  The class never builds $(\hat{H}-\omega)^2$ as one operator. `_generate_operators` puts two observables on the simulator, `Hamiltonian(self.ham**2)` and `Hamiltonian(-2 * self.target_energy * self.ham)`; `evaluate` reads both back through MindQuantum's `get_expectation_with_grad` and assembles `fval = f1 + f2 + self.target_energy**2` with `gval = g1 + g2`. That is $\langle\hat{H}^2\rangle - 2\omega\langle\hat{H}\rangle + \omega^2$, algebraically the folded-spectrum objective, with the constant $\omega^2$ added classically so it never enters the gradient. Two things Cadi Tazi and Thom treat as the substance of the method are absent here: there is no Pauli grouping — the squared operator is handed to the simulator whole — and there are no shots, since the gradients are the simulator's analytic ones on the default `mqvector` statevector backend. The target energy is a constructor argument documented as "the approximate energy of around the eigenenergy of the target eigenstate", and it is assigned only in `__init__`, never updated by the run. The demo drives the class with SciPy's `l-bfgs-b` at `jac=True` on a `HardwareEfficientAnsatz`, not with UCCSD and not with a noise-tolerant optimizer.

  None of its own; the Hamiltonian is a caller's `QubitOperator`. The bundled `report.ipynb` supplies a four-qubit open Heisenberg chain built by a local `ham_heis(N, J)` as $\sum_i (X_iX_{i+1} + Y_iY_{i+1} + Z_iZ_{i+1})$ at $J=1$, with the reference spectrum obtained in the notebook by `numpy.linalg.eigvals` on the dense matrix. The ansatz is `HardwareEfficientAnsatz(4, [RY, RZ], depth=3)` and the initial parameters are `numpy.random.rand(...) - 0.5` under `numpy.random.seed(100)`. The four target energies are chosen by hand as $-6.5$, $-4$, $-1$ and $0.5$ — that is, the scan over $\omega$ that this method requires is a literal list in the notebook, not anything the algorithm produces.

  MindQuantum, `research` branch, path `challenges/2023/General_module_of_excited_states_based_on_MindQuantum/`, three files: `README.md`, `algorithm.py` and `report.ipynb`. The method is the class `Folded_spectrum(BaseVQEClass)` in `algorithm.py`, with `__init__`, `evaluate` and `_generate_operators`; the base class supplies `_initialize_simulator`, `_initialize_energy_evaluator`, `_initialize_grad_evaluator` and `energy`. The branch root carries an Apache License 2.0 and the module directory carries no licence file of its own, so the licence claim is about the branch. A byte-identical copy of `algorithm.py` is mirrored on GitHub at `2024-MindSpore-1/Code3` under `VQE/`, whose README names the Gitee tree as its origin. The notebook records the versions it ran under: `mindquantum` 0.8.0, `numpy` 1.20.1, `scipy` 1.6.1.

  The notebook's four runs return $-6.464101609059055$, $-3.8284270983054305$, $-1.0000000775643823$ and $0.464101615290512$ against a dense-diagonalisation reference of $-6.464101615137754$, $-3.8284271247461867$, $-1$ and $0.4641016151377547$ — the ground state and three distinct higher levels of the four-qubit chain, each reached from its own hand-chosen $\omega$ and the same seeded random start, agreeing to between seven and nine decimal places. This is a statevector demonstration on one four-qubit spin model; nothing here is a molecule, a shot-noise study or a device run, and the module ships no test suite and no benchmark beyond this notebook.

• The adaptive folded-spectrum method on Ising chains (Sec. IV)

  • Adaptive variational quantum eigensolvers for highly excited states

  An independent implementation in a different domain by a different group, and built by those authors as the comparison arm for their own proposal. Zhang et al.'s subject is adaptive VQE-X — "In Sec. II, we propose an algorithm, adaptive VQE-X, that samples eigenstates from the whole spectrum of H in an unbiased manner using the energy variance as a cost function" — and Sec. IV, headed "COMPARISON TO ADAPTIVE FOLDED-SPECTRUM METHOD", is where they "introduce a variant of the FSM that uses the adaptive procedure outlined in Sec. II" and measure it against that reference. Their Introduction states the gap they mean to close: existing eigenstate-targeting algorithms, the folded-spectrum method named first among them, "have so far only been used to probe low-lying excited states. Moreover, they have typically been applied with fixed variational ansatze used for ground-state problems, which may or may not be able to provide faithful low-depth representations of highly excited states." Sec. IV then removes the fixed ansatz from the folded-spectrum method itself and asks whether it still covers the spectrum. It predates the paper this method is recorded from by two years.

  The change is one line of the algorithm and the paper says so: "The adaptive FSM is obtained from adaptive VQE-X by replacing the cost function in Eq. (1) by $C(|\psi(\theta)\rangle) = \langle\psi(\theta)|(H-\lambda)^2|\psi(\theta)\rangle$ and leaving the remainder of the algorithm unchanged. The new cost function drives the variational method to converge to the eigenstate with energy closest to the shift parameter $\lambda$." Everything else is Sec. II's machinery: the ansatz is grown one operator at a time from a pool of Pauli strings, each candidate scored by a one-parameter Golden-section search and the winner kept, then all parameters re-optimised by Nelder-Mead, chosen because "it avoids the need to measure gradients of the cost function with respect to the ansatz parameters". The run stops at $N_{\max}=100$ steps or when $\mathcal{F}(|\psi(\theta)\rangle) = 1 - |\langle\psi(\theta)|H|\psi(\theta)\rangle| / \|H|\psi(\theta)\rangle\| < \delta = 10^{-4}$, a collinearity test rather than a check against $\lambda$; the paper flags its own failure mode, that "It is possible for a state $|\Psi\rangle$ that is a superposition of eigenstates nearby in energy to satisfy $\mathcal{F}(|\Psi\rangle) < \delta$". Measurement cost is asserted equal to the variance objective's rather than reduced: "the quantum resource requirements for evaluating the FSM cost function (10) and the VQE-X cost function (1) on a QPU are comparable, since both cost functions require the evaluation of $\langle\psi(\theta)|H^2|\psi(\theta)\rangle$ and $\langle\psi(\theta)|H|\psi(\theta)\rangle$." There is no Pauli grouping and no shot model.

  The mixed-field Ising model $H = J\sum_i Z_iZ_{i+1} + \sum_i (h_xX_i + h_zZ_i)$ under periodic boundary conditions, with $J=1$ and $(h_x, h_z) = (0.8, 0)$ for the integrable transverse-field case and $(0.8, 0.5)$ for the nonintegrable case. "We have tested the adaptive FSM for both the integrable TFIM ($h_z = 0$) and the nonintegrable MFIM ($h_z = 0.5$) using the pools $\mathcal{P}_{\min}$ and $\mathcal{P}_{\max}$ for $N \leq 7$", with Fig. 5 reporting $N=6$. The shift $\lambda$ is scanned over the bandwidth of $H$, obtained classically by Lanczos where that is tractable or estimated by a qubit mean-field calculation where it is not. Each $\lambda$ is run from a single start, not an ensemble: "we choose 'one' of the same random initial product states that we used in the adaptive VQE-X method", the quotation marks around 'one' the paper's own, and Fig. 5's caption confirms that "Results for each $\lambda$ start from the same random initial product state" — so coverage here comes from the $\lambda$ scan, where adaptive VQE-X gets it from "an ensemble of random product states", and the released drivers accordingly read a single line out of their list of product states per run. A qubit mean-field start was also tried, and "We found the performance relative to a random initial state to be equivalent for the nonintegrable model and slightly worse for the integrable case."

  The paper's Note Added releases the artefact — "The data and source code used for this work have been made publicly available" — and the reference it points to is a bare hyperlink that `pdftotext` drops; read out of the PDF's link annotations it resolves to figshare DOI 10.6084/m9.figshare.14916282.v3, published 2021-07-06 under the same five authors and the same title, the record setting the licence to GPL 3.0+ while the archive itself carries no licence file. Its single file `VQE-X-master.zip` unpacks to a tree whose `folded_spectrum/` directory holds the two drivers `src/vqe-x_minpool.py` and `src/vqe-x_maxpool.py`, the lists of initial product states they read, the $N = 6$ converged runs `N6hx0.8hz0.0.out` and `N6hx0.8hz0.5.out`, the exact-diagonalisation references `ED-hz0.0.dat` and `ED-hz0.5.dat`, and the plotting script `fig_folded_spectrum.py` that reads all four. It is plain NumPy and SciPy on dense `numpy.kron` matrices with no quantum SDK anywhere: the cost function returns $\langle\hat H^2\rangle - 2\lambda\langle\hat H\rangle + \lambda^2$, each pool candidate is scored by `minimize_scalar` with `method='Golden'` over $(0, \pi)$, and the enlarged ansatz is re-optimised by `minimize` with `method='nelder-mead'`, at the hard-coded tolerance `eps = 1e-4` that the paper calls $\delta$. Read the deposited constants as one run's settings rather than as the paper's: their command-line forms are commented out immediately above, a single start-and-end line into the state list is frozen in, and the step cap is left at 200 in the minimal-pool driver and 256 in the maximal-pool one beside a comment naming 100, where the paper states $N_{\max} = 100$.

  "When $\lambda$ is scanned over the full bandwidth of $H$, the pools $\mathcal{P}_{\min}$ and $\mathcal{P}_{\max}$ produce near-complete coverage of the spectrum within a limited number of variational steps, $N_{\max} = 100$, for the integrable and nonintegrable cases, respectively", and "The results shown in Fig. 5(a),(b) demonstrate that the adaptive FSM is capable of producing converged trials throughout the many-body spectrum for $N = 6$ using the same operator pools and algorithmic parameters as adaptive VQE-X." The comparison the section exists to make comes out level rather than favourable to either side: the distribution of converged parameter counts $N_c$ in Fig. 5(c),(d) has an average "consistent with our adaptive VQE-X results for the same parameters and operator pools". The pool dependence carries over too — the minimal pool "yields longer circuits and a reduced rate of convergence in the nonintegrable case, resulting in less uniform coverage of the spectrum", with the paper noting that data is not shown. Nothing here is a molecule and nothing is a device run; the paper says the adaptive FSM was tested for $N \leq 7$ but shows results only at $N = 6$, and the released deposit's only folded-spectrum outputs are the two $N = 6$ runs. Sec. V's scaling analysis, which finds the converged parameter count growing roughly exponentially and approaching the Hilbert-space dimension, is stated for adaptive VQE-X rather than measured for the folded-spectrum variant.

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.

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

• Folded-spectrum VQE

  Minimizing the squared shifted Hamiltonian targets eigenstates near a chosen energy shift.

• Folded Spectrum VQE : A quantum computing method for the calculation of molecular excited states↗Lila Cadi Tazi, Alex J.W. Thom · 2023theory yes · simulation yes · hardware no