Phase gates: S and T

So far, every gate you’ve met has done something visible — flipping a bit, creating a superposition, rotating by $\pi$. This lesson introduces two gates that look, in the computational basis, like they do almost nothing.

That’s the point.

The S gate

The $S$ gate, also called the phase gate, is:

$S = \begin{pmatrix} 1 & 0 \\ 0 & i \end{pmatrix}$

All it does is multiply the $|1\rangle$ component by $i$. It leaves $|0\rangle$ alone. On a pure $|0\rangle$ or pure $|1\rangle$ state, you’d never know anything happened — $|1\rangle$ and $i|1\rangle$ are the same state up to global phase.

On a superposition, though, it rotates the relative phase by $\pi/2$. Geometrically, it’s a $\pi/2$ rotation around the $z$-axis of the Bloch sphere. If you start at $|+\rangle$ on the equator and apply $S$, you end up at $|+i\rangle$ — still on the equator, but a quarter-turn around.

Here’s the crucial fact: $S$ is the square root of $Z$:

$S^2 = Z$

Apply $S$ twice — you get $Z$. Which makes sense geometrically: $Z$ is a $\pi$ rotation around the $z$-axis, and $S$ is half of that.

The T gate

The $T$ gate is the square root of $S$ — an eighth of a full revolution around the $z$-axis:

$T = \begin{pmatrix} 1 & 0 \\ 0 & e^{i\pi/4} \end{pmatrix}$

So $T$ rotates relative phase by $\pi/4$ (that’s $45°$). And:

$T^2 = S \qquad T^4 = Z \qquad T^8 = I$

$T$ is even more subtle than $S$. But it’s arguably the most important gate in fault-tolerant quantum computing — we’ll come back to why in a moment.

See them in action

The widget now has $S$ and $T$ buttons. Try these:

1. Start from $|0\rangle$. Apply $S$. Nothing visible happens. Apply $T$. Still nothing.
2. Reset. Apply $H$ first (making $|+\rangle$). Now apply $S$ — the state moves from $|+\rangle$ to $|+i\rangle$. Apply $S$ again — now you’re at $|-\rangle$. Two $S$ gates = one $Z$ gate, which is exactly what $S^2 = Z$ says.
3. Reset. $H$, then $T$, then $T$, then $T$, then $T$ — four $T$s should equal a $Z$.
4. Reset. $H$, then $T$, then $H$. Where does the state land? (This is a genuinely interesting place. It’s called a magic state.)

Why we care about T

There’s a deep theorem in quantum computing called the Solovay–Kitaev theorem that says: given a small universal set of gates, you can approximate any single-qubit gate to arbitrary precision using only gates from that set. The most commonly used universal set for fault-tolerant quantum computers is:

$\{H, S, CNOT, T\}$

The $H$, $S$, and $CNOT$ gates are all “Clifford” gates — they have nice algebraic properties that make them easy to make fault-tolerant. But Clifford gates alone are not universal; you can only reach a finite subset of quantum states with them (this is the Gottesman–Knill theorem).

The one gate that breaks Clifford and gives you full universality is $T$. It’s the magic ingredient.

The catch: $T$ is much harder to make fault-tolerant than Cliffords. On real fault-tolerant quantum hardware, the bottleneck is almost always the T count — the number of $T$ gates in your circuit. Quantum algorithms are often described in terms of how many $T$s they need, because that’s what determines how long they take to run on a real machine.

So $T$ looks like the gentlest possible gate — a tiny phase twist — but it’s carrying more weight than any gate except maybe the Hadamard.

What’s next

The Pauli, Hadamard, S, and T gates are all discrete — fixed rotations by specific angles. The next lesson introduces rotation gates, which give you continuous control over the angle. You’ll be able to rotate by any amount you want, and you’ll see that all the discrete gates we’ve met so far are just special cases of continuous rotations.