Qubits and Superposition: Why 'Both 0 and 1 at Once' Is Wrong

Terminology

What & Why

A classical bit is either 0 or 1. A qubit is a quantum system that, before measurement, exists in a state described by two complex numbers. This is not "both 0 and 1 at the same time." That popular analogy is misleading. A qubit in superposition is in a single, definite quantum state that happens to have a nonzero probability of producing either outcome when measured.

Why does this matter for computing? Because quantum algorithms exploit superposition (and later, entanglement and interference) to process information in ways that have no classical analogue. Grover's search achieves $O(\sqrt{n})$ lookups. Shor's algorithm factors integers in polynomial time. These speedups are not magic: they come from carefully manipulating amplitudes so that correct answers interfere constructively and wrong answers interfere destructively.

This post builds the foundation. Before you can understand quantum gates, entanglement, or any quantum algorithm, you need a precise understanding of what a qubit actually is, how Dirac notation works, and what the Bloch sphere represents geometrically.

Key properties of qubits:

• State space: a qubit lives in $\mathbb{C}^2$, a 2-dimensional complex vector space
• Normalization: the state $\alpha|0\rangle + \beta|1\rangle$ must satisfy $|\alpha|^2 + |\beta|^2 = 1$
• Measurement is destructive: observing a qubit collapses it to $|0\rangle$ or $|1\rangle$
• No cloning: you cannot copy an unknown quantum state (the no-cloning theorem)

How It Works

Classical Bits vs Qubits

A classical bit has two possible states: 0 and 1. You can represent this as a switch that is either off or on. A qubit also has two basis states, $|0\rangle$ and $|1\rangle$, but its general state is a linear combination:

where $\alpha, \beta \in \mathbb{C}$ and $|\alpha|^2 + |\beta|^2 = 1$.

The key difference: a classical bit IS 0 or 1. A qubit is described by a state vector that encodes the probabilities of each measurement outcome. Before measurement, the qubit is not "secretly" 0 or 1. It is in a genuine quantum state with no classical equivalent.

Dirac Notation Basics

Quantum computing uses Dirac (bra-ket) notation. The two basis states are written as column vectors:

A general qubit state is then:

The "bra" $\langle\psi|$ is the conjugate transpose: $\langle\psi| = (\alpha^*, \beta^*)$. The inner product $\langle\phi|\psi\rangle$ gives the overlap between two states. The normalization condition $\langle\psi|\psi\rangle = |\alpha|^2 + |\beta|^2 = 1$ ensures valid probabilities.

Some important states beyond the computational basis:

These are the eigenstates of the Hadamard gate and form the "X-basis," an equally valid measurement basis.

Why "Both 0 and 1 at Once" Is Wrong

The popular description of superposition as "being 0 and 1 simultaneously" suggests a qubit is like a coin that is both heads and tails. This is wrong for a precise reason: a qubit in state $\frac{1}{\sqrt{2}}(|0\rangle + |1\rangle)$ is not in two states at once. It is in one state, the $|+\rangle$ state, which is a perfectly definite quantum state with specific, predictable properties.

The confusion arises because we try to describe quantum states using classical language. A better analogy: think of a qubit as an arrow pointing in some direction on the Bloch sphere. The arrow has a single, definite direction. It is only when we force the arrow to "choose" north or south (measurement in the Z-basis) that we get a probabilistic classical outcome.

What superposition actually gives quantum computing:

• Interference: amplitudes can add constructively or destructively, allowing algorithms to amplify correct answers
• Parallelism in amplitude space: a quantum operation transforms all amplitudes simultaneously, but you only extract one measurement outcome
• Not exponential parallelism: $n$ qubits do not "try all $2^n$ answers at once." The power comes from structured interference, not brute-force parallelism

The Bloch Sphere

Any single-qubit pure state can be written using two angles $\theta$ and $\phi$:

This maps every qubit state to a unique point on the surface of a unit sphere. The north pole ($\theta = 0$) is $|0\rangle$, the south pole ($\theta = \pi$) is $|1\rangle$, and the equator contains equal superpositions like $|+\rangle$ and $|-\rangle$.

The Bloch sphere is powerful because quantum gates correspond to rotations of this sphere. A Hadamard gate rotates the state 180 degrees around an axis halfway between X and Z. A Pauli-Z gate rotates 180 degrees around the Z-axis. This geometric picture makes it much easier to visualize what quantum operations do.

Measurement and the Born Rule

When you measure a qubit in state $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$ in the computational basis:

• You get outcome 0 with probability $|\alpha|^2$
• You get outcome 1 with probability $|\beta|^2$
• After measurement, the qubit collapses to whichever state was observed

This is the Born rule. It is the bridge between the quantum world (amplitudes) and the classical world (probabilities). Crucially, measurement is irreversible: the pre-measurement superposition is destroyed.

Multiple Qubits and State Space Growth

A single qubit has a state in $\mathbb{C}^2$. Two qubits live in $\mathbb{C}^2 \otimes \mathbb{C}^2 = \mathbb{C}^4$, with basis states $|00\rangle, |01\rangle, |10\rangle, |11\rangle$. In general, $n$ qubits require $2^n$ complex amplitudes to describe their joint state:

This exponential growth in state space is what makes quantum computing potentially powerful, and also what makes simulating quantum systems on classical computers so hard. Storing the state of 50 qubits requires $2^{50} \approx 10^{15}$ complex numbers, roughly a petabyte of memory.

Complexity Analysis

Quantum computing introduces its own complexity classes. The key comparison with classical computing:

State Space Scaling

The memory required to classically simulate $n$ qubits grows exponentially:

This is why 50+ qubits is considered the "quantum supremacy" threshold: classical supercomputers cannot store or manipulate the full state vector.

Implementation

Qubit State Representation

STRUCTURE QubitState:
    alpha: Complex    // amplitude for |0⟩
    beta: Complex     // amplitude for |1⟩

FUNCTION createQubit(alpha, beta):
    INPUT: alpha, beta are complex numbers
    OUTPUT: a valid QubitState

    norm ← sqrt(|alpha|² + |beta|²)
    IF norm = 0 THEN
        ERROR "Cannot create zero-norm state"
    END IF

    RETURN QubitState(alpha / norm, beta / norm)

Measurement Simulation

FUNCTION measure(qubit):
    INPUT: qubit is a QubitState with amplitudes alpha, beta
    OUTPUT: classical bit (0 or 1), updated qubit state

    prob_zero ← |qubit.alpha|²
    r ← RANDOM_UNIFORM(0, 1)

    IF r < prob_zero THEN
        qubit.alpha ← 1
        qubit.beta ← 0
        RETURN 0
    ELSE
        qubit.alpha ← 0
        qubit.beta ← 1
        RETURN 1
    END IF

Bloch Sphere Coordinates

FUNCTION blochCoordinates(qubit):
    INPUT: qubit is a QubitState (alpha, beta)
    OUTPUT: (theta, phi) angles on the Bloch sphere

    // Extract theta from the magnitudes
    theta ← 2 * arccos(|qubit.alpha|)

    // Extract phi from the relative phase
    IF |qubit.beta| > 0 THEN
        phi ← arg(qubit.beta) - arg(qubit.alpha)
    ELSE
        phi ← 0
    END IF

    RETURN (theta, phi)

Multi-Qubit State Vector

FUNCTION tensorProduct(stateA, stateB):
    INPUT: stateA has amplitudes [a0, a1], stateB has amplitudes [b0, b1]
    OUTPUT: 4-element amplitude vector for the joint state

    // |stateA⟩ ⊗ |stateB⟩
    result ← ARRAY of size 4
    result[0] ← a0 * b0    // amplitude for |00⟩
    result[1] ← a0 * b1    // amplitude for |01⟩
    result[2] ← a1 * b0    // amplitude for |10⟩
    result[3] ← a1 * b1    // amplitude for |11⟩

    RETURN result

Probability Distribution from State Vector

FUNCTION probabilities(stateVector):
    INPUT: stateVector is an array of 2^n complex amplitudes
    OUTPUT: array of 2^n real probabilities

    n ← LENGTH(stateVector)
    probs ← ARRAY of size n

    FOR i ← 0 TO n - 1 DO
        probs[i] ← |stateVector[i]|²
    END FOR

    // Verify normalization
    total ← SUM(probs)
    ASSERT |total - 1.0| < 1e-10

    RETURN probs

Real-World Applications

• Quantum key distribution (QKD): BB84 protocol uses qubits in different bases ($|0\rangle/|1\rangle$ and $|+\rangle/|-\rangle$) to detect eavesdropping. Any measurement by an interceptor disturbs the superposition, revealing their presence
• Quantum random number generation: measuring a qubit in the $|+\rangle$ state produces truly random bits, not pseudorandom. Commercial QRNGs from ID Quantique use this principle
• Quantum sensing: superposition makes qubits extremely sensitive to magnetic fields, gravity, and temperature. Quantum magnetometers achieve sensitivity impossible with classical sensors
• Drug discovery and molecular simulation: representing molecular electron orbitals naturally maps to qubit superpositions. Simulating a caffeine molecule classically requires $\sim 10^{48}$ amplitudes, but maps to ~160 qubits
• Quantum machine learning: variational quantum circuits use parameterized superpositions as a feature space, with potential advantages for certain kernel methods and sampling tasks
• Classical simulation research: understanding qubit state spaces drives advances in tensor network methods, matrix product states, and other classical techniques that approximate quantum behavior

Key Takeaways

• A qubit is not "both 0 and 1 at once." It is a state vector $\alpha|0\rangle + \beta|1\rangle$ in a 2D complex vector space, with $|\alpha|^2 + |\beta|^2 = 1$
• Measurement collapses superposition: you get outcome 0 with probability $|\alpha|^2$ and outcome 1 with probability $|\beta|^2$ (the Born rule)
• The Bloch sphere maps every single-qubit pure state to a point on a unit sphere, making quantum gates visualizable as rotations
• The power of quantum computing comes from interference (constructive and destructive amplitude manipulation), not from "trying all answers at once"
• $n$ qubits require $2^n$ complex amplitudes to describe classically, which is why quantum systems become intractable to simulate beyond ~50 qubits