Tensor products, visually

So far, every example has involved a single qubit. In this module, we add a second one — and immediately unlock about three-quarters of what’s interesting about quantum computing. (The other quarter is algorithms.)

The first thing we need is a way to describe the combined state of two qubits at once. If qubit A is in state $|\psi_A\rangle$ and qubit B is in state $|\psi_B\rangle$, what’s the state of “both together”?

The answer is the tensor product, written $|\psi_A\rangle \otimes |\psi_B\rangle$ (or sometimes just $|\psi_A\rangle|\psi_B\rangle$ to save space).

The four basis states

One qubit has two basis states: $|0\rangle$ and $|1\rangle$.

Two qubits have four basis states:

$|00\rangle \qquad |01\rangle \qquad |10\rangle \qquad |11\rangle$

Each one describes a definite classical configuration: “qubit 1 is 0 and qubit 0 is 1,” or “both qubits are 1,” and so on. Any state of two qubits is a superposition of these four:

$|\psi\rangle = c_{00}|00\rangle + c_{01}|01\rangle + c_{10}|10\rangle + c_{11}|11\rangle$

There are four complex amplitudes now, with the normalization rule:

$|c_{00}|^2 + |c_{01}|^2 + |c_{10}|^2 + |c_{11}|^2 = 1$

Three qubits would have $2^3 = 8$ basis states. Ten qubits would have $2^{10} = 1024$. A hundred qubits would have $2^{100}$ — more basis states than there are atoms in the observable universe. This exponential blow-up is one reason why simulating quantum computers on classical computers is hard.

The tensor product formula

If qubit 0 is independent of qubit 1, the combined state is a product. Here’s the formula:

$(\alpha_0|0\rangle + \beta_0|1\rangle) \otimes (\alpha_1|0\rangle + \beta_1|1\rangle)$

Multiply it out like polynomials (or like you would with algebraic distribution):

$= \alpha_1\alpha_0|00\rangle + \beta_1\alpha_0|01\rangle + \alpha_1\beta_0|10\rangle + \beta_1\beta_0|11\rangle$

Each of the four combined amplitudes is just the product of the two individual amplitudes. The tensor product is built from ordinary multiplication — there’s nothing mysterious about it.

A quick convention: in $|q_1 q_0\rangle$, the left bit is qubit 1 and the right bit is qubit 0. So $|10\rangle$ means “qubit 1 is in state 1, qubit 0 is in state 0.” (This matches how binary numbers are written, where the most significant bit is on the left.)

See it in action

Drag the sliders for each qubit. Watch the combined tensor product update. Notice that the four amplitudes in the result on the right are always just products of the four amplitudes on the left.

Try:

1. Set both qubits to $|0\rangle$ ($\theta = 0$ on both). The combined state is $|00\rangle$ — a single nonzero amplitude.
2. Set qubit 0 to $|+\rangle$ ($\theta = \pi/2, \varphi = 0$) and qubit 1 to $|0\rangle$. The result is $\frac{1}{\sqrt{2}}(|00\rangle + |01\rangle)$: qubit 1 is definitely 0, but qubit 0 is in superposition.
3. Set both to $|+\rangle$. The result is $\frac{1}{2}(|00\rangle + |01\rangle + |10\rangle + |11\rangle)$: a uniform superposition over all four basis states.

This last one is worth pausing on. Two qubits, each in superposition, give you a combined state that has equal weight on every possible bitstring. If you had ten qubits all in $|+\rangle$, you’d have a uniform superposition over $2^{10} = 1024$ bitstrings at once. This is the starting move of almost every quantum algorithm.

Notation shortcuts

A few shorthand conventions you’ll see everywhere:

• $|ab\rangle = |a\rangle \otimes |b\rangle$ (just concatenate)
• $|0\rangle|1\rangle = |01\rangle$ (juxtaposition means tensor product)
• $|0\rangle^{\otimes n} = |00\ldots 0\rangle$ ($n$-fold tensor product — useful for “all qubits in $|0\rangle$”)

The $\otimes$ symbol is often dropped when context makes it clear.

What’s next

You now know how to describe a pair of qubits when they behave independently. The next lesson asks the question you should already be suspicious about: is every 2-qubit state a tensor product?

Spoiler: no. And the ones that aren’t are the most interesting thing in this whole subject.