Single-Qubit Gates: X, Y, Z, H

A single qubit's pure state is a vector $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$ in $\mathbb{C}^2$, with $|\alpha|^2+|\beta|^2=1$. Any physically allowed operation on this state — one that could arise from unitary time evolution — is represented by a $2\times 2$ unitary matrix $U$, meaning $U^\dagger U = U U^\dagger = I$. Unitarity is not a stylistic choice; it is forced by the requirement that the total measurement probability stays equal to one after the gate is applied, and that the operation be reversible (run the physics backward and you undo the gate). The Pauli matrices and the Hadamard matrix are the smallest, most heavily used family of such unitaries. The three Pauli matrices are

Each is Hermitian ($U^\dagger = U$) and unitary, and each squares to the identity: $X^2=Y^2=Z^2=I$. Because they are Hermitian, they double as observables (measurable quantities) as well as gates — a fact you will meet again when Pauli operators appear as error generators and as building blocks of Hamiltonians. On the Bloch sphere, applying $X$, $Y$, or $Z$ corresponds exactly to a rotation by $\pi$ radians ($180°$) about the $x$-, $y$-, or $z$-axis respectively. This is why $X$ is called a "bit flip," $Z$ a "phase flip," and $Y$ a combination of both. The Hadamard gate is

$H$ is also Hermitian and unitary, and also squares to the identity, but it is geometrically different from the Paulis: it is a $180°$ rotation about the axis $(\hat{x}+\hat{z})/\sqrt{2}$, which has the visible effect of swapping the roles of the $x$- and $z$-axes. Concretely, $H$ maps the computational basis states $|0\rangle,|1\rangle$ (the poles of the Bloch sphere, along $z$) into the equator states $|+\rangle,|-\rangle$ (along $x$), and vice versa. This is the mechanism behind essentially every superposition-based quantum algorithm: apply $H$ to a $|0\rangle$ register to spread amplitude evenly over all classical strings before doing something interference-based with the result.

Each gate acts on a qubit state by ordinary matrix-vector multiplication, using the column-vector convention $|0\rangle = \binom{1}{0}$, $|1\rangle = \binom{0}{1}$.

X (Pauli-X, "bit flip" / quantum NOT).

On a general state: $X(\alpha|0\rangle+\beta|1\rangle) = \beta|0\rangle + \alpha|1\rangle$ — the amplitudes are swapped.

Z (Pauli-Z, "phase flip").

On a general state: $Z(\alpha|0\rangle+\beta|1\rangle) = \alpha|0\rangle - \beta|1\rangle$ — only the $|1\rangle$ amplitude picks up a minus sign. This has zero effect on the outcome probabilities of a $Z$-basis measurement (since $|-\beta|^2=|\beta|^2$), but it changes interference behavior, which is exactly why relative phase is physically meaningful even though a global phase is not.

Y (Pauli-Y, "bit-and-phase flip").

On a general state: $Y(\alpha|0\rangle+\beta|1\rangle) = i\beta|0\rangle - i\alpha|1\rangle$. Algebraically $Y = iXZ$ (check: $XZ|0\rangle = X|0\rangle=|1\rangle$, so $iXZ|0\rangle = i|1\rangle = Y|0\rangle$ ✓; $XZ|1\rangle = X(-|1\rangle) = -|0\rangle$, so $iXZ|1\rangle = -i|0\rangle = Y|1\rangle$ ✓). Y both swaps the basis states and multiplies by $\pm i$.

H (Hadamard, "superposition maker").

On a general state: $H(\alpha|0\rangle+\beta|1\rangle) = \frac{\alpha+\beta}{\sqrt2}|0\rangle + \frac{\alpha-\beta}{\sqrt2}|1\rangle$. The following pseudocode implements all four gates as explicit matrix-vector operations, and can be used as a reference simulator for a single qubit. ```

# State representation: complex pair (alpha, beta) meaning alpha|0> + beta|1>

# Gate representation: 2x2 complex matrix [[a,b],[c,d]] function apply_gate(matrix, state): a, b = matrix[0][0], matrix[0][1] c, d = matrix[1][0], matrix[1][1] alpha, beta = state new_alpha = a alpha + b beta new_beta = c alpha + d beta return (new_alpha, new_beta)

# Canonical gate matrices X = [[0, 1], [1, 0]] Y = [[0, -1i], [1i, 0]] Z = [[1, 0], [0, -1]] H = (1 / sqrt(2)) * [[1, 1], [1, -1]] function apply_X(state): return apply_gate(X, state) function apply_Y(state): return apply_gate(Y, state) function apply_Z(state): return apply_gate(Z, state) function apply_H(state): return apply_gate(H, state)

# Sanity check: every gate here is self-inverse function assert_involution(matrix, state): once = apply_gate(matrix, state) twice = apply_gate(matrix, once) assert twice approx_equals state # should hold for X, Y, Z, H ``` The diagram below shows the geometric action of all four gates on the Bloch sphere: X, Y, Z each rotate $180°$ about their named axis, while H reflects through the diagonal axis that swaps $x$ and $z$.

Time and space complexity. Applying any single-qubit gate to a classically simulated state vector of a single qubit is a $2\times 2$ matrix-vector multiplication: $O(1)$ time and $O(1)$ space, since the matrix has a fixed $4$ entries and the state vector has $2$ entries, independent of any problem size. This constant-time cost is why single-qubit gates are treated as the fundamental "atoms" of circuit depth — a circuit's depth is literally a count of how many such $O(1)$ layers are applied in sequence. The complexity story changes when a single-qubit gate is applied to one qubit inside an $n$-qubit register, because the full state vector has $2^n$ amplitudes. Applying $X$, $Y$, $Z$, or $H$ to qubit $j$ out of $n$ still only touches the two amplitude "slots" that differ in bit $j$, but there are $2^{n-1}$ such pairs, so classically simulating the gate costs $O(2^n)$ time and $O(2^n)$ space to store the state — exponential in $n$. This is precisely the resource blow-up that motivates building real quantum hardware rather than simulating everything classically: the physical gate itself is still a local, constant-time control pulse, only the classical simulation of it is expensive.

Correctness: unitarity and involution. Correctness for these gates reduces to two algebraic facts, both checkable directly from the matrices. First, unitarity ($U^\dagger U = I$) guarantees that gate application preserves the normalization $|\alpha|^2+|\beta|^2=1$, so that the output is always a valid quantum state whose Born-rule probabilities sum to one. For example, for $H$:

The same computation for $X$, $Y$, $Z$ gives $I$ directly since each is both Hermitian and its own inverse (shown next), so $U^\dagger U = U \cdot U = U^2 = I$. Second, each of $X, Y, Z, H$ is an involution: $U^2 = I$. Verify for $X$:

For $Z$: $Z^2$ multiplies the diagonal entries $1\cdot1=1$ and $(-1)(-1)=1$, giving $I$. For $Y$: $Y^2 = (iXZ)^2 = i^2 (XZ)(XZ)$; since $XZ = \begin{pmatrix}0&-1\\1&0\end{pmatrix}$, squaring it gives $-I$, so $Y^2 = (-1)(-I) = I$. For $H$, the computation above already showed $H^2 = H^\dagger H = I$ because $H$ is Hermitian. This involution property is the algebraic reason applying any of these gates twice in a row is always a no-op: $U(U|\psi\rangle) = U^2|\psi\rangle = I|\psi\rangle = |\psi\rangle$. It is a useful sanity check for debugging quantum circuits — if you expect a gate pair to cancel and it doesn't, either the gates are not identical or a phase has been mismanaged.

Tradeoffs and honesty about scope. These four gates are not universal by themselves for continuous single-qubit control: they generate only a finite subgroup of $SU(2)$ (together with global phases, essentially the Pauli group), so they cannot produce an arbitrary point on the Bloch sphere. Reaching arbitrary single-qubit unitaries requires continuously parameterized Rotation Gates and Arbitrary Single-Qubit Unitaries such as $R_x(\theta), R_y(\theta), R_z(\theta)$, of which X, Y, Z are the special case $\theta=\pi$ (up to phase). Similarly, single-qubit gates alone can never entangle two qubits — that requires two-qubit interactions such as the CNOT gate.

Let the input state be $|\psi\rangle = \frac{1}{\sqrt3}|0\rangle + \sqrt{\frac{2}{3}}\,e^{i\pi/4}|1\rangle$, i.e. $\alpha = \frac{1}{\sqrt3} \approx 0.5774$ and $\beta = \sqrt{2/3}\,e^{i\pi/4} \approx 0.5774 + 0.5774i$ (since $\sqrt{2/3}\approx0.8165$, and $e^{i\pi/4}=\frac{\sqrt2}{2}(1+i)\approx0.7071+0.7071i$, giving $\beta \approx 0.8165\times(0.7071+0.7071i) \approx 0.5774+0.5774i$). Check normalization: $|\alpha|^2 = 1/3$, $|\beta|^2 = 2/3$, sum $=1$ ✓. We trace this state through $X$, $Z$, $Y$, and $H$ in turn (each applied to the original $|\psi\rangle$, not chained), and also chain $H$ then $Z$ then $H$ to illustrate a classic identity.

Row-by-row reasoning:

• Row 1 ($X$): amplitudes swap exactly as the rule $X(\alpha|0\rangle+\beta|1\rangle)=\beta|0\rangle+\alpha|1\rangle$ dictates. Note $P(0)$ and $P(1)$ swap too — X is the quantum analogue of NOT for measurement statistics.
• Row 2 ($Z$): only $\beta$ flips sign; $|\beta'|^2 = |-\beta|^2 = |\beta|^2$, so the measurement probabilities are unchanged from the input, even though the state vector differs. This is the signature behavior of a pure phase gate.
• Row 3 ($Y$): using $Y(\alpha|0\rangle+\beta|1\rangle) = i\beta|0\rangle - i\alpha|1\rangle$: $i\beta = i(0.5774+0.5774i) = 0.5774i - 0.5774 = -0.5774+0.5774i$, and $-i\alpha = -0.5774i$. Probabilities match the $X$-flipped ones (row 1) because multiplying by a unit-modulus phase $i$ or $-i$ doesn't change $|\cdot|^2$ — consistent with $Y=iXZ$ combining a bit flip with a phase.
• Row 4 ($H$): $\alpha+\beta \approx 0.5774+(0.5774+0.5774i) = 1.1548+0.5774i$, divided by $\sqrt2\approx1.4142$ gives $\approx0.8165+0.4082i$; magnitude-squared $\approx 0.667+0.167=0.833$. Similarly $\alpha-\beta \approx -0.5774i$, divided by $\sqrt2$ gives $\approx -0.4082i$, magnitude-squared $\approx0.167$. Sum $0.833+0.167=1.000$ ✓ — normalization survives, as guaranteed by unitarity.

Chained identity check ($HZH = X$): apply $H$ to $|0\rangle$ to get $|+\rangle = \frac{1}{\sqrt2}(|0\rangle+|1\rangle)$; apply $Z$ to get $\frac{1}{\sqrt2}(|0\rangle-|1\rangle) = |-\rangle$; apply $H$ again: $H|-\rangle = H\left(\frac{|0\rangle-|1\rangle}{\sqrt2}\right) = \frac{H|0\rangle - H|1\rangle}{\sqrt2} = \frac{|+\rangle-|-\rangle}{\sqrt2} = \frac{1}{\sqrt2}\cdot\frac{(|0\rangle+|1\rangle)-(|0\rangle-|1\rangle)}{\sqrt2} = \frac{2|1\rangle}{2} = |1\rangle$. Since $X|0\rangle=|1\rangle$ too, this confirms $HZH|0\rangle = X|0\rangle$, an instance of the general identity $HZH=X$ (and dually $HXH=Z$), which is exactly why Hadamard is described as "swapping the roles of $X$ and $Z$."

The mathematical objects behind these gates predate quantum computing by decades: the Pauli matrices were introduced to describe electron spin, and the Hadamard matrix originates in classical combinatorics and signal processing, long before either was recast as a quantum logic gate.

Single-qubit X, Y, Z, and H gates are the daily working tools of every quantum computing platform. In superconducting-qubit processors (as used by IBM, Google, and Rigetti), X and Y rotations are implemented as microwave pulses of specific amplitude and phase, and Z rotations are often applied "virtually" — as a bookkeeping phase shift in software rather than a physical pulse — because they commute with the natural qubit Hamiltonian. In trapped-ion systems, laser pulses of controlled duration and phase realize the same rotations directly on atomic energy levels. The Hadamard gate is the standard first step in nearly every textbook quantum algorithm: it is used to place a register into uniform superposition at the start of Grover's search, Simon's algorithm, and the quantum Fourier transform pipeline underlying Shor's factoring algorithm. The Pauli gates appear again at the heart of quantum error correction, where $X$ and $Z$ errors (bit flips and phase flips) are the two basic error types that stabilizer codes such as the surface code are explicitly designed to detect and correct — every more complex error is expressible as a combination of Pauli operators. Random Pauli gates are also injected deliberately in randomized benchmarking and dynamical decoupling protocols to characterize and suppress noise on real hardware. Beyond dedicated quantum hardware, these gates appear in every classical quantum-circuit simulator (Qiskit, Cirq, Q#, PennyLane) as built-in primitives, and they are the first four gates taught in essentially every quantum computing curriculum before moving on to multi-qubit interactions and general single-qubit rotation gates.

Ask the tutor: How do X, Y, Z, and H relate to the general rotation gates $R_x(\theta)$, $R_y(\theta)$, $R_z(\theta)$, and why are the Paulis just the special case $\theta = \pi$?