Quantum Computing

A classical bit is like a coin lying on a table — it's either heads (1) or tails (0). That's it. Every bit in your phone, your laptop, every server on earth stores information this way: definite, certain, one or the other.

A qubit is like a coin spinning in the air. While it spins, it's not heads and tails — it's in a state that has some probability of landing heads and some probability of landing tails. Only when it lands (when you measure it) does it become a definite value. This is superposition.

The Bloch Sphere

Every possible state of a single qubit can be visualized as a point on the surface of a sphere. The north pole is |0⟩, the south pole is |1⟩, and every other point represents a superposition.

Two angles fully describe any single-qubit state: θ (theta, shown in yellow) measures the angle from the north pole (z-axis) down to the state vector — it controls how much |0⟩ vs |1⟩ you have. φ (phi, shown in cyan) measures the rotation around the equator — it controls the phase between |0⟩ and |1⟩. Together, they show that a qubit carries far more information than a classical bit — it's a point on a continuous sphere, not just 0 or 1.

A Simple Quantum Circuit: Creating a Bell State

This circuit creates an entangled pair (Bell state). Apply Hadamard to the first qubit, then CNOT with the first as control and second as target.

Measurement in quantum mechanics is irreversible and destructive. When you measure a qubit, its superposition collapses to one of the basis states. You get a classical bit of information, and the quantum state is gone forever.

The Born Rule tells us the probability of each outcome:

For example, if α = 1/√2 and β = 1/√2 (the |+⟩ state), then:

• • P(|0⟩) = |1/√2|² = 1/2 = 50%
• • P(|1⟩) = |1/√2|² = 1/2 = 50%
• • Each run gives a random result, but statistics match the probabilities exactly

This is why quantum algorithms run the same circuit many times — to build up statistics and extract the answer from the probability distribution.

One of quantum mechanics' most important results: you cannot copy an unknown quantum state. There is no quantum Ctrl+C. This is mathematically proven — it follows directly from the linearity of quantum mechanics.

This sounds like a limitation, but it's actually a feature for quantum cryptography. If an eavesdropper tries to copy quantum-encrypted data, they inevitably disturb it — and the sender and receiver can detect the intrusion. This is the foundation of Quantum Key Distribution (QKD).

• • Classical: you can copy bits perfectly, endlessly
• • Quantum: copying destroys the original state's information
• • This enables provably secure communication (QKD)
• • Also means you can't "back up" a quantum computation mid-way

Dirac notation (bra-ket notation) is the standard language of quantum mechanics. It's elegant and surprisingly simple once you get used to it.

Kets (column vectors)

|0⟩ = [1]     |1⟩ = [0]
      [0]           [1]

Bras (row vectors — conjugate transpose)

⟨0| = [1, 0]     ⟨1| = [0, 1]

Inner Product ⟨φ|ψ⟩

The inner product gives overlap between states. Orthogonal states have zero inner product:

⟨0|0⟩ = 1     (same state → probability 1)
⟨0|1⟩ = 0     (orthogonal → probability 0)
⟨1|1⟩ = 1

General Single-Qubit State

Two-Qubit System

Two qubits have four basis states:

|ψ⟩ = α₀₀|00⟩ + α₀₁|01⟩ + α₁₀|10⟩ + α₁₁|11⟩

Four complex amplitudes, four probabilities summing to 1
|α₀₀|² + |α₀₁|² + |α₁₀|² + |α₁₁|² = 1

Every quantum gate is a unitary matrix. A matrix U is unitary if U†U = I (its conjugate transpose times itself equals the identity). This ensures probabilities are preserved and operations are reversible.

Applying Hadamard to |0⟩ — Step by Step

// H gate matrix
H = 1/√2 × [ 1   1 ]
              [ 1  -1 ]

// Apply to |0⟩
H|0⟩ = 1/√2 × [ 1   1 ] × [ 1 ]
               [ 1  -1 ]   [ 0 ]

     = 1/√2 × [ 1×1 + 1×0 ]
               [ 1×1 + (-1)×0 ]

     = 1/√2 × [ 1 ]
               [ 1 ]

     = 1/√2 |0⟩ + 1/√2 |1⟩  =  |+⟩

// 50/50 superposition! Each outcome has probability (1/√2)² = 1/2

CNOT Matrix (4×4)

CNOT = [ 1  0  0  0 ]   |00⟩ → |00⟩
        [ 0  1  0  0 ]   |01⟩ → |01⟩
        [ 0  0  0  1 ]   |10⟩ → |11⟩  ← flipped!
        [ 0  0  1  0 ]   |11⟩ → |10⟩  ← flipped!

// When control qubit is |1⟩, the target qubit gets flipped

Unitarity means every quantum gate is reversible. Unlike classical computing (where AND gates lose information), quantum computation is always reversible — you can always undo a gate by applying its inverse (conjugate transpose).

This is where quantum computing's power comes from. When you add qubits, the state space grows exponentially.

// Tensor product: combining two qubits
|0⟩ ⊗ |0⟩ = |00⟩ = [ 1 ]
                       [ 0 ]
                       [ 0 ]
                       [ 0 ]

// General: |ψ⟩ ⊗ |φ⟩ multiplies every amplitude of |ψ⟩
// with every amplitude of |φ⟩

Exponential State Space

A 50-qubit system requires about 10¹⁵ (a quadrillion) complex numbers to describe its state. A classical computer needs ~32 petabytes of RAM just to store this state vector, let alone manipulate it. At ~300 qubits, you'd need more numbers than there are atoms in the observable universe.

How does one query tell you everything?

Think of it like this: instead of checking numbers one at a time, the quantum computer creates a wave that represents all numbers at once. When this wave passes through the mystery machine, the machine imprints a pattern on the wave. If the machine is "boring" (constant), the wave comes out undisturbed. If it's "fair" (balanced), the wave gets a distinctive ripple pattern. One look at the output wave tells you which.

This works because of interference: the quantum amplitudes for all billion inputs either all add up (constant function → strong signal) or perfectly cancel out (balanced function → zero signal on the original state). It's like how a perfectly calm pond tells you no one threw a stone, but a specific ripple pattern tells you exactly where one landed.

The Quantum Circuit

Don't worry if this looks abstract — it's a visual shorthand for the steps described above. Each line is a qubit, boxes are operations.

How does it narrow things down so fast?

Imagine all million books are on a giant table, and each has a tiny voice whispering "pick me!" at the same volume. Grover's algorithm does something clever in two repeating steps:

Repeat these two steps about √N times (for 1 million books, that's ~1,000 repetitions), and the correct book is screaming while everything else is silent. When you finally measure, you almost certainly find the golden bookmark.

Watching the Amplitudes Grow

Each bar represents the probability of measuring that item. The target item (green) gets amplified with each iteration while others shrink.

How does it work? (No PhD required)

The key insight is surprisingly elegant: factoring can be turned into a pattern-finding problem, and quantum computers are exceptionally good at finding patterns.

The Speed Difference

Real qubits are incredibly fragile. They interact with their environment and lose their quantum properties — this is decoherence. Gate operations are imperfect too. Current error rates are ~0.1-1% per gate, far too high for complex algorithms.

The Solution: Redundancy

Just as classical error correction uses redundant bits, quantum error correction encodes one logical qubit across many physical qubits. But it's harder because:

• • You can't copy qubits (no-cloning theorem)
• • Measuring destroys the state
• • Errors are continuous, not just bit-flips
• • Need to detect errors without learning the quantum state

Surface Codes

The leading approach uses a 2D grid of qubits where "data" qubits store information and "syndrome" qubits detect errors. Current estimates: ~1,000 to 10,000 physical qubits per logical qubit, depending on the target error rate.

Qubits are absurdly sensitive. A stray photon, a vibration, a cosmic ray, even thermal noise at temperatures above near-absolute-zero can destroy the quantum state. This loss of quantum information is called decoherence, and it's the single biggest engineering challenge in quantum computing.

Superconducting quantum computers (IBM, Google) operate at 15 millikelvin — colder than outer space. They use dilution refrigerators, which are the large, chandelier-like structures you see in photos of quantum computers.

The race is to either: (a) make qubits last longer, (b) make gates faster, or (c) use error correction to compensate. All three approaches are being pursued simultaneously.

We're in the NISQ era — Noisy Intermediate-Scale Quantum. Current quantum computers have enough qubits to be interesting but too much noise to be broadly useful.

Key Milestones

• • Google (2019): "Quantum supremacy" — Sycamore (53 qubits) performed a specific sampling task in 200 seconds that would take classical supercomputers ~10,000 years. Contested — classical algorithms improved significantly since.
• • IBM (2023): Condor processor with 1,121 superconducting qubits. Heron processor (133 qubits) with improved error rates.
• • IBM (2024): Demonstrated useful quantum computation with error mitigation on 127-qubit Eagle processor, matching classical simulation for certain physics problems.
• • Google (2024): Willow chip — demonstrated quantum error correction below threshold for the first time, a major milestone.
• • Quantinuum (2024): Achieved record quantum volume scores with trapped-ion systems.
• • Microsoft (2025): Announced Majorana-based topological qubit progress.

What's Real vs. Hype

Quantum Key Distribution (QKD)

QKD uses quantum mechanics to generate shared secret keys between two parties with provable security. The most famous protocol is BB84 (Bennett & Brassard, 1984):

• • Alice sends qubits encoded in random bases (rectilinear or diagonal)
• • Bob measures in random bases
• • They publicly compare bases (not values) and keep only matching ones
• • Any eavesdropper (Eve) disturbs the qubits — detected by error rate check
• • No-cloning theorem ensures Eve can't copy without disturbing

Post-Quantum Cryptography (PQC)

While QKD needs special hardware, PQC runs on normal computers using math problems that even quantum computers can't efficiently solve. NIST finalized standards in August 2024:

You can run quantum circuits today on real hardware — for free.

Creating a Bell State in Qiskit

# Create an entangled Bell state: (|00⟩ + |11⟩) / √2
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

# Build the circuit
qc = QuantumCircuit(2, 2)   # 2 qubits, 2 classical bits

qc.h(0)          # Hadamard on qubit 0 → superposition
qc.cx(0, 1)      # CNOT: qubit 0 controls qubit 1 → entanglement
qc.measure([0, 1], [0, 1])  # Measure both

# Run on simulator
simulator = AerSimulator()
result = simulator.run(qc, shots=1000).result()
counts = result.get_counts()

print(counts)
# Output: ${'00': ~500, '11': ~500$}
# Always correlated! Never '01' or '10'.
# That's entanglement in action.