Multi-Qubit States

One qubit is a coin caught in flight. But a quantum computer with just 50 qubits already juggles more numbers than there are grains of sand on Earth — and it does so with a chip you could hold in your hand. Where does all that room come from? Not from adding qubits together, but from multiplying them. Two qubits are not "two coins"; they are a single system living in a space of 2 \times 2 = 4 dimensions, three qubits in 8, and n qubits in a space of 2^{n}. That doubling is the engine of quantum computing — and the wall that stops classical machines from keeping up.

The rule for combining qubits is the tensor product. Stacking n single-qubit spaces gives

\underbrace{\mathbb{C}^2 \otimes \mathbb{C}^2 \otimes \cdots \otimes \mathbb{C}^2}_{n} = (\mathbb{C}^2)^{\otimes n}, \qquad \dim = 2^{n}.

Its basis is every bit-string of length n: for two qubits the four states |00\rangle, |01\rangle, |10\rangle, |11\rangle; for n qubits all 2^{n} strings from |00\cdots0\rangle to |11\cdots1\rangle. Each basis label is just the single-qubit labels concatenated: |0\rangle \otimes |1\rangle = |01\rangle.

A general two-qubit state

A single qubit needs two amplitudes; two qubits need four, one for each basis string. The most general two-qubit state is

a unit vector in \mathbb{C}^4. Just like one qubit, the amplitudes are complex numbers and must be normalised so that some outcome is certain:

|a|^2 + |b|^2 + |c|^2 + |d|^2 = 1.

When you measure, out pops one of the four bit-strings, and the string x appears with probability equal to the squared magnitude of its amplitude:

\Pr[x] = \bigl|\langle x | \psi \rangle\bigr|^2 = |\text{amplitude of } |x\rangle|^2.

In coordinates, the four amplitudes are literally the four entries of the state vector — one bar per cell of the basis grid:

Worked example: reading off a probability

Consider the two-qubit state

|\psi\rangle = \tfrac{1}{2}\,|00\rangle + \tfrac{1}{2}\,|01\rangle + \tfrac{1}{\sqrt2}\,|11\rangle.

First, is it legal? Sum the squared magnitudes: \left(\tfrac12\right)^2 + \left(\tfrac12\right)^2 + \left(\tfrac{1}{\sqrt2}\right)^2 = \tfrac14 + \tfrac14 + \tfrac12 = 1 — normalised, so yes. (The missing |10\rangle just has amplitude 0.) Now measure. The probability of getting the string 11 is the square of its amplitude:

\Pr[11] = \left|\tfrac{1}{\sqrt2}\right|^2 = \tfrac12,

while \Pr[00] = \Pr[01] = \tfrac14 and \Pr[10] = 0 — you will never see 10. The four probabilities add to 1, as they must.

Worked example: building a product state

If the two qubits are prepared independently — the first in |\psi\rangle, the second in |\varphi\rangle — the joint state is the product |\psi\rangle \otimes |\varphi\rangle, computed by the Kronecker product of the two vectors: scale a whole copy of the second by each entry of the first. Take the first qubit as |0\rangle and the second as |{+}\rangle = \tfrac{1}{\sqrt2}(|0\rangle + |1\rangle):

|0\rangle \otimes |{+}\rangle = \begin{bmatrix} 1 \\ 0 \end{bmatrix} \otimes \tfrac{1}{\sqrt2}\begin{bmatrix} 1 \\ 1 \end{bmatrix} = \tfrac{1}{\sqrt2}\begin{bmatrix} 1 \\ 1 \\ 0 \\ 0 \end{bmatrix} = \tfrac{1}{\sqrt2}\bigl(|00\rangle + |01\rangle\bigr).

The first qubit stays 0 (only the 00 and 01 strings survive), while the second is an even blend. Push it one step further — both qubits in |{+}\rangle:

|{+}\rangle \otimes |{+}\rangle = \tfrac{1}{\sqrt2}\begin{bmatrix} 1 \\ 1 \end{bmatrix} \otimes \tfrac{1}{\sqrt2}\begin{bmatrix} 1 \\ 1 \end{bmatrix} = \tfrac{1}{2}\bigl(|00\rangle + |01\rangle + |10\rangle + |11\rangle\bigr).

Every string equally likely, each with probability \left(\tfrac12\right)^2 = \tfrac14 — a uniform superposition over all 4 outcomes. States you can factor this way are called product states; the ones you cannot are entanglement, the subject of the next lesson.

n qubits combine by tensor product into (\mathbb{C}^2)^{\otimes n}, of dimension 2^{n};
the basis is the 2^{n} bit-strings |00\cdots0\rangle, \ldots, |11\cdots1\rangle;
a state is a unit vector \sum_x c_x |x\rangle with \sum_x |c_x|^2 = 1; measuring gives string x with probability |c_x|^2;
a product state |\psi\rangle \otimes |\varphi\rangle is the Kronecker product of the parts — but most states are not products at all.

A quantum register of n qubits is a list of 2^{n} complex amplitudes. Watch it grow: 50 qubits already need 2^{50} \approx 10^{15} amplitudes — a petabyte-scale table, right at the edge of the largest supercomputers. At 300 qubits the state carries 2^{300} \approx 10^{90} amplitudes, more numbers than there are atoms in the observable universe (about 10^{80}). You could never write that list down on any classical machine, ever — yet 300 physical qubits hold it without effort. This single fact is both the promise of quantum computing (state that grows exponentially for free) and the classical-simulation wall (why we cannot just fake it on a laptop).

Two easy slips. First, bit-string order is positional: |01\rangle means the first qubit is 0 and the second is 1 — it is not the same as |10\rangle. The leftmost symbol is the first qubit, always. Second, when you add a qubit the state space multiplies, not adds: going from 2 to 3 qubits takes the dimension from 2^2 = 4 to 2^3 = 8 (doubling), never to 4 + 2 = 6. Tensor dimensions multiply — that is the whole reason a few qubits reach so far.