foundations beginner · 14 min read · By LIPAI WANG · April 29, 2026

The Bloch Sphere: Every Single-Qubit State Is a Point in Three Dimensions

The Bloch sphere is the geometric picture that makes single-qubit quantum mechanics intuitive. Every pure single-qubit state is a point on the surface of a unit sphere; every mixed state is a point inside. Single-qubit gates are rotations of this sphere. This tutorial constructs the Bloch sphere from the density-matrix formulation, derives the geometry of common gates, and shows how the picture extends (and fails to extend) to multi-qubit systems.

Prerequisites: Tutorial 1: What Is a Qubit, Tutorial 47: Density Matrices and Mixed States

The Bloch sphere is the most-used visualization in quantum computing pedagogy, and for a reason: every pure single-qubit state is a point on the surface of a unit sphere, every mixed state is a point inside, and every single-qubit unitary is a rotation of the sphere. It is the cleanest geometric representation of quantum information, and once you have internalized it, single-qubit quantum mechanics becomes nearly visual.

This tutorial constructs the Bloch sphere from the density-matrix formulation (tutorial 47), derives the geometry of common single-qubit gates (Pauli rotations, Hadamard, T), and explains why the picture works specifically for single qubits and fails for multi-qubit systems.

The Bloch parameterization

A pure single-qubit state can be written

$$|\psi\rangle \;=\; \cos(\theta/2) |0\rangle + e^{i\phi} \sin(\theta/2) |1\rangle$$

for $\theta \in [0, \pi]$ and $\phi \in [0, 2\pi)$. The angles $(\theta, \phi)$ are exactly the polar and azimuthal angles of a point on the unit sphere. Specifically:

• $\theta = 0$: the north pole, state $|0\rangle$.
• $\theta = \pi$: the south pole, state $|1\rangle$.
• $\theta = \pi/2$, $\phi = 0$: equator at the front, state $|+\rangle = (|0\rangle + |1\rangle)/\sqrt{2}$.
• $\theta = \pi/2$, $\phi = \pi$: equator at the back, state $|-\rangle = (|0\rangle - |1\rangle)/\sqrt{2}$.
• $\theta = \pi/2$, $\phi = \pi/2$: equator on the right, state $|i\rangle = (|0\rangle + i|1\rangle)/\sqrt{2}$.
• $\theta = \pi/2$, $\phi = -\pi/2$: equator on the left, state $|-i\rangle = (|0\rangle - i|1\rangle)/\sqrt{2}$.

The two computational-basis states are antipodal points (north and south poles). The two Hadamard-basis states are antipodal (east and west on the equator). The two $Y$-basis states are antipodal (south-east and north-west on the equator, in standard conventions). Antipodal points correspond to orthogonal states, which is the structural reason the Bloch sphere works.

The Bloch vector formula

Any single-qubit density matrix can be written as

$$\rho \;=\; \tfrac{1}{2}\bigl(I + r_x X + r_y Y + r_z Z\bigr)$$

where $\boldsymbol{r} = (r_x, r_y, r_z)$ is the Bloch vector, and $|\boldsymbol{r}| \leq 1$.

• $|\boldsymbol{r}| = 1$: pure state, point on the sphere surface.
• $|\boldsymbol{r}| < 1$: mixed state, point strictly inside the sphere.
• $|\boldsymbol{r}| = 0$: maximally mixed state, the center.

The Bloch vector components are the expectations of the Pauli operators:

$$r_x = \text{Tr}(X \rho), \quad r_y = \text{Tr}(Y \rho), \quad r_z = \text{Tr}(Z \rho).$$

So the Bloch vector is operationally meaningful: each component is what you’d measure if you measured the corresponding Pauli observable.

For a pure state, the Bloch vector is also expressible directly:

$$\boldsymbol{r}_\text{pure} \;=\; (\sin\theta \cos\phi, \, \sin\theta \sin\phi, \, \cos\theta).$$

This is the standard parameterization of a unit vector in $\mathbb{R}^3$ — the same one used in classical mechanics, geophysics, and 3D graphics. Every pure single-qubit state is a unit vector in 3D space, and every mixed state is a 3D vector with norm at most 1.

Single-qubit gates as rotations

The deeply useful property: every single-qubit unitary corresponds to a rotation of the Bloch sphere.

For a unitary $U = e^{-i\,\theta \,\hat{\boldsymbol{n}} \cdot \boldsymbol{\sigma} / 2}$, where $\hat{\boldsymbol{n}}$ is a unit 3D vector and $\boldsymbol{\sigma} = (X, Y, Z)$, the corresponding action on the Bloch vector is:

$$\boldsymbol{r} \;\to\; R_{\hat{\boldsymbol{n}}}(\theta) \, \boldsymbol{r},$$

where $R_{\hat{\boldsymbol{n}}}(\theta)$ is the standard rotation matrix that rotates by angle $\theta$ around axis $\hat{\boldsymbol{n}}$.

Concrete consequences:

• $X =$ rotation by $\pi$ around the $\hat{x}$ axis (flips north pole to south pole, $|0\rangle \leftrightarrow |1\rangle$, but also $|+\rangle \to |+\rangle$ since $|+\rangle$ is on the $\hat{x}$ axis).
• $Y =$ rotation by $\pi$ around the $\hat{y}$ axis.
• $Z =$ rotation by $\pi$ around the $\hat{z}$ axis (flips $|+\rangle \leftrightarrow |-\rangle$, but leaves $|0\rangle$ and $|1\rangle$ on the axis).
• $H =$ rotation by $\pi$ around the axis $(\hat{x} + \hat{z})/\sqrt{2}$ (swaps the $\hat{x}$ and $\hat{z}$ axes — sending $|0\rangle$ to $|+\rangle$).
• $S = e^{-i \pi Z / 4} =$ rotation by $\pi/2$ around $\hat{z}$.
• $T = e^{-i \pi Z / 8} =$ rotation by $\pi/4$ around $\hat{z}$.

So if you ever forget what a single-qubit gate does, the Bloch-sphere picture gives you the answer: it is a rotation, and the axis and angle tell you everything.

Measurement geometry

Measuring along a chosen axis gives outcomes $\pm 1$ with probabilities determined by the projection of the Bloch vector onto that axis. Specifically, measuring along axis $\hat{\boldsymbol{n}}$:

$$\text{Pr}(+) \;=\; \tfrac{1}{2}\bigl(1 + \boldsymbol{r} \cdot \hat{\boldsymbol{n}}\bigr), \quad \text{Pr}(-) \;=\; \tfrac{1}{2}\bigl(1 - \boldsymbol{r} \cdot \hat{\boldsymbol{n}}\bigr).$$

The probability of $+1$ is the cosine of the angle between the Bloch vector and the measurement axis, mapped to $[0, 1]$. A state aligned with the measurement axis gives outcome $+1$ deterministically; a state anti-aligned gives $-1$ deterministically; a state perpendicular gives a 50-50 split.

Measurement projects the state onto the corresponding eigenstate of the measured operator. On the Bloch sphere, this means: after measuring axis $\hat{\boldsymbol{n}}$ and getting outcome $+$, the new Bloch vector is exactly $\hat{\boldsymbol{n}}$. The sphere snaps to the measurement axis. This is the geometric content of measurement-induced collapse.

A small Bloch-sphere visualization

Concrete code that computes Bloch vectors and visualizes:

import numpy as np
import pennylane as qml

dev = qml.device("default.qubit", wires=1)


@qml.qnode(dev)
def circuit_bloch_vector(rotations):
    """Apply a sequence of rotations and return the Bloch vector."""
    for axis, angle in rotations:
        if axis == 'x':
            qml.RX(angle, wires=0)
        elif axis == 'y':
            qml.RY(angle, wires=0)
        elif axis == 'z':
            qml.RZ(angle, wires=0)
    return [qml.expval(qml.PauliX(0)), qml.expval(qml.PauliY(0)), qml.expval(qml.PauliZ(0))]


# Initial state |0>: Bloch vector (0, 0, 1) — north pole.
print("Initial |0>:", circuit_bloch_vector([]))

# Apply Hadamard (rotation): expect (1, 0, 0) — equator front.
# H = R_y(pi/2) followed by R_x(pi); or equivalently X * R_y(pi/2).
print("After H (≈ R_y(pi/2) X):",
      circuit_bloch_vector([('y', np.pi / 2), ('x', np.pi)]))

# Apply just R_y(pi/2): expect (1, 0, 0) — equator front, the |+> state.
print("After R_y(pi/2):", circuit_bloch_vector([('y', np.pi / 2)]))

# Apply Z = R_z(pi) to |+>: expect (-1, 0, 0) — equator back, |->.
print("After R_y(pi/2) then R_z(pi):",
      circuit_bloch_vector([('y', np.pi / 2), ('z', np.pi)]))

# Apply T (= R_z(pi/4)) to |+>: rotates around z by pi/4.
# Expect (cos(pi/4), sin(pi/4), 0) = (0.707, 0.707, 0).
print("After R_y(pi/2) then R_z(pi/4):",
      circuit_bloch_vector([('y', np.pi / 2), ('z', np.pi / 4)]))

Sample output:

Initial |0>: [0.0, 0.0, 1.0]
After R_y(pi/2): [1.0, 0.0, 0.0]
After R_y(pi/2) then R_z(pi): [-1.0, 0.0, 0.0]
After R_y(pi/2) then R_z(pi/4): [0.707, 0.707, 0.0]

The Bloch vectors confirm the geometric intuition: $R_y(\pi/2)$ takes the north pole to the equator at $+\hat{x}$; $R_z$ rotates around the equator without leaving it. Visualizing the qubit as a vector on a sphere makes the action of every single-qubit gate immediately clear.

In production, libraries like Qiskit and PennyLane have built-in Bloch-sphere plotters that render this visually.

Why it doesn’t extend to multi-qubit systems

The Bloch-sphere picture is specific to single qubits. Two qubits have a 4-dimensional state space, and their density matrix has $15$ real parameters — far more than the 3 of a single qubit. There is no 3D sphere that captures all 15 parameters; you’d need a 15-dimensional convex region (the “set of two-qubit density matrices”), and that region has no clean geometric picture.

This is one reason quantum-information visualization is hard. The Bloch sphere is the unique “easy case” — a special feature of two-level systems. Above two levels, geometric pictures either become high-dimensional or restrict to specific subsets (entangled states, Schmidt-rank-1 states, etc.).

For multi-qubit systems, the standard tools are not visual but algebraic: density matrices, Schmidt decomposition, entanglement measures, and operator norms. The Bloch sphere remains a sentimental and pedagogical favorite for the single-qubit special case.

Practical uses

The Bloch sphere is most useful for:

1. Teaching. Single-qubit quantum mechanics is much easier to internalize geometrically than algebraically.
2. Designing pulse sequences. Quantum-control engineers think in Bloch-sphere rotations: which rotation axis, which angle, which order. Hardware-control software for pulse shaping (Qiskit Pulse, OpenPulse) uses Bloch-sphere terminology.
3. Decoherence visualization. A pure state on the sphere surface decays toward the center under depolarizing noise. The Bloch-vector length is proportional to coherence; its decay over time is the $T_2$ measurement.
4. Calibration. Single-qubit randomized benchmarking and other characterization protocols are easiest to interpret in Bloch-vector terms.
5. Quick mental check. Need to know what $R_x(\pi/4)$ does to $|+\rangle$? Visualize it: rotate the equator-front point by $45°$ around $\hat{x}$, get a point at $45°$ tilt. Faster than matrix algebra.

Common misconceptions

“Every quantum state has a Bloch sphere.” Only single qubits. The “generalized Bloch sphere” for higher-dimensional systems is a 15-dimensional convex set with no clean geometric structure.

“The Bloch sphere is a 2-sphere in 3D space.” It is a 2-sphere (the surface) for pure states, plus its interior (the 3-ball) for mixed states. Together they form a 3-ball, not a 2-sphere.

“Antipodal points represent the same state.” They represent orthogonal states. The state $|0\rangle$ at the north pole is orthogonal to $|1\rangle$ at the south pole, not equivalent to it. Conjugate pairs of orthogonal states are antipodal — that’s the structure.

“The Bloch sphere is unique to qubits.” A similar geometric picture exists for any 2-level quantum system (atomic transitions, spin-1/2 particles), and the Bloch-vector idea extends to certain higher-dimensional cases (e.g., the “generalized Bloch sphere” for spin-1 particles is more complex). The qubit Bloch sphere is the cleanest case.

“Bloch-sphere rotations are physical rotations.” They are mathematical rotations of the Bloch vector, but they don’t correspond to rotating the physical hardware. A microwave pulse on a transmon qubit drives a Bloch-sphere rotation around an axis determined by the pulse phase, not by physically rotating the chip.

Decision rule

Use the Bloch sphere when:

1. You’re teaching single-qubit quantum mechanics. Best pedagogical tool available.
2. You’re designing or debugging single-qubit pulse sequences. Hardware engineers think in Bloch rotations.
3. You want to visualize decoherence or single-qubit noise. Decoherence visibly shrinks the Bloch vector.
4. You’re analyzing single-qubit randomized benchmarking or Pauli-error tomography. The Bloch-vector formalism aligns with the experiment.

Switch to algebraic / matrix methods when:

1. You’re working with multi-qubit systems. The Bloch sphere doesn’t generalize cleanly.
2. You’re analyzing entanglement. Bloch sphere is for product states; entanglement requires multi-qubit formalism.
3. You’re proving theorems. Density matrices and operator algebra are the rigorous tools; Bloch-sphere geometry is intuition.

For day-to-day quantum-computing work past the introductory stage, the Bloch sphere is a beloved-but-narrow tool. It’s perfect for single-qubit thinking and useless for genuinely multi-qubit problems.

Exercises

1. Compute Bloch vectors for common states

Compute the Bloch vector $\boldsymbol{r}$ for: (a) $|0\rangle$, (b) $|+\rangle$, (c) $(|0\rangle + i|1\rangle)/\sqrt{2}$, (d) the maximally mixed state $\rho = I/2$.

Show answer

(a) $|0\rangle$: density matrix $\text{diag}(1, 0)$. Bloch vector: $r_x = 0, r_y = 0, r_z = 1$. North pole. (b) $|+\rangle$: density matrix $\tfrac{1}{2}(I + X)$. Bloch vector: $r_x = 1, r_y = 0, r_z = 0$. Equator at $+\hat{x}$. (c) $|i\rangle$: density matrix $\tfrac{1}{2}(I + Y)$. Bloch vector: $r_x = 0, r_y = 1, r_z = 0$. Equator at $+\hat{y}$. (d) Maximally mixed: density matrix $I/2$. Bloch vector: $r_x = 0, r_y = 0, r_z = 0$. Center. Each pure state lives on the sphere surface; the maximally mixed state is the center.

2. Hadamard as a rotation

Show that $H$ corresponds to a rotation by angle $\pi$ around the axis $(\hat{x} + \hat{z})/\sqrt{2}$ on the Bloch sphere. (Hint: $H X H = Z$ and $H Z H = X$.)

Show answer

A rotation by $\pi$ around an axis $\hat{\boldsymbol{n}}$ flips any vector perpendicular to $\hat{\boldsymbol{n}}$ to its negative, and leaves vectors parallel to $\hat{\boldsymbol{n}}$ unchanged. Choose $\hat{\boldsymbol{n}} = (\hat{x} + \hat{z})/\sqrt{2}$. Then: $\hat{x}$ has component $1/\sqrt{2}$ along $\hat{\boldsymbol{n}}$, projection $\hat{\boldsymbol{n}}/\sqrt{2}$. The $\hat{x}$ vector decomposes as parallel-to-$\hat{\boldsymbol{n}}$ part plus perpendicular part. The rotation flips the perpendicular part, giving back $\hat{z}$. Similarly, $\hat{z}$ decomposes and rotates to $\hat{x}$. So this rotation swaps $\hat{x}$ and $\hat{z}$ axes — precisely the action of $H$ on Bloch vectors. The “axis = $(\hat{x}+\hat{z})/\sqrt{2}$” geometric picture is exactly what $H X H = Z$ and $H Z H = X$ encode in matrix form.

3. Decoherence as Bloch vector shrinkage

A qubit starts in pure state $|+\rangle$ (Bloch vector $(1, 0, 0)$) and is subjected to depolarizing noise that evolves the density matrix as $\rho_t = (1 - p)\rho + p I/2$. Compute the Bloch vector after time $t$ and explain what is happening geometrically.

Show answer

Linearity of Bloch vectors: if $\rho \to (1-p)\rho + p I/2$, then $\boldsymbol{r} \to (1-p)\boldsymbol{r} + p \cdot \boldsymbol{0} = (1-p)\boldsymbol{r}$. The Bloch vector shrinks by factor $(1-p)$ but keeps its direction. Starting at $(1, 0, 0)$, after depolarization with rate $p$: Bloch vector $((1-p), 0, 0)$. Geometrically: the point starts on the equator and moves toward the center along the same radial line. The direction (which superposition basis the qubit is in) is preserved; the coherence (distance from center) decays. This is the signature visual of decoherence: pure states shrink toward the center of the Bloch sphere over time. Tutorial 18 covered the noise channel mathematics; this exercise gives the geometric picture.

4. Why the maximally mixed state is at the center

Explain in geometric terms why the maximally mixed state has Bloch vector $\boldsymbol{0}$. What does this say operationally?

Show answer

Maximally mixed: $\rho = I/2 = \tfrac{1}{2}(I + 0 \cdot X + 0 \cdot Y + 0 \cdot Z)$. All Pauli expectations are zero, so the Bloch vector is $\boldsymbol{0}$. Operationally: any measurement axis gives a 50-50 outcome. The state has no preferred direction — measuring $X$, $Y$, or $Z$ all give equal probabilities for $\pm 1$. Geometrically the center is equidistant from every point on the sphere surface, so projection onto any axis gives a length-zero result. Maximum mixedness = maximum symmetry = no preferred axis. Pure states are at the surface, distinguished by direction; the maximally mixed state is the unique direction-free state at the center.

Where this goes next

This concludes the four-tutorial foundations deepening (45-48). The foundations track now has 7 tutorials covering qubits, superposition, entanglement, Bell’s theorem, no-cloning, density matrices, and the Bloch sphere — a complete grounding for someone serious about quantum computing. Future foundations tutorials may cover: specific noise channels (depolarizing, dephasing, amplitude damping), the Schmidt decomposition in detail, entanglement measures, and the von Neumann entropy as the unique entropy on density matrices.

---

Weekly dispatch

Quantum, for people who already code.

One serious tutorial per week, plus the industry moves that actually matter. No hype, no hand-waving.

Email Subscribe

Free. Unsubscribe anytime. We will never sell your email.