Measurement and the Born Rule

A single qubit can hold a state like $\tfrac{1}{\sqrt2}|0\rangle + \tfrac{1}{\sqrt2}|1\rangle$ . This is a superposition of two possibilities at once. But no experiment has ever shown a "half-0, half-1" reading on a meter. Every measurement of a qubit yields exactly one classical bit, 0 or 1. It is never something in between. The puzzle this article resolves is how a continuous, complex-valued description of a quantum state produces a single discrete, probabilistic outcome. It also asks what happens to the state the instant after that outcome appears. This matters because measurement is the only way information ever leaves a quantum computer. Every quantum algorithm, no matter how clever its interference pattern, ultimately reduces to reading out classical bits at the end. The statistics of those bits are governed by one rule. Understanding that rule precisely is a prerequisite for reasoning about anything built on top of Dirac Notation and the State Vector. This means not "state collapses somehow," but the exact formula for outcome probabilities and the exact post-measurement state. Gates, circuits, entanglement, and error correction all lean on measurement working exactly this way. The rule in question is the Born rule, named for Max Born. He proposed the probabilistic interpretation of the wavefunction in 1926. In the language of qubits, it says this: the probability of observing outcome $x$ when measuring in the computational basis equals the squared modulus of the amplitude on $|x\rangle$ . Immediately afterward, the state vector snaps — collapses — to $|x\rangle$ itself. This discards all the other amplitudes that were present a moment before. This article gives the precise statement of projective measurement in the computational basis. It derives outcome probabilities from amplitude moduli squared. It works through multi-qubit examples with full arithmetic. It also explains why collapse must work this way for probability to be conserved, and for repeated measurement to be consistent. It closes by connecting measurement to the gates (Single-Qubit Gates: X, Y, Z, H) that manipulate amplitudes before measurement reads them out. It also connects to Entanglement and Correlated Measurement, where measuring one qubit constrains the state of another.

Key takeaways

A qubit state $\alpha|0\rangle+\beta|1\rangle$ yields outcome $0$ with probability $|\alpha|^2$ and outcome $1$ with probability $|\beta|^2$ ; these must sum to 1.
This is the Born rule: probability equals the squared modulus of the amplitude on the observed basis state.
After measurement, the state collapses: all amplitudes are erased except the one corresponding to the observed outcome, which is renormalized to have modulus 1.
For $n$ qubits, computational-basis measurement of all qubits gives outcome string $x \in \{0,1\}^n$ with probability $|\langle x|\psi\rangle|^2$ .
Measuring only some qubits of an entangled multi-qubit state still obeys the Born rule, but collapses the remaining qubits into a conditional state — the seed of quantum correlations.
Measurement is irreversible and destructive: it is not a unitary gate, and repeating it on the collapsed state always reproduces the same outcome.

The core insight

The probability of a measurement outcome is the squared modulus of its amplitude, and after measurement the state collapses to exactly that outcome.

The idea

A qubit's state vector $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$ lives in a two-dimensional complex Hilbert space, with $\alpha,\beta \in \mathbb{C}$ and the normalization constraint $|\alpha|^2 + |\beta|^2 = 1$ . This vector is not itself an observable quantity — no instrument reads off $\alpha$ or $\beta$ directly. What an instrument can do is perform a projective measurement: a physical interaction, engineered to have exactly two possible classical outcomes, labeled $0$ and $1$ , corresponding to the two basis states $|0\rangle$ and $|1\rangle$ . This choice of basis is called the computational basis, and measuring "in the computational basis" means asking the question "is this qubit closer to $|0\rangle$ or to $|1\rangle$ ?" in the precise sense made below. The Born rule states that measuring $|\psi\rangle = \alpha|0\rangle+\beta|1\rangle$ in the computational basis produces outcome $0$ with probability $P(0) = |\alpha|^2$ and outcome $1$ with probability $P(1) = |\beta|^2$ . Because $\alpha$ and $\beta$ can be complex, $|\alpha|^2 = \alpha\alpha^*$ (the amplitude times its complex conjugate) is what makes this quantity real, non-negative, and interpretable as a probability. The normalization condition $|\alpha|^2+|\beta|^2=1$ is exactly the statement that these two probabilities sum to one — normalization of the state vector is the statement that Born-rule probabilities form a valid distribution. The second half of the rule is collapse. Immediately after an outcome is observed, the qubit's state is no longer $|\psi\rangle$ ; it is exactly the basis state corresponding to the outcome. If outcome $0$ occurs, the post-measurement state is $|0\rangle$ (with certainty); if outcome $1$ occurs, it is $|1\rangle$ . All information about the original $\alpha,\beta$ — apart from the classical bit that came out — is gone. This is fundamentally different from a classical measurement of, say, a coin already lying heads-up: quantum measurement actively creates a definite value where before there was only a probability distribution over the two possibilities, and it does so destructively, discarding coherence between the outcomes. This distinguishes measurement from any Single-Qubit Gates: X, Y, Z, H operation, all of which are reversible unitary transformations that preserve superposition; measurement is irreversible and non-unitary.

How it works

For a single qubit the mechanism is direct: compute two probabilities from the amplitudes, sample an outcome according to those probabilities, then reset the state vector to the corresponding basis vector. For $n$ qubits the same logic applies to the $2^n$ -dimensional state, with basis states indexed by bit strings $x \in \{0,1\}^n$ .

General statement (n qubits, full measurement). Let

|\psi\rangle = \sum_{x \in \{0,1\}^n} \alpha_x |x\rangle, \qquad \sum_x |\alpha_x|^2 = 1.

Measuring all $n$ qubits in the computational basis yields outcome string $x$ with probability

P(x) = |\alpha_x|^2 = |\langle x|\psi\rangle|^2,

and the post-measurement state collapses to $|x\rangle$ .

Partial measurement. If only a subset $S$ of qubits is measured, group the amplitudes by the value $s$ that $S$ takes. Let $\Pi_s$ project onto the subspace where those qubits equal $s$ . The probability of observing $s$ on the measured qubits is

P(s) = \sum_{x: \, x_S = s} |\alpha_x|^2 = \| \Pi_s |\psi\rangle \|^2,

and the collapsed (renormalized) state of the whole system becomes

|\psi'\rangle = \frac{\Pi_s |\psi\rangle}{\sqrt{P(s)}}.

The unmeasured qubits are left in whatever conditional state remains after discarding all amplitude branches inconsistent with the observed $s$ — this is exactly the mechanism behind measurement-induced correlations discussed in Entanglement and Correlated Measurement. ``` // MEASURE-COMPUTATIONAL-BASIS // Input: state vector alpha[0 .. 2^n - 1] (complex amplitudes), subset S of qubit indices to measure // Output: classical outcome string s (bits for qubits in S), and the updated state vector function MEASURE(alpha, n, S): // Step 1: bucket basis states by the value they assign to the measured qubits for each possible value s of the qubits in S: prob[s] <- 0 for x in 0 .. 2^n - 1: s <- extract_bits(x, S) // the sub-string of x on positions S prob[s] <- prob[s] + |alpha[x]|^2 // Step 2: sanity check — probabilities must sum to 1 (up to floating-point tolerance) assert abs(sum(prob) - 1.0) < EPSILON // Step 3: sample the classical outcome s_observed <- SAMPLE_FROM_DISTRIBUTION(prob) // Step 4: collapse — zero out every amplitude inconsistent with s_observed norm_sq <- prob[s_observed] for x in 0 .. 2^n - 1: if extract_bits(x, S) != s_observed: alpha[x] <- 0 else: alpha[x] <- alpha[x] / sqrt(norm_sq) // renormalize survivors return s_observed, alpha ``` Two details make this pseudocode faithful to the physics rather than a generic sampling routine. First, the assert in Step 2 is not defensive programming — it is the correctness invariant of the whole theory: if amplitudes are properly normalized and evolved only by unitary gates, that sum is guaranteed to equal 1 exactly (see the Complexity & Correctness section). Second, Step 4's renormalization by $\sqrt{P(s)}$ is required precisely because after zeroing inconsistent amplitudes, the surviving ones no longer sum (in squared modulus) to 1 — dividing by $\sqrt{P(s)}$ restores a valid unit-norm state vector, which is what allows further gates or measurements to be applied consistently.

Figure

Measurement of a single qubit: superposition collapses to one basis outcome

Complexity & correctness

Time and space complexity. Simulating a full computational-basis measurement of an $n$ -qubit state requires computing $2^n$ squared-modulus terms and sampling from a distribution of size (up to) $2^n$ , giving $O(2^n)$ time and $O(2^n)$ space, since the state vector itself already occupies $2^n$ complex amplitudes. For a partial measurement over $|S|=k$ qubits, bucketing takes $O(2^n)$ time (one pass over all amplitudes) and $O(2^{n-k})$ space for the collapsed survivor amplitudes. This is a statement about classical simulation cost, not about physical measurement, which on real hardware takes a fixed, basis-independent physical time (e.g., microseconds for superconducting qubit readout) regardless of $n$ for a single measurement event — the exponential cost is the price of simulating quantum measurement on a classical computer, which is precisely why quantum computers are of interest in the first place.

Correctness — why probabilities sum to one. This is not an assumption to be checked once; it is an invariant maintained by construction. The state vector starts normalized ( $\||\psi_0\rangle\|=1$ ). Every gate applied to it before measurement is represented by a unitary matrix $U$ , satisfying $U^\dagger U = I$ . Unitary evolution preserves the norm:

\||U\psi\rangle\|^2 = \langle \psi | U^\dagger U | \psi \rangle = \langle \psi|\psi\rangle = \||\psi\rangle\|^2 = 1.

So no matter what sequence of gates (studied in detail under Single-Qubit Gates: X, Y, Z, H) is applied, the state reaching the measurement step is guaranteed to still be a unit vector, and therefore $\sum_x |\alpha_x|^2 = 1$ automatically — the Born-rule probabilities are guaranteed to form a valid distribution because every prior operation was unitary. This is the mathematical reason quantum circuits never need explicit "renormalize before measuring" steps for intermediate gates, only after measurement's own collapse.

Correctness — why collapse must renormalize. After observing outcome $s$ , the surviving amplitudes satisfy $\sum_{x: x_S = s} |\alpha_x|^2 = P(s) < 1$ in general (unless $P(s)=1$ exactly). A state vector representing a physical state must have norm 1, so dividing by $\sqrt{P(s)}$ is forced, not optional — it is the unique rescaling that restores unit norm while preserving the relative phases and magnitudes among the surviving amplitudes. This guarantees a crucial consistency property: measuring the same qubit again immediately afterward always reproduces the same outcome with probability 1. Concretely, if qubit collapses to $|0\rangle$ , then $\alpha = 1, \beta = 0$ , and re-measuring gives $P(0) = |1|^2 = 1$ . This repeatability is what makes "the qubit is now in state $|0\rangle$ " a meaningful, checkable statement rather than a metaphor.

Tradeoffs and honesty about the model. The projective, computational-basis measurement described here is the simplest and most common model, sufficient for essentially all textbook algorithms and most experimental readouts. It is a special case of a more general framework (positive operator-valued measures, POVMs) that is needed to model noisy or non-orthogonal measurements realistically; that generalization is not needed at this level but is worth knowing exists. Also worth flagging: the Born rule as stated here assumes an ideal, instantaneous, and noiseless measurement — real hardware readout has finite fidelity (a few percent error rates on current devices), which is a separate engineering problem from the rule itself.

Worked example

Consider the two-qubit entangled state prepared by a Hadamard on the first qubit followed by a CNOT (the standard construction that appears again under Entanglement and Correlated Measurement):

|\psi\rangle = \frac{1}{\sqrt2}|00\rangle + \frac{1}{\sqrt2}|11\rangle.

Written out over the four basis strings, the amplitudes are:

basis state $x$	amplitude $\alpha_x$	$\|\alpha_x\|^2$
00	$1/\sqrt2$	$1/2$
01	$0$	$0$
10	$0$	$0$
11	$1/\sqrt2$	$1/2$

Full measurement (both qubits). Applying the algorithm: $\text{prob}[00] = 1/2$ , $\text{prob}[01]=0$ , $\text{prob}[10]=0$ , $\text{prob}[11]=1/2$ . These sum to $1$ , confirming the invariant. Sampling gives outcome $00$ or $11$ , each with probability $1/2$ ; outcomes $01$ and $10$ are impossible, no matter how many times the experiment is repeated. Say the sampler returns $11$ . Collapse zeroes every amplitude except $\alpha_{11}$ , then renormalizes: $\alpha_{11} \to \alpha_{11}/\sqrt{1/2} = (1/\sqrt2)/(1/\sqrt2) = 1$ . The post-measurement state is exactly $|11\rangle$ .

Partial measurement (qubit 1 only), traced through the algorithm explicitly. Now measure only the first qubit, $S = \{1\}$ . Bucket by the first bit: $x \in \{00,01\}$ has first bit $0$ , and $x\in\{10,11\}$ has first bit $1$ .

P(0) = |\alpha_{00}|^2 + |\alpha_{01}|^2 = \tfrac12 + 0 = \tfrac12, \qquad P(1) = |\alpha_{10}|^2 + |\alpha_{11}|^2 = 0 + \tfrac12 = \tfrac12.

Suppose the sampler returns outcome $0$ for the first qubit. Zero out every amplitude whose first bit is $1$ : $\alpha_{10}, \alpha_{11} \to 0$ . Renormalize the survivor: $\alpha_{00} \to \alpha_{00}/\sqrt{P(0)} = (1/\sqrt2)/(1/\sqrt2) = 1$ . The collapsed two-qubit state is

|\psi'\rangle = 1\cdot|00\rangle,

meaning the second qubit is now also forced into $|0\rangle$ , even though it was never directly touched by the measurement apparatus. This is the numerical signature of entanglement: measuring one half of an entangled pair instantaneously determines the state of the other half, with the Born rule and collapse rule together fully accounting for the correlation — no extra physics is needed beyond the rules given here.

Figure

Partial measurement of an entangled pair: measuring qubit 1 collapses qubit 2 too

Common pitfalls & traps

Pitfall	Why it happens	Fix
Using amplitude directly as probability ( $P = \alpha$ , not $\|\alpha\|^2$ )	Amplitudes can be negative or complex; forgetting the modulus-squared step	Always compute $\alpha\alpha^* = \|\alpha\|^2$ , a real non-negative number, before treating it as a probability
Forgetting to renormalize after collapse	Zeroing out inconsistent amplitudes leaves a sub-unit-norm vector that looks like a state but isn't	Divide surviving amplitudes by $\sqrt{P(\text{outcome})}$ before any further gate or measurement
Treating measurement as a reversible gate	All other circuit operations so far are unitary matrices, tempting the assumption that measurement is too	Recognize measurement as a distinct, irreversible, non-unitary operation — it has no inverse
Assuming measuring one qubit tells you nothing about others	Ignoring entanglement between the measured qubit and the rest of the register	Always recompute the joint collapsed state via the projector $\Pi_s$ , not just the measured qubit's marginal
Off-by-one in bit indexing when extracting $x_S$	Confusing qubit-index order (big-endian vs little-endian basis labeling)	Fix a labeling convention once (e.g., leftmost bit = qubit 1) and use it consistently throughout a computation

Pioneers & history

Origins · 1 minMax Born and how this was discovered

Max Born

1882–1970 · German physicist who, while analyzing Schrödinger's wave mechanics for particle scattering in 1926, proposed that the squared modulus of the wavefunction gives a probability density — the interpretive rule now bearing his name. He received the Nobel Prize in Physics in 1954 for this contribution, decades after the original proposal, reflecting how controversial the probabilistic interpretation was even among quantum theory's own founders.

History

1926

— Max Born proposes the probabilistic interpretation of the wavefunction, the origin of the Born rule.

1927

— Werner Heisenberg's uncertainty principle and Niels Bohr's complementarity sharpen the measurement debate.

1932

— John von Neumann formalizes measurement mathematically in his axiomatization of quantum mechanics, introducing projective collapse.

1935

— Einstein, Podolsky, and Rosen challenge completeness of quantum mechanics via entangled-state thought experiments, foreshadowing Entanglement and Correlated Measurement.

1964

— John Bell derives inequalities showing no local hidden-variable theory reproduces quantum measurement statistics, later confirmed experimentally.

Where this matters

Every quantum algorithm — Shor's factoring algorithm, Grover's search, quantum phase estimation, variational quantum eigensolvers running on today's cloud-accessible hardware — ends with computational-basis measurement, because that is the only channel through which quantum information becomes classical, human-readable output. The Born rule is what a compiler or simulator (Qiskit, Cirq, Q#) implements internally every time it reports "shots" and histograms of measurement outcomes from a circuit run many times. Quantum random number generators sold commercially rely directly on measuring a superposition like $\tfrac{1}{\sqrt2}(|0\rangle+|1\rangle)$ repeatedly and reading off genuinely unpredictable bits, with unpredictability guaranteed by the Born rule rather than by computational hardness as in classical pseudorandom generators. Quantum key distribution protocols (BB84 and its descendants) build their entire security argument on the fact that measuring a qubit in the wrong basis disturbs it irreversibly — a direct consequence of collapse. Quantum error correction, the technology needed to build large-scale fault-tolerant quantum computers, relies on carefully designed partial measurements (syndrome measurements) that extract only error information without collapsing the encoded logical qubit, a delicate application of exactly the partial-measurement machinery developed here.

Ask the tutor: If I measure only one qubit of a 3-qubit entangled state, how do I compute the exact collapsed state of the remaining two qubits?

Why is it the squared modulus of the amplitude, and not just the amplitude itself, that gives the probability?

Amplitudes are complex numbers and can be negative or have nonzero imaginary parts, so they cannot directly serve as probabilities, which must be real and non-negative. The quantity $|\alpha|^2 = \alpha \alpha^*$ (amplitude times its complex conjugate) is always real and non-negative, and the normalization condition $\sum_x |\alpha_x|^2 = 1$ that every valid state vector satisfies makes these quantities sum to exactly 1 — the defining property of a probability distribution. This specific choice, rather than say $|\alpha|$ or $\alpha^4$ , is an empirically verified postulate of quantum mechanics (the Born rule), not something derivable from more basic principles within the theory itself; it is confirmed by matching predicted statistics to measured outcome frequencies in countless experiments.

Is collapse a physical process, or just an update to our knowledge, like updating a classical probability after seeing a coin land?

This question sits at the heart of long-standing interpretational debates in quantum mechanics, but for the purposes of quantum computing the operational answer is unambiguous: whatever collapse "really is" philosophically, it produces measurable consequences that a classical-ignorance picture cannot reproduce. Bell's inequalities show that no theory where the qubit "secretly already had" a definite value consistent with classical probability can match quantum experimental statistics. So collapse must be treated, at minimum, as an objective update to the physically meaningful state vector, actively destroying superposition and entanglement, not merely narrowing an observer's uncertainty about a preexisting fact.

Can you measure a qubit in a basis other than the computational basis?

Yes — projective measurement in any orthonormal basis is well-defined, and the same Born-rule logic applies: expand the state in that basis, take squared moduli of the resulting amplitudes as probabilities, and collapse to the corresponding basis vector. A common example measures in the $|+\rangle, |-\rangle$ basis (equal superpositions), which requires first applying a Hadamard gate (see Single-Qubit Gates: X, Y, Z, H) and then measuring in the computational basis — a standard trick since most hardware only implements native computational-basis readout directly.

Does measuring a qubit affect other, unentangled qubits in the same register?

No. If a qubit is not entangled with the rest of the system, its state factors as a tensor product, and measuring it only collapses its own amplitudes, leaving every other qubit's state completely untouched. The dramatic effect on other qubits described in the worked example arises specifically because those qubits were entangled — their combined state could not be written as a product of individual qubit states. Distinguishing entangled from unentangled qubits is essential before predicting the effect of a partial measurement, a distinction developed further in Entanglement and Correlated Measurement.

Why can't we just read out α and β directly instead of getting one probabilistic bit?

Because no physical process is known — or, under standard quantum mechanics, believed possible — that extracts the full complex amplitudes of an unknown state from a single copy without disturbing it. Any attempt to measure "how much $|0\rangle$ " and "how much $|1\rangle$ " a qubit contains necessarily collapses it, destroying the very superposition being probed, and a single classical bit is all that survives the interaction. This is closely related to the The No-Cloning Theorem: if you could perfectly read out $\alpha,\beta$ , you could reconstruct arbitrarily many copies of the state, which cloning forbids for unknown quantum states.

If measurement is probabilistic, how can quantum algorithms give reliable, repeatable answers?

Quantum algorithms are engineered so that interference — constructive and destructive combination of amplitudes via gates — concentrates most of the probability mass onto the correct answer state before measurement ever happens. Shor's algorithm, for instance, guarantees the correct period is recovered with high probability (boosted arbitrarily close to 1 by repeating the whole circuit a constant number of times and taking a majority vote or post-processing check). The randomness of measurement is tamed at the algorithm-design level, not eliminated at the physics level; this design discipline is a running theme once gates are introduced in Single-Qubit Gates: X, Y, Z, H.

What is the difference between measuring all qubits versus measuring only a subset?

Measuring all $n$ qubits collapses the entire state vector down to a single classical bit string $x$ , with probability $|\alpha_x|^2$ , leaving no quantum information behind — the computation is fully finished and read out. Measuring only a subset $S$ collapses just the amplitude branches inconsistent with the observed sub-string, but leaves the unmeasured qubits in a genuine (possibly still entangled, possibly still superposed) quantum state that can undergo further gates. This partial-measurement capability is essential for techniques like quantum error correction syndrome extraction and mid-circuit measurement, where only diagnostic information is read out without destroying the computation in progress.