The Qubit and Superposition

A qubit (quantum bit) is the quantum analogue of a classical bit: a two-level system whose state space is the complex vector space ℂ². We fix an orthonormal basis for this space, called the computational basis, and label its two vectors |0⟩ and |1⟩ (read "ket zero" and "ket one"), corresponding to the classical bit values 0 and 1. Concretely, using column-vector representations, ``` |0⟩ = (1, 0)ᵗ |1⟩ = (0, 1)ᵗ ``` The state postulate of quantum mechanics says that the state of an isolated quantum system is a unit vector in a complex Hilbert space. For a qubit, that Hilbert space is exactly ℂ² with the standard inner product, so the most general possible qubit state is ``` |ψ⟩ = α|0⟩ + β|1⟩, α, β ∈ ℂ, |α|² + |β|² = 1 ``` This is superposition: the state |ψ⟩ is a genuine linear combination of |0⟩ and |1⟩, not a statement of ignorance about which one it "really" is. A classical bit that we merely don't know the value of would be described by a probability distribution (e.g., 50% chance of 0, 50% chance of 1) — a classical mixture. A qubit in superposition is described instead by complex amplitudes α and β whose relative phase produces interference effects that no classical probability distribution can reproduce. This distinction — probabilistic ignorance versus coherent superposition — is the entire reason quantum computing is not just "randomized classical computing." The numbers α and β are called probability amplitudes. They are not themselves probabilities; the connection to observable probabilities is given by the Born rule: if |ψ⟩ = α|0⟩ + β|1⟩ is measured in the computational basis, the outcome is 0 with probability |α|², and 1 with probability |β|². Because these are the only two outcomes, the amplitudes must satisfy the normalization condition |α|² + |β|² = 1, which is precisely the statement that |ψ⟩ has unit length in ℂ² under the standard norm. Two states that differ only by an overall complex phase, |ψ⟩ and eⁱᶿ|ψ⟩, are experimentally indistinguishable and are considered the same physical state — a fact we will exploit heavily once we introduce the Bloch sphere picture elsewhere.

There is no "algorithm" that produces superposition from nothing — it is a state of the physical system, prepared by hardware (a laser pulse on an ion, a microwave pulse on a superconducting circuit) and manipulated by Quantum Gates. But there is a precise computational recipe for reasoning about superposition states: represent them as vectors, apply linear operators (gates) as matrix multiplication, and extract probabilities via the Born rule at measurement time. This is the operational core that every quantum algorithm reduces to.

Step 1 — State representation. Represent a qubit as a column vector (α, β)ᵗ with α, β ∈ ℂ, tracked exactly (not sampled) throughout a computation.

Step 2 — Prepare or evolve. Starting from |0⟩ = (1,0)ᵗ, apply unitary gates. The canonical superposition-creating gate is the Hadamard gate: ``` H = (1/√2) * [ 1 1 ] [ 1 -1 ] ``` Applying H to |0⟩ gives (1/√2)(|0⟩ + |1⟩), the "50/50" superposition; applying it to |1⟩ gives (1/√2)(|0⟩ − |1⟩). Every unitary gate is norm-preserving, which is exactly why it always maps valid qubit states to valid qubit states.

Step 3 — Compose (optional). Chain more gates; each is a 2×2 unitary matrix, and composition is ordinary matrix multiplication. The state remains a superposition α|0⟩ + β|1⟩ with new coefficients throughout, until a measurement is performed.

Step 4 — Measure. Measurement in the computational basis is a probabilistic, irreversible operation: sample outcome 0 with probability |α|², outcome 1 with probability |β|², and afterward the qubit's state has collapsed to exactly |0⟩ or |1⟩ respectively — all information about the original α, β (beyond which one "won") is gone. The pseudocode below captures this simulate-a-qubit workflow, which is exactly what classical quantum-circuit simulators (e.g., Qiskit's `statevector_simulator`) do internally for small numbers of qubits. ``` STATE: complex pair (alpha, beta) # represents alpha|0> + beta|1> function INIT_QUBIT(): return (1 + 0i, 0 + 0i) # |0>, the standard starting state function APPLY_GATE(state, U): # U is a 2x2 unitary matrix (alpha, beta) = state new_alpha = U[0][0]alpha + U[0][1]beta new_beta = U[1][0]alpha + U[1][1]beta return (new_alpha, new_beta) function HADAMARD(): c = 1 / sqrt(2) return [[c, c], [c, -c]] function MEASURE(state): (alpha, beta) = state p0 = |alpha|^2 p1 = |beta|^2

# sanity check (should always hold to numerical precision): assert abs(p0 + p1 - 1) < EPSILON r = uniform_random(0, 1) if r < p0: return (0, collapsed_state = (1, 0)) else: return (1, collapsed_state = (0, 1))

# --- Example run: create and measure a superposition --- q = INIT_QUBIT() # q = |0> = (1, 0) q = APPLY_GATE(q, HADAMARD()) # q = (1/sqrt2, 1/sqrt2) -- superposition outcome, q = MEASURE(q) # outcome is 0 or 1, each with prob 1/2 ``` The key thing this pseudocode makes explicit: superposition lives entirely inside `APPLY_GATE`, where amplitudes are tracked exactly and can interfere; `MEASURE` is the only place randomness and collapse enter, and it is a one-way, information-destroying operation. The figure below shows the qubit's state space and one gate acting on it, viewed as vectors in the α–β plane (a simplification of the real geometry, which is the Bloch sphere, introduced separately).

Space complexity of representation. A single qubit's state requires storing two complex numbers, i.e., O(1) classical space (up to floating-point precision) — trivial. The interesting complexity appears with multiple qubits: n qubits are described not by n independent pairs of amplitudes but by a single vector in the tensor product space ℂ² ⊗ ℂ² ⊗ ⋯ ⊗ ℂ² (n factors), which has dimension 2ⁿ. So representing a general n-qubit superposition classically costs O(2ⁿ) space, since you must store one complex amplitude per basis string in {0,1}ⁿ. This exponential blowup is why classical simulation of generic quantum circuits is believed to be intractable for large n, and it is the structural reason quantum computers are conjectured to outperform classical ones on certain problems.

Time complexity of basic operations. Applying a single-qubit gate to one qubit within an n-qubit register naively touches an amplitude vector of size 2ⁿ (since the gate acts on that qubit's two-dimensional subspace, tensored with the identity on the rest), giving O(2ⁿ) time per single-qubit gate in a classical simulation, though real quantum hardware performs this in O(1) physical time regardless of n, since the operation acts locally on the physical qubit. This gap — O(2ⁿ) to simulate versus O(1) to physically execute — is precisely the resource asymmetry that motivates building quantum hardware at all.

Correctness of the representation (why unit vectors are the right model). The correctness argument here is not an algorithmic proof but a consistency argument tying the mathematical model to physical predictions: 1. Normalization is necessary and sufficient for valid probabilities. The Born rule assigns P(0) = |α|² and P(1) = |β|², and these must sum to 1 since 0 and 1 are the only possible outcomes of a computational-basis measurement. This forces |α|² + |β|² = 1, i.e., (α, β) must lie on the unit sphere in ℂ² — no more, no less. 2. Unitarity preserves validity. Any physically realizable evolution of a closed quantum system is represented by a unitary matrix U (U†U = I). Unitary matrices preserve the ℂ² inner product, hence preserve norm: if ‖(α,β)‖ = 1 then ‖U(α,β)ᵗ‖ = 1. This is why chaining any sequence of quantum gates always yields another valid qubit state — the invariant "the state vector has unit norm" is maintained by construction at every step, exactly the loop invariant that makes the `APPLY_GATE` procedure above correct. 3. Global phase is unobservable. States |ψ⟩ and eⁱᶿ|ψ⟩ give identical Born-rule probabilities for every possible measurement, since |eⁱᶿα|² = |α|². Hence quantum states are more precisely rays (equivalence classes under global phase) in ℂ², though we conventionally work with a fixed representative vector. 4. Superposition is distinguishable from classical mixture by interference. A classical mixture "50% |0⟩, 50% |1⟩" and the superposition (|0⟩+|1⟩)/√2 give the same measurement statistics if measured immediately in the computational basis. They diverge once you apply a further unitary (like another Hadamard) before measuring: H applied to (|0⟩+|1⟩)/√2 returns exactly |0⟩ (probability 1 of outcome 0), because the amplitudes for |1⟩ cancel — destructive interference. No classical probabilistic model of a bit, evolved by any stochastic process on probabilities alone, can reproduce this perfect cancellation. This experimentally testable fact (interference) is the operational proof that the complex-amplitude model, not a classical hidden-probability model, is the correct description.

Tradeoffs to be honest about. Superposition alone does not confer computational advantage — it is necessary but not sufficient. An algorithm must also arrange constructive and destructive interference (via subsequent gates) so that wrong answers cancel and right answers reinforce, which is exactly the harder design problem tackled by algorithms like Grover's and Shor's, discussed elsewhere. Additionally, superposition is fragile: interaction with an uncontrolled environment causes decoherence, effectively turning a coherent superposition into something statistically indistinguishable from a classical mixture — the central engineering battle in building real quantum hardware.

Trace a concrete two-step circuit on a single qubit: start at |0⟩, apply a Hadamard gate, then apply a phase-flip gate Z, then measure, tracking exact amplitudes at each stage. Recall: ``` H = (1/√2) [ 1 1 ] Z = [ 1 0 ] [ 1 -1 ] [ 0 -1 ] ```

Notice something crucial between steps 1 and 2: the Z gate changes β from +1/√2 to −1/√2, but the measurement probabilities stay exactly 0.5/0.5 in both rows — because |−1/√2|² = |1/√2|². If you only ever looked at measurement statistics after each step in isolation, steps 1 and 2 would look identical. But the states are physically different, and this difference is observable if you apply one more gate before measuring.

Continuing the trace to expose the difference: apply H again after step 2. ``` H (1/√2, -1/√2)ᵗ = (1/√2)(1/√2 1 + (-1/√2) 1, 1/√2 1 + (-1/√2) (-1)) = (1/√2)(1/√2 - 1/√2, 1/√2 + 1/√2) = (1/√2)(0, 2/√2) = (0, 1) = |1⟩ ``` So H·Z·H|0⟩ = |1⟩ with certainty (P(1) = 1, P(0) = 0). Compare: H·I·H|0⟩ = H·H|0⟩ = |0⟩ with certainty, since H² = I. The intermediate Z gate — which left single-step measurement probabilities unchanged — completely flips the final deterministic outcome. This is interference in action: the relative phase introduced by Z, invisible to an immediate measurement, becomes visible after a second Hadamard recombines the amplitudes. This is exactly the kind of effect that a classical bit, or a classical probabilistic bit, cannot replicate, and it is the worked-example proof that amplitudes (with sign/phase) carry real information beyond their squared magnitudes.

The idea that a physical system could exist in a superposition of classically distinct states traces back to the founders of quantum mechanics, but the specific move of treating a two-level quantum system as an information-bearing "bit" — the qubit — is a later, computer-science-driven synthesis.

Every physical quantum computing platform is, at bottom, an engineering effort to create, hold, and manipulate qubit superpositions long enough to run a useful Quantum Circuit. Superconducting-qubit machines from IBM and Google encode |0⟩ and |1⟩ as distinct energy levels of a Josephson-junction circuit and use microwave pulses to create superpositions; trapped-ion systems from IonQ and Quantinuum use two internal electronic states of an ion, manipulated by laser pulses. Photonic quantum processors encode qubits in properties of light, such as polarization, where superposition is simply a photon polarized along a diagonal axis rather than purely horizontal or vertical. Superposition is the raw resource consumed by every well-known quantum algorithm: Grover's Algorithm spreads a search-space register into an equal superposition over all candidate indices before amplifying the correct one via interference; Shor's Algorithm relies on superposition combined with the quantum Fourier transform to extract periodicity; quantum simulation algorithms use superposition to represent many-particle states that would need exponential classical storage. Quantum key distribution protocols such as BB84 rely on superposition states of photons, since measuring an unknown superposition in the wrong basis necessarily disturbs it — a physical mechanism for detecting eavesdroppers that has no classical analogue. Beyond algorithms, superposition underlies quantum sensing (superposition states are exquisitely sensitive to small perturbations, used in atomic clocks and magnetometers) and is the conceptual seed for Quantum Entanglement, where superposition extends across multiple qubits in ways that cannot be decomposed into independent single-qubit states — the topic that naturally follows once single-qubit superposition, and its geometric picture on the Bloch Sphere, are firmly understood.

Ask the tutor: How does a single qubit's superposition become entangled once you combine it with a second qubit through a two-qubit gate like CNOT?