Single-qubit gates as matrices

A classical gate is a lookup table: feed it bits, read bits back. A quantum gate cannot be a table, because a qubit is not a bit, it is a unit vector. So a gate has to be the one thing that moves a unit vector without ever stretching it off the unit circle: a rotation. This lesson turns five named gates into five small matrices, and shows you they are all just turns of the same arrow.

The one rule a gate must obey

Before any matrices, one probe. In the reversible-gates lesson we saw that a gate that throws information away has no place in a quantum circuit. Keep that in mind here.

That constraint has a precise name. A one-qubit gate is a $2\times 2$ matrix $U$ that is unitary, meaning $U^{†}U=I$. Read that condition twice, because it is the whole story:

The first consequence, $U^{-1}=U^{†}$, says every gate can be run backward just by taking its conjugate-transpose, so quantum circuits are always reversible. The second says lengths never change, so a state that started with $|\alpha {|}^2+|\beta {|}^2=1$ still sums to one after the gate. Probabilities stay probabilities. A matrix that keeps every length is exactly a rotation (possibly with a reflection), which is why every gate you meet is a turn of the Bloch arrow.^[2]

Play the gates before you read them

Below, the qubit starts at $|0⟩$, the north pole. Click a gate and watch the arrow sweep; the panel shows the gate as a matrix and keeps the running product of your whole chain. Try the two preset chains, then read on to see why they land where they do.^[1]

Five gates, five matrices

Here are the workhorses. Each acts on the state vector $\left[\begin{array}{c}\alpha \\ \beta \end{array}\right]$ by ordinary matrix multiplication.

$X$ is the bit flip: it swaps the two amplitudes, so $X|0⟩=|1⟩$ and $X|1⟩=|0⟩$. It is the quantum NOT. $Z$ is the phase flip: it leaves $|0⟩$ alone and multiplies $|1⟩$ by $-1$. It touches no probability at all (both amplitudes keep their magnitude) yet it is far from nothing, as the next lesson on phase will make loud. $S$ and $T$ are gentler cousins of $Z$: they rotate the phase of $|1⟩$ by a quarter and an eighth of a turn instead of a half.

The star is the Hadamard gate $H$. Multiply it against $|0⟩=\left[\begin{array}{c}1\\ 0\end{array}\right]$:

One matrix multiply turns a definite $|0⟩$ into the equal superposition $|+⟩$, the state that is half zero and half one. That is $H$ building superposition out of a plain bit. Feed it $|1⟩$ instead and you get $|-⟩=\frac{1}{\sqrt{2}}(|0⟩-|1⟩)$, the same split but with a minus sign hiding in it.

Chaining gates is just multiplying matrices

Applying gate $A$ then gate $B$ is the single matrix $BA$ (the second gate sits on the left, the way matrix multiplication composes linear transformations). Two facts fall straight out of this, and the lab drew both.

First, $H$ is its own undo. Multiply it by itself:

So a Hadamard followed by a Hadamard is the identity: it does nothing. The superposition $H$ creates, a second $H$ uncreates. This is derived, not asserted, and it is the whole reason interference can work: you can spread a state out, let phases do something, then fold it back.

Second, and more surprising, a phase flip sandwiched between two Hadamards is a bit flip:

Nothing in $HZH$ ever mentions swapping bits, yet the product is exactly $X$. A flip in one basis is a flip in another once you rotate into it and back. In the lab, chaining H, Z, H walked the arrow from $|0⟩$ out to the equator and down to $|1⟩$, which is precisely where a single $X$ sends it. Same destination, different route.

import numpy as np

H = (1/np.sqrt(2)) * np.array([[1, 1], [1, -1]])
Z = np.array([[1, 0], [0, -1]])
X = np.array([[0, 1], [1, 0]])

np.allclose(H @ H, np.eye(2))   # True  -> H is its own inverse
np.allclose(H @ Z @ H, X)       # True  -> HZH is a bit flip

# In Qiskit you would just write the gates onto a wire:
#   qc.h(0); qc.z(0); qc.h(0)     is the same unitary as   qc.x(0)