Quantum Amplitudes and the Mathematics of Possibility

After last week’s foray into coding a Bell State, I wanted to make sure I understood what was really happening before moving on. I’m glad I did, because it turns out I really didn’t grok something: Quantum amplitudes. This post isn’t going to be a sanitized explanation that glosses over the conceptual difficulties I had. Instead, I want to work through the confusion I experienced while trying to understand what these amplitudes actually are and why they matter.

The Problem with Probabilities

When I first encountered qubits, I made the same mistake most people do: I thought of them as probabilistic bits. A classical bit is either 0 or 1, so a qubit must be some kind of fuzzy bit that’s maybe 70% likely to be 0 and 30% likely to be 1, right? This intuition is seductive because it feels like a natural extension of what we already understand.

But this probabilistic interpretation misses something crucial. Probabilities are always positive numbers between 0 and 1, and they represent our uncertainty about the state of a system. Quantum amplitudes, on the other hand, can be negative (or even complex), and they represent something more fundamental: the mathematical weights that determine how quantum possibilities interfere with each other.

The key insight that finally clicked for me is this: amplitudes are not probabilities, but probabilities come from amplitudes. Specifically, the probability of measuring a particular outcome is the square of the absolute value of its amplitude. This might seem like a trivial mathematical detail, but it’s actually the source of quantum computing’s power.

The Mathematics of Interference

Let me walk through a concrete example that illustrates why this matters. Consider the simplest possible quantum circuit: apply a Hadamard gate to a qubit initially in state |0⟩, then apply a Z gate (which flips the sign of the |1⟩ amplitude), then apply another Hadamard gate.

Initially: |0⟩ (amplitude 1 for |0⟩, amplitude 0 for |1⟩)

After first Hadamard: $ \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle) $

Amplitude $ \frac{1}{\sqrt{2}} $ for both states

After Z gate: $ \frac{1}{\sqrt{2}}(|0\rangle - |1\rangle) $

Amplitude $ \frac{1}{\sqrt{2}} $ for |0⟩, amplitude $ -\frac{1}{\sqrt{2}} $ for |1⟩

After second Hadamard: |1⟩ (amplitude 0 for |0⟩, amplitude 1 for |1⟩)

Here’s what’s remarkable: we started with |0⟩ and ended with |1⟩ with complete certainty. This isn’t a probabilistic process—it’s a deterministic manipulation of amplitudes that creates perfect destructive interference for the |0⟩ outcome and perfect constructive interference for the |1⟩ outcome.

import pennylane as qml
import numpy as np

dev = qml.device("default.qubit", wires=1)

@qml.qnode(dev)
def interference_demo():
    qml.Hadamard(wires=0)  # Create superposition
    qml.PauliZ(wires=0)    # Flip sign of |1⟩ amplitude
    qml.Hadamard(wires=0)  # Let amplitudes interfere
    return qml.probs(wires=0)

print(interference_demo())  # [0. 1.] - certain to measure |1⟩

This is fundamentally different from classical probability. If I flip a fair coin twice, I can’t use the “interference” between the flips to guarantee a particular outcome. But quantum amplitudes can be orchestrated to cancel out unwanted possibilities and amplify desired ones.

The Deeper Implications

What strikes me about this is how it reveals something profound about the nature of computation itself. Classical computers work by manipulating bits that represent definite states of information. Quantum computers work by manipulating amplitudes that represent the mathematical relationships between possible states.

This isn’t just a clever engineering trick—it’s a different way of thinking about information processing altogether. Instead of computing with actual values, we’re computing with the mathematical structures that determine which values are possible and with what likelihood.

The power of quantum algorithms like Grover’s search comes from this ability to sculpt the landscape of amplitudes so that the “correct” answer has a high amplitude (and therefore high probability of being measured) while “incorrect” answers have low or zero amplitudes. It’s as if we can reach into the mathematical substrate beneath classical probability and rewire the connections between possibilities.

The Conceptual Challenge

I’ll be honest: even after working through the mathematics, quantum amplitudes still feel conceptually slippery to me. They’re not quite mathematical abstractions (since they have measurable consequences) but they’re not quite physical properties either (since they can’t be directly observed). They exist in this strange liminal space between mathematics and physics that quantum mechanics seems to inhabit.

Perhaps that’s appropriate. Quantum computing forces us to grapple with systems that don’t conform to our classical intuitions about how information should behave. The amplitudes are our way of making mathematical sense of processes that seem to operate according to alien logic.

What I’ve learned is that truly understanding quantum computing requires sitting with this conceptual discomfort rather than trying to resolve it too quickly. The weirdness isn’t a bug—it’s the feature that makes quantum supremacy possible.

---

I’m still working through these concepts myself, so if you have insights or corrections, I’d love to hear them. The journey of understanding quantum mechanics is humbling in the best possible way.