Single-qubit gates are unitary operations that act on one qubit. They are represented by $2 \times 2$ unitary matrices and form the Lie group $\mathrm{SU}(2)$. Every quantum computation can be decomposed into single-qubit rotations and two-qubit entangling gates (e.g., CNOT), making single-qubit gates the fundamental building blocks of quantum circuits.

A single-qubit gate is applied to a state $|\psi\rangle$ to produce a new state $U|\psi\rangle$. The gates compose: two gates in sequence form a new gate (matrix product). Some gates are self-inverse (like Pauli gates and Hadamard); others have finite order ($S^4 = I$, $T^8 = I$); some are parameterized (RX, RY, RZ with rotation angle $\theta$).

All single-qubit gates correspond to rotations on the Bloch sphere; any unitary in $\mathrm{SU}(2)$ can be decomposed as a product of rotations around two perpendicular axes.

• Pauli gates
  • Identity (I)
  • Pauli X (NOT)
  • Pauli Y
  • Pauli Z
• Hadamard (H)
• Phase gates
  • S (phase) gate
  • S† (inverse phase gate)
  • T gate
  • T† gate (inverse T gate)
• Rotation gates
  • Rx (rotation around X)
  • Ry (rotation around Y)
  • Rz (rotation around Z)
  • U (universal single-qubit)

Single-qubit gates act as rotations on the Bloch sphere. Pauli gates (X, Y, Z) are 180° rotations around their respective axes. The Hadamard swaps the x and z axes. Phase gates (S, S†, T, T†) are rotations around the z-axis. Rotation gates ($R_X$, $R_Y$, $R_Z$) parameterize arbitrary angles around each axis. Universal gate specifies an arbitrary rotation via three Euler angles: $U(\phi, \theta, \lambda)$.

Composing rotations around different axes yields a rotation around a third axis. The $2 \times 2$ unitary matrices $\mathrm{SU}(2)$ are isomorphic to the unit quaternions $\mathrm{Sp}(1)$, which naturally represent 3D rotations via quaternion multiplication. This explains the double-cover relationship between $\mathrm{SU}(2)$ and $\mathrm{SO}(3)$: two distinct quantum gates (differing by a global phase factor of $-1$) represent the same Bloch sphere rotation.

Pauli gates:

$$I = \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix} \quad X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} \quad Y = \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix} \quad Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$$

Hadamard:

$$H = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}$$

Clifford phase gates:

$$S = \begin{pmatrix} 1 & 0 \\ 0 & i \end{pmatrix} \quad S^\dagger = \begin{pmatrix} 1 & 0 \\ 0 & -i \end{pmatrix}$$

Non-Clifford phase gates:

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

Parametric rotation gates (angle $\theta$):

$$R_X(\theta) = \begin{pmatrix} \cos(\theta/2) & -i\sin(\theta/2) \\ -i\sin(\theta/2) & \cos(\theta/2) \end{pmatrix} \quad R_Y(\theta) = \begin{pmatrix} \cos(\theta/2) & -\sin(\theta/2) \\ \sin(\theta/2) & \cos(\theta/2) \end{pmatrix} \quad R_Z(\theta) = \begin{pmatrix} e^{-i\theta/2} & 0 \\ 0 & e^{i\theta/2} \end{pmatrix}$$

Note: T and T† are special cases ($T = R_Z(\pi/4)$, $T^\dagger = R_Z(-\pi/4)$).

Single-qubit gates partition into two classes:

Clifford gates (24 total) conjugate Pauli operators to Paulis: if $C$ is Clifford and $P$ is Pauli, then $C P C^\dagger$ is also Pauli (up to global phase). Single-qubit Cliffords include: Pauli gates (I, X, Y, Z), Hadamard, S, and S†. Examples:

• $H X H = Z$, $H Z H = X$
• $S X S^\dagger = Y$, $S Z S^\dagger = Z$

Clifford circuits are efficiently simulatable classically using the stabilizer tableau method in $O(n^3)$ time; they cannot provide quantum advantage alone.

Non-Clifford gates (T, T†) break the Pauli closure property:

$$T X T^\dagger = \frac{1}{\sqrt{2}}(X + Y), \quad T Z T^\dagger = Z$$

The result is a superposition of Paulis, not a Pauli itself. This breakdown is precisely what enables universal quantum computation and exponential speedup. However, non-Clifford gates require magic state distillation in fault-tolerant systems, making T-count the dominant cost metric.

Single-qubit gates form the Lie group $\mathrm{SU}(2)$, the group of $2 \times 2$ unitary matrices with determinant 1. This group is isomorphic to $\mathrm{Sp}(1)$ (compact symplectic group) and to $\mathrm{SO}(3)$ (3D rotations), explaining why single-qubit gates correspond to Bloch sphere rotations.

The Clifford subgroup $\mathcal{C}_1$ has exactly 24 elements. These are generated by Hadamard and S: $(HS)^3 = I$. Any Clifford can be decomposed into H, S, and CNOT gates (when acting on multiple qubits).

The group $\mathrm{SU}(2)$ is continuous and infinite-dimensional. Single-qubit rotations at arbitrary angles form a dense subset; any unitary can be approximated to desired accuracy using the Solovay-Kitaev theorem with $O(\log^c(1/\epsilon))$ gates.

Any single-qubit unitary can be expressed as a product of rotations around two perpendicular axes. The standard parametrization is:

$$U(\phi, \theta, \lambda) = R_Z(\phi) R_Y(\theta) R_Z(\lambda)$$

where $\phi, \theta, \lambda \in [0, 2\pi)$. Alternative decompositions exist (e.g., $R_X R_Y R_Z$) depending on axis ordering. The U gate implements this parametrization directly.

This decomposition proves that any single-qubit unitary requires at most three rotations. Combined with two-qubit gates (like CNOT), the Euler angles form a universal gate set.

• State preparation: Rotate computational basis states to arbitrary points on the Bloch sphere
• Circuit synthesis: Decompose arbitrary single-qubit unitaries into rotation sequences
• Variational algorithms: VQE and QAOA use parameterized rotation layers as ansatze
• Measurement basis rotation: Apply single-qubit gates before measurement to extract different observables (e.g., H before Z-basis measurement gives X-basis measurement)
• Quantum error correction: Pauli and Hadamard gates measure stabilizers in different bases without collapsing encoded information
• Basis switching: Prepare for operations in rotated bases (Hadamard for X basis, S for Y basis)

Gate performance varies by platform:

Superconducting qubits:

• Pauli rotations (RX, RY): ~20–40 ns; achieved via microwave pulses
• RZ gates: typically virtual (reference frame adjustment), free cost
• Hadamard: ~20–50 ns; often decomposed as RZ + RX + RZ
• S, S† gates: virtual on most systems; no pulse needed
• T, T† gates: ~20–30 ns when implemented as RZ rotations; bottleneck is magic state distillation for fault tolerance, not gate time
• Fidelity: typically 99–99.9%

Trapped ions:

• Single-qubit gates: ~1–5 μs via laser pulses at multiple frequencies
• RZ gates: detuned pulse (leaves Rabi frequency small)
• Fidelity: 99.9%+ achievable

Photonic:

• Rotations via beam splitters and optical wave plates
• RZ via optical phase shifters
• Fidelity: ~99% (limited by optical component precision)

• Pauli gates: X, Y, Z are 180° Bloch rotations and Clifford gates
• Hadamard (H): basis rotation; single most important Clifford gate
• Phase gates: S, S†, T, T† are rotations around z-axis
• Rotation gates: $R_X$, $R_Y$, $R_Z$ parametrize Bloch rotations
• U gate: universal single-qubit; implements Euler angle decomposition
• Clifford gates: single-qubit Cliffords form 24-element subgroup of $\mathrm{SU}(2)$
• Non-Clifford gates: T and T† enable universality but require magic state distillation
• Two-qubit gates: single-qubit gates plus CNOT form universal gate set
• $\mathrm{SU}(2)$: group structure of single-qubit unitaries
• Bloch sphere: geometric interpretation of single-qubit operations