Hamiltonian Simulation

Every quantum system evolves according to the Schrodinger equation. Given a Hamiltonian $H$ describing the system’s energy, the state at time $t$ is obtained by applying the time evolution operator $e^{-iHt}$ to the initial state. For a classical computer, computing this operator exactly requires working with exponentially large matrices. A quantum computer, being itself a quantum system, can implement $e^{-iHt}$ directly as a quantum circuit of manageable size. Hamiltonian simulation is the formal task of building that circuit, and it is the engine underneath almost every quantum algorithm for chemistry, materials science, and quantum field theory.

The details

The Schrodinger equation in natural units ($\hbar = 1$) is:

$i\frac{d}{dt}|\psi(t)\rangle = H|\psi(t)\rangle$

whose solution is $|\psi(t)\rangle = e^{-iHt}|\psi_0\rangle$. For an $n$-qubit system, $H$ is a $2^n \times 2^n$ Hermitian matrix. Diagonalising it classically requires $O(2^{3n})$ time. A quantum computer with $n$ qubits can represent $|\psi\rangle$ natively and apply $e^{-iHt}$ without ever forming the full matrix.

Trotterization is the oldest and most widely used simulation method. Most physically relevant Hamiltonians decompose as sums of local terms:

$H = \sum_{k=1}^{L} H_k$

Each $H_k$ acts on only a few qubits and is straightforward to exponentiate as a short quantum circuit. The first-order Trotter-Suzuki formula approximates:

$e^{-iHt} \approx \left(\prod_{k=1}^{L} e^{-iH_k t/n}\right)^n$

with error $O(Lt^2/n)$, controllable by increasing $n$ (the number of Trotter steps). The second-order symmetric formula:

$e^{-iHt} \approx \left(\prod_{k=1}^{L} e^{-iH_k t/(2n)} \prod_{k=L}^{1} e^{-iH_k t/(2n)}\right)^n$

halves the error prefactor and is widely used in practice. Higher-order ($2k$-th order) Trotter formulae achieve error $O(t^{2k+1}/n^{2k})$ at the cost of more exponentials per step.

import numpy as np
from qiskit.synthesis import SuzukiTrotter
from qiskit.quantum_info import SparsePauliOp

# Transverse-field Ising model: H = -J sum Z_i Z_{i+1} - h sum X_i
n = 4
J, h = 1.0, 0.5

zz_terms = [("ZZ", [i, i+1], -J) for i in range(n - 1)]
x_terms  = [("X",  [i],       -h) for i in range(n)]
H = SparsePauliOp.from_sparse_list(zz_terms + x_terms, num_qubits=n)

# Build a second-order Trotter circuit for time t with r steps
t, r = 1.0, 10
synthesiser = SuzukiTrotter(order=2, reps=r)
evo_circuit = synthesiser.synthesize(H * t)
print(evo_circuit.depth())

Qubitisation and quantum signal processing (QSP) are asymptotically superior alternatives developed after 2016. Qubitisation block-encodes $H$ in a larger unitary; QSP then applies a polynomial transformation to synthesise $e^{-iHt}$ with gate count $O(\lambda t + \log(1/\epsilon))$, where $\lambda$ is the one-norm of $H$. This is asymptotically optimal and can reduce circuit depth by orders of magnitude over Trotter for large molecules.

In second quantisation (standard for chemistry), the Hamiltonian is mapped to qubits via Jordan-Wigner or Bravyi-Kitaev transformations (one qubit per spin-orbital); first quantisation encodes particle positions on a spatial grid with better qubit scaling but more complex circuits. Hamiltonian simulation underlies quantum phase estimation: QPE uses controlled-$U(t)$ to extract eigenvalues of $H$ to chemical accuracy on fault-tolerant hardware.

Why it matters for learners

Hamiltonian simulation is arguably the most important subroutine in fault-tolerant quantum computing. It underlies quantum simulation of molecules and materials, quantum phase estimation, and quantum field theory applications. Virtually every quantum advantage claim in chemistry traces to how efficiently $e^{-iHt}$ can be implemented.

The gap between Trotter and qubitisation-based methods shows why algorithmic research matters: it translates directly into orders-of-magnitude differences in physical qubit counts. The algorithm also connects to VQE, which sidesteps $e^{-iHt}$ via a variational ansatz, and to adiabatic quantum computing, where slow time evolution is the computation.

Common misconceptions

Misconception 1: Trotterization error can always be made arbitrarily small by adding more steps. In theory yes; in practice, more Trotter steps mean deeper circuits and more gate errors. Past a device-specific optimum, accumulated hardware noise exceeds the Trotter error, so the best step count must be tuned to the device’s noise rates.

Misconception 2: Hamiltonian simulation and quantum simulation are the same thing. Hamiltonian simulation is the specific subroutine of implementing $e^{-iHt}$ as a circuit. Quantum simulation is the broader task of learning properties of a quantum system, which may use this subroutine but also includes VQE and other methods that never directly implement $e^{-iHt}$.

Misconception 3: The Hamiltonian must be sparse for quantum simulation to work. Sparse Hamiltonians are the easiest case, and most physically relevant ones (local condensed-matter interactions, few-body chemistry terms) are sparse. But qubitisation and block encoding techniques apply to denser Hamiltonians, and research is extending simulation methods to the dense cases arising in quantum field theory.

See also

• Quantum Simulation
• Variational Quantum Eigensolver
• Quantum Fourier Transform
• Adiabatic Quantum Computing
• Fault-Tolerant Quantum Computing