Part II. Mathematical Core · Chapter 10

Inner Products, Orthogonality, and Projection

One number — the inner product — tells you how much two quantum states overlap, whether any measurement can tell them apart, and what is left of a state after you measure it. This chapter turns that number into something you can compute, not just recognize.

Steven GellerPublished July 25, 2026Revised August 14, 2026

Artifact

In this chapter 8 sections

Reader question. How does the inner product quantify overlap and determine the probability of projecting onto a measurement outcome?

The complex inner product uses conjugation to measure overlap; orthogonal states have zero overlap, normalized projection magnitude squared gives an outcome probability, and nonorthogonal states cannot be perfectly separated by a single projective test.

Scope and non-goals.

This chapter does not derive optimal state discrimination or generalized POVMs.
It does not treat geometric similarity as a metaphor detached from the Born rule.

Figure 10.1. Notice that the same geometry settles three different questions: how much the states overlap, what probability a measurement returns, and whether any measurement can distinguish the states at all.

Conjugation makes overlap physical

Derive conjugate symmetry and nonnegative self-overlap.

The inner product answers a single question: how much does one state lean in the direction of another? For real vectors it is the dot product you already know. Quantum states carry complex amplitudes, so the first vector must be conjugated before anything is multiplied:

\lvert a\rangle=\begin{pmatrix}a_0\\a_1\end{pmatrix},\quad \lvert b\rangle=\begin{pmatrix}b_0\\b_1\end{pmatrix}

\langle a\vert b\rangle=a_0^\ast b_0+a_1^\ast b_1

Skip the conjugation and you get answers that are wrong in a specific way: phases that should cancel do not, and probabilities come out complex or negative. With the conjugate in place, the result is always a complex number whose magnitude never exceeds the product of the two lengths.

When that number is zero, the states are orthogonal; they share no direction at all. Orthogonal states can be distinguished perfectly by a single measurement in the right basis. Non-orthogonal states cannot be, no matter how clever the instrument. That is a theorem, not an engineering limitation.

Evidence boundary. Complex inner products are conjugate-linear in one argument and define norms and orthogonality. [John Watrous] [Michael A. Nielsen]

Zero overlap means distinguishable directions

Calculate orthogonal and nonorthogonal pairs.

Projection onto a normalized vector $\lvert v\rangle$ is itself an operator, built from the outer product:

P_v=\lvert v\rangle\!\langle v\rvert

Apply $P_v$ to $\lvert\psi\rangle$ and you get the component of the state that lies along $\lvert v\rangle$ . Three different objects then follow, and keeping them straight is most of this chapter:

The amplitude $\langle v\vert\psi\rangle$ ; a complex number, the overlap itself.
The probability $\lvert\langle v\vert\psi\rangle\rvert^2$ ; the Born rule; a real number between 0 and 1.
The post-measurement state; the projected vector $P_v\lvert\psi\rangle$ , renormalized to unit length.

Measurement returns the outcome $v$ with the Born-rule probability, and afterward the system is described by the renormalized projection. A probability is a number; the post-measurement state is a vector. Confusing the two is the classic beginner error, and it poisons every calculation downstream of it.

Evidence boundary. A rank-one projector |v><v| is Hermitian and idempotent for normalized |v>. [John Watrous] [John Preskill]

A projector asks one yes-or-no question

Construct |v><v| and apply it to a state.

A stronger error is overstating distinguishability. If two states are not orthogonal, no measurement; on one copy, in any basis, with any cleverness; identifies them perfectly. A claim that quietly assumes perfect discrimination of non-orthogonal states is a claim that violates the Born rule.

Evidence boundary. Projection probabilities follow from squared overlaps under projective measurement. [Michael A. Nielsen] [John Watrous]

\langle a\vert b\rangle=a^\dagger b;\quad P_v=\lvert v\rangle\!\langle v\rvert

Probability and surviving component

Separate projection norm from normalized post-measurement state.

An inner product is a similarity query with strict physical semantics. Overlaps appear everywhere: state-preparation checks, amplitude amplification, quantum kernels, error-correction syndromes, and verification protocols all reduce, at some point, to computing $\langle a\vert b\rangle$ and deciding what it means.

What it means depends on the task. In an algorithm an overlap may be a success amplitude; in verification it may compare a prepared state against a target; in communication it may bound how well two signals can be told apart. The evidence type differs too: a simulator can report state fidelity directly, while hardware gives you sampled outcomes. Related, but not interchangeable; a test plan that mixes them will lie to you.

A discrimination limit visible in two dimensions

Use nonzero overlap to rule out a perfect projective separator.

Perfect one-shot discrimination requires orthogonal supports. For |0> and |+>, the overlap magnitude is 1/sqrt(2), so no measurement can assign a unique outcome to both states without error. More elaborate measurements can optimize the error probability or admit an inconclusive result, but cannot manufacture orthogonality. Any protocol that assumes otherwise has hidden impossible information in its readout contract.

Inner-product and projector verifier

Acceptance contract for Inner-product and projector verifier
Field	Reader-visible record
Format	Symbolic/numerical notebook with geometric visualization
Verification	Tests conjugate symmetry, idempotent projectors, probability bounds, and normalized conditional states.
Availability	Source-embedded acceptance record; no separate download is claimed

{
  "artifact": "Inner-product and projector verifier",
  "format": "Symbolic/numerical notebook with geometric visualization",
  "acceptance_test": "Tests conjugate symmetry, idempotent projectors, probability bounds, and normalized conditional states.",
  "publication_state": "source-embedded contract and worked fixture"
}

Executable reference fixture

Run with Python 3.11 or later. The final assertion is the chapter-level pass condition for this small instance.

import math

def inner(left, right):
    return sum(a.conjugate() * b for a, b in zip(left, right))

def matvec(matrix, vector):
    return tuple(sum(value * vector[column] for column, value in enumerate(row)) for row in matrix)

def matmul(left, right):
    return tuple(tuple(sum(left[row][k] * right[k][column] for k in range(len(right)))
                       for column in range(len(right[0]))) for row in range(len(left)))

def projector(ket):
    norm = inner(ket, ket).real
    if abs(norm - 1.0) > 1e-12:
        raise ValueError("projector ket must be normalized")
    return tuple(tuple(ket[row] * ket[column].conjugate() for column in range(len(ket)))
                 for row in range(len(ket)))

def condition(matrix, state):
    projected = matvec(matrix, state)
    probability = inner(projected, projected).real
    if probability < 1e-15:
        raise ValueError("cannot normalize a zero-probability branch")
    return probability, tuple(value / math.sqrt(probability) for value in projected)

scale = math.sqrt(0.5)
kets = ((1 + 0j, 0j), (scale, 1j * scale))
states = ((0.6, 0.8), (scale, scale), (scale, -1j * scale))
max_idempotence_error = 0.0
probabilities = []
for ket in kets:
    matrix = projector(ket)
    squared = matmul(matrix, matrix)
    max_idempotence_error = max(max_idempotence_error,
                                *(abs(squared[row][column] - matrix[row][column])
                                  for row in range(2) for column in range(2)))
    for state in states:
        probability = inner(state, matvec(matrix, state)).real
        assert -1e-12 <= probability <= 1.0 + 1e-12
        probabilities.append(probability)
        if probability > 1e-12:
            branch_probability, conditional = condition(matrix, state)
            assert abs(branch_probability - probability) < 1e-12
            assert abs(inner(conditional, conditional) - 1.0) < 1e-12
assert max_idempotence_error < 1e-12

for left in states:
    for right in states:
        assert abs(inner(left, right) - inner(right, left).conjugate()) < 1e-12
assert abs(inner(kets[0], kets[1])) == scale

zero_branch_rejected = False
try:
    condition(projector((1, 0)), (0, 1))
except ValueError:
    zero_branch_rejected = True
assert zero_branch_rejected
bad_projector_rejected = False
try:
    projector((2, 0))
except ValueError:
    bad_projector_rejected = True
assert bad_projector_rejected
naive = lambda left, right: sum(a * b for a, b in zip(left, right))
assert abs(naive((1j, 0), (1j, 0)) - inner((1j, 0), (1j, 0))) > 1.0
print(f"PASS: 10 projector verifier checks {len(probabilities)} Born probabilities; range=[{min(probabilities):.3f},{max(probabilities):.3f}], last derived probability={probability:.3f}, max P^2-P error={max_idempotence_error:.2e}")

Scope boundary

This chapter does not derive optimal state discrimination or generalized POVMs.
It does not treat geometric similarity as a metaphor detached from the Born rule.

Depth commitment. One inner-product derivation, one projector proof, one nonorthogonal limit, and one verified exercise.

Practice problem

For $\lvert\psi\rangle=(\lvert0\rangle+i\lvert1\rangle)/\sqrt{2}$ and $\lvert v\rangle=(\lvert0\rangle+\lvert1\rangle)/\sqrt{2}$ , compute overlap, projection probability, and normalized post-measurement state.

Deliverable: Exact complex overlap, probability, projected vector, and invariant checks.
Pass condition: The notebook asserts P²=P, 0≤p≤1, and unit norm after conditioning.

Verification record

Expected solution form. Aligned derivation plus independent matrix calculation.

Model answer. The overlap <v|psi> is (1+i)/2 and the projection probability is its squared magnitude, 1/2. The normalized projected state is |v> up to the global phase exp(i pi/4).

Model result and check. A test constructs P numerically and compares direct projection with overlap-based probability.

Acceptance test. The notebook asserts P²=P, 0≤p≤1, and unit norm after conditioning.

Companion work

Artifacts for this chapter

These entries resolve to checked-in local source. Commands are reproduced exactly from the chapter manifest, and source-embedded fixtures are exported as direct downloads.

executable derivation
Inner-product and projector verifier
Download fixture (.py)Verification record (.json)
Reproduce or test
python3 tools/validate_briefs.py --briefs data/editorial_briefs_00_35.json --from 0 --through 35 --check-rewritten-sources --execute-artifacts

Provenance

Sources and review

The load-bearing claims in the chapter are mapped inline to this registered source set. A citation supports only the bounded claim beside it.

External review: Open.

How review works Revision history Report or inspect errata

Book contents

Part II. Mathematical Core

Inner Products, Orthogonality, and Projection

Conjugation makes overlap physical

Zero overlap means distinguishable directions

A projector asks one yes-or-no question

Probability and surviving component

A discrimination limit visible in two dimensions

Inner-product and projector verifier

Artifacts for this chapter

Inner-product and projector verifier

Sources and review

Cite this chapter

Conjugation makes overlap physical#

Zero overlap means distinguishable directions#

A projector asks one yes-or-no question#

Probability and surviving component#

A discrimination limit visible in two dimensions#

Inner-product and projector verifier#

Artifacts for this chapter

Inner-product and projector verifier

Sources and review

Prerequisites for this chapter

Next concepts from this chapter

Conjugation makes overlap physical

Zero overlap means distinguishable directions

A projector asks one yes-or-no question

Probability and surviving component

A discrimination limit visible in two dimensions

Inner-product and projector verifier