The Density Matrix

Definition

Quantum mechanics as usually taught assigns a state vector — a ket |ψ⟩ — to a system. But that only works when the state is completely known. The density matrix generalizes this to cover incomplete knowledge, thermal ensembles, and subsystems of entangled wholes. It is a single operator ρ that carries every physically accessible prediction.

For a system that is, with classical probability p_i, in one of several normalized pure states |ψ_i⟩, the density operator is:

ρ = Σ_i p_i |ψ_i⟩⟨ψ_i|

where each p_i ≥ 0 and Σ_i p_i = 1. The states |ψ_i⟩ need not be orthogonal. Every valid density matrix satisfies three defining properties:

• Hermitian: ρ = ρ† (real eigenvalues — the probabilities of its eigenstates).
• Positive semidefinite: ⟨φ|ρ|φ⟩ ≥ 0 for all |φ⟩ (no negative probabilities).
• Unit trace: Tr(ρ) = 1 (total probability conserved).

Any operator with these three properties is a legitimate quantum state, and every quantum state can be written this way. That is the sense in which ρ is the most general description available.

Pure states vs. mixed states

When the ensemble collapses to a single term — the system is definitely in |ψ⟩ — the density matrix becomes a rank-1 projector:

ρ_pure = |ψ⟩⟨ψ|,   ρ² = ρ,   Tr(ρ²) = 1

This is a pure state. It is idempotent (ρ² = ρ) because projecting twice is the same as projecting once. A mixed state is anything else: a classical probabilistic blend of distinguishable pure states. Its purity dips below one, Tr(ρ²) < 1.

The single most-important conceptual trap here: a superposition is not a mixture. The state (|0⟩ + |1⟩)/√2 is a pure state — you know it exactly — and its density matrix has nonzero off-diagonal terms. A 50/50 statistical mixture of |0⟩ and |1⟩, by contrast, is diagonal and represents genuine ignorance. Both have populations (½, ½), but only the superposition can interfere.

Property	Pure state	Mixed state
Form	ρ = |ψ⟩⟨ψ|	ρ = Σ p_i |ψ_i⟩⟨ψ_i|, ≥ 2 terms
Idempotence	ρ² = ρ	ρ² ≠ ρ
Purity Tr(ρ²)	= 1	< 1 (down to 1/d)
Von Neumann entropy S	0	> 0 (up to ln d)
Eigenvalues	one is 1, rest are 0	several nonzero, summing to 1
Describable by a ket?	Yes	No
Bloch vector (qubit)	on the surface, |r| = 1	inside, |r| < 1

Expectation values: ⟨A⟩ = Tr(ρA)

The single most useful formula involving ρ predicts the average outcome of measuring any observable A (a Hermitian operator):

⟨A⟩ = Tr(ρ A)

Here Tr denotes the trace — the sum of diagonal elements — which is basis-independent, so ⟨A⟩ is the same computed in any representation. Symbols: ρ is the density matrix (dimensionless, unit trace); A is the observable operator (units match the physical quantity — energy in J, spin in ℏ, etc.); ⟨A⟩ is the ensemble-averaged expectation value.

For a pure state this collapses to the textbook rule: Tr(|ψ⟩⟨ψ| A) = ⟨ψ|A|ψ⟩. For a mixture it automatically produces the classically-weighted quantum average, ⟨A⟩ = Σ_i p_i ⟨ψ_i|A|ψ_i⟩. One recipe, both cases — this is precisely why ρ is so powerful.

Populations and coherences

Write ρ as a matrix in some orthonormal basis {|n⟩}. The entries split into two physically distinct groups:

• Diagonal elements ρ_nn — populations. ρ_nn = ⟨n|ρ|n⟩ is the probability of finding the system in |n⟩. They are real, non-negative, and sum to 1 (that is what Tr(ρ) = 1 says).
• Off-diagonal elements ρ_mn (m ≠ n) — coherences. These complex numbers encode the definite phase relationship between |m⟩ and |n⟩. Their magnitude bounds interference contrast; a purely diagonal ρ is a classical mixture that cannot interfere.

For a single qubit the density matrix in the {|0⟩, |1⟩} basis is:

      ⎡ ρ₀₀   ρ₀₁ ⎤     ⎡ population(0)   coherence ⎤
ρ  =  ⎢           ⎥  =  ⎢                          ⎥
      ⎣ ρ₁₀   ρ₁₁ ⎦     ⎣ coherence*   population(1)⎦

Hermiticity forces ρ₁₀ = ρ₀₁*. Decoherence — coupling to the environment — attacks the coherences directly: ρ₀₁(t) = ρ₀₁(0) e^(−t/T₂), where T₂ is the dephasing time. The populations may relax more slowly on the energy-relaxation timescale T₁ (with T₂ ≤ 2T₁). Once the coherences vanish, the state is an ordinary classical probability distribution — the superposition is gone.

The Bloch-sphere picture for a qubit

Every single-qubit density matrix can be written with the Pauli matrices σ_x, σ_y, σ_z and the identity I:

ρ = ½ ( I + r · σ ) = ½ ( I + r_x σ_x + r_y σ_y + r_z σ_z )

The real 3-vector r = (r_x, r_y, r_z) is the Bloch vector, with r_i = Tr(ρ σ_i) = ⟨σ_i⟩. Its length sets the purity exactly:

Tr(ρ²) = ½ ( 1 + |r|² )

Pure states have |r| = 1 and live on the surface of the Bloch sphere; mixed states have |r| < 1 and sit strictly inside; the center r = 0 is the maximally mixed state ρ = I/2 with purity ½. Decoherence shrinks r toward the axis or the center — the geometry makes "losing coherence" literally visible.

Reduced density matrix, entanglement, and decoherence

Take two systems A and B in a joint state ρ_AB. Everything predictable by measurements on A alone is contained in the reduced density matrix, obtained by the partial trace over B:

ρ_A = Tr_B(ρ_AB) = Σ_k ⟨b_k|_B  ρ_AB  |b_k⟩_B

Here {|b_k⟩} is any orthonormal basis of B. The magic: if the combined system AB is in an entangled pure state, ρ_A comes out mixed — Tr(ρ_A²) < 1 — even though ρ_AB itself is pure with Tr(ρ_AB²) = 1. The loss of purity upon tracing out a partner is the operational fingerprint of entanglement.

Consider the maximally entangled Bell state |Φ⁺⟩ = (|00⟩ + |11⟩)/√2. The joint density matrix ρ_AB = |Φ⁺⟩⟨Φ⁺| is pure. But tracing out qubit B leaves:

ρ_A = Tr_B(|Φ⁺⟩⟨Φ⁺|) = ½ (|0⟩⟨0| + |1⟩⟨1|) = I/2

Each qubit alone is maximally mixed — completely random, purity ½, entropy ln 2 — while the pair is perfectly correlated. This is the sense in which "the whole knows more than the sum of the parts." Decoherence is the same mechanism playing out with an uncontrolled environment as partner B: entanglement with the surroundings leaves the system in an effectively classical mixed state, its coherences traced away, without any need to invoke wavefunction collapse.

Von Neumann entropy

The quantum analog of Gibbs–Shannon entropy is the von Neumann entropy:

S(ρ) = -Tr(ρ ln ρ) = -Σ_i λ_i ln λ_i

where λ_i are the eigenvalues of ρ. Symbols: S is entropy (dimensionless in nats; multiply by k_B = 1.381 × 10⁻²³ J/K for thermodynamic units, or use log₂ for bits); λ_i are the eigenvalues (the probabilities in the diagonalizing eigenbasis). Key values:

• Pure state: one eigenvalue is 1, the rest 0, so S = 0. No missing information.
• Maximally mixed state (d dimensions): all λ_i = 1/d, giving the maximum S = ln d. For a qubit, S_max = ln 2 ≈ 0.693 nats = 1 bit.
• Entanglement entropy: for a bipartite pure state, S(ρ_A) = S(ρ_B) is a rigorous measure of how entangled A and B are; it is ln 2 for a Bell pair and 0 for a product state.

The thermal (Gibbs) state ρ = e^(−H/k_BT)/Z maximizes S(ρ) at fixed average energy — this is quantum statistical mechanics built directly on the density operator, with the partition function Z = Tr(e^(−H/k_BT)).

Time evolution: the von Neumann equation

A closed system's density matrix evolves by the quantum Liouville (von Neumann) equation, the operator form of the Schrödinger equation:

iℏ dρ/dt = [H, ρ] = Hρ - ρH

Symbols: ℏ = 1.055 × 10⁻³⁴ J·s (reduced Planck constant); H is the Hamiltonian (energy operator, in J); [H, ρ] is the commutator. Unitary evolution preserves the eigenvalues of ρ, hence purity and von Neumann entropy stay constant — a closed system never spontaneously decoheres. To describe decoherence and dissipation you couple to an environment and derive a master equation (e.g. the Lindblad equation), which can lower purity and raise entropy while keeping Tr(ρ) = 1.

Python — building and probing a density matrix

import numpy as np

# --- single-qubit basis ---
ket0 = np.array([[1], [0]], dtype=complex)
ket1 = np.array([[0], [1]], dtype=complex)

def dm(ket):                      # pure-state density matrix |psi> + |1>)/sqrt(2)  -- has coherences
psi   = (ket0 + ket1) / np.sqrt(2)
rho_pure = dm(psi)

# Classical 50/50 mixture of |0> and |1>  -- diagonal, no coherences
rho_mix  = 0.5 * dm(ket0) + 0.5 * dm(ket1)

def purity(rho): return np.real(np.trace(rho @ rho))
def vn_entropy(rho):
    w = np.linalg.eigvalsh(rho)
    w = w[w > 1e-12]
    return float(-np.sum(w * np.log(w)))

print("Tr(rho_pure) =", np.real(np.trace(rho_pure)))   # 1.0
print("purity pure  =", purity(rho_pure))              # 1.0
print("purity mix   =", purity(rho_mix))               # 0.5
print("S(pure) nats =", vn_entropy(rho_pure))          # 0.0
print("S(mix)  nats =", vn_entropy(rho_mix))           # 0.693 = ln 2

# Expectation value   = Tr(rho A),  A = sigma_x
sx = np.array([[0, 1], [1, 0]], dtype=complex)
print("<sx> pure =", np.real(np.trace(rho_pure @ sx)))  # +1.0 (coherent)
print("<sx> mix  =", np.real(np.trace(rho_mix  @ sx)))  # 0.0  (no coherence)

# --- Bell state and the partial trace ---
bell = (np.kron(ket0, ket0) + np.kron(ket1, ket1)) / np.sqrt(2)
rho_ab = dm(bell)                                      # pure, 4x4

def partial_trace_B(rho4):                             # trace out qubit B
    r = rho4.reshape(2, 2, 2, 2)                       # a,b,a',b'
    return np.trace(r, axis1=1, axis2=3)               # sum over b=b'

rho_a = partial_trace_B(rho_ab)
print("rho_A =\n", np.round(rho_a, 3))                 # I/2
print("purity(rho_AB) =", purity(rho_ab))             # 1.0 (whole is pure)
print("purity(rho_A)  =", purity(rho_a))              # 0.5 (part is mixed!)
print("entanglement S =", vn_entropy(rho_a))          # 0.693 = ln 2

Where the density matrix shows up

• Quantum information. Noisy qubits, quantum channels, fidelity, and error correction are all defined on density matrices — a physical qubit is almost never a clean ket.
• Decoherence theory. The environment-induced diagonalization of ρ explains the quantum-to-classical transition without collapse.
• Quantum statistical mechanics. The thermal state ρ = e^(−H/k_BT)/Z is the workhorse of finite-temperature quantum physics.
• Quantum optics. Unpolarized light, thermal light, and the states produced by lasers are naturally mixed and described by ρ.
• NMR and spin ensembles. Bulk magnetic resonance works entirely with the spin density matrix and its T₁/T₂ relaxation.
• Entanglement measures. Entanglement entropy S(ρ_A), negativity, and concurrence are all functions of reduced density matrices.
• Black-hole thermodynamics. The entanglement entropy of quantum fields across a horizon is a von Neumann entropy of a reduced density matrix.

Common misconceptions

• Confusing a superposition with a mixture. (|0⟩+|1⟩)/√2 is a pure state (purity 1, S = 0, has coherences). A 50/50 mixture of |0⟩ and |1⟩ is mixed (purity ½, S = ln 2, no coherences). Same populations, entirely different physics.
• Thinking ρ is unique to its ensemble. The decomposition ρ = Σ p_i |ψ_i⟩⟨ψ_i| is not unique — many different ensembles give the same ρ, and no measurement can tell them apart. Only ρ itself is physical.
• Assuming a subsystem always has a wavefunction. If A is entangled with B, subsystem A has no pure state — only a reduced density matrix. Insisting on a ket for A is simply wrong.
• Forgetting the trace is basis-independent. ⟨A⟩ = Tr(ρA) gives the same number in every basis; picking a "convenient" basis never changes a prediction.
• Treating decoherence as collapse. Decoherence suppresses off-diagonal coherences via entanglement with the environment; globally the evolution stays unitary. It explains classicality without a measurement postulate.
• Reading off-diagonal elements as populations. Only the diagonal ρ_nn are probabilities. The off-diagonal ρ_mn are complex phase relationships and can even be negative or imaginary.