Minimise the energy variance

What it fills

• Minimise the objective over the parameters

  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.

When it applies

Zhang et al. name the property the objective is chosen for: variance-VQE "can be viewed as an self-verifying eigensolver for arbitrary eigenstate by designing, since an eigenstate for a Hamiltonian should have zero energy variance". Two consequences they state and this slot cares about. It is not selective — the variance is zero at EVERY eigenstate, so on its own it does not say which one was reached, and they find "optimization of a combination of energy and variance may be more efficient to find low-energy excited states than those of minimizing energy or variance alone". And it is expensive in the way any variance is, since it needs the square of the Hamiltonian; their answer is to stop evaluating all of it — "the optimization can be boosted with stochastic gradient descent by Hamiltonian sampling, which uses only a few terms of the Hamiltonian and thus significantly reduces the quantum resource for evaluating variance and its gradients".

Requires

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

Example

given  Hamiltonian H = sum_{i=1}^{N} c_i L_i, each L_i a tensor product of a
       few Pauli matrices (a "local term"), real coefficients c_i         (Sec. II A)
       ansatz |psi(theta)> = U(theta)|R>, the same parameterized-circuit
       form used for energy-minimizing VQE                                (Sec. II A)
       initial parameters theta_0, learning rate eta, iteration count T

requires  every element of the covariance matrix built below is obtainable
    as a measurement on the quantum processor -- "Note that each element of
    G(theta) can be obtained on a quantum computer"                       (Sec. II B)
    # the paper draws no further conclusion from that sentence. Reading it
    #   as "the method never forms a classical description of H^2" is a
    #   gloss on it, not a claim the paper states anywhere

# --- cost function: the energy VARIANCE, not the energy ---------------------
Delta(theta) = <psi(theta)| H^2 |psi(theta)> - <psi(theta)|H|psi(theta)>^2   (Eq. 2)
    # chosen because it "is zero only for eigenstates and positive for
    #   others" -- so it is zero at EVERY eigenstate, not only the ground
    #   state: "As all eigenstates always have zero variance, optimizing
    #   variance-VQE by minimizing energy variance may lead to any
    #   eigenstate"                                                (Sec. III, Sec. II A)
    # so Delta(theta)=0 certifies that SOME eigenstate was reached; it
    #   does not by itself pick which one -- see the closing note

# --- reduce the cost function to a measurable bilinear form -----------------
G_ij(theta) = <L_i L_j>_theta - <L_i>_theta <L_j>_theta                     (Eq. 3)
Delta(theta) = c^T G(theta) c   [>= 0 since G(theta) is positive semi-definite]  (Eq. 4)
    # each of the O(N^2) entries of G(theta) is measured on the quantum
    #   processor                                                          (Sec. II B)
    # this is the price of the objective: measuring H^2 this way costs
    #   O(N^2), against O(N) for the energy itself --
    #   "calculating energy variance costs O(N^2), which is larger than
    #   a cost of O(N) for calculating energy"                             (Sec. II B)

# --- gradient descent on the variance ----------------------------------------
# the paper presents this as one of two options, not the method: "Minimization
#   energy variance is carried with gradient free or gradient descents"     (Sec. II B)
for t = 1 .. T:
    dDelta(theta_{t-1})/dtheta = c^T ( dG(theta_{t-1})/dtheta ) c           (Eq. 5)
        # each dG_ij/dtheta is taken by numerical differentiation or the
        #   parameter-shift rule -- no closed form is assumed              (Sec. II B)
    theta_t = theta_{t-1} - eta * dDelta(theta_{t-1})/dtheta                (Eq. 6)
    # the paper's own H2 demonstration takes the gradient-free branch
    #   instead (Scipy's default optimizer) over randomly sampled theta_0;
    #   the update above is the form the paper derives explicitly, not the
    #   optimizer it runs there                                            (Sec. III A)

return  |psi(theta_T)>  and  Delta(theta_T)  as the self-verification value
# a small Delta(theta_T) (the paper's runs land below 1e-8) is evidence
#   theta_T sits on SOME eigenstate; under random theta_0 the run lands
#   on the ground state far less often than on an excited state --
#   "solutions to ground states are far less than excited states"          (Sec. III A)
# picking a PARTICULAR eigenstate is a separate construction, not part
#   of this objective: either a set of orthogonal ansatzs summed into
#   one weighted-variance cost (Eq. 7), or a mixed cost that adds the
#   energies back in (Eq. 10) -- "Here we develop another method, using
#   a set of orthogonal ansatz wavefunctions"                              (Sec. III B)
# cutting the O(N^2) measurement cost by Hamiltonian sampling at rate s
#   (which "can be reduced by a factor s^2", Eq. 12) is also a separate,
#   empirically-motivated addition: at small s "the variance ceases to
#   converge at small values... to solve this issue, we can turn to no
#   sampling (sampling rate s = 1) at the late stage of optimization" --
#   a numerical observation, not a proven convergence result              (Sec. IV)

Cost, as the source states it

Zhang, Yuan and Yin: for $H = \sum_{i=1}^{N} c_i L_i$ with $N$ Pauli-product terms, the energy variance $\Delta(\theta) = c^T G(\theta) c$ needs the $O(N^2)$ elements of $G_{ij} = \langle L_i L_j \rangle_\theta - \langle L_i \rangle_\theta \langle L_j \rangle_\theta$, so "calculating energy variance costs $O(N^2)$, which is larger than a cost of $O(N)$ for calculating energy" (Sec. II B). That counts distinct expectation values, not shots, and scales in the term count alone: no per-parameter circuit count is given, each $\partial G_{ij} / \partial \theta$ taken only "using numeral differential or the shift rule". Hamiltonian sampling at rate $s$ cuts the elements to $O(s^2 N^2)$, but their simulations, not a proof, confine that saving to the early stage: on 4-qubit $H_2$, $s = 0.1, 0.2$ match no sampling, then stall above zero, forcing $s = 1$ late. Nothing bounds the iteration count; the runs are gradient descent at $\eta = 0.05$ over 50 to 100 steps (Figs. 3-5), with 9 and 21 UCC parameters for $H_2$ and 6-qubit $H_4$.

Implementations

• Variance minimisation of the Lipkin-Meshkov-Glick spectrum on IBMQ manila and IBM nairobi

  • Variance Minimisation of the Lipkin-Meshkov-Glick Model on a Quantum Computer

  The abstract states the target and the claim together: "Here we present work in which we use a variance minimisation method to find the full spectrum of energy eigenvalues of the Lipkin-Meshkov-Glick model; an exactly-solvable nuclear shell model-type system", and "Using these IBM quantum computers we are able to obtain all eigenvalues for the cases of three and seven fermions (nucleons) in the Lipkin-Meshkov-Glick model." Section III makes the objective swap in one sentence — "Here, we adapt the typical VQA to seek the minimum of the variance of the Hamiltonian, $\sigma^2 = \langle H^2 \rangle - \langle H \rangle^2$" (Eq. 6) — and then states the same non-selectivity this record's own conditions carry, with a caveat the record does not carry: "The variance is a positive semi-definite function which is zero when the wave function is an eigenfunction of the Hamiltonian. Hence, its set of equally deep global minima will correspond to the set of eigenstates of the Hamiltonian, except possibly for accidental zeros of the variance which can be checked for." **The physics motivation is nuclear, not chemical.** The model is fixed at "$V/\epsilon = 0.5$ and $W/\epsilon = 0$" (Sec. IV A), "making the common choice to ignore the $W$ term which does not affect ground state correlations" (Sec. I), and the paper is explicit that it wants the whole spectrum, not a single excited state.

  The objective is the only change to the loop, and Sec. III prices it qualitatively: "This method allows the use of the same quantum circuit ansatzes as when using the VQE to find the ground state of $H$ directly, but requires additional circuit measurements to be performed for the terms in $\langle H^2 \rangle$. This increases the time taken to perform calculations but does not introduce any additional circuit depth or variational parameters to the calculations compared with an energy-minimizing ground state VQE." Both $H$ and $H^2$ reach the device as explicit Pauli sums printed in the paper: for $N = 3$, $H_{N=3A} = -0.5 - 1.0Z_0 - 0.8660254X_0$ (Eq. 9) and $H^2_{N=3A} = 2.0 + 0.8660254X_0 + 1.0Z_0$ (Eq. 13); for $N = 7$, Eq. 16 is a constant plus six Pauli strings and Eq. 18 a constant plus nine. **The paper states no circuit count anywhere, and the arithmetic on those equations is milder than it looks**: Sec. IV D's rule is "one circuit for each term in the Hamiltonians", and Eq. 16's set $\{X_1, Z_1, X_0X_1, Y_0Y_1, Z_0, Z_0X_1\}$ is a proper subset of Eq. 18's $\{X_1, Z_1, X_0, X_0X_1, X_0Z_1, Y_0Y_1, Z_0, Z_0X_1, Z_0Z_1\}$, so the variance needs nine distinct measurement circuits where the energy needs six, three more rather than nine more; for $N = 3$ the sets of Eqs. 9 and 13 are identical, $\{X_0, Z_0\}$, and the variance costs no circuit the energy has not already bought. That subset reading is arithmetic on the printed equations, and Sec. IV D's rule is stated for the $N = 3$ hardware runs, carried to $N = 7$ on Sec. V C's "again using 20,000 shots per circuit". The ansatz is a single $R_y(\theta)$ on one qubit for $N = 3$ (Fig. 2) and "a sufficiently general circuit for this case, with three parameters" on two qubits for $N = 7$ (Fig. 5). "In our implementation, we make use of the IBM qiskit environment to perform our VQE on real quantum hardware, as noted later where individual results are presented, using qiskit's classical COBYLA solver for the ansatz parameter optimisation" (Sec. III). Two mitigation layers sit under the hardware runs. Readout bias is corrected per iteration: "These additional circuits prepare a state that represents each possible output of the quantum computer, using Pauli X gates", two extra circuits for a single qubit, rebuilt "per iteration step of the VQE" so that "up-to-date corrections" are applied. For $N = 7$ only, Sec. V C adds "a method of CNOT mitigation" — identity-insertion zero-noise extrapolation — which "adds pairs of CNOT gates to the circuit where there is a CNOT present, allowing for a linear extrapolation to the theoretical case where there are no CNOT gates in the circuit". **One $N = 3$ hardware figure is not an optimisation at all**: Fig. 3 is "a parameter sweep, since this is feasible for a single parameter and will help visualise the results" (Sec. IV D), with the caption reporting 50 iteration steps; the iterative minimisations are Figs. 4 and 7.

  No dataset, and none is needed — every input is written out in the paper. The two inputs are the parity submatrices of the LMG Hamiltonian at $V/\epsilon = 0.5$, $W/\epsilon = 0$: the $2 \times 2$ pair of Eqs. 7 and 8 for $N = 3$ and the $4 \times 4$ matrix of Eq. 15 for $N = 7$, each with its square (Eqs. 11, 12 and 17) and its Pauli decomposition (Eqs. 9, 10, 13, 14, 16 and 18) printed alongside, "where we have kept more significant figures than given in the matrix representation" (Sec. IV A). The Pauli coefficients are not derived by hand: "For the given numerical Hamiltonians with particular values for the interaction strengths $V/\epsilon$ and $W/\epsilon$, the coefficients $\beta_i$ were found using a custom code [38]" (Sec. II). Ground truth is analytic rather than measured — the model is chosen "due to its exactly solvable nature" (Sec. I), the exact eigenvalues sit in the "Exact Value" column of Tables I and II, and Table III compares the recovered wavefunctions against the analytic solution's wavefunctions through the overlap $\langle \psi_A | \psi_{QC} \rangle^2$ (Eq. 19). No measurement record, circuit list or fitted parameter set is released.

  **The paper releases no repository of its own and carries no code- or data-availability statement.** It names two software artefacts it used, and a third only as an equivalent. The first is the framework: "the IBM qiskit environment" with "qiskit's classical COBYLA solver" (Sec. III), with no version pinned anywhere in the paper. The second covers the encoding step rather than the objective — "the coefficients $\beta_i$ were found using a custom code [38], whose functionality is also found in common quantum computing libraries (e.g. the pauli decompose method of PennyLane [39])" (Sec. II) — PennyLane being the third, named as an alternative rather than as something run. **Reference 38 is the H2ZIXY preprint, not a repository**: it reads "R. M. N. Pesce and P. D. Stevenson, H2ZIXY: Pauli spin matrix decomposition of real symmetric matrices (2021), arXiv:2111.00627", and that preprint's only statement about released code is "In the final version of the paper, the code will be linked to a repository associated with the journal". The code exists at https://github.com/pdstevenson/h2zixy, owned by one of the two authors and crediting both in its README — "written by Rocco Monteiro Nunes Pesce as a summer undergraduate project in 2021, and by Paul Stevenson" — but neither paper names that URL, so the link between reference 38 and this repository is an identification made here rather than one either source states. The repository holds two files, `README.md` and `h2zixy.py`, Python, 148 lines as read on 2026-08-27, last pushed 2022-10-30, no tags and no releases, **no LICENSE file and no licence header in the source**, with the GitHub API returning a null licence. Its single public entry point is `h2zixy(hamiltonian)`, documented as "Decompose square real symmetric matrix into Pauli spin matrices"; it pads the input to the next power of two, discards coefficients below a hard-coded `eps = 1.e-5`, generates "all combinations of I,X,Y,Z, excluding those with an odd number of Y matrices", and returns "a string consisting of terms each of which has a numerical coefficient multiplying a Kronecker (tensor) product of Pauli spin matrices" — a string, not an operator object, so the bridge from it into the Qiskit run is not itself published. **Nothing in either place implements the variance objective**: the loop of Sec. III exists in this work only as prose, equations and figures.

  Both hardware runs use 20,000 shots per circuit. For $N = 3$ on a single qubit, Table I gives exact value, measured variance and recovered energy for all four states of the two parity sectors: ground $-1.823$, variance $0.073$, $-1.788 \pm 0.062$; second excited $0.823$, $0.001$, $0.826 \pm 0.064$; first excited $-0.823$, $-0.004$, $-0.816 \pm 0.063$; third excited $1.823$, $0.001$, $1.810 \pm 0.063$ — **one of the four reported variances is negative**, at $-0.004$, for a quantity the paper has just called "a positive semi-definite function", which the paper does not comment on. For $N = 7$ on two qubits, Table II gives ground $-6.208$, $0.139$, $-6.067 \pm 0.901$; first $-2.944$, $0.016$, $-3.151 \pm 0.503$; second $1.208$, $0.010$, $1.184 \pm 0.484$; third $5.944$, $0.114$, $5.902 \pm 0.660$, and the text names the degradation and its cause: "these results are further from their respective exact solutions than the $N = 3$ results. This is likely due to the increase in circuit depth required to perform the calculations for the $N = 7$ case, as well as the additional qubit, resulting in greater gate error and noise within the circuit." Table III's overlaps against the analytic eigenvectors run $0.924$, $0.947$, $0.991$ and $0.972$ down the diagonal, and "the ground state introduces slightly more overlap with the first excited state, which could be due to only achieving a partial convergence in the time available for the run on real quantum hardware". **The hardware attribution for $N = 7$ is internally inconsistent and a reader should not resolve it silently**: Sec. V C says "Measurements for the $N = 7$ LMG excitation spectra were performed using the IBM nairobi quantum computer, again using 20,000 shots per circuit" and names nairobi again for Fig. 7, while Table II's own caption reads "$N = 7$ LMG model results calculated using the IBMQ manila quantum computer using 20000 shots"; the acknowledgment covers both — "In this paper we used IBMQ manilla and IBMQ nairobi, which are IBM Quantum Processors" — without saying which ran which. The device spelling is unstable across the paper too: "IMBQ manila" in Sec. IV D, "IBMQ manila" in the Table I and Table II captions, "IBMQ manilla" in the acknowledgment. The simulator arm is unnamed: Fig. 1 comes from minimisations "starting from random initial parameters, using noiseless simulations" (Sec. IV C) and Fig. 6 from noiseless simulations "also started from randomised initial parameters" (Sec. V B), and no backend, shot count or simulator package is given for either.

• `VVQE`, the Qiskit Aqua variance eigensolver written for a Midwest Summer Jam many-body-localization project

  **An artefact with no paper.** The repository README states the project and its framing: "Exploring MBL via VVQE & BBA — A Qiskit Summer Jam 2020 hackathon project", with the physics given as "in the quantum world there are phases of matter known as many-body localized (MBL) phases that do not equilibrate, like a never-cooling cup of coffee. In this hackathon, we wanted to study MBL using quantum computers." That is a different reason to want the variance objective than the chemistry excited-state argument the method is recorded from: this project aims at the middle of the spectrum rather than at the bottom of it, which its own code says outright — `combined_optimizer`'s docstring is "Combines the VQE and VVQE optimization processes to find an eigenstate with energy close to 0 with respect to a certain Hamiltonian H", and the committed drivers warm-start from a VQE run on $H^2$ rather than on $H$. The jam is identifiable from the repository itself: its presentation link points into HackerEarth's `qiskit-community-summer-jam-mid-west` challenge, the same challenge Qiskit's event repository lists under "Midwest Summer Jam" for "Michigan State University, University of Chicago, University of Michigan, and other Illinois & Michigan area schools" (`qiskit-community/qiskit-summer-jam-20`, `README.md`). **Whether this is the winning entry is an inference, not a record.** That README says "The winning team is QuarantineQbits with the project 'Exploring Localization and Excited States with VQE'", where this repository is titled "Exploring MBL via VVQE & BBA" and spells its team "Team: Quarantine Qubits" — a different project title, a different spelling, and a different HackerEarth submission id from the one the presentation URL carries; nothing in either file links the two. The listed members are Abid Khan, Ryan Levy, James Allen, Eli Chertkov and Di Luo.

  `src/vqe/vvqe.py` defines `class VVQE(VQAlgorithm, MinimumEigensolver)`, declared in its own header to be "a derivative work of the code at https://qiskit.org/documentation/_modules/qiskit/aqua/algorithms/minimum_eigen_solvers/vqe.html#VQE" with "Changes by Eli Chertkov, Ryan Levy 2020". The change is the cost function and its plumbing: the constructor computes `operator2 = square(operator)`, then overwrites the operator with `ListOp([self.operator, operator2])` under the comment "we can get two operators to be contracted at once using ListOp", and passes `cost_fn=self._variance_evaluation` up to `VQAlgorithm`. `_variance_evaluation` unpacks one sampler pass as `E,Var = np.real(sampled_expect_op.eval())[0]` and returns `mean_results = [means2[i] - means[i]**2.0 for i in range(len(means))]`. **So the objective is $\langle H^2 \rangle - \langle H \rangle^2$ read off two operator expectation values on the same bound circuit, not Zhang, Yuan and Yin's $O(N^2)$ quantum covariance matrix**, and $H^2$ is built classically before any circuit runs: `square()` in `src/vqe/hamiltonian.py` does `op2 = operator.compose(operator)`, then `op2.reduce().reduce()`, then `sum_duplicates` and `remove_zeros`, whose zero threshold defaults to `tol=1e-15`, so what is measured is a freshly collapsed Pauli sum. The ansatz is `sz_conserved_ansatz` in `src/vqe/variational_form.py`, which lays unparameterised $X$ gates to fix the total $S_z$ sector and then "applies an ExcitationPreserving circuit to parameterize the system without changing the total number of spin ups/downs". **Both committed drivers run two optimisations per disorder realisation, not one.** `results/vvqe/generate_data_statevector.py` first runs a stock Qiskit `VQE(H_squared, ansatz, SLSQP(maxiter=100))` from a random `initial_point`, then hands `vqe_results['optimal_point']` to `VVQE(H, ansatz, SLSQP(maxiter=500))`; minimising $\langle H^2 \rangle$ is a different objective from minimising the variance, and it is used here only as a warm start. `src/vqe/run_multiple_tests.py` reaches the same recipe by calling `combined_optimization.combined_optimizer` as its main loop, whose docstring states the intent: "Combines the VQE and VVQE optimization processes to find an eigenstate with energy close to 0 with respect to a certain Hamiltonian $H$. First uses VQE on $H^2$ to find an energy close to 0, then uses VVQE to refine the variance $\langle H^2 \rangle - \langle H \rangle^2$ and get as close to a real eigenstate of the Hamiltonian as possible." **Neither driver, exactly as committed, can have produced the whole released grid.** `generate_data_statevector.py` fixes `num_qubits = 4`, `reps = 2`, `entanglement = "sca"` and reads $W$ as `int(sys.argv[1])`, so it reaches only the eight integer-$W$, four-qubit, `rep2` pickles of the 55 committed; `run_multiple_tests.py` is the one that parses `Wrange = [float(Wpart) for Wpart in Wstring.split(',')]`, defaults to `num_qubits = 6` and `reps = 1` — the two commonest committed settings — and merges its per-trial files with `collect_pickles(base_name, out_name)` into the single per-setting pickles that are committed, but it sets `entanglement = 'full'` where every committed filename reads `sca`, and it writes four keys (`elapsed_time`, `reps`, `entanglement`, `Opt`) that the committed files' documented schema in `results/vvqe/readme.md` does not list. The released data therefore came from edited states of these drivers, and which file produced which pickle cannot be settled without unpickling them.

  No external dataset; every input is generated in the repository and committed beside the results. `src/vqe/hamiltonian.py` builds a one-dimensional open-boundary Heisenberg chain, `heisenberg1D`, documented as $\frac{1}{4}\sum_i (X_i X_{i+1} + Y_i Y_{i+1} + Z_i Z_{i+1})$, and adds `magnetic_fields`, $\frac{1}{2}\sum_i h_i Z_i$, scaled by a disorder strength $W$. The disorder is drawn once and frozen: `results/generate_disorder.py` sets `np.random.seed(42)` and writes 1000 realisations of `2.0*np.random.rand(num_qubits) - 1.0`, uniform on $[-1, 1]$, to `q4_1000potentials.pkl` and its text twin, with the same pair committed for 4, 6, 8 and 10 qubits; `results/README.md` states the design choice — "We fix the same disorder patterns (named `potentials` in the code) for all strengths `W`." Ground truth is committed exact diagonalisation rather than a literature value: `results/exact_diagonalization/` holds `ed_entropy_data_4_qubits.pkl`, `ed_entropy_data_6_qubits.pkl`, `ed_entropy_data_8_qubits.pkl` and one gzipped spectrum file for 4 qubits, and both readmes admit the set is truncated by GitHub's file limits — "large spectrum data not uploaded due to file size" and "(some files are too large for github, email for more)"; the folder's own readme also documents an `ed_entropyData_df.pkl.gz` DataFrame that is not in the tree. Both `results/vvqe/` drivers and the test re-check the classical construction in-line with `assert(np.allclose(np.sort(np.abs(evals)**2.0), evals2))`, i.e. that the eigenvalues of the classically formed $H^2$ really are the squares of those of $H$; `src/vqe/run_multiple_tests.py` does not, its only assertion being `assert len(potential) == num_qubits`.

  https://github.com/abid1214/mbl-vvqe-bba, default branch `master`, Python and Jupyter, 108 files, last push 2021-03-17 as commit `dbed18c`, "Update README.md to include links", with no tags and no releases; read 2026-08-27. **The licence position needs stating precisely rather than summarising.** The repository has no LICENSE file and the GitHub API returns a null licence for it, yet `src/vqe/vvqe.py` opens with the notice it inherited from Qiskit — "(C) Copyright IBM 2018, 2020. Changes by Eli Chertkov, Ryan Levy 2020. This code is licensed under the Apache License, Version 2.0. You may obtain a copy of this license in the LICENSE.txt file in the root directory of this source tree or at http://www.apache.org/licenses/LICENSE-2.0" — and no `LICENSE.txt` exists in that root. The files a reader should open, with line counts read on 2026-08-27: `src/vqe/vvqe.py`, 582 lines (`class VVQE`, `_variance_evaluation`, `construct_circuit`, `get_optimal_cost`, `VVQEResult`); `src/vqe/hamiltonian.py`, 145 lines (`heisenberg1D`, `magnetic_fields`, `sum_duplicates`, `remove_zeros`, `square`); `src/vqe/variational_form.py`, 67 lines (`sz_conserved_ansatz`); `src/vqe/combined_optimization.py`, 129 lines (`combined_optimizer`, `random_initial_point`, `expectation`, `attach_parameters`, `get_vector_from_circuit`); the three drivers `results/vvqe/generate_data_statevector.py`, 101 lines, `results/vvqe/generate_data_qasm.py`, 124 lines, and `src/vqe/run_multiple_tests.py`, 133 lines (`collect_pickles`, `random_disordered_hamiltonian`); and the test `src/vqe/tests/test_vvqe.py`, 59 lines. The last commit to touch the algorithm file is `88d4199`, "use new H^2 in VVQE", 2020-06-27, the day after `4a554ca`, "add working VVQE", 2020-06-26 — the code is the hackathon week's, and the 2021 commit only edited the README. **It is very unlikely to install against a current Qiskit, though nothing was executed for this entry.** The README pins "This was built using Qiskit version 0.19.6"; every algorithm, operator and optimizer import is from `qiskit.aqua` (`qiskit.aqua.operators`, `qiskit.aqua.components.optimizers`, `qiskit.aqua.algorithms.vq_algorithm`), whose distribution's last PyPI release is 0.9.5, uploaded 2021-09-08 (read 2026-08-27); and the non-`aqua` Qiskit imports that remain are themselves removed API — `from qiskit.providers import BaseBackend` and `from qiskit.quantum_info.operators.pauli import Pauli` used as `Pauli(label=...)`.

  **There is no paper, so the numbers are the committed artefacts and the tests, and neither is a performance claim.** `results/vvqe/` holds 55 pickled runs named `W[#]_q[#]_VVQE_SLSQP_sca_rep[#].pkl`, covering $W$ in $\{1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 6, 7, 8, 9, 10\}$, 4, 6, 8 and 10 qubits and `reps` 1 and 2 — 55 of a possible 112, an incomplete grid rather than a full sweep — each file a list of per-realisation dictionaries whose keys `results/vvqe/readme.md` gives as `W`, `opt_params`, `statevector`, `E`, `Var`, `fidelity`. `results/overlap/` holds eight more, the entanglement-entropy side the MBL question actually turns on: `qc_dict_q{4,6,8,10}_VVQE_SLSQP_sca_rep2.pkl`, 3.2 to 37.8 MB, "a dictionary of lists of QuantumCircuit objects" keyed by $W$, and `sw_ent_dict_list_q{4,6,8,10}_VVQE_SLSQP_sca_rep2.pkl`, "a list of dictionary of lists of second renyi entropies" indexed by the cut position (`results/overlap/datatype.txt`). None of them were unpickled here; they are Qiskit 0.19.6 objects. The only numeric assertions the repository makes about its own output are in `src/vqe/tests/test_vvqe.py`, on a two-qubit chain at $W = 5.0$ under `np.random.seed(42)` with `SLSQP(maxiter=500)` on Aer's `statevector_simulator`: `assert abs(variance-opt_result1['optimal_value']) < 1e-8` (the returned cost really is the variance of the returned state), then `assert 0.5 > variance > 0` and `assert fidelity<1 and fidelity > 0.9`. **The acceptance bar is a fidelity above $0.9$ and a strictly positive variance below $0.5$ — the test does not require the run to reach an eigenstate**, and its comments record what the target was: "Eigenvalue of $H$ closest to zero is $0.01933818$" and "Eigenvalue of $H^2$ closest to zero is $3.73965165 \times 10^{-4}$". **No hardware anywhere, and no shot noise in the committed numbers either.** Every committed result file carries the `SLSQP` statevector naming; nothing named `qasm8192` was ever committed, so `generate_data_qasm.py` produced none of the released data. That driver also carries two defects a reuser should see first: `useCOBYLA = True` selects `SPSA()` for both optimisers while the output filename is built as `("COBYLA" if useCOBYLA else "SPSA")`, so a run would be labelled COBYLA and be SPSA; and although the optimisation itself runs on `QuantumInstance(Aer.get_backend("qasm_simulator"), shots=8192, backend_options={'method': "statevector"})`, the `energy`, `variance` and `fidelity` written out are recomputed exactly from a separate `statevector_simulator` execution of the optimal circuit, so even its recorded numbers would carry no sampling error.

What it needs

Nobody has taken this apart yet. That is a gap in this graph, not a claim that the method has no parts.

Other ways to fill the same slot

Different approaches

• Conditional-value-at-risk objective

  Change what the classical loop is minimising rather than how it minimises. Instead of averaging every measurement outcome into an expectation value, keep only the best tail of them and average that — which is defensible precisely when the answer is a single good bitstring rather than a physical average.

• Analytic-gradient parameter search

  Get the gradient of the objective exactly, rather than by finite differences, by running the same circuit again at shifted parameter values. The direction is then not an estimate of a slope taken from two noisy numbers; it is the slope, estimated to whatever precision the shots allow.

• Follow the steepest descent in the state's own geometry

  Take the step that moves the state fastest, not the one that moves the parameters fastest. The two differ because equal changes in parameters do not make equal changes in the state, and the metric measuring that difference has to be estimated before every step.

• Grow the circuit a layer at a time while training it

  Do not settle the circuit before optimising it. Start shallow, train what is there, then hold most of it fixed and add the next layer on top — so every step of the search runs on a shallow circuit with few free parameters, which is where a gradient is still large enough to follow.

• Simultaneous-perturbation optimization

  Perturb every parameter at once, in one random direction, and take the difference of two objective evaluations as the gradient estimate. The estimate is bad in any single round and unbiased across rounds, so the cost of a step stops growing with the number of parameters.

In the Atlas

• Variance-minimizing VQE

  Hamiltonian variance supplements or replaces energy to target eigenstates and diagnose convergence.

Sources

• Variational quantum eigensolvers by variance minimization↗Dan-Bo Zhang, Zhan-Hao Yuan, Tao Yin · 2020theory yes · simulation yes · hardware no