How Quantum Computing Uses Linear Algebra

What if a quantum computer isn't actually doing anything magical? What if it's just multiplying vectors by matrices, over and over, and the "weirdness" is just us not being used to the geometry?

That's basically the whole story. Every strange word you've heard, superposition, entanglement, collapse, has a completely ordinary linear algebra explanation underneath it. You already know most of the ingredients. Let's assemble them.

A Bit Is a Switch. A Qubit Is an Arrow.

A regular computer bit is either 0 or 1. Flip a physical switch, read it, done. There's no in-between, and there's nothing to picture beyond an on/off light.

A qubit is different in one specific way: instead of picking 0 or 1, it's a vector that can point anywhere between them. Picture two directions at right angles, one labeled $|0\rangle$, one labeled $|1\rangle$. Those funny angle-bracket symbols just mean "quantum state," nothing scarier than that. A qubit is an arrow somewhere in the plane those two directions span.

Drag the arrow around. The two dashed lines are its shadows on the $|0\rangle$ and $|1\rangle$ axes. Those shadow lengths are called amplitudes, written $\alpha$ and $\beta$. Notice that no matter where you drag, $\alpha^2 + \beta^2$ stays pinned at $1.000$. That's not a coincidence, it's just the arrow always having length one.

We write the full state as

Read that as "the state is $\alpha$ worth of the 0-direction, plus $\beta$ worth of the 1-direction." That's it. That's superposition. It's a linear combination, the exact same operation you use to describe any vector as a mix of basis vectors.

"Superposition" Just Means Two Numbers Instead of One

Here's the part that trips people up: a qubit in superposition isn't secretly both 0 and 1 at once, like some fuzzy ghost state. It's one specific vector, at one specific angle, described by two coordinates instead of one.

Compare it to describing a point on a map. You don't say "this point is secretly both north and east." You just say it's 3 miles north and 4 miles east, two numbers, one location. A qubit works the same way, except the two numbers have to satisfy $\alpha^2+\beta^2=1$, and squaring them gives you odds instead of miles.

We're using real numbers here to keep the picture simple enough to draw. The real math uses complex numbers, and the full geometric picture is a sphere instead of a quarter circle (the Bloch sphere, if you want to look it up later). But every idea in this post, linear combinations, matrices, squared lengths, carries over exactly. Nothing about the complex version changes the logic, it just adds another axis.

A Gate Isn't an Instruction. It's a Matrix.

Classical computers use logic gates: AND, OR, NOT. Quantum computers use gates too, but a quantum gate isn't a rule you follow, it's a matrix you multiply the state vector by.

Try the X gate on an input at $\theta = 0$. That's the state sitting exactly on $|0\rangle$. Watch it land exactly on $|1\rangle$, because X is the matrix that swaps the two axes. Now try H, the Hadamard gate, on that same input. The arrow swings to the exact midpoint between $|0\rangle$ and $|1\rangle$, equal parts of each. That's the "equal superposition" state you've probably heard mentioned as the starting point of half the algorithms in quantum computing, and now you can see exactly why it happens: it's just what the Hadamard matrix does to $(1,0)$.

Notice something else: the output arrow never gets longer or shorter than the input, no matter which gate you pick. Quantum gates are only allowed to rotate and reflect the vector, never stretch it. Matrices with that property have a name: they're called unitary. It's the same requirement as $\alpha^2+\beta^2=1$, just applied after every gate instead of only at the start.

Where the Probabilities Actually Come From

So a qubit is a vector, and gates move that vector around. Fine. But at some point you have to actually read out an answer, 0 or 1. Where does randomness enter a process that's been perfectly deterministic matrix multiplication this whole time?

The rule, called the Born rule, says: to measure a qubit, square the amplitudes. $\alpha^2$ is the chance you get 0. $\beta^2$ is the chance you get 1.

Set $\theta$ somewhere in the middle and hit play. Each tick is one simulated measurement, landing on 0 or 1 at random. Watch the bars bounce around early on, then settle down and hug the dashed lines as more trials pile up. Those dashed lines are exactly $\alpha^2$ and $\beta^2$, nothing was tuned to make that happen, it's just what squaring amplitudes predicts and what the simulation confirms.

This is the one truly random step in the whole pipeline. Everything before measurement, every gate, every superposition, is completely deterministic linear algebra. The randomness only shows up the instant you look.

Two Qubits Aren't Two Arrows. They're One Bigger Arrow.

Now stack two qubits together. You might guess you just need two separate arrows, one per qubit. Sometimes that's true. But the honest way to combine two qubits is to build one combined vector living in a four-dimensional space, with one number for each pair of outcomes: $|00\rangle$, $|01\rangle$, $|10\rangle$, $|11\rangle$.

We can arrange those four amplitudes into a $2\times2$ grid instead of a flat list, one row per qubit A outcome, one column per qubit B outcome. When the two qubits genuinely don't interact, this grid factors cleanly: every entry is just (something about A) times (something about B). When it doesn't factor, something more interesting is going on.

Some States Refuse to Be Pulled Apart

That "doesn't factor" case is entanglement, and it's a real, checkable linear algebra fact, not a philosophical mystery.

At $t=0$, the grid is built from two separate arrows, one for qubit A and one for qubit B, multiplied together entry by entry. Click "flip pair" a bunch of times here. Qubit A comes up random, qubit B comes up random, and they barely agree with each other beyond coincidence, because they genuinely don't depend on each other.

Now drag $t$ up toward $1$. The grid reshapes into a Bell state, one of the most famous states in quantum computing. Flip pairs again. Qubit A is still a fair coin on its own. So is qubit B. But now they always match. Every single flip. That's entanglement: two individually random qubits locked into perfect agreement, and you can't explain that agreement by writing down a separate arrow for A and a separate arrow for B. There isn't one.

The readout backs this up with actual numbers. For a $2\times2$ amplitude grid $\begin{bmatrix} a & b \\ c & d \end{bmatrix}$, the quantity $2|ad-bc|$ is called the concurrence. It's exactly $0$ when the grid factors into two separate qubits, and it climbs toward $1$ as the qubits become maximally entangled. You just watched that number move in real time as you dragged the slider.

That determinant-like quantity isn't some special quantum formula invented for this occasion. It's the same test you'd use to check whether any $2\times2$ matrix has rank 1 or rank 2. Entanglement is a rank question.

Putting the Whole Pipeline Together

Here's the full recipe, and by now none of it should sound mystical:

1. Start with a vector, a linear combination of basis states.
2. Apply a sequence of unitary matrices (gates), which rotate that vector around without changing its length.
3. For multiple qubits, the vector just lives in a bigger space, built from tensor products, and some of those combined states can't be split back into separate qubits, that's entanglement.
4. Measure, which means squaring amplitudes to get probabilities, and randomly sampling one outcome.

A quantum algorithm is really just a clever choice of gates, a specific sequence of matrices, designed so that the wrong answers cancel out through interference and the right answer's amplitude gets left large before you measure. That's a whole topic on its own, but notice it's still linear algebra: which vectors these matrices send where, and which combinations of amplitudes add constructively or cancel out.

The Short Version

A qubit is a vector. A gate is a matrix that moves it. Measuring means squaring the amplitudes to get odds, then rolling the dice once. Two qubits live in a bigger combined vector space, and entanglement is just what happens when that combined vector can't be pulled apart into two separate ones, a rank-1-versus-rank-2 question you can check with a determinant.

None of it requires new math. It requires seeing vectors, matrices, and squared lengths in a place you weren't expecting to find them.

All visualizations are interactive React components running entirely in your browser, built with plain SVG and no external libraries. The measurement sampler uses requestAnimationFrame to step forward; everything else responds instantly to drags, clicks, and slider changes.