Universal Single-Qubit Decomposition

You have been meeting new single-qubit gates for five chapters now — X, Y, Z, H, S, T, and the continuous family R_x(\theta), R_y(\theta), R_z(\theta). At some point the sensible reader stops and asks: when does this zoo end? Do I have to memorise a new gate every time I open a paper?

The answer is no. The zoo ends here. There is, in fact, only one gate — a general 2 \times 2 unitary matrix with four real parameters — and every specific gate you have met is just a particular choice of those four parameters. Every U you will ever write down on a single qubit can be built from three rotations about two axes plus a global phase. That is the content of the chapter.

This is not a small claim. It means a quantum engineer at Google or IBM does not need to build a Hadamard gate, a T gate, and a phase gate and a rotation-by-\pi/7-about-the-weird-axis gate as four separate physical operations. They need to calibrate two rotation types — usually R_x(\theta) and R_z(\theta) — and the compiler handles the rest. Every single-qubit circuit is sliced, at compile time, into this three-rotation sandwich, which lands on whatever the hardware can physically do. The algorithm designer gets to work in the abstract space of "any unitary I want"; the hardware only ever sees two kinds of pulse.

This chapter builds the decomposition from the Bloch-sphere picture — where the theorem is obvious — down to the algebraic form that a compiler actually uses. Then the payoff: a worked decomposition of the Hadamard into ZYZ Euler angles, a worked hardware compilation of a small R_y rotation into native R_x and R_z gates, and a preview of the Solovay-Kitaev theorem that handles the discrete-gate case.

The picture — every qubit gate is a Bloch rotation

The Bloch sphere chapter built the picture already; pull it back into focus.

Every pure single-qubit state is a point on a unit sphere. Every single-qubit gate is a rotation of that sphere — an orthogonal-transformation-with-orientation of the 3D ball of possible Bloch vectors. A rotation of 3D space is determined by three numbers: an axis direction (two angles to specify a direction in 3D) plus a rotation angle (one more number). Three numbers, three degrees of freedom.

So every single-qubit unitary — up to global phase — carries exactly three real parameters. And any three numbers that specify a 3D rotation can be specified in many ways. One of the oldest ways is Euler angles: instead of giving one axis and one angle, give three successive rotations about two fixed axes (like a gimbal).

This is the Bloch-sphere-level content of the ZYZ theorem. Every rotation of the sphere can be performed as:

1. Spin around the z-axis by some angle \delta.
2. Tip around the y-axis by some angle \gamma.
3. Spin around the z-axis again by some angle \beta.

Three spins, two axes. Every rotation, ever.

Why three rotations suffice: you need to specify two things for any orientation of the sphere — where the "north pole" |0\rangle ends up (two angles on the target sphere, specified by R_y(\gamma) after R_z(\delta)), and how the sphere is rotated around that new north (one angle, specified by R_z(\beta)). Two plus one is three. That is the whole counting argument.

The theorem — stated carefully

Now the algebraic statement the compiler actually uses.

Reading the theorem. The matrix U has four complex entries, which is eight real numbers. The constraint U^\dagger U = I imposes four equations, leaving four free real parameters. Those four parameters are \alpha, \beta, \gamma, \delta — the global phase and the three Euler angles. The theorem promises you can always find them, and gives a concrete parameterisation in the process.

Why this is called "universal single-qubit": because every one-qubit unitary is reachable by picking the right (\alpha, \beta, \gamma, \delta). If a hardware device can execute R_z(\theta) and R_y(\theta) for arbitrary continuous \theta, it can execute any single-qubit gate. You never need a separate "Hadamard instruction" or "T instruction" — those are just specific choices of the four angles.

There is nothing magical about choosing z-y-z. The same job can be done with X-Y-X, or Z-X-Z, or any other non-parallel pair of axes. ZYZ is the conventional choice because it matches how Qiskit's U3 gate and IBM's compiler are written. Any quantum SDK you will ever meet uses some version of this three-rotation form.

Why three rotations suffice — the counting argument

You saw the counting glimpse above. Write it out carefully, because the degree-of-freedom count is how you know the theorem isn't accidentally over- or under-determined.

A general 2 \times 2 unitary has four real parameters. A complex 2 \times 2 matrix has 8 real entries (4 complex numbers, 2 reals each). The unitary constraint U^\dagger U = I imposes:

• 2 normalisation conditions (each column is a unit vector).
• 1 orthogonality condition (the two columns are orthogonal, as a complex inner product — that is 2 real equations, one for real part, one for imaginary part).

Total: 4 real equations on 8 real numbers, leaving 8 - 4 = 4 free parameters. That matches the four numbers (\alpha, \beta, \gamma, \delta) in the ZYZ form. Coincidence? Not at all — the theorem is designed to match.

Why R_z(\beta) R_y(\gamma) R_z(\delta) covers the three angles of SU(2): SU(2) is the special unitary group — unitaries with determinant +1. It has 3 real parameters. Bloch-sphere rotations are exactly SU(2) (up to a double cover), and Euler angles are the classical coordinates on it. The fourth parameter \alpha is the determinant phase, which SU(2) has forced to 1 but U(2) allows to roam.

The global phase \alpha separately. The matrix e^{i\alpha} I commutes with everything, so multiplying by it doesn't affect how the gate interacts with other gates — except when the gate is placed inside a controlled operation (more on this in the next chapter). In isolation, \alpha is invisible: a measurement can't see it, because probabilities are |\text{amplitude}|^2 and the |e^{i\alpha}|^2 = 1 factor drops out.

The algorithm — computing the Euler angles

Given a specific U = \begin{pmatrix} a & b \\ c & d \end{pmatrix}, you can pull the angles out by direct algebra.

Step 1. Extract the global phase. The determinant of U is some complex number with modulus 1, so \det(U) = e^{2i\alpha} for some real \alpha. Compute \alpha = \tfrac{1}{2}\arg(\det U). Now define the phase-stripped matrix \tilde U = e^{-i\alpha} U. This \tilde U has \det(\tilde U) = 1 — it is an element of SU(2).

Step 2. Identify the absolute values of the diagonal entries. For \tilde U in SU(2), write it as \tilde U = R_z(\beta) R_y(\gamma) R_z(\delta) and multiply out. The result is:

Why this matrix-multiply works: R_z(\delta) on the right multiplies each column by a diagonal phase, then R_y(\gamma) mixes the rows with cosine and sine, then R_z(\beta) on the left multiplies each row by another diagonal phase. Track the phases and you get the four-entry pattern above.

Step 3. Read off \gamma from the magnitudes.

So \gamma/2 = \arctan\!\big(|\tilde U_{21}| \,/\, |\tilde U_{11}|\big) and \gamma is between 0 and \pi.

Step 4. Read off \beta + \delta and \beta - \delta from the phases. The top-right entry is -e^{-i(\beta-\delta)/2}\sin(\gamma/2), and you already know \sin(\gamma/2) from step 3. So the phase of -\tilde U_{12} / \sin(\gamma/2) gives you -(\beta - \delta)/2. Similarly for \tilde U_{21}. Combine the two to recover \beta and \delta separately.

That's the whole algorithm. Every step is one line of arithmetic. A compiler can execute it in microseconds.

Edge case (at \gamma = 0 or \gamma = \pi). The decomposition becomes degenerate — the two R_z rotations merge into one, and only their sum \beta + \delta is determined, not the individual values. Compilers pick \delta = 0 by convention in these cases. This is a measure-zero corner of the parameter space; don't worry about it on first pass.

Worked example 1 — Hadamard in ZYZ angles

Time to actually decompose a gate you know by heart. Take the Hadamard,

Find (\alpha, \beta, \gamma, \delta) such that H = e^{i\alpha} R_z(\beta) R_y(\gamma) R_z(\delta).

Worked example 2 — compiling a rotation to native X/Z gates

Real superconducting quantum hardware at companies like IBM and Google implements R_x(\theta) and R_z(\theta) natively — R_x via a microwave pulse that drives the qubit transition, and R_z essentially for free by reassigning phase labels in software (the "virtual-Z" trick). R_y is not a native gate: it has to be compiled into R_x and R_z.

Take a small rotation U = R_y(\pi/4), which written as a matrix is

Find a native-gate (R_x, R_z only) sequence that realises this.

Common unitaries and their ZYZ angles — a reference table

Keep this table near your desk when you are writing quantum circuits by hand. Verify any entry by multiplying out — the algebra is always a clean exercise.

Notice how the Paulis all have \gamma = \pi (a full y-tip by 180°, or 0 when they act trivially), while S and T have \gamma = 0 (no y-tip — they are pure z-rotations, so the ZYZ form collapses to a single z). The Hadamard is the one that spreads its angles evenly across all three rotations, which matches its role as the "mixer" of the computational and plus-minus bases.

Exact vs approximate — the discrete gate problem

Everything above assumes you have access to R_z(\theta) and R_y(\theta) for arbitrary continuous angles \theta. Real fault-tolerant hardware does not have this luxury. In a fault-tolerant architecture (the kind you need for Shor's algorithm on a scale that factors realistic RSA keys), the only gates you can do reliably are a discrete set — typically the Clifford group plus the T gate. That is \{H, S, \text{CNOT}, T\}, and nothing else.

Call this set G. Since G is a finite set, and you can only compose finitely many gates in finite time, any sequence you build from G is one of countably many unitaries. But the single-qubit unitaries U(2) form a four-dimensional continuum — uncountably many. So you will never get every U exactly from \{H, T\} alone.

The question becomes: how closely can you approximate an arbitrary U with a sequence from \{H, T\}? Can you make the error \|U - U_\text{approx}\| as small as you like? And if so, how many gates does the approximation need?

The Solovay-Kitaev theorem is the answer, and it is spectacular.

What this actually says, translated. To approximate a unitary to 10^{-10} accuracy (more than good enough for any real quantum algorithm), you need roughly \log^3(10^{10}) \approx 1000 \cdot 23^3 / 10 \approx a few hundred to a few thousand gates, depending on constants. The number grows polynomially in \log(1/\varepsilon) — not polynomially in 1/\varepsilon itself, which would be catastrophic. Logarithms are kind.

This is the theoretical foundation for how fault-tolerant quantum computing is even possible. Without Solovay-Kitaev, the fact that fault-tolerant architectures can only do a discrete set of gates would be a showstopper: you couldn't approximate arbitrary rotations cheaply, so you couldn't do the Fourier transform, so Shor's algorithm would be a paper tiger. With Solovay-Kitaev, it's just an engineering cost — a logarithmic overhead that you pay gladly.

Practical compilation in Qiskit — the U3 gate

IBM's Qiskit has a gate called U3(θ, φ, λ) that is, up to global phase, exactly the ZYZ decomposition:

Every single-qubit unitary you can write in Qiskit gets compiled, at some point, to a U3 gate with three specific angles. The Qiskit decompose() function exposes this — ask it to decompose a Hadamard, and it gives you U3(π/2, 0, π) (one conventional form).

Higher-level languages like Cirq, tket, and IBM Qiskit's "transpiler" all ultimately rest on this decomposition. When you learn it, you learn the bottleneck that every compiler has to pass through.

Why this matters — the Indian context

Active quantum groups at IISc Bangalore and IIT Bombay are using exactly this decomposition in Variational Quantum Eigensolver (VQE) experiments — circuits that parameterise a quantum state with continuous angles (\theta_1, \theta_2, \ldots) and minimise energy by adjusting them, used to simulate small molecules relevant to Indian pharmaceutical research.

VQE circuits build their ansatz (a parameterised trial wavefunction) out of R_y(\theta) rotations precisely because Cycling through ZYZ angles is the most natural way to sweep SU(2). Every parameter the optimiser tweaks is one of these angles. At the hardware level, each rotation decomposes to one R_x pulse plus two virtual R_z updates — cheap.

Without the ZYZ decomposition, the VQE optimiser would have no way to scan the full space of single-qubit rotations; with it, the parameter sweep is 3-dimensional per qubit, tractable and differentiable. The parameter-shift rule — a technique for computing exact gradients of VQE circuits — depends on the R_y gate having a specific rotation form, which only holds in this decomposed framework.

Common confusions

• "Three rotations is some magic number." It is not magic; it is dimension-counting. SU(2) is a 3-dimensional manifold, so three parameters are necessary and sufficient to locate any point in it. Two rotations are not enough (only 2D slice); four would be redundant (over-determined).

• "The global phase \alpha doesn't matter, so I can ignore it." In isolation, yes. But the instant the gate U is placed inside a controlled operation — "apply U if the control qubit is |1\rangle" — the global phase \alpha becomes a relative phase of the compound gate, and therefore fully observable. The next chapter (Global vs Relative Phase) unpacks this carefully.

• "Universal single-qubit means universal quantum." It does not. "Universal for single qubits" means you can build any one-qubit gate. "Universal for quantum computation" means you can build any n-qubit unitary. The latter requires at least one entangling gate (like CNOT) in addition to a universal single-qubit gate set. Single-qubit universality alone is not enough — you could build every one-qubit rotation and still be trapped in the land of unentangled product states.

• "Why bother with ZYZ if my hardware has native R_x?" You don't — you use XZX or XYX or whatever matches the hardware. ZYZ is a convention, not a requirement. Qiskit standardises on ZYZ because IBM's superconducting qubits use virtual-Z, making R_z essentially free and R_y the only expensive rotation; that makes ZYZ the cheapest layout.

• "Solovay-Kitaev means I can compile anything for free." No — it says the overhead is logarithmic, but you still pay it. An approximation to 10^{-15} accuracy with \{H, T\} might need a thousand gates. In a fault-tolerant setting where each T gate costs a magic-state distillation routine that eats dozens of physical qubits, those thousand Ts add up.

• "The angles (\beta, \gamma, \delta) are physical angles in 3D space." Not exactly. They are Bloch-sphere angles — which are twice the Hilbert-space angles because of the \theta/2 appearing in the state parameterisation. A \beta = \pi rotation in the ZYZ form corresponds to a 180° rotation of the Bloch sphere, but in the underlying state's complex amplitude, the phase changes are \beta/2 = \pi/2. The factor of 2 is lurking; the ZYZ convention just hides it inside the R_z(\beta) and R_y(\gamma) matrices.

Going deeper

KAK and cosine-sine decomposition for multi-qubit gates

ZYZ is the single-qubit version of a much more general theorem. For an arbitrary n-qubit unitary U \in U(2^n), the KAK decomposition (Cartan-style) breaks U into a sequence of:

• Local (single-qubit) rotations on each qubit,
• Entangling layers that couple the qubits via two-qubit gates.

For two qubits, KAK gives U = (A_1 \otimes A_2) \cdot V \cdot (A_3 \otimes A_4) where each A_i is a single-qubit rotation (three ZYZ angles) and V is a specific 15-parameter entangling gate parameterised by three angles (for the two-qubit case specifically, V can be written in terms of \exp(i(\alpha_x XX + \alpha_y YY + \alpha_z ZZ)) with three \alphas). Total: 4 \times 3 + 3 = 15 real parameters, matching \dim SU(4) = 15.

Every two-qubit unitary — no matter how tangled — compiles to at most three CNOTs, plus single-qubit rotations. This is Vidal & Dawson's result (2004). Three CNOTs is the worst case; many useful gates (like iSWAP or SWAP-variants) need fewer.

The cosine-sine decomposition is the numerical-linear-algebra algorithm that the transpiler uses. Given a 2^n \times 2^n unitary, it recursively splits U into block-diagonal rotations and anti-diagonal mixing terms, down to single-qubit levels. Every major quantum SDK has an implementation.

The ZYZ decomposition you learned in this chapter is the base case of this recursion.

The Bloch-sphere algorithm for computing Euler angles

A more geometric way to find (\beta, \gamma, \delta) for a given unitary U (without going through determinants and phase-stripping) is this:

1. Compute where U sends the north pole. The Bloch vector of |0\rangle is (0, 0, 1). After U, it lands at some (x, y, z) with x^2 + y^2 + z^2 = 1. Find this by computing U|0\rangle and then taking the Bloch-vector formula \vec{r} = \langle \psi | \vec{\sigma} | \psi \rangle.

2. \gamma is the polar angle: \gamma = \arccos(z). This is the angle to tip down.

3. \delta is the azimuth of where the pole came from — the pre-image of the north pole under R_z(-\beta), which itself is determined by the target azimuth. You find \delta by asking: "which z-rotation brings the unit-vector (x, y, z) to the x-z plane before the y-tip?"

4. \beta is then the residual z-rotation needed to match the full unitary — specifically, the azimuthal component of where U sends the equatorial state |+\rangle.

The algebra works out identically to the determinant-and-phase approach, but the geometric derivation is more satisfying.

Solovay-Kitaev — statement and proof sketch

The full theorem, in its cleanest form:

Solovay-Kitaev theorem. Let G be a set of single-qubit gates closed under inversion and generating a dense subgroup of SU(2). Then there is a universal constant c (with the best current bounds around c \approx 3) such that for any target unitary U \in SU(2) and any \varepsilon > 0, there exists a sequence g_1 g_2 \ldots g_L of elements from G with L = O(\log^c(1/\varepsilon)) such that \|U - g_1 g_2 \ldots g_L\| \leq \varepsilon. Furthermore, this sequence can be found by a classical algorithm in O(\log^c(1/\varepsilon)) time.

Proof sketch. Start with any sequence V_0 that approximates U to some fixed accuracy \varepsilon_0 < 1 (achievable because G is dense). Compute the "error" U V_0^\dagger. Find a group commutator W_1 = A_1 B_1 A_1^\dagger B_1^\dagger in G that approximates this error. By careful choice, W_1 has error O(\varepsilon_0^{3/2}) — the commutator structure gives you a squared improvement. Iterate: at each step, the error improves polynomially. After O(\log \log(1/\varepsilon)) iterations the error is below \varepsilon, and the total gate count is the sum of geometric gate counts from each iteration, which works out to O(\log^c(1/\varepsilon)).

The key insight is that group commutators "amplify" small corrections into still-smaller corrections, essentially by cancelling the leading-order error terms. This is Kitaev's original idea from the early 1990s; Dawson and Nielsen [4] gave the cleanest modern proof and explicit algorithms.

For a practical implementation, the Dawson-Nielsen paper gives pseudocode that runs in reasonable time for \varepsilon down to about 10^{-10} with the Clifford+T gate set — good enough for essentially every foreseeable quantum algorithm.

Virtual-Z gates and why ZYZ fits superconducting hardware

A superconducting transmon qubit is (to first approximation) a nonlinear LC oscillator whose two lowest energy levels are labelled |0\rangle and |1\rangle. A microwave pulse resonant with the |0\rangle \leftrightarrow |1\rangle transition drives population back and forth, effecting an R_x(\theta) or R_y(\theta) rotation depending on the pulse phase. But R_z(\theta) rotations — rotations about the z-axis — are free, because rotating about z is just changing the reference phase of the rotating frame in which the qubit lives.

McKay, Wood, Sheldon, Chow, Gambetta (2017) formalised this as the virtual-Z gate. Instead of waiting some time for a z-rotation to accumulate, the compiler updates a software register that tracks the phase of all subsequent R_x and R_y pulses applied to that qubit. When later gates fire, they fire at an adjusted phase that is equivalent to having applied the R_z — but no real physical pulse was emitted. It costs zero nanoseconds.

This is why the ZYZ decomposition is so convenient for superconducting hardware: the two R_z's bracketing the R_y are free, so every single-qubit gate reduces to one R_y pulse plus phase bookkeeping. IBM's transpiler targets exactly this. The choice of z-y-z (rather than z-x-z or any other combination) is largely historical — the same logic works with y replaced by x — but ZYZ is the industry standard.

The parameter-shift rule for variational circuits

In variational quantum algorithms (VQE, QAOA, quantum machine learning), you have a parameterised circuit U(\vec{\theta}) and you want to compute the gradient \partial \langle H \rangle / \partial \theta_k of some expectation value with respect to each parameter \theta_k. Classical automatic differentiation does not work on quantum hardware (no backpropagation through a collapsed measurement).

The parameter-shift rule says: if your parameter \theta_k controls a gate of the form R_y(\theta_k) (or R_x(\theta_k) or R_z(\theta_k)), then

Two extra circuit runs give you the exact gradient. No finite-difference error, no approximation. The proof uses the fact that R_y(\theta) has generator \tfrac{1}{2}Y with eigenvalues \pm\tfrac{1}{2}, and that a Pauli operator with two distinct eigenvalues has this specific shift structure.

This is why variational circuits are built out of exactly the rotation gates you've been learning — not any old parameterised unitary, specifically R_x, R_y, R_z — because only those have the two-eigenvalue generator that makes the parameter-shift rule work. The whole edifice of near-term variational quantum computing rests on ZYZ.

Where this leads next

• Global vs Relative Phase — why \alpha in the decomposition is invisible on its own but observable in a controlled gate.
• Measurement in Arbitrary Bases — how a single-qubit rotation before a computational-basis measurement realises measurement in any orthonormal basis.
• Solovay-Kitaev Theorem — a full chapter on the approximation theorem and its algorithms.
• Universal Gate Sets — what a set of gates needs to be universal for all of quantum computation (single-qubit decomposition plus one entangling gate).
• Variational Quantum Eigensolver — the direct application of parameterised R_y rotations to chemistry and materials science, with an Indian industry angle.

References

1. Nielsen and Chuang, Quantum Computation and Quantum Information, §4.2 (single-qubit operations and the ZYZ theorem) — Cambridge University Press.
2. John Preskill, Lecture Notes on Quantum Computation, Ch. 4 (universal gates) — theory.caltech.edu/~preskill/ph229.
3. Wikipedia, Euler angles — the classical geometry of three-rotation decompositions of SO(3) and SU(2).
4. Christopher M. Dawson and Michael A. Nielsen, The Solovay-Kitaev algorithm (2005) — arXiv:quant-ph/0505030. The clean modern proof and algorithm.
5. Qiskit Documentation, U-gate (U3) reference — the practical software interface to the ZYZ decomposition.
6. Wikipedia, Single-qubit gates / Universality — concise reference for the set of universal single-qubit gates.