Projective Measurement
Projective Measurement
Measurement is where the deterministic, unitary world of quantum mechanics hands you a random classical number — and then violently rewrites the state to match. This lesson makes that precise. The Born rule assigns the probabilities, Hermitian observables package the question you ask, and projection describes the collapse. Get this exactly right and the rest of quantum information — uncertainty, POVMs, entanglement, every algorithm's read-out step — follows without mysticism.
Learning Objectives
After this lesson you will be able to:
- State the Born rule and compute outcome probabilities .
- Decompose an observable into its spectral projectors and read off measurement outcomes and probabilities.
- Apply the projection postulate: the post-measurement state .
- Prove repeatability of projective measurement and explain measuring in different bases (computational vs. ).
- Show that orthogonal states are perfectly distinguishable by a single projective measurement.
Intuition
A measurement asks the state a question with a fixed list of allowed answers. The question is an observable; the allowed answers are its eigenvalues. Quantum mechanics adds two twists that classical physics does not have:
- The answer is random unless the state was already an eigenstate of the question. The amount of "overlap" the state has with each eigenstate sets the probability — that's the Born rule.
- Asking changes the state. Once you get answer , the state snaps onto the subspace of states that would have given with certainty. This is collapse, and it is described by a projector.
Geometrically: a normalized state is a unit vector. Measuring in an orthonormal basis drops a perpendicular onto each axis; the squared length of the shadow on axis is the probability of outcome , and after the measurement the vector is that axis. Pythagoras () is exactly why the probabilities sum to one.
Theory
The Born rule
Born rule (basis form). If a system is in normalized state and we measure in the orthonormal basis , the probability of outcome is
These are genuine probabilities: each , and using completeness (0.1.3),
So normalization is conservation of probability. This is also why states are only defined up to a global phase: and give identically (the cancels), so no measurement can ever distinguish them.
Observables and spectral decomposition
A measurable quantity is an observable: a Hermitian operator . By the spectral theorem for Hermitian operators (0.1.5, 0.1.6) it has real eigenvalues and an orthonormal eigenbasis. Grouping eigenvectors that share an eigenvalue into eigenspaces, write the spectral decomposition
where the are the distinct eigenvalues and is the orthogonal projector onto the -eigenspace. These projectors form a complete set of orthogonal projectors:
The first two say each is a projector () and distinct eigenspaces are orthogonal; the last is completeness (the eigenvectors span ). The eigenvalues are the possible measured values; the projectors encode the question's answer-slots.
Projective (von Neumann) measurement
Projective measurement postulate. A projective measurement is specified by a complete set of orthogonal projectors (, ), one per outcome. Measuring state yields outcome with probability
and the state immediately after, given outcome , is
The basis-form Born rule is the special case where every is rank one: then , recovering the boxed rule above. The projector form is more general because it allows degenerate outcomes (rank ): a measurement need not resolve which vector inside an eigenspace you landed on.
Why these are probabilities, again. Positivity: $p_k = \langle\psi|P_k|\psi\rangle = \langle\psi|P_k^\dagger P_k|\psi\rangle = |P_k|\psi\rangle|^2 \ge 0P_k=P_k^\dagger=P_k^2$. Normalization: .
Renormalization of the collapsed state. The raw post-measurement vector has norm , so dividing by restores a unit vector — collapse keeps us on the unit sphere. Note this is a non-linear, non-unitary, irreversible update: information about the components in the other eigenspaces is gone.
Expectation preview. Once you have , the average measured value is . We make this — and its spread — the whole subject of the next lesson.
Repeatability
Projective measurement is repeatable: measure the same observable twice in immediate succession and the second result equals the first, with certainty.
Proof. Suppose the first measurement returned , collapsing to . The probability that an immediate second measurement of the same returns outcome is
using and . So if and otherwise. ∎
Repeatability is what makes the eigenvalue a property of the post-measurement state: after measuring, the system is in an eigenstate of with definite value . (This idealization assumes no evolution between the two measurements; dynamics — Term 1.6 — will generally move the state off the eigenstate.)
Measuring in different bases
The same state gives different statistics depending on which observable you measure — i.e. which orthonormal basis you project onto.
- Computational () basis. , so the projectors are , . Outcome "" () with probability , outcome "" () with .
- Hadamard () basis. with . The projectors are , , and outcome probabilities are .
Hardware almost always measures in the computational basis only. To measure in another basis you rotate that basis onto the computational basis first, then measure . Since and (the Hadamard swaps the - and -bases, ; Appendix E), measuring on is identical to applying and measuring :
This "rotate, then read " pattern is how all basis changes (and expectation-value estimation) are implemented on real devices — we use it from Term 1.2.3 onward and in the Braket code below.
Perfect distinguishability of orthogonal states
Claim. Two orthogonal states can be distinguished with certainty by a single projective measurement. Non-orthogonal states cannot (proved in Lesson 3).
Proof. Extend to an orthonormal basis and take the projective measurement with and . If the system is prepared in , then , while . Symmetrically for . So the outcome reveals the prepared state with zero error. ∎
This is the bedrock fact behind quantum communication and read-out: an orthonormal basis is a set of perfectly reliable codewords. The moment states are non-orthogonal, perfect discrimination is impossible — the seed of the uncertainty principle and of quantum cryptography.
Worked Examples
Example 1 — Measuring in the basis
Let and measure the observable , i.e. project with , .
Probabilities.
A coin flip, as expected for an equatorial Bloch state. The associated eigenvalues are and , so .
Collapse. If we get outcome "",
The superposition is destroyed; a re-measurement of now yields "" with certainty (repeatability).
Example 2 — Measuring in the basis
Same state , now measure the observable with projectors , .
Probabilities. Because is itself an eigenstate of (with eigenvalue ),
So in the basis the outcome is deterministic: always "". The state did not need to collapse — leaves it unchanged.
The lesson. A single state is maximally uncertain in () yet perfectly certain in . "Definiteness" is a relationship between a state and a chosen observable, not an intrinsic property of the state. This complementarity is quantified by the uncertainty relation next lesson, and the "rotate then read " recipe (-measurement apply , measure ) is exactly the Braket experiment below.
Hands-on (Python)
A self-contained NumPy simulator for projective measurement, then a brief Braket sanity check. We do all quantitative work in NumPy; Braket here is only an illustration of sampling on the (free) local simulator.
import numpy as np
# ---- States and observables (big-endian; |0> is index 0) -----------------
ket0 = np.array([1, 0], dtype=complex)
ket1 = np.array([0, 1], dtype=complex)
plus = (ket0 + ket1) / np.sqrt(2) # |+>
minus = (ket0 - ket1) / np.sqrt(2) # |->
Z = np.array([[1, 0], [0, -1]], dtype=complex)
X = np.array([[0, 1], [1, 0]], dtype=complex)
def projectors_from_observable(A):
"""Spectral decomposition A = sum_k lambda_k P_k.
Returns (distinct eigenvalues, projectors) with eigenvalues grouped so that
degenerate eigenspaces yield a single (possibly rank>1) projector.
"""
A = (A + A.conj().T) / 2 # symmetrize for numerical safety
eigvals, eigvecs = np.linalg.eigh(A) # eigh: Hermitian, orthonormal columns
distinct = []
projectors = []
for lam, vec in zip(eigvals, eigvecs.T):
P = np.outer(vec, vec.conj()) # |v><v|
# merge into an existing eigenspace if this eigenvalue already appeared
for i, d in enumerate(distinct):
if np.isclose(lam, d):
projectors[i] = projectors[i] + P
break
else:
distinct.append(lam.real)
projectors.append(P)
return np.array(distinct), projectors
def born_probabilities(psi, projectors):
"""p_k = <psi|P_k|psi> for each projector."""
return np.array([np.real(psi.conj() @ (P @ psi)) for P in projectors])
def collapse(psi, P, p):
"""Post-measurement state P|psi>/sqrt(p)."""
return (P @ psi) / np.sqrt(p)
def measure_once(psi, projectors, eigvals, rng):
"""Sample one projective-measurement outcome; return (eigenvalue, new_state)."""
p = born_probabilities(psi, projectors)
k = rng.choice(len(projectors), p=p)
return eigvals[k], collapse(psi, projectors[k], p[k])
# ---- Measuring |+> in the Z basis vs the X basis -------------------------
valsZ, projZ = projectors_from_observable(Z)
valsX, projX = projectors_from_observable(X)
print("Z-basis probs on |+>:", np.round(born_probabilities(plus, projZ), 6)) # [0.5 0.5]
print("X-basis probs on |+>:", np.round(born_probabilities(plus, projX), 6)) # deterministic
# Sanity checks against the postulate
for P in projZ:
assert np.allclose(P @ P, P) and np.allclose(P, P.conj().T) # projector
assert np.allclose(sum(projZ), np.eye(2)) # completeness
assert np.isclose(born_probabilities(plus, projZ).sum(), 1.0) # normalization# ---- Empirical sampling: 50/50 for Z, and repeatability ------------------
rng = np.random.default_rng(0)
shots = 10_000
counts = {+1: 0, -1: 0}
for _ in range(shots):
val, _ = measure_once(plus, projZ, valsZ, rng)
counts[int(round(val.real))] += 1
print("Z-measurement of |+> :", counts) # ~5000 / ~5000
# Repeatability: after collapse, remeasure -> same outcome, every time
val1, psi_after = measure_once(plus, projZ, valsZ, rng)
val2, _ = measure_once(psi_after, projZ, valsZ, rng)
assert val1 == val2 # always equal
print("Collapsed eigenvalue", int(val1.real), "is repeatable:", val1 == val2)A brief look on Braket's local simulator (free — no AWS charges, no account needed). Measuring
in is H on then a default (computational-basis) measurement; we expect a
roughly even split. To measure instead, you would apply a second H before measuring (rotate the
-basis onto ).
# Braket LocalSimulator: prepare |+> = H|0>, sample in the computational (Z) basis.
from braket.circuits import Circuit
from braket.devices import LocalSimulator
device = LocalSimulator() # free local state-vector simulator
circ = Circuit().h(0) # |0> -> |+>
counts = device.run(circ, shots=1000).result().measurement_counts
print(counts) # e.g. Counter({'0': ~500, '1': ~500})
# Big-endian: the single bit is qubit 0. Outcome '0' <-> Z eigenvalue +1.The NumPy
measure_onceis the reference semantics; Braket samples the same Born distribution on a high-performance simulator. We keep expectation/probability computations in NumPy (exact), and use Braket only for sampling — the deep Braket introduction is Term 2.1.
Exercises
E1 (easy). A qubit is in . Compute the probabilities of outcomes "" and "" in a computational-basis measurement, and the post-measurement state for each.
Solution
, ; they sum to . ✓ Collapse: outcome "" gives ; outcome "" gives . (Computational-basis projectors are rank one, so collapse always lands exactly on or .)
E2 (easy). Measure the state in the basis. What are the probabilities, and what is the collapsed state for each outcome?
Solution
, so . Outcome "" collapses to , outcome "" to . ( is unbiased in the basis, mirroring Example 2 with the roles of and swapped.)
E3 (medium). Let A = \begin{psmallmatrix}2&0\\0&5\end{psmallmatrix} and . Find the spectral projectors of , the probability of each measured value, and the expectation two ways (via and via ).
Solution
is already diagonal: eigenvalues (eigenvector ) and (), so , . Probabilities: , . Then . Directly, . ✓ Agreement is the identity .
E4 (medium). Consider the degenerate observable on two qubits acting on . Find the spectral projectors of (note the eigenvalues are degenerate, rank-2), the outcome probabilities, and the collapsed states.
Solution
has eigenvalue on the span of and on , so and (each rank 2). On : , giving and collapse ; likewise with collapse . The degenerate measurement learns only qubit 0's value, but here that already pins the full state because of the entanglement — a preview of Term 1.4.
E5 (hard). Prove that the average post-measurement state (averaging over outcomes, weighted by their probabilities, before you learn the outcome) is the "decohered" operator where . Then show its diagonal in the measurement basis matches the Born probabilities.
Solution
With probability the state becomes (a pure state). Averaging over outcomes: $\bar\rho = \sum_k p_k,\rho_k = \sum_k P_k|\psi\rangle\langle\psi|P_k = \sum_k P_k,\rho,P_kp_kP_k = |k\rangle\langle k|$, , whose entry is and whose off-diagonal entries vanish: measurement (unconditioned) destroys coherences. This map is the prototype of a quantum channel — Term 4.1. ∎
E6 (hard). Prove the perfect-distinguishability claim in reverse: if a projective measurement distinguishes states with zero error (outcome prepared , outcome , each with certainty), then .
Solution
Zero error means and , with (since implies the "wrong" probabilities are ). From and with , equality forces ; likewise and . Therefore $\langle\psi_0|\psi_1\rangle = \langle\psi_0|P_0|\psi_1\rangle = \langle\psi_0|(P_0|\psi_1\rangle) = \langle\psi_0|0\rangle = 0$. ∎ So only orthogonal states are perfectly distinguishable — non-orthogonal states need POVMs and still cannot reach zero error (Lesson 3).
Checkpoint
- State the Born rule and prove that the outcome probabilities sum to .
- What three algebraic conditions define a complete set of orthogonal projectors ?
- Write the post-measurement state after outcome , and explain the role of the .
- Prove that projective measurement is repeatable.
- How do you measure the observable on hardware that can only measure ?
- Why are orthogonal states perfectly distinguishable but and are not?
Answers
- . $\sum_k p_k = \langle\psi|\sum_k P_k|\psi\rangle = \langle\psi|I|\psi\rangle = 1$ by completeness and normalization.
- (Hermitian), (orthogonal idempotents), and (complete).
- . The raw vector has norm ; dividing renormalizes it to a unit vector so it is a valid state.
- After collapse to , a second measurement gives outcome with probability using .
- Rotate the -eigenbasis onto the computational basis (apply , since ), then measure ; .
- A projective measurement assigns outcome 0 with certainty only if ; orthogonality lets be the corresponding rank-1 projectors with no overlap. have , so no projective measurement (indeed no measurement) separates them with zero error.
Further Reading
- [NC] Nielsen & Chuang, §2.2.3–2.2.5 — the measurement postulate, projective measurements, and the global-phase / observable discussion.
- [Sak] Sakurai & Napolitano, §1.4 — measurements, observables, and the collapse postulate, with the Stern–Gerlach intuition.
- [Pre] Preskill, Ph219, Ch. 2 — the axioms of measurement and the orthogonal-projector formalism.
← Prev: Bases & Expectation Values · Up: Term 1 · Next: Expectation & Uncertainty →