qcr:2606.40511.1

Variational Quantum Deflation (VQD)

The Variational Quantum Deflation (VQD) algorithm extends the Variational Quantum Eigensolver (VQE) to compute not just the ground state but also higher excited states of a Hamiltonian, and this Qiskit tutorial implements it with the algorithms library. While VQE finds only the lowest eigenvalue, many problems in chemistry and physics require excited-state energies, for example to predict spectra or reaction pathways. VQD finds the k lowest eigenstates sequentially: after computing the ground state, it adds a penalty (deflation) term that pushes the optimization away from already-found states, so each subsequent variational optimization converges to the next-higher eigenstate that is orthogonal to the previous ones. The tutorial shows how to configure VQD in Qiskit with an ansatz, an optimizer, and the Estimator primitive, set the number of states to find and the penalty weights (betas) that enforce orthogonality, run the algorithm, and read back the array of eigenvalues and their optimal parameters. It explains how the betas must be chosen large enough to separate states without destabilizing the optimization. It is a practical, worked guide to extracting excited-state energies on near-term quantum hardware with Qiskit.

Qubit

Circuit-based

Uploaded 3 days ago

Views

View Publication

GitHub

183

Citing this entry? Use this QCR ID

qiskit-community/qiskit-algorithms

183

In [ ]:

# --- Setup cell added by QCR (not part of the original tutorial) ---
# Source: qiskit-community/qiskit-algorithms @ 0.4.0, Apache License 2.0.
# Installs the example's dependencies. If a later cell still reports a missing
# package, restart the runtime/kernel and run again from the top.
%pip install -q qiskit-algorithms==0.4.0 qiskit-aer matplotlib pylatexenc qiskit-algorithms

Variational Quantum Deflation (VQD) Algorithm

This notebook demonstrates how to use our implementation of the Variational Quantum Deflation (VQD) algorithm for computing higher energy states of a Hamiltonian, as introduced in this reference paper.

Introduction

VQD is a quantum algorithm that uses a variational technique to find the k lowest eigenvalues of the Hamiltonian H of a given system.

The algorithm computes excited state energies of generalized hamiltonians by optimizing over a modified cost function. Each successive eigenvalue is calculated iteratively by introducing an overlap term with all the previously computed eigenstates that must be minimized. This ensures that higher energy eigenstates are found.

Complete working example for VQD

The first step of the VQD workflow is to create a qubit operator, ansatz and optimizer. For this example, you can use the H2 molecule, which should already look familiar if you have completed the previous VQE tutorials:

In [1]:

from qiskit.quantum_info import SparsePauliOp

H2_op = SparsePauliOp.from_list(
    [
        ("II", -1.052373245772859),
        ("IZ", 0.39793742484318045),
        ("ZI", -0.39793742484318045),
        ("ZZ", -0.01128010425623538),
        ("XX", 0.18093119978423156),
    ]
)

You can set up, for example, a n_local ansatz with two qubits, and choose SLSQP as the optimization method.

In [2]:

from qiskit.circuit.library import n_local
from qiskit_algorithms.optimizers import COBYLA

ansatz = n_local(2, rotation_blocks=["ry", "rz"], entanglement_blocks="cz", reps=1)

optimizer = COBYLA()
ansatz.draw("mpl")

The next step of the workflow is to define the required primitives for running VQD. This algorithm requires two different primitive instances: one Estimator for computing the expectation values for the "VQE part" of the algorithm, and one Sampler. The sampler will be passed along to the StateFidelity subroutine that will be used to compute the cost for higher energy states. There are several methods that you can use to compute state fidelities, but to keep things simple, you can use the ComputeUncompute method already available in qiskit_algorithm.state_fidelities.

In [3]:

from qiskit.primitives import StatevectorSampler, StatevectorEstimator
from qiskit_algorithms.state_fidelities import ComputeUncompute
from qiskit_algorithms.utils import algorithm_globals

algorithm_globals.random_seed = 42

estimator = StatevectorEstimator(seed=42)
sampler = StatevectorSampler(seed=42)
fidelity = ComputeUncompute(sampler)

In order to set up the VQD algorithm, it is important to define two additional inputs: the number of energy states to compute (k) and the betas defined in the original VQD paper. In this example, the number of states (k) will be set to three, which indicates that two excited states will be computed in addition to the ground state.

The betas balance the contribution of each overlap term to the cost function, and they are an optional argument in the VQD construction. If not set by the user, they can be auto-evaluated for input operators of type SparsePauliOp. Please note that if you want to set your own betas, you should provide a list of values of length k.

In [4]:

k = 3
betas = [3, 3, 3]

You are almost ready to run the VQD algorithm, but let's define a callback first to store intermediate values:

In [5]:

counts = []
values = []
steps = []


def callback(eval_count, params, value, meta, step):
    counts.append(eval_count)
    values.append(value)
    steps.append(step)

You can finally instantiate VQD and compute the eigenvalues for the chosen operator.

In [6]:

from qiskit_algorithms import VQD

vqd = VQD(estimator, fidelity, ansatz, optimizer, k=k, betas=betas, callback=callback)
result = vqd.compute_eigenvalues(operator=H2_op)
vqd_values = result.eigenvalues

You can see the three state energies as part of the VQD result:

In [7]:

print(vqd_values.real)

[-1.85727501 -1.24519007 -0.8838798 ]

And we can use the values stored by the callback to plot the energy convergence for each state:

In [8]:

import numpy as np
import pylab

pylab.rcParams["figure.figsize"] = (12, 8)

steps = np.asarray(steps)
counts = np.asarray(counts)
values = np.asarray(values)

for i in range(1, 4):
    _counts = counts[np.where(steps == i)]
    _values = values[np.where(steps == i)]
    pylab.plot(_counts, _values, label=f"State {i-1}")

pylab.xlabel("Eval count")
pylab.ylabel("Energy")
pylab.title("Energy convergence for each computed state")
pylab.legend(loc="upper right");

This molecule can be solved exactly using the NumPyEigensolver class, which will give a reference value that you can compare with the VQD result:

In [9]:

from qiskit_algorithms import NumPyEigensolver


exact_solver = NumPyEigensolver(k=3)
exact_result = exact_solver.compute_eigenvalues(H2_op)
ref_values = exact_result.eigenvalues

Let's see a comparison of the exact result with the previously computed VQD eigenvalues:

In [10]:

print(f"Reference values: {ref_values}")
print(f"VQD values: {vqd_values.real}")

Reference values: [-1.85727503 -1.24458455 -0.88272215]
VQD values: [-1.85727501 -1.24519007 -0.8838798 ]

As you can see, the result from VQD matches the values from the exact solution, and extends VQE to also compute excited states.

In [11]:

import tutorial_magics

%qiskit_version_table
%qiskit_copyright

Version Information

Software	Version
`qiskit`	2.0.2
`qiskit_algorithms`	0.4.0
System information
Python version	3.13.5
OS	Linux
Sun Jul 20 19:49:34 2025 CEST

This code is a part of a Qiskit project

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.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.

Join the Discussion

Comments (0)

No comments yet. Be the first to share your thoughts!

Publication

doi:10.48550/arxiv.1805.08138

Variational Quantum Computation of Excited States

Oscar Higgott, Daochen Wang, Stephen Brierley

Versions

v1 Latest

Jun 16, 2026

qcr:2606.40511.1

Cite all versions? Use the base QCR ID to always reference the latest version of this entry.

Tools used

Qiskit

Keywords

vqd

excited-states

variational

qiskit

deflation