The Bloch sphere is a picture of a qubit, the quantum version of a bit, as a point on a sphere. Post 1 showed that a single photon passes a polarizer with probability $\cos^2\theta$. This post goes one level deeper: what the photon’s state is before it is measured. No quantum background is needed, and every new term is defined the first time it appears.
Quick recap: a qubit is a two-outcome quantum system
A classical bit is either 0 or 1. A qubit (quantum bit) is a quantum system with two possible outcomes when measured. A polarized photon is a good example. Call “horizontal” the outcome 0 and “vertical” the outcome 1.
We write the two outcomes as $|0\rangle$ and $|1\rangle$. The symbol $|\cdot\rangle$ is called a ket. It is just a label, like writing “horizontal” but in a form that is easy to combine with numbers.
A state is the complete description of a qubit: a short list of numbers that tells you the odds of each outcome. The two numbers in the state are called amplitudes.
Superposition: a mix of both outcomes
A qubit can be in a superposition of $|0\rangle$ and $|1\rangle$. In general its state is
$$|\psi\rangle = a\,|0\rangle + b\,|1\rangle$$
Here $a$ and $b$ are amplitudes. An amplitude is a complex number, which is a number with two parts: a real part and an imaginary part, written $x + iy$. Its size is $\sqrt{x^2 + y^2}$, and its phase is the angle it makes with the positive real axis.
Think of each amplitude as an arrow on a map. The arrow has a length and a direction. The state is the pair of arrows, one for each outcome. Only the arrow lengths decide the odds for one measurement, and the phases matter later, when paths are combined.
Two rules complete the picture:
- Probabilities come from the squared size of each amplitude (this is the Born rule from post 1):
$$P(0) = |a|^2, \qquad P(1) = |b|^2$$
- The probabilities must add to 1, because one outcome always happens:
$$|a|^2 + |b|^2 = 1$$
A quick example: $a = b = 1/\sqrt{2}$ gives $P(0) = P(1) = 1/2$. Each amplitude has size $1/\sqrt{2} \approx 0.707$, and the squares add to $1$.
Malus law is a qubit state
Take a photon polarized at angle $\alpha$ from horizontal. Its state is
$$|\psi\rangle = \cos\alpha\,|0\rangle + \sin\alpha\,|1\rangle$$
Applying the Born rule gives $P(0) = \cos^2\alpha$. That is exactly Malus law from post 1, now read as a qubit probability.

Figure 1: For a photon polarized at angle $\alpha$, the chance of horizontal is $\cos^2\alpha$ and vertical is $\sin^2\alpha$. They are equal at 45 degrees.
The Bloch sphere: every qubit state as a point
Ignoring an overall phase that never affects probabilities, every qubit state can be written with two angles, $\theta$ and $\varphi$:
$$|\psi\rangle = \cos\frac{\theta}{2}\,|0\rangle + e^{i\varphi}\,\sin\frac{\theta}{2}\,|1\rangle$$
Here $e^{i\varphi}$ is a complex number of size 1 and phase $\varphi$. It is the only place the phase enters the state.
Now map the state to a point on a sphere of radius 1, the Bloch sphere:
$$(x, y, z) = (\sin\theta\cos\varphi,\ \sin\theta\sin\varphi,\ \cos\theta)$$
Reading the sphere:
- The north pole is $|0\rangle$: outcome 0 for certain.
- The south pole is $|1\rangle$: outcome 1 for certain.
- The equator is an equal mix of $|0\rangle$ and $|1\rangle$. Each point on it has a different phase $\varphi$.
- Any other point is an unequal mix. The closer it is to a pole, the more likely that outcome.
Some states to know:
- $|+\rangle = (|0\rangle + |1\rangle)/\sqrt{2}$ sits on the $+x$ axis.
- $|-\rangle = (|0\rangle – |1\rangle)/\sqrt{2}$ sits on the $-x$ axis.
- $|+i\rangle = (|0\rangle + i|1\rangle)/\sqrt{2}$ sits on the $+y$ axis.
All three have a 50/50 chance of 0 or 1 when measured in the $|0\rangle$/$|1\rangle$ direction. What differs is the phase, which is hidden in that one measurement but matters in later posts.

One link to the photon picture: a photon polarized at angle $\alpha$ sits at Bloch angle $\theta = 2\alpha$. So a 45 degree polarization lands on the equator, and a 90 degree polarization lands on the south pole.
Python: states, Born rule, and the Bloch vector
This code builds the states above, checks the Born rule, and matches the photon case from post 1. It also measures 10,000 copies of $|+\rangle$.
import numpy as np
def qubit_state(theta, phi=0.0):
"""Qubit state on the Bloch sphere: cos(theta/2)|0> + e^{i phi} sin(theta/2)|1>."""
return np.array([np.cos(theta / 2), np.exp(1j * phi) * np.sin(theta / 2)])
def probabilities(state):
"""Born rule: the probability of each outcome is the squared size of its amplitude."""
return np.abs(state) ** 2
def bloch_vector(state):
"""Point (x, y, z) on the Bloch sphere for a qubit state."""
a, b = state
x = 2 * np.real(np.conj(a) * b)
y = 2 * np.imag(np.conj(a) * b)
z = np.abs(a) ** 2 - np.abs(b) ** 2
return np.array([x, y, z])
# Equal superposition |+> = (|0> + |1>)/sqrt(2)
plus = qubit_state(np.pi / 2, 0.0)
print("amplitudes: ", np.round(plus, 3))
print("probabilities:", np.round(probabilities(plus), 3))
print("Bloch vector: ", np.round(bloch_vector(plus), 3))
print("sum of probabilities:", np.round(probabilities(plus).sum(), 6))
# Same photon as in post 1: polarized 30 degrees from horizontal
alpha = np.deg2rad(30)
photon = qubit_state(2 * alpha) # Bloch angle = 2 x polarization angle
print("P(horizontal), Born rule:", probabilities(photon)[0].round(3))
print("cos^2(30 deg), Malus law:", (np.cos(alpha) ** 2).round(3))
# Phase moves the point around the equator, but not the 50/50 odds
i_state = qubit_state(np.pi / 2, np.pi / 2) # |+i>
print("Bloch vector |+i>:", np.round(bloch_vector(i_state), 3))
# Measure 10,000 fresh copies of |+>
rng = np.random.default_rng(3)
got_zero = rng.random(10_000) < probabilities(plus)[0]
print("fraction of |0> outcomes:", got_zero.mean().round(3))Running it prints:
amplitudes: [0.707+0.j 0.707+0.j]
probabilities: [0.5 0.5]
Bloch vector: [1. 0. 0.]
sum of probabilities: 1.0
P(horizontal), Born rule: 0.75
cos^2(30 deg), Malus law: 0.75
Bloch vector |+i>: [0. 1. 0.]
fraction of |0> outcomes: 0.503The Born rule and Malus law agree at 30 degrees. The $|+\rangle$ state gives about 50/50 over 10,000 measurements.
Three common misunderstandings
- “A qubit is 0 and 1 at the same time.” Better: it has a state, described by two amplitudes. A measurement always gives one outcome, 0 or 1.
- “The amplitude is the probability.” No. The probability is the squared size of the amplitude. Amplitudes can be negative or complex, and the squared sizes must add to 1.
- “I can read $a$ and $b$ from one measurement.” No. One measurement gives one bit, not the full state. Finding the state needs many copies, measured in several directions. That is the next post.
What comes next
Post 3 covers measurement. The same qubit gives different results depending on which direction you measure along, and that choice is the heart of BB84.
Summary
- A qubit is a two-outcome quantum system, and its state is a pair of amplitudes.
- Probabilities are the squared sizes of the amplitudes, and they add to 1.
- Every qubit state (up to overall phase) is a point on the Bloch sphere.
- A polarized photon at angle $\alpha$ sits at Bloch angle $2\alpha$, and its odds follow Malus law.
Learning path: Quantum basics for engineers
- Malus law and polarization
- Qubits and the Bloch sphere
- Measurement and basis choice
- Quantum bit error rate
- The BB84 protocol
- BB84 simulation with an eavesdropper
References
- Qubit (Wikipedia): the definition and examples.
- Bloch sphere (Wikipedia): the sphere picture and the state formula used here.
- Bra-ket notation (Wikipedia): what the $|\cdot\rangle$ symbol means.
- Quantum superposition (Wikipedia): superposition in general.
- Probability amplitude (Wikipedia): why amplitudes, not probabilities, are the basic objects.
- Complex number (Wikipedia): the background for $a$, $b$ and $e^{i\varphi}$.
- Quantum measurement (Stanford Encyclopedia of Philosophy): a deeper treatment of measurement, for post 3.
Classical communication math behind this series. Complex amplitudes, squared magnitudes and error probabilities also appear in digital communications. The GaussianWaves eBooks cover that classical side with runnable Python and Matlab code.