Understanding Quantum: The Mathematical Foundation

Welcome back to Beyond the Bit!

Last week, we explored the mind-bending concepts of superposition and entanglement—the "what" of quantum computing. We realized that a quantum computer isn't just a faster classical computer; it relies on entirely different laws of physics.

However, to actually build circuits and algorithms, we cannot simply wave our hands and say "it's in superposition." We need a precise way to write this down. We need a new mathematical language.

Today, we’re learning that language. We are diving into the mathematical playground where qubits live and learning the standard notation used by quantum scientists around the world.

Since this series is a continuing journey, if you missed last week's post—"What Is Quantum Computing, Anyway?"—I highly recommend checking it out first for a better understanding of today's topic.

(A quick heads-up: A little background in linear algebra might make this click faster, but if you don’t have it, that’s totally fine. We’ll walk through the essentials together.)

What We'll Cover

The Vector View of Qubits: Defining the quantum arena and state vectors.
Matrix Representation: Translating those vectors into actual numbers.
The Bloch Sphere: A 3D map for visualizing single qubit states.
Multiple Forms of Representation: Seeing the states side-by-side.
My Takeaway: Converting analogies into precise tools.

The Vector View of Qubits

The Quantum Arena: Hilbert Space

Before we dive deep today, a quick recap of our standard notation is essential. These are the computational basis states:

∣0⟩ ("ket-zero") is our "ground" state.
∣1⟩ ("ket-one") is our "excited" state.

Just remember: that ∣…⟩ symbol always means you're looking at a vector.

To kick things off, we need to define the mathematical "arena" where standard quantum operations take place. This arena is formally known as Hilbert Space.

Think of it as a specific kind of complex vector space. It uses complex numbers for coordinates (rather than just regular real numbers)—this is vital, as it enables the wave-like interference that gives quantum computers their unique power.

For a single qubit, this arena is strictly two-dimensional. Why only two? Because when we finally measure it, it must collapse into one of only two distinct states: 0 or 1.

(Side note: While one qubit needs only 2 dimensions, the space grows exponentially as we add more. For n qubits, we need a 2^n-dimensional space!)

The Axes: Computational Basis States

Every 2D space needs a set of axes so we can orient ourselves—like North and South on a map, or the X and Y axes on a graph.

In quantum computing, our standard reference axes are called the computational basis states:

∣0⟩: Our quantum version of "North" or "Up."
∣1⟩: Our quantum version of "South" or "Down."

(Note: In standard quantum mechanics, these basis axes are always perpendicular (orthogonal) to each other, no matter how many dimensions the space has. For n qubits, we have 2^n axes, and every single one is perpendicular to all the others!)

The General State & Superposition

Usually, a qubit isn't pointing perfectly along one of these axes. It's pointing somewhere in between, in a state of superposition. Standard notation uses the shorthand ∣ψ⟩ (pronounced "ket psi") to represent this general state vector.

Whenever you see ∣ψ⟩ in an equation, just think: "This represents specifically which way our qubit vector is currently pointing."

We describe this mathematically by creating a linear combination of our basis states. This is arguably the most famous equation in standard introductory quantum computing:

$$∣ψ⟩=α∣0⟩+β∣1⟩$$

Let’s break down what those Greek letters mean:

α (alpha): The amplitude for state ∣0⟩.
β (beta): The amplitude for state ∣1⟩.

These amplitudes are complex numbers that tell us "how much" of ∣0⟩ and "how much" of ∣1⟩ are currently in our qubit's state. They are the precise instructions for exactly how the qubit is superposed.

Figure: A 2D vector diagram representing a qubit in a superposition state.

The Golden Rule: It Must Be a Unit Vector

There is one strict rule for any valid quantum state vector: its total length must always equal 1.

Why? Because these amplitudes are directly related to probabilities. If we measure the qubit, we must find it in either state 0 or state 1. The total probability has to add up to 100% (or exactly 1).

Mathematically, this means if you square the magnitudes of these amplitudes and add them up, they must equal 1:

$$∣α∣ ^2 +∣β∣ ^2 =1$$

In standard terminology, we say that all valid quantum state vectors are normalized unit vectors. If a vector's length isn't exactly 1, it doesn't represent a real physical quantum state.

Matrix Representation: Seeing the Numbers

We've talked about "vectors" and drawn them as arrows in a standard 2D space. But when we actually do standard quantum physics on a computer, we don't draw arrows. We use numbers.

In standard mathematical terms, our "kets" are column vectors - which are just simple matrices with one column.

Single Qubit States

Let's look at our standard basis states again. Remember, standard state ∣0⟩ is 100% "Up" and 0% "Down." We write that as a list:

$$|0\rangle = \begin{bmatrix} 1 \\ 0 \end{bmatrix}$$

Standard state ∣1⟩ is 0% "Up" and 100% "Down":

$$|1\rangle = \begin{bmatrix} 0 \\ 1 \end{bmatrix}$$

What about our superposition state, ∣ψ⟩=α ∣0⟩+β ∣1⟩? It's just a combination of those two lists! The top number is always the amplitude for ∣0⟩, and the bottom number is always the amplitude for ∣1⟩:

$$|ψ\rangle = \begin{bmatrix} α \\ β \end{bmatrix}$$

The Scaling Problem: N-Qubit States

This looks simple enough for one qubit. But remember our standard note about dimensions growing exponentially? This is where you see it.

For 2 qubits, we have 4 standard basis states (∣00⟩,∣01⟩,∣10⟩,∣11⟩). The vector needs 4 entries:

$$|\psi_{2-qubits}\rangle = \begin{bmatrix} c_{00} \\ c_{01} \\ c_{10} \\ c_{11} \end{bmatrix}$$

For a standard n-qubit system, this vector has 2^n entries. A standard 3-qubit system needs a column of 8 complex numbers. A standard 10-qubit system needs a column of 1,024 complex numbers. By the time you have 50 qubits, that single column vector has more entries than there are terabytes of data on most supercomputers.

(Standard Note: We officially call these pure states. A pure state is always represented by just a single column vector, no matter how tall that column gets.)

This massive vector is exactly why simulating standard quantum computers on standard classical laptops is so difficult!

The Bloch Sphere: Visualizing the Unseeable

Column vectors are great for calculations, but they aren't very intuitive. It’s hard to look at a column of complex numbers and immediately "see" what the qubit is doing.

Since standard amplitudes α and β are complex numbers, we can't easily draw them on a 2D piece of paper. We need a clever hack to visualize this.

Enter the Bloch Sphere.

Figure: Two Bloch spheres showing standard coordinate axes and their corresponding qubit states.

It’s a geometric representation that maps the state of a single qubit onto the surface of a 3D sphere. It helps us build intuition by turning abstract complex numbers into a concrete picture.

Take a look at the image above. It shows how standard 3D axes map to specific quantum states:

The Landmarks

The Z-Axis (The Poles): This is our standard computational basis. The North Pole (+z) is ∣0⟩, and the South Pole (-z) is ∣1⟩.
The X-Axis (The Equator): These represent perfectly even superpositions.

$$\begin{align*} +x \quad \text{is the state} \quad |+\rangle &= \frac{|0\rangle + |1\rangle}{\sqrt{2}} \\ -x \quad \text{is the state} \quad |-\rangle &= \frac{|0\rangle - |1\rangle}{\sqrt{2}} \end{align*}$$

The Y-Axis (Complex states): These are also even superpositions, but with distinct complex parts (involving i).

When a qubit is in a superposition, it points somewhere between these poles. The closer it is to the North Pole, the higher the probability of measuring 0.

(Important Warning: The Bloch sphere is an amazing tool, but it only works effectively for single, unentangled qubits. Once you have multiple qubits entangled together, this simple picture breaks down!)

Multiple Forms of Representation (Examples)

Here's how our fundamental qubit states can be represented in both their Ket notation and column vector form:

State ∣0⟩: A qubit definitely in the '0' state.

$$|0\rangle = \begin{bmatrix} 1 \\ 0 \end{bmatrix} = 1|0\rangle + 0|1\rangle$$

State ∣1⟩: A qubit definitely in the '1' state.

$$|1\rangle = \begin{bmatrix} 0 \\ 1 \end{bmatrix} = 0|0\rangle + 1|1\rangle$$

State ∣ψ⟩: A general superposition state with amplitudes α and β.

$$|\psi\rangle = \begin{bmatrix} \alpha \\ \beta \end{bmatrix} = \alpha|0\rangle + \beta|1\rangle$$

Figure: Sphere 1: The state ∣0⟩*, pointing to the north pole (positive z-axis). **Sphere 2: The state ∣+i⟩ ( or ∣y+⟩ ), pointing along the positive y-axis. Sphere 3: The state ∣−⟩ ( or ∣x−⟩ ), pointing along the negative x-axis. Sphere 4: The state ∣1⟩**, pointing to the south pole (negative z-axis). (From Left to Right)*

My Takeaway (For Now)

Today, we swapped standard spooky analogies for precise tools. It might feel like a lot of new notation, but remember, we just defined our playground:

The Arena (Hilbert Space): The complex mathematical space where all qubit operations happen.
The Address (Kets ∣ψ⟩): The specific vector telling us exactly which way our qubit is pointing.
The Map (Bloch Sphere): Our trusted visual guide to seeing these complex states in 3D.

Right now, we can perfectly describe a qubit floating in superposition. But quantum computing gets really interesting when we stop just looking at the qubit and actually ask it a question.

Next time, we’ll dive into Measurement. We’ll explore the moment probability collapses into reality, and the strict mathematical rules that keep the whole system from breaking.

See you then!

Speaking Quantum: The Math Beneath the Magic

What We'll Cover