The Qubit

The Bloch sphere

Every one-qubit state is a point on a sphere

~12 minLesson 7 of 24Written by Claude Fable 5

The last two lessons gave you a qubit as two amplitudes on a circle, which is the honest picture but a cramped one: it hides the phase, and it makes it hard to see what a gate does. There is a single map that fixes both. Every pure one-qubit state is a point on the surface of a ball, and every operation you can perform is a rotation of that ball. Once you have this picture, most single-qubit reasoning becomes "where does the point move."

The myth to drop first: 'the sphere is where the qubit is'

The Bloch sphere looks like ordinary 3D space, so it is natural to read the point as a location - where the particle sits, which way it points in the room. It is neither. The sphere is an abstract map of states, not of physical space. Its three axes are not up, north, and east; they are three different questions you could ask the qubit. A point near the top does not mean "the qubit is up high," it means "this state answers 0 with high probability." Keep the sphere as a chart of possible states and it will never mislead you.

Play first: tour the named states

Below is the sphere itself. Jump to each named state and watch where it lands, then take the equator walk. The buttons fly the state vector to the landmarks; the walk holds the vector on the equator and sweeps it all the way around. Notice what stays fixed during that walk - the 50/50 odds - and what changes.

North is |0>, south is |1>, and the whole equator is the equal superpositions. Jump to a stop, or drag the ball yourself.

theta: 0 deg
phi: 0 deg
alpha: 1
beta: 0
P(0): 1
P(1): 0

Drag the ball to steer the state, or focus it and use the arrow keys (hold shift for finer steps).

North pole. Measuring gives 0 every time.

Three things to carry out of the tour. $∣ 0 ⟩$ is the north pole and $∣ 1 ⟩$ is the south pole, directly opposite it. The equator is a whole ring of equal superpositions - $∣ + ⟩$ , $∣ - ⟩$ and everything between - all with the same 50/50 measurement odds. And going around that equator changed something you could not see in the odds at all: the phase.

The two angles

Every point on the sphere is fixed by two angles, and the state vector reads straight off them. This parametrization is stated - it is the standard way to write a pure qubit, and the next lesson unpacks the phase term:

∣ ψ ⟩ = cos \frac{θ}{2} ∣ 0 ⟩ + e^{i ϕ} sin \frac{θ}{2} ∣ 1 ⟩ .

is the polar angle measured down from $∣ 0 ⟩$ at the top. It controls the odds: at the north pole $θ = 0$ gives $cos 0 = 1$ , a certain 0; at the equator $θ = π /2$ gives $cos (π /4) = 1/ 2$ , an even split. is the angle around the equator, and it sets the $e^{i ϕ}$ in front of the $∣ 1 ⟩$ part - the relative phase. That is why the equator walk left the odds untouched: it moved $ϕ$ only, and $ϕ$ never enters $cos^{2} (θ /2)$ .

Why the half-angle: opposite points are orthogonal

The

θ /2

is the one detail worth pausing on. Two states are when a measurement can tell them apart with certainty - like

∣ 0 ⟩

and

∣ 1 ⟩

. On the sphere those two sit at opposite poles, a full half-turn apart, not at a right angle. The half-angle is what does this: the physical angle on the ball is twice the angle between the states, so a quarter-turn in state space opens out to a half-turn, antipodal, on the sphere. Opposite points on the Bloch sphere are always the perfectly distinguishable pairs.

This is why the sphere is the right tool for the gates that come next. Because every valid single-qubit operation preserves length and orthogonality, on the Bloch sphere it can only be a rotation. The abstract algebra of unit vectors and orthogonality turns into something you can literally watch: a point sliding across a ball. The next lesson uses exactly this to separate the phase you can see from the phase you cannot.

import numpy as np

def bloch_state(theta, phi):
    # |psi> = cos(theta/2)|0> + e^{i phi} sin(theta/2)|1>
    alpha = np.cos(theta / 2)
    beta = np.exp(1j * phi) * np.sin(theta / 2)
    return np.array([alpha, beta])

north = bloch_state(0, 0)          # |0>   -> [1, 0]
south = bloch_state(np.pi, 0)      # |1>   -> [0, 1], antipodal to |0>
plus = bloch_state(np.pi/2, 0)     # |+>   -> [0.707, 0.707], on the equator
p0_plus = abs(plus[0])**2          # 0.5   theta = pi/2 gives even odds

The two Bloch angles give the amplitudes directly.

Lock it in

Every pure one-qubit state is a point on the Bloch sphere; every single-qubit gate is a rotation of that sphere.
|0> is the north pole, |1> the south pole, and the equator is the ring of equal superpositions.
theta sets the measurement odds (P(0) = cos^2(theta/2)); phi sets the relative phase and leaves standard-basis odds unchanged.
Orthogonal, perfectly distinguishable states sit at opposite poles - the half-angle theta/2 is what makes antipodal mean orthogonal.

Check yourself

Two states sit at opposite poles of the Bloch sphere. What does that tell you?

You move a state around the equator, changing phi but not theta. What changes?

On the Bloch sphere, where are |0>, |1>, and the equal superpositions, and what do theta and phi each control?

The map and its two dials. Try to state it, then check.

Match each feature of the sphere to its meaning.

drop here

the state |0>

drop here

the state |1>

drop here

the equal superpositions

drop here

the relative phase

Primary source

Quirk, the drag-and-drop quantum circuit simulator

Craig Gidney's Quirk shows a live Bloch sphere for each qubit as you build a circuit, so you can watch gates rotate the point in real time. It is the fastest way to turn the parametrization here into muscle memory: drop an X, an H, a Z, and see the sphere turn.

Sources

The Bloch sphere and its live rotations are best explored in Quirk^[1]; the parametrization follows Nielsen & Chuang section 1.2^[2].