variational advanced · 14 min read · May 1, 2026

Imaginary-Time Evolution: How Quantum Algorithms Find Ground States

Imaginary-time evolution is a classical numerical technique for finding ground states: replace t with -i*t in the Schrödinger equation, and the wavefunction projects onto the ground state exponentially fast. Quantum analogs — variational imaginary-time evolution (VITE), quantum imaginary time evolution (QITE), and the deep connection to quantum natural gradient (tutorial 40) — are now central to ground-state quantum algorithms. This tutorial covers the math, the algorithms, and the regimes where each variant shines.

Prerequisites: Tutorial 13: Variational Quantum Eigensolver, Tutorial 40: Quantum Natural Gradient

In classical quantum chemistry, the most common technique for finding the ground state of a Hamiltonian is imaginary-time evolution. Replace the time variable $t$ in the Schrödinger equation with $-i \tau$ :

\frac{\partial |\psi\rangle}{\partial \tau} \;=\; -H |\psi\rangle.

The solution is $|\psi(\tau)\rangle = e^{-H \tau} |\psi(0)\rangle$ . As $\tau \to \infty$ , the lowest-energy component dominates exponentially, and after normalization $|\psi(\tau)\rangle$ projects onto the ground state. This is the engine behind density-matrix renormalization group (DMRG), tensor-network ground-state methods, and many other classical algorithms.

The structural problem for quantum computing: $e^{-H \tau}$ is not unitary. Quantum computers can only do unitaries directly. Implementing imaginary-time evolution requires either probabilistic protocols (like LCU, tutorial 59) or variational approximations.

Two main quantum analogs:

Variational imaginary-time evolution (VITE): evolve the parameters of an ansatz to track imaginary-time-evolved states. Connected directly to quantum natural gradient (tutorial 40).
Quantum imaginary time evolution (QITE): McArdle-Yamamoto-Yuan-Endo-Benjamin 2019. Use measurement-based reconstruction to apply an effectively non-unitary operation.

This tutorial covers both, the deep connection to quantum natural gradient, and a decision rule for which variant fits which problem.

Classical imaginary-time evolution

For a Hamiltonian $H$ with eigendecomposition $H = \sum_k E_k |\phi_k\rangle\langle \phi_k|$ , the imaginary-time-evolved state is

|\psi(\tau)\rangle \;=\; \frac{e^{-H \tau} |\psi(0)\rangle}{\| e^{-H \tau} |\psi(0)\rangle \|} \;=\; \frac{\sum_k c_k e^{-E_k \tau} |\phi_k\rangle}{\sqrt{\sum_k |c_k|^2 e^{-2 E_k \tau}}}.

The component with the lowest energy $E_0$ decays slowest. As $\tau$ grows, all components except the ground-state one decay exponentially relative to the ground state. Convergence is exponential at rate $E_1 - E_0$ (the gap to the first excited state).

For ill-conditioned Hamiltonians (small gap), convergence is slow. For typical chemistry molecules (gap $\sim 1-10$ Hartree), $\tau \sim 1-10$ is enough to reach near-ground-state.

VITE: variational imaginary-time evolution

The McLachlan variational principle (1964) gives the best parameter trajectory $\boldsymbol{\theta}(\tau)$ such that the variational state $|\psi(\boldsymbol{\theta}(\tau))\rangle$ approximates the imaginary-time-evolved state $e^{-H \tau} |\psi(\boldsymbol{\theta}(0))\rangle / \|\cdot\|$ .

The McLachlan equation:

\sum_j A_{ij} \dot{\theta}_j \;=\; -C_i,

where:

$A_{ij} = \mathrm{Re}\bigl[ \langle \partial_i \psi | \partial_j \psi \rangle - \langle \partial_i \psi | \psi \rangle \langle \psi | \partial_j \psi \rangle \bigr]$ — the quantum Fisher information matrix (tutorial 40, divided by 4).
$C_i = \mathrm{Re}\bigl[ \langle \partial_i \psi | H | \psi \rangle - \langle \partial_i \psi | \psi \rangle \langle \psi | H | \psi \rangle \bigr]$ — the gradient of the energy (tutorial 39 parameter-shift terms).

The connection: the McLachlan equation is exactly the quantum natural gradient flow with the Hamiltonian as the cost function. Solving the McLachlan ODE step by step is exactly running QNG with infinitesimal step size.

This means: QNG-based VQE is, in continuous-time, imaginary-time evolution of the variational ansatz. The two methods are different discretizations of the same continuous flow. QNG with finite step size is a forward-Euler discretization; backward-Euler or adaptive step-size discretizations exist and are sometimes preferred for stiff problems.

QITE: quantum imaginary time evolution

VITE is variational — it works only as well as the ansatz allows. For situations where you want to implement exact imaginary-time evolution on a quantum computer, the McArdle-Yamamoto-Yuan-Endo-Benjamin 2019 paper introduced QITE.

The QITE algorithm:

Decompose $H = \sum_i h_i$ into local terms (e.g., Pauli strings).
Apply imaginary-time evolution one term at a time: $|\psi\rangle \to e^{-h_i \delta\tau} |\psi\rangle / \|\cdot\|$ for each $h_i$ in sequence.
For each step, $e^{-h_i \delta\tau}$ is non-unitary. Approximate it by a unitary $e^{-i A_i \delta\tau}$ where $A_i$ is a Hermitian operator chosen to match the imaginary-time-evolved state. The choice of $A_i$ is determined by a small linear system involving the local Hamiltonian and current state.
Apply the unitary $e^{-i A_i \delta\tau}$ to the state. Repeat for all terms.
After many sweeps, the state approximates the imaginary-time-evolved state.

The key trick: the unitary $e^{-i A_i \delta\tau}$ can be constructed at run-time using measurements of the current state. The measurement step is what allows non-unitary effects on the quantum state.

QITE is exact in the limit of small $\delta\tau$ and small support for $A_i$ . It is more expensive per step than VITE but doesn’t require an ansatz; the state is held in the full Hilbert space.

When to use which

VITE (= QNG-based variational evolution):

Works with any parameterized ansatz; cheaper per step.
Limited by ansatz expressivity — won’t reach states the ansatz can’t represent.
Best for problems where you have a good problem-tailored ansatz (chemistry: UCCSD or ADAPT-VQE).

QITE:

Works in the full Hilbert space; not limited by an ansatz.
More expensive per step (measurement-based reconstruction of the unitary).
Best for problems where ansatz design is hard or where you want exact imaginary-time evolution.

Static VQE (no imaginary-time):

Just minimizes the energy by gradient descent or other optimizers.
Doesn’t track an imaginary-time trajectory.
Often faster to converge in practice if the optimizer is well-tuned.

For most production chemistry work in 2026, static VQE with a problem-tailored ansatz (UCCSD or ADAPT-VQE) is the default. VITE is used when QNG-style optimization stability is needed. QITE is mostly research-stage.

Connection to the broader picture

The deep insight from this tutorial: imaginary-time evolution provides a unifying continuous-time framework for many ground-state algorithms.

VQE is a discretization of imaginary-time evolution if you use QNG.
Adiabatic quantum computing is a slow-then-fast version of imaginary-time evolution along a Hamiltonian path.
Tensor-network methods (DMRG, MERA optimization) are imaginary-time evolution in tensor-network representation.
Ground-state algorithms based on signal processing (the QSVT-based ground-state preparation) implement imaginary-time evolution exponentials directly via polynomial approximation.

Each method picks a different way to implement the abstract $e^{-H \tau}$ operator. Understanding the imaginary-time-evolution lens gives a unified way to compare them.

A small VITE demonstration

Concrete code that runs VITE on a 2-qubit Hamiltonian using PennyLane’s QNGOptimizer:

import numpy as np
import pennylane as qml
from pennylane import numpy as pnp

n_qubits = 2
dev = qml.device("default.qubit", wires=n_qubits)

H = qml.Hamiltonian(
    [1.0, -0.5, 0.5],
    [qml.PauliZ(0), qml.PauliZ(0) @ qml.PauliZ(1), qml.PauliX(1)]
)


@qml.qnode(dev, interface="autograd")
def ansatz(weights):
    qml.RY(weights[0], wires=0)
    qml.RY(weights[1], wires=1)
    qml.CNOT(wires=[0, 1])
    qml.RY(weights[2], wires=0)
    qml.RY(weights[3], wires=1)
    return qml.expval(H)


# QNG optimizer is essentially VITE in continuous time.
qng_opt = qml.QNGOptimizer(stepsize=0.1)
weights = pnp.array([0.5, 0.5, 0.5, 0.5], requires_grad=True)

print("Step | Energy")
for step in range(50):
    weights, energy = qng_opt.step_and_cost(ansatz, weights)
    if step % 10 == 0:
        print(f"{step:4d} | {float(energy):.6f}")

print(f"Final energy: {ansatz(weights):.6f}")
print(f"Exact ground-state energy: {min(np.linalg.eigvalsh(qml.matrix(H))):.6f}")

The QNG optimizer converges quickly to the ground-state energy. The trajectory it follows is the discretized imaginary-time evolution of the ansatz.

Common misconceptions

“Imaginary-time evolution doesn’t work on quantum computers.” It works — just not directly as a unitary. VITE and QITE are practical implementations.

“VITE and static VQE are different algorithms.” VITE is QNG-based VQE in continuous-time limit. The difference is the optimizer choice and discretization strategy, not the algorithm.

“QITE is always better than VITE.” It’s exact in the Hilbert space but expensive. For problems with good ansätze, VITE is more efficient.

“Imaginary-time evolution gives exact ground states.” Only in the infinite-time limit. At finite $\tau$ , it’s an approximation. Convergence speed depends on the gap; small-gap problems require long $\tau$ .

Where this goes next

Tutorial 66 covers Hamiltonian variational ansatz design — the discipline of choosing parameterized ansätze that exploit the structure of the target Hamiltonian, often providing better starting points for VITE/VQE. Tutorial 67 covers warm-start strategies that initialize variational algorithms in good regions of parameter space, dramatically improving convergence.