Steven GellerQuantum Computing, End to End

Book contents

Type at least two characters.

    Current section

    Part III. Circuit Model

    1. Circuit Notation as a Programming Language
    2. One-Qubit Gates and the Bloch Sphere
    3. Controlled Gates and Reversible Classical Computation
    4. Multi-Qubit Circuits
    5. Bell States and GHZ States
    6. No-Cloning and Why Copying Breaks Quantum Logic
    7. Circuit Cost: Depth, Width, Gate Set, Connectivity
    All chaptersGlossaryLabsSourcesAbout

    Part III. Circuit Model · Chapter 20

    Bell States and GHZ States

    One Hadamard and one CNOT turn ∣ 00 ⟩ into the most reused object in quantum information. This chapter builds Bell and GHZ states gate by gate, predicts their measurement statistics, and draws the line between correlation and control.

    Steven Geller
    Lab
    In this chapter 8 sections

    Reader question. How are Bell and GHZ states prepared, verified, and distinguished from ordinary correlated mixtures?

    Bell and GHZ states arise from a superposition followed by controlled gates, cannot factor into independent pure states, and retain basis-dependent coherence that a classically correlated mixture lacks; verification therefore needs more than matching computational-basis counts.

    Scope and non-goals.
    • This chapter does not certify entanglement from a single measurement setting or survey all multipartite entanglement classes.
    • It does not claim GHZ states are robust memories or direct evidence of useful computation.
    Bell and GHZ preparation by CNOT fan-out H, then CNOT fan-out: Bell on two wires, GHZ on three |0> |0> |0> H + + after H + one CNOT: q0,q1 are a Bell pair after the fan-out: (|000> + |111>)/√2
    Figure 20.1. Notice the fan-out: one control wire, a new target for each added qubit. Two gates entangle two qubits; one more CNOT extends the same correlation to three.

    Four Bell states from one circuit family

    Derive preparation operations and basis labels.

    Bell states are the simplest entangled states, and the recipe fits on an index card: put one qubit into superposition with a Hadamard, then let it control a CNOT onto a second qubit. GHZ states repeat the trick, fanning the same control out to more targets; the three-qubit version is:

    (∣000⟩+∣111⟩)/2(\lvert000\rangle+\lvert111\rangle)/\sqrt2(20.1)

    These states earn their keep as resources: their joint measurement statistics cannot be reproduced by qubits that are merely correlated the classical way. What they do not do, by themselves, is send controllable messages. The usable pattern is always joint state, chosen measurement bases, and a classical comparison afterwards.

    Evidence boundary. Bell states form an entangled orthonormal basis of two qubits. [Michael A. Nielsen] [John Watrous] [John S. Bell]

    Extend one control into a GHZ chain

    Trace ∣000⟩\lvert000\rangle to (∣000⟩+∣111⟩)/2(\lvert000\rangle+\lvert111\rangle)/\sqrt{2}.

    The canonical Bell state is:

    ∣Φ+⟩=(∣00⟩+∣11⟩)/2\lvert\Phi^+\rangle=(\lvert00\rangle+\lvert11\rangle)/\sqrt2(20.2)

    Ideal computational-basis measurements return 00 or 11 with equal probability, and never 01 or 10; perfect correlation from a state neither party controls alone. The preparation follows directly from the CNOT basis action:

    CNOT⁡∣c,t⟩=∣c,t⊕c⟩\operatorname{CNOT}\lvert c,t\rangle=\lvert c,t\oplus c\rangle(20.3)

    Traced from |00>:

    ∣00⟩→H⊗I(∣00⟩+∣10⟩)/2→CNOT(∣00⟩+∣11⟩)/2\lvert00\rangle\xrightarrow{H\otimes I}(\lvert00\rangle+\lvert10\rangle)/\sqrt2\xrightarrow{\mathrm{CNOT}}(\lvert00\rangle+\lvert11\rangle)/\sqrt2(20.4)

    GHZ preparation continues the same pattern: from ∣000⟩\lvert000\rangle, apply H to the first qubit, then CNOT from the first qubit to the second, and from the first to the third.

    There are actually four Bell states, reached by flipping phases or bits on the pattern above, and together they form an orthonormal basis for two qubits; the Bell basis. That basis is the standard currency of quantum protocols: Chapters 24 and 25 spend exactly this currency, in opposite directions.

    Evidence boundary. GHZ states are multipartite entangled states prepared by a Hadamard and controlled-gate chain. [John Preskill] [Michael A. Nielsen]

    Matching Z counts are insufficient

    Construct the classically correlated density matrix.

    The seductive mistake is to think entanglement lets one party choose the other's result. It does not. In a Bell state, each local measurement is individually random; Alice cannot steer Bob's outcome toward 0 or 1 by anything she does to her half. The correlation becomes visible only when the two compare notes over an ordinary classical channel; Chapter 7 (Entanglement Without Faster-Than-Light Myths) spends a full chapter on why the no-signaling theorem closes every workaround.

    The quieter mistake is filing Bell and GHZ states under big superpositions. Product states can have just as many terms after expansion, as ∣+⟩⊗∣−⟩\lvert+\rangle\otimes\lvert-\rangle showed in Chapter 19. What makes these states special is that no per-wire description exists at all.

    Evidence boundary. Computational-basis correlation alone cannot distinguish coherent entanglement from an incoherent correlated mixture. [John Watrous] [Michael A. Nielsen]

    ∣GHZ⁡n⟩=(∣0n⟩+∣1n⟩)/2\lvert\operatorname{GHZ}_n\rangle=(\lvert0^n\rangle+\lvert1^n\rangle)/\sqrt2(20.5)

    Notation contract: Bell states labeled Φ±,Ψ±\Phi^\pm,\Psi^\pm; GHZn=(∣0n⟩+∣1n⟩)/2\mathrm{GHZ}_n=(\lvert0^n\rangle+\lvert1^n\rangle)/\sqrt{2}; density matrices used for mixture comparison; parity convention stated.

    An X-basis coherence check

    Predict parity that separates coherent and incoherent preparations.

    For builders, Bell and GHZ circuits are the hello-world of correctness. A simulator should produce exactly the ideal outcome distribution. A real device will leak into 01 and 10 through gate error, readout error, decoherence, and crosstalk; and the size of that leakage is a quick, honest health metric.

    The discipline is to keep four things separate when you look at output:

    • the ideal state;
    • the measurement distribution it implies;
    • the finite-shot sample you actually collected;
    • the device's error pattern.

    Conflating the sample with the state, or the diagram with the device, is how small experiments get oversold.

    Verification as a test suite

    Specify state preparation, multiple settings, and tolerances.

    When a team demonstrates entanglement, ask five questions. Which state were they aiming for? Which basis did they measure? What fidelity or correlation metric did they report? What controls ran alongside? And how did they separate device error from ideal behavior? Those answers tell you whether you are looking at physics or at a rendering of physics.

    Keep the ceiling in view as well: one small entangled state proves entanglement. It does not prove scalable computation, network utility, or application advantage; each of those needs its own evidence.

    Bell/GHZ verification harness

    Acceptance contract for Bell/GHZ verification harness
    FieldReader-visible record
    FormatCircuit fixtures, density-matrix simulator, and multi-basis test report
    VerificationTests all four Bell preparations, GHZ parity in X/Z settings, and rejection of a matched-count classical mixture.
    AvailabilityPublished companion and deterministic command

    Bell-state run record is the executable companion used by this page.

    cd labs && PYTHONPATH=src python -m quantum_end_to_end bell --shots 10000 --seed 7

    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 h(state, wire, qubits):
    mask = 1 << (qubits - 1 - wire)
    output = state[:]
    scale = math.sqrt(0.5)
    for basis in range(len(state)):
        if basis & mask == 0:
            paired = basis | mask
            output[basis] = (state[basis] + state[paired]) * scale
            output[paired] = (state[basis] - state[paired]) * scale
    return output

def pauli(state, wire, qubits, gate):
    mask = 1 << (qubits - 1 - wire)
    output = [0j] * len(state)
    for basis, amplitude in enumerate(state):
        if gate == "X":
            output[basis ^ mask] += amplitude
        elif gate == "Z":
            output[basis] += -amplitude if basis & mask else amplitude
        else:
            raise ValueError("unsupported Pauli gate")
    return output

def cnot(state, control, target, qubits):
    if control == target:
        raise ValueError("control and target must differ")
    control_mask = 1 << (qubits - 1 - control)
    target_mask = 1 << (qubits - 1 - target)
    output = [0j] * len(state)
    for basis, amplitude in enumerate(state):
        output[basis ^ target_mask if basis & control_mask else basis] += amplitude
    return output

def distribution(state):
    qubits = len(state).bit_length() - 1
    return {format(index, f"0{qubits}b"): round(abs(amplitude) ** 2, 12)
            for index, amplitude in enumerate(state) if abs(amplitude) > 1e-12}

def in_x_basis(state, qubits):
    for wire in range(qubits):
        state = h(state, wire, qubits)
    return state

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

bell = [1.0, 0j, 0j, 0j]
bell = cnot(h(bell, 0, 2), 0, 1, 2)
messages = ((0, 0), (0, 1), (1, 0), (1, 1))
bell_states = []
for phase_bit, flip_bit in messages:
    state = bell[:]
    if flip_bit:
        state = pauli(state, 0, 2, "X")
    if phase_bit:
        state = pauli(state, 0, 2, "Z")
    bell_states.append(state)
max_overlap = 0.0
for left_index, left in enumerate(bell_states):
    for right_index, right in enumerate(bell_states):
        overlap = abs(inner(left, right))
        if left_index != right_index:
            max_overlap = max(max_overlap, overlap)
        assert abs(overlap - (1.0 if left_index == right_index else 0.0)) < 1e-12
assert distribution(bell_states[0]) == {"00": 0.5, "11": 0.5}
assert distribution(bell_states[1]) == {"01": 0.5, "10": 0.5}

ghz = [1.0] + [0j] * 7
ghz = cnot(cnot(h(ghz, 0, 3), 0, 1, 3), 0, 2, 3)
assert distribution(ghz) == {"000": 0.5, "111": 0.5}
ghz_x = distribution(in_x_basis(ghz, 3))
expected_even = {bits for bits in (format(index, "03b") for index in range(8)) if bits.count("1") % 2 == 0}
assert set(ghz_x) == expected_even and all(abs(value - 0.25) < 1e-12 for value in ghz_x.values())

zero_zero = [1.0, 0j, 0j, 0j]
one_one = [0j, 0j, 0j, 1.0]
mixture_x = {}
for component in (zero_zero, one_one):
    for outcome, probability in distribution(in_x_basis(component, 2)).items():
        mixture_x[outcome] = mixture_x.get(outcome, 0.0) + 0.5 * probability
bell_x = distribution(in_x_basis(bell, 2))
mixture_anticorrelation = mixture_x["01"] + mixture_x["10"]
assert bell_x == {"00": 0.5, "11": 0.5}
assert abs(mixture_anticorrelation - 0.5) < 1e-12
phase_mutation_x = distribution(in_x_basis(pauli(bell, 0, 2, "Z"), 2))
assert phase_mutation_x == {"01": 0.5, "10": 0.5}

invalid_control_rejected = False
try:
    cnot(bell, 0, 0, 2)
except ValueError:
    invalid_control_rejected = True
assert invalid_control_rejected
print(f"PASS: 20 Bell/GHZ harness verifies {len(bell_states)} orthogonal Bell states (max cross-overlap={max_overlap:.1e}), GHZ X-even support={len(ghz_x)}, classical-mixture X anticorrelation={mixture_anticorrelation:.3f}")

    Scope boundary

    • This chapter does not certify entanglement from a single measurement setting or survey all multipartite entanglement classes.
    • It does not claim GHZ states are robust memories or direct evidence of useful computation.

    Depth commitment. Four Bell states, one GHZ trace, one mixture counterexample, and a test harness.

    Practice problem

    Design the minimum X/Z measurement set that distinguishes a Bell state from the corresponding classical mixture.

    Deliverable
    Circuit settings, predicted distributions/parities, and a decision rule.
    Pass condition
    The density-matrix fixture generates both cases and demonstrates that Z statistics match while X parity differs.

    Verification record

    Expected solution form. Measurement-setting table plus executable discrimination test.

    Model answer. A Z/Z test cannot distinguish |Phi+> from the 50/50 mixture of |00> and |11>. Measuring X on both qubits does: the Bell state has <X tensor X>=1 and only equal X outcomes, while the mixture has expectation zero and four uniform X outcomes.

    Model result and check. CI evaluates both density matrices under the submitted settings and applies the decision rule.

    Acceptance test. The density-matrix fixture generates both cases and demonstrates that Z statistics match while X parity differs.

    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.

    1. Reproduce or test

      cd labs && PYTHONPATH=src python -m quantum_end_to_end bell --shots 10000 --seed 7

    Provenance

    Sources and review

    1. Michael A. Nielsen and Isaac L. Chuang. Quantum Computation and Quantum Information. Cambridge University Press. 2010textbook
    2. John Watrous. The Theory of Quantum Information. Cambridge University Press / University of Waterloo. 2018textbook
    3. John S. Bell. On the Einstein Podolsky Rosen paradox. Physics Physique Fizika. 1964primary paper
    4. John Preskill. Lecture Notes for Physics 219: Quantum Computation. California Institute of Technology. 2018graduate lecture notes

    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 worksRevision historyReport or inspect errata

    Dependency graph

    Prerequisites for this chapter

    1. Density Matrices and Mixed StatesPart II. Mathematical Core · Chapter 15
    2. Controlled Gates and Reversible Classical ComputationPart III. Circuit Model · Chapter 18

    Continue the thread

    1. No-Cloning and Why Copying Breaks Quantum LogicPart III. Circuit Model · Chapter 21
    2. Superdense CodingPart IV. Protocols and Algorithms · Chapter 24
    3. Public Playground MVPPart X. Capstones · Chapter 87

    Cite this chapter