Why chemistry is a natural target
In 1981, at a conference at MIT, Richard Feynman pointed out that simulating quantum mechanics on a classical computer seems to need resources that grow exponentially with the size of the system, and asked whether a computer built from quantum parts could do better. Chemistry is the obvious customer. Everything in Quantum mechanics for chemists and Molecular orbitals comes down to the electronic Schrödinger equation, and the exact solution within a basis of orbitals — full configuration interaction (FCI) — is a linear combination of every way of placing the electrons in the orbitals. For spin-up and spin-down electrons that is
determinants, a number that grows roughly exponentially with the size of the molecule. Twenty-odd electrons in twenty-odd orbitals already needs trillions of coefficients, as you will compute below.
Yet most of chemistry is not stuck. Computational chemistry showed why: density functional theory, coupled cluster with perturbative triples, CCSD(T), and their many relatives scale polynomially and are accurate whenever one electronic configuration dominates the wavefunction. They struggle when several configurations matter at once — strong (static) correlation — which is exactly what happens in stretched and breaking bonds, in many excited states, and in clusters of transition-metal ions with partly filled d shells. Those are not exotic cases. They include the iron–molybdenum cofactor (FeMoco) at the heart of nitrogenase, the enzyme with which bacteria fix atmospheric nitrogen at room temperature, while industry needs the high temperatures and pressures of the Haber–Bosch process; the iron–porphyrin site of cytochrome P450 enzymes, which metabolise a large share of medicines; and many catalysts and battery materials.
The appeal of a quantum computer is a matching of sizes. A register of qubits has a state space of dimension , growing exactly as fast as the space the wavefunction lives in: one qubit per spin orbital holds every determinant at once. The hard question, which the rest of this lesson is about, is not storing the wavefunction but getting a number out of it.
From orbitals to qubits
A qubit is a two-level quantum system with basis states and ; a register of qubits has the basis states and can be in any normalised superposition of them. Its natural operators are the Pauli matrices
and tensor products of them, Pauli strings such as (written ), which form a basis for all operators on the register.
Chemistry enters through second quantisation. Choose spin orbitals (for example the molecular orbitals of a Hartree–Fock calculation, each with spin α or β). A determinant is then specified by which spin orbitals are occupied, an occupation-number string like , and the Hamiltonian is written with operators and that add and remove an electron in spin orbital :
The one-electron integrals (kinetic energy and attraction to the nuclei) and the two-electron integrals (electron repulsion) are the same numbers a classical program computes; everything chemical is in them.
Definition— Jordan–Wigner transformation
The Jordan–Wigner transformation (Pascual Jordan and Eugene Wigner, 1928) represents spin orbital by qubit , with meaning occupied, and the annihilation operator by
The string of operators supplies the sign that fermions need: it counts, with a sign, the occupied orbitals "before" , which is how the antisymmetry of the electronic wavefunction from Quantum mechanics for chemists is imposed on qubits, which are not fermions. Substituting into turns it into a weighted sum of Pauli strings, , of which there are .
Two remarks keep the picture honest. First, the qubit count is modest — twice the number of spatial orbitals — but the number of Pauli terms grows as the fourth power, and every term must be measured or simulated. Second, other encodings exist (the Bravyi–Kitaev and parity mappings) that trade the long strings for other overheads, and symmetries such as particle number and spin let one remove qubits altogether, a trick called tapering.
The hydrogen molecule, from integrals up
The smallest real example is H₂ in the minimal STO-3G basis: one 1s function per atom, each a fixed sum of three Gaussians. The code computes every integral from closed-form Gaussian formulas (the method of Computational chemistry), forms the σg and σu orbitals, and writes the Hamiltonian in the basis of the two configurations that can mix in the ground state, and . Spin and spatial symmetry forbid any other determinant from mixing in, so this two-level problem is full configuration interaction for H₂ in this basis.
import numpy as np
from math import erf, pi, sqrt
# STO-3G hydrogen 1s: three Gaussians (exponents in bohr^-2, contraction coefficients)
ALPHA = np.array([3.42525091, 0.62391373, 0.16885540])
COEF = np.array([0.15432897, 0.53532814, 0.44463454]) * (2 * ALPHA / pi) ** 0.75
def boys0(t):
return 1.0 if t < 1e-12 else 0.5 * sqrt(pi / t) * erf(sqrt(t))
def ao_integrals(R):
"""Overlap S, core Hamiltonian h (kinetic + attraction to both protons) and
two-electron integrals (ij|kl) over the two 1s functions of H2, bond length R in bohr."""
X = [np.zeros(3), np.array([0.0, 0.0, R])]
prims = [(a, c, A) for A in X for a, c in zip(ALPHA, COEF)] # 6 primitives, 3 per atom
atom = [0, 0, 0, 1, 1, 1]
S, h, g = np.zeros((2, 2)), np.zeros((2, 2)), np.zeros((2, 2, 2, 2))
for i, (a, ca, A) in enumerate(prims):
for j, (b, cb, B) in enumerate(prims):
p, m = a + b, a * b / (a + b)
P, AB2 = (a * A + b * B) / p, np.sum((A - B) ** 2)
ov = ca * cb * (pi / p) ** 1.5 * np.exp(-m * AB2)
S[atom[i], atom[j]] += ov
h[atom[i], atom[j]] += ov * m * (3 - 2 * m * AB2)
for C in X:
h[atom[i], atom[j]] -= ca * cb * 2 * pi / p * np.exp(-m * AB2) * boys0(p * np.sum((P - C) ** 2))
for k, (c, cc, C) in enumerate(prims):
for l, (d, cd, D) in enumerate(prims):
q = c + d
Q = (c * C + d * D) / q
g[atom[i], atom[j], atom[k], atom[l]] += (
ca * cb * cc * cd * 2 * pi**2.5 / (p * q * sqrt(p + q))
* np.exp(-m * AB2 - c * d / q * np.sum((C - D) ** 2))
* boys0(p * q / (p + q) * np.sum((P - Q) ** 2)))
return S, h, g
def mo_integrals(R):
S, h, g = ao_integrals(R)
s = S[0, 1]
C = np.array([[1, 1], [1, -1]]) / np.sqrt([2 * (1 + s), 2 * (1 - s)]) # sigma_g, sigma_u (fixed by symmetry)
return C.T @ h @ C, np.einsum("pi,qj,rk,sl,pqrs->ijkl", C, C, C, C, g)
def two_level(R):
"""H2's Hamiltonian in the basis {sigma_g^2, sigma_u^2}, in hartree, nuclear repulsion included."""
h, g = mo_integrals(R)
E1, E2, K = 2 * h[0, 0] + g[0, 0, 0, 0], 2 * h[1, 1] + g[1, 1, 1, 1], g[0, 1, 0, 1]
return np.array([[E1, K], [K, E2]]) + np.eye(2) / R
h, g = mo_integrals(1.4)
print("MO integrals at R = 1.4 bohr (74 pm), hartree:")
print(f" h11 = {h[0, 0]:.6f} h22 = {h[1, 1]:.6f} (11|11) = {g[0, 0, 0, 0]:.6f} (22|22) = {g[1, 1, 1, 1]:.6f}"
f" (11|22) = {g[0, 0, 1, 1]:.6f} (12|12) = {g[0, 1, 0, 1]:.6f}")
for R in (1.4, 4.0):
H = two_level(R)
c0, cz, cx = (H[0, 0] + H[1, 1]) / 2, (H[0, 0] - H[1, 1]) / 2, H[0, 1]
print(f"one-qubit form at {R * 52.9177:.0f} pm: H = ({c0:.6f}) I + ({cz:.6f}) Z + ({cx:.6f}) X")
print()
print(" R/pm Hartree-Fock exact (FCI) correlation weight of HF configuration (energies in hartree)")
for R in [1.0, 1.4, 2.0, 3.0, 4.0, 6.0]:
H = two_level(R)
E, V = np.linalg.eigh(H)
print(f"{R * 52.9177:5.0f} {H[0, 0]:13.4f} {E[0]:13.4f} {E[0] - H[0, 0]:13.4f} {V[0, 0] ** 2:16.3f}")
h_far = ao_integrals(1e6)[1] # protons a million bohr apart
print(f"two separate H atoms in this basis: {2 * h_far[0, 0]:.4f}")At the equilibrium bond length the Hartree–Fock energy is −1.1167 hartree and the exact energy in this basis is −1.1373: the correlation energy, 0.0206 hartree or about 54 kJ mol⁻¹, is small, and the Hartree–Fock configuration carries 98.7 % of the wavefunction. Stretch the bond and everything changes. At 318 pm the exact energy has almost reached that of two separate atoms (−0.9332), while Hartree–Fock, forced to keep both electrons in one delocalised orbital, is 0.288 hartree (about 760 kJ mol⁻¹) too high. The weight of the Hartree–Fock configuration falls towards one half: the wavefunction has become an equal mixture of two determinants, the textbook case of static correlation.
The Hamiltonian on four qubits, and the exponential wall
Now map H₂ onto qubits for real. The code builds the four annihilation operators as 16 × 16 matrices with the Jordan–Wigner rule, assembles from the integrals printed above, expands it in Pauli strings by computing for all 256 strings, and diagonalises it. Then it counts qubits and determinants for larger problems.
import numpy as np
from itertools import product
from math import comb
# H2 molecular-orbital integrals at R = 1.4 bohr, in hartree (printed by the previous block)
h = np.diag([-1.252797, -0.475602])
g = np.zeros((2, 2, 2, 2)) # chemists' notation (ij|kl), real orbitals
g[0, 0, 0, 0], g[1, 1, 1, 1] = 0.674594, 0.697495
g[0, 0, 1, 1] = g[1, 1, 0, 0] = 0.663564
for i, j, k, l in [(0, 1, 0, 1), (1, 0, 1, 0), (0, 1, 1, 0), (1, 0, 0, 1)]:
g[i, j, k, l] = 0.181258
E_nuc = 1 / 1.4
# Jordan-Wigner: spin orbital p -> qubit p; |1> = occupied. Order: g-alpha, g-beta, u-alpha, u-beta.
I2, Z = np.eye(2), np.diag([1.0, -1.0])
lower = np.array([[0.0, 1.0], [0.0, 0.0]]) # |1> -> |0>: removes an electron
def kron(*ms):
out = np.eye(1)
for m in ms:
out = np.kron(out, m)
return out
n_q = 4
a = [kron(*([Z] * p + [lower] + [I2] * (n_q - p - 1))) for p in range(n_q)]
spatial, spin = [0, 0, 1, 1], [0, 1, 0, 1]
H = E_nuc * np.eye(2**n_q)
for p, q in product(range(n_q), repeat=2):
if spin[p] == spin[q]:
H += h[spatial[p], spatial[q]] * a[p].T @ a[q]
for p, q, r, s in product(range(n_q), repeat=4):
if spin[p] == spin[q] and spin[r] == spin[s]:
H += 0.5 * g[spatial[p], spatial[q], spatial[r], spatial[s]] * a[p].T @ a[r].T @ a[s] @ a[q]
# Write H as a sum of Pauli strings: c_P = Tr(P H) / 2^n
paulis = {"I": I2, "X": np.array([[0, 1], [1, 0]]), "Y": np.array([[0, -1j], [1j, 0]]), "Z": Z}
terms = {}
for label in product("IXYZ", repeat=n_q):
c = np.trace(kron(*[paulis[x] for x in label]) @ H).real / 2**n_q
if abs(c) > 1e-9:
terms["".join(label)] = c
print(f"{len(terms)} Pauli strings (of {4**n_q} possible):")
print(" " + "\n ".join(f"{c:+.6f} {lab}" for lab, c in terms.items()))
N = sum(ai.T @ ai for ai in a) # number operator
E, V = np.linalg.eigh(H)
two = [k for k in range(len(E)) if abs(V[:, k] @ N @ V[:, k] - 2) < 1e-9]
psi = V[:, two[0]]
print(f"\nlowest two-electron energy: {E[two[0]]:.6f} hartree")
big = {format(i, "04b"): psi[i] for i in range(16) if abs(psi[i]) > 1e-6}
print("ground state:", ", ".join(f"{amp:+.4f}|{bits}>" for bits, amp in big.items()))
print("\nactive space qubits determinants memory at 8 bytes each")
for name, ne, no in [("H2 here", 2, 2), ("benzene pi", 6, 6), ("(24e, 24o)", 24, 24),
("FeMoco, 54 orbitals", 54, 54), ("FeMoco, 76 orbitals", 113, 76)]:
na, nb = (ne + 1) // 2, ne // 2
d = comb(no, na) * comb(no, nb)
print(f"{name:20s} {2 * no:5d} {d:14.3g} {8 * d:16.2g} bytes")Fifteen Pauli strings describe H₂: an identity term, single and double terms that measure occupations and their correlations, and four -type terms that move a pair of electrons from σg to σu. The ground state, , has energy −1.137276 hartree, exactly the two-level result, which confirms the reduction. The one-qubit form printed earlier is that reduction written in Pauli language: with standing for and for , the Hamiltonian is .
Read the last table as a budget. A (24e, 24o) active space needs 48 qubits on a quantum computer and 7.3 × 10¹² coefficients, 58 terabytes, on a classical one — large but feasible on a supercomputer, which is roughly where exact methods stop. The two published FeMoco models need 108 and 152 qubits for the orbitals, against about 10³⁰ and 10³⁵ coefficients. No classical memory will ever hold those, which is why FeMoco became the standard benchmark.
The variational quantum eigensolver
Holding a wavefunction is useless unless an energy can be read out, and a quantum measurement returns only random outcomes. The variational quantum eigensolver (VQE), proposed by Peruzzo, McClean and colleagues in 2014, is the most economical way to read one: let the quantum computer prepare a parameterised trial state , estimate by measuring each Pauli string many times, and let a classical optimiser adjust . By the variational principle of Molecular orbitals, the true is never below the ground-state energy.
The trial state, or ansatz, is the crux. Chemically motivated ansätze such as unitary coupled cluster apply exponentials of excitation operators to the Hartree–Fock state; "hardware-efficient" ansätze use whatever gates the device does best. For H₂ a single double excitation is exact: on the one-qubit reduction it is the rotation , for which , and . The simulation below estimates and only from finite samples, as hardware must, and follows the gradient given by the parameter-shift rule, , which is exact for this kind of gate and needs only two more energy estimates.
import numpy as np
c0, cz, cx = -0.328069, -0.788645, 0.181258 # H2 at 74 pm: H = c0 I + cz Z + cx X (hartree)
E_exact = c0 - np.hypot(cz, cx)
def measure(theta, shots, rng):
"""Estimate <H> for Ry(theta)|0> from finite samples of Z and of X, as hardware must."""
pz, px = (1 + np.cos(theta)) / 2, (1 + np.sin(theta)) / 2 # probabilities of the +1 outcome
z = 2 * rng.binomial(shots, pz) / shots - 1
x = 2 * rng.binomial(shots, px) / shots - 1
return c0 + cz * z + cx * x
def vqe(shots, seed=1, steps=40, lr=1.0):
rng = np.random.default_rng(seed)
theta = 0.0 # start from the Hartree-Fock state |0>
for _ in range(steps):
grad = (measure(theta + np.pi / 2, shots, rng) - measure(theta - np.pi / 2, shots, rng)) / 2
theta -= lr * grad # parameter-shift rule: exact gradient, noisy estimate
estimate = measure(theta, shots, rng)
true = c0 + cz * np.cos(theta) + cx * np.sin(theta)
return theta, estimate, true, steps * 4 * shots + 2 * shots
print(f"exact ground state {E_exact:.6f} hartree; Hartree-Fock {c0 + cz:.6f}")
print("shots/term theta estimate sd of estimate true E of state true error (mEh) total shots")
for shots in [100, 1_000, 10_000, 100_000]:
th, est, true, n = vqe(shots)
sd = np.sqrt(cz**2 * np.sin(th)**2 + cx**2 * np.cos(th)**2) / np.sqrt(shots)
print(f"{shots:9,d} {th:8.4f} {est:10.4f} {sd:12.4f} {true:16.6f} {1000 * (true - E_exact):15.3f} {n:15,d}")
theta_opt = np.arctan2(-cx, -cz)
var1 = cz**2 * np.sin(theta_opt)**2 + cx**2 * np.cos(theta_opt)**2 # Var(Z) = sin^2, Var(X) = cos^2
print(f"\nsd of one-shot energy at the optimum: {np.sqrt(var1):.3f} hartree")
print(f"shots per term for a standard error of 1.6 mEh: {var1 / 0.0016**2:,.0f}")Two results stand out. The optimiser finds a good state even with 100 shots per term: the true energy of the state it ends in is within 0.05 millihartree of exact, because the energy is flat near its minimum. But the reported energy is another matter. With 100 shots it is −1.1444, with 1,000 shots −1.1556 — both below the exact ground-state energy, by more than chemical accuracy. The standard deviation of a single-shot energy estimate at the optimum is 0.25 hartree, so a standard error of 1.6 millihartree, the conventional chemical accuracy of 1 kcal mol⁻¹, needs about 24,000 shots per term, for a two-term Hamiltonian, once. For a molecule with to Pauli terms, many shots per term and hundreds of optimisation steps, the arithmetic becomes forbidding, even after grouping commuting terms.
VQE did what it was designed for: since 2014 it has put small molecules on every kind of hardware — HeH⁺ on a photonic chip (2014), H₂ on superconducting qubits at Google (2016), H₂, LiH and BeH₂ on up to six qubits at IBM (2017), and a 12-qubit Hartree–Fock calculation on Google's Sycamore processor (2020). None of these were beyond classical reach, and most researchers now regard VQE as a testbed rather than a route to chemical advantage.
Quantum phase estimation
The algorithm expected to deliver chemistry on a fault-tolerant machine is phase estimation, introduced by Alexei Kitaev in 1995 and applied to eigenvalues by Abrams and Lloyd in 1999; in 2005 Aspuru-Guzik, Dutoi, Love and Head-Gordon showed by classical simulation how it would compute molecular energies. Instead of measuring term by term, it lets the state evolve under , which multiplies each energy eigenstate by a phase , and reads that phase into a register of ancilla qubits.
Theorem— Phase estimation
Let have eigenstates with eigenvalues , , and let the system start in . The circuit with readout qubits returns the integer with probability
and, for each , the probability that lies within of (modulo 1) is at least .
Two consequences shape everything. Precision is cheap in shots and expensive in depth: each extra bit halves the error but doubles the evolution time, so reaching precision takes total time proportional to (the Heisenberg limit), against the repetitions of sampling. And you get the eigenvalue you are lucky enough to land on: the ground-state energy comes out with probability , the squared overlap of the prepared state with the true ground state. The simulation below takes the Hartree–Fock state as input, with an energy window of 3 hartree, and computes the readout distribution exactly.
import numpy as np
# One-qubit H2 Hamiltonians (hartree) from the earlier block: c0 I + cz Z + cx X
cases = {"74 pm": (-0.328069, -0.788645, 0.181258), "212 pm": (-0.660054, -0.101028, 0.265128)}
E_TOP, WINDOW = 1.0, 3.0 # U = exp(-i (H - E_TOP) t) with t = 2 pi / WINDOW
def readout_probabilities(H, psi, m):
"""Distribution of the m-bit phase-estimation readout k for input state psi."""
E, V = np.linalg.eigh(H)
w = np.abs(V.T @ psi) ** 2 # overlap of the input with each eigenstate
phi = (E_TOP - E) / WINDOW # eigenphases in [0, 1)
M = 2**m
k = np.arange(M)
x = np.arange(M)
P = np.zeros(M)
for wj, pj in zip(w, phi):
amp = np.exp(2j * np.pi * np.outer(pj - k / M, x)).sum(axis=1) / M
P += wj * np.abs(amp) ** 2
return P, E, w
hf = np.array([1.0, 0.0]) # the Hartree-Fock configuration as input
for name, (c0, cz, cx) in cases.items():
H = np.array([[c0 + cz, cx], [cx, c0 - cz]])
for m in (8, 11):
P, E, w = readout_probabilities(H, hf, m)
M = 2**m
energy = E_TOP - WINDOW * np.arange(M) / M # the energy each readout stands for
near = lambda e: P[np.abs(energy - e) <= WINDOW / M].sum()
best = np.argmax(P)
print(f"{name}, {m} bits: resolution {1000 * WINDOW / M:.2f} mEh, U applied {M - 1:,} times")
print(f" most likely readout {energy[best]:.4f} (exact ground state {E[0]:.4f});"
f" P(near ground) {near(E[0]):.3f}, P(near excited {E[1]:.4f}) {near(E[1]):.3f};"
f" |<HF|ground>|^2 = {w[0]:.3f}")With 8 readout bits the resolution is 11.7 millihartree; with 11 bits it is 1.46 millihartree, inside chemical accuracy, at the cost of 2,047 applications of instead of 255. At equilibrium the Hartree–Fock state overlaps the ground state with weight 0.987, and the ground-state energy is read out 98 % of the time with 11 bits. At 212 pm the overlap has fallen to 0.678, and about a quarter of the runs return the excited state's energy instead. Repetition sorts this out for H₂. For a large molecule the overlap of any simple state with the true ground state can shrink exponentially with size, and then phase estimation offers no shortcut: preparing a good initial state becomes the hard part.
On real hardware is not available as a matrix. It is built from gates, either by Trotterisation, , as Seth Lloyd proposed in 1996, or by newer methods, qubitisation and block encodings, that implement a function of with cost governed by the sum of the absolute values of its coefficients. Either way the circuits are millions to billions of gates deep, far beyond what physical qubits can run without errors. Phase estimation for chemistry therefore needs quantum error correction: many noisy physical qubits encode each reliable logical qubit, and the expensive operations are the non-Clifford gates (T or Toffoli gates), which must be prepared by a costly process called magic-state distillation.
What would it take? Resource estimates
Because no machine yet exists that can run these algorithms at useful scale, the field's most informative documents are resource estimates: careful counts of logical qubits, non-Clifford gates and run time for specific molecules, compiled down to an error-correcting code with stated assumptions about physical hardware. The FeMoco story shows how they are made and how fast they move.
- Reiher, Wiebe, Svore, Wecker and Troyer (2017) took a 54-electron, 54-orbital model of FeMoco and, with a Trotter-based phase-estimation algorithm, needed more than T gates on about 111 logical qubits: possible in principle, but impractical at realistic error-correction overheads.
- Li, Li, Dattani, Umrigar and Chan (2019) showed that this model had almost none of the open-shell character of the real cluster, and proposed a larger, more faithful 113-electron, 76-orbital model. The benchmark itself had to be corrected by better classical chemistry.
- Algorithmic improvements — qubitisation combined with factorisations of the two-electron integrals, single and double factorisation (Berry and co-workers, 2019; von Burg and co-workers, 2021, for a ruthenium catalyst that converts carbon dioxide to methanol) and tensor hypercontraction (Lee and co-workers, 2021) — cut the cost by orders of magnitude. The 2021 tensor-hypercontraction estimates are about 2,100–2,200 logical qubits and Toffoli gates for the 54-orbital model, for the 76-orbital one. Compiled into the surface code for the 54-orbital model, that is about four million physical qubits running for under four days, assuming 0.1 % physical error rates and 1-microsecond cycles, or about one million physical qubits at 0.01 %.
- Goings and co-workers (2022), from Google and Boehringer Ingelheim, set quantum estimates for cytochrome P450 models alongside the best classical calculations (DMRG with perturbation theory, and CCSD(T)), and located a boundary in model size beyond which phase estimation would be expected to win — the right way to argue for advantage: against the classical state of the art, for a question chemists care about.
Later work through 2025 has continued to lower these counts, and newer estimates should be read the same way: which Hamiltonian, which accuracy, which hardware assumptions, and compared with which classical method?
An honest status report, 2026
Hardware. Error correction crossed important thresholds in 2023–25. Google Quantum AI showed a surface-code memory whose logical error rate fell as the code grew, operating below threshold on its Willow processor; a Harvard, MIT and QuEra collaboration ran circuits on up to 48 logical qubits encoded in neutral atoms; and in 2025 Quantinuum ran phase estimation for H₂ on logical qubits protected by a quantum error-correcting code on its trapped-ion machine. Physical two-qubit error rates of about 0.1–0.5 % are now routine on the leading platforms — superconducting circuits, trapped ions and neutral atoms — and groups across the United States, Europe, China, Japan, Canada and Australia are building them. Published roadmaps, such as IBM's target of a fault-tolerant machine with about 200 logical qubits by 2029, aim at the end of the decade. FeMoco-class estimates need thousands of logical qubits and billions of Toffoli gates, so on current estimates useful phase estimation for such molecules lies in the 2030s at the earliest. The physics of the devices is the subject of Lumenary EE's quantum hardware.
Chemistry on today's machines. The largest chemistry runs use hybrid methods. In 2024 IBM and RIKEN sampled electronic configurations with circuits of up to 77 qubits on a Heron processor and diagonalised the Hamiltonian in the sampled space on the Fugaku supercomputer, for N₂ and for [2Fe–2S] and [4Fe–4S] clusters. The energies are rigorous upper bounds, but they did not surpass the best classical methods for those systems, and whether the quantum sampling step can ever beat classical ways of choosing configurations is actively debated. As of 2026, no quantum computation of a molecule's electronic structure has been accepted as beating the best classical methods; claims of quantum advantage so far concern physics benchmarks, not chemistry.
What to expect. Candidates for the first genuine advantage are problems where classical methods are uncertain and the answer matters: multi-metal catalytic clusters, spin-state energetics of transition-metal complexes, and dynamics and excited states that classical methods handle poorly; lattice models of materials may come first of all. Meanwhile classical methods keep improving — DMRG, selected configuration interaction, quantum Monte Carlo, neural-network wavefunctions — and every claim of advantage is a moving target. That competition is healthy.
Tools. Workflows start with a classical program that produces the integrals, usually PySCF, then use OpenFermion, Qiskit or PennyLane to build qubit Hamiltonians and circuits. A PySCF check of this lesson's numbers looks like this (not run here; it needs PySCF installed):
# Not run here: requires PySCF (pip install pyscf)
from pyscf import gto, scf, fci
mol = gto.M(atom="H 0 0 0; H 0 0 0.740848", basis="sto-3g") # 1.4 bohr, in angstrom
mf = scf.RHF(mol).run() # Hartree-Fock energy
e_fci, civec = fci.FCI(mf).kernel() # full CI in the same basis
print(mf.e_tot, e_fci) # compare with -1.116714 and -1.137276 aboveCommon misconceptions
Misconception
"A quantum computer tries every configuration at once and picks the best." The register does hold a superposition of all determinants, but a measurement returns one random outcome. Every useful algorithm must arrange interference so that the answer is likely, and the art lies in that arrangement.
Misconception
"VQE on today's machines gives quantum advantage for chemistry." Every VQE experiment so far has been on a problem a laptop solves exactly. The measurement cost (thousands of shots per term per step), hardware noise and barren plateaus make it unlikely to scale to classically hard molecules without error correction.
Misconception
"The number of qubits is the measure of progress." For chemistry what matters is the number of logical qubits and how many non-Clifford gates they can run before an error. A thousand noisy physical qubits cannot run phase estimation for FeMoco; a few thousand good logical qubits running billions of Toffoli gates could.
Misconception
"Phase estimation always returns the ground-state energy." It returns an eigenvalue chosen at random with probability equal to the squared overlap of the input state with that eigenstate. Preparing a state with good overlap is the problem's hidden difficulty.
Exercises
1. Quantum computing for chemistry
Warm-upHumanWater in the minimal STO-3G basis has one basis function for each hydrogen (1s) and five for oxygen (1s, 2s and three 2p). Without any symmetry reductions, how many qubits does the Jordan–Wigner transformation need for the full set of molecular orbitals?
2. Quantum computing for chemistry
Warm-upHumanHow many determinants are there in a full configuration-interaction expansion of 8 electrons in 8 spatial orbitals with four spin-up and four spin-down electrons?
3. Quantum computing for chemistry
CoreHumanA VQE run on hardware reports −1.1444 hartree for H₂ in the STO-3G basis at 74 pm, while the exact (full CI) energy in that basis is −1.1373 hartree. What is the most likely explanation?
4. Quantum computing for chemistry
CoreHumanFor some trial state, a single-shot estimate of the energy has a standard deviation of 0.4 hartree. How many shots are needed for the standard error of the averaged energy to be 1.6 millihartree (chemical accuracy)?
5. Quantum computing for chemistry
CoreHumanPhase estimation maps an energy window of 3.0 hartree onto the possible readouts, so each readout step is hartree. What is the smallest number of readout bits for which the step is at most 1.6 millihartree?
6. Quantum computing for chemistry
CoreComputationalEvery operator on two qubits is a unique combination of the 16 Pauli strings with , and for a Hermitian the coefficients are real: .
Write pauli_coefficients(H) that takes a 4 × 4 Hermitian matrix and returns a dictionary from two-letter labels such as "XZ" (first letter for the first tensor factor, as in np.kron(A, B)) to float coefficients, keeping only those with absolute value above .
7. Quantum computing for chemistry
StretchComputationalWrite qpe_probabilities(phi, m) that returns a NumPy array of the probabilities of the readouts of textbook phase estimation for an exact eigenstate with eigenphase ():
The tests check that a phase on the grid is read exactly, that phases wrap around at 1, and the guarantee of the lesson's theorem.
8. Quantum computing for chemistry
CoreHumanWhich statement best describes quantum computing for chemistry as of 2026?
Further reading and resources
- Simulating physics with computers · Richard P. Feynman · 1982The 1981 lecture that proposed quantum simulation.
- Universal Quantum Simulators · Seth Lloyd · 1996
- Quantum measurements and the Abelian Stabilizer Problem · A. Yu. Kitaev · 1995The origin of phase estimation.
- Quantum Algorithm Providing Exponential Speed Increase for Finding Eigenvalues and Eigenvectors · Daniel S. Abrams, Seth Lloyd · 1999
- Simulated Quantum Computation of Molecular Energies · Aspuru-Guzik, Dutoi, Love, Head-Gordon · 2005
- A variational eigenvalue solver on a photonic quantum processor · Peruzzo et al. · 2014The first variational quantum eigensolver.
- The theory of variational hybrid quantum-classical algorithms · McClean, Romero, Babbush, Aspuru-Guzik · 2016
- Scalable Quantum Simulation of Molecular Energies · O'Malley et al. · 2016
- Hardware-efficient variational quantum eigensolver for small molecules and quantum magnets · Kandala et al. · 2017
- Elucidating reaction mechanisms on quantum computers · Reiher, Wiebe, Svore, Wecker, Troyer · 2017The first detailed fault-tolerant resource estimate for FeMoco.
- Quantum Computing in the NISQ era and beyond · John Preskill · 2018
- The electronic complexity of the ground-state of the FeMo cofactor of nitrogenase as relevant to quantum simulations · Li, Li, Dattani, Umrigar, Chan · 2019
- Quantum Chemistry in the Age of Quantum Computing · Cao et al. · 2019
- Quantum computational chemistry · McArdle, Endo, Aspuru-Guzik, Benjamin, Yuan · 2020
- Quantum Algorithms for Quantum Chemistry and Quantum Materials Science · Bauer, Bravyi, Motta, Chan · 2020
- Hartree-Fock on a superconducting qubit quantum computer · Google AI Quantum and collaborators · 2020
- Quantum computing enhanced computational catalysis · von Burg, Low, Häner, Steiger, Reiher, Roetteler, Troyer · 2021
- Even More Efficient Quantum Computations of Chemistry Through Tensor Hypercontraction · Lee, Berry, Gidney, Huggins, McClean, Wiebe, Babbush · 2021
- Noisy intermediate-scale quantum algorithms · Bharti et al. · 2022
- Reliably assessing the electronic structure of cytochrome P450 on today's classical computers and tomorrow's quantum computers · Goings et al. · 2022
- Evaluating the evidence for exponential quantum advantage in ground-state quantum chemistry · Lee et al. · 2023
- Logical quantum processor based on reconfigurable atom arrays · Bluvstein et al. · 2024
- Chemistry Beyond the Scale of Exact Diagonalization on a Quantum-Centric Supercomputer · Robledo-Moreno et al. · 2024
- Quantum error correction below the surface code threshold · Google Quantum AI and collaborators · 2024
- Quantum Error-Corrected Computation of Molecular Energies · Yamamoto et al. · 2025
- OpenFermionOpen-source library for turning electronic-structure problems into qubit Hamiltonians and circuits.
- Qiskit
- PennyLane
- PySCFThe open-source quantum-chemistry package most quantum-computing workflows use to generate integrals.