Multi-Qubit Systems and Entanglement

So far we’ve been living in a 2-dimensional complex vector space — one qubit. That’s already weirder than classical bits, but the real magic only shows up when you have more than one qubit and they start talking to each other. Two qubits live in a 4-dimensional space. Three qubits in 8. $n$ qubits in $2^n$.

That exponential scaling is the reason people believe quantum computers can do things classical computers fundamentally can’t. But raw dimensionality isn’t quite the secret — classical probability distributions over $n$ bits also live in a $2^n$-dimensional space, and nobody thinks of Monte Carlo as exponentially more powerful than serial computation. The secret is a specific kind of two-qubit state called entanglement, which classical probability simply cannot express.

This tutorial builds the tensor-product machinery, defines entanglement, introduces the four Bell states, and uses Qiskit to demonstrate a measurement correlation that is physically impossible in any classical theory.

Combining two qubits: the tensor product

If qubit A is in state $|\psi_A\rangle = \alpha|0\rangle + \beta|1\rangle$ and qubit B is in $|\psi_B\rangle = \gamma|0\rangle + \delta|1\rangle$, the joint state of the two-qubit system is their tensor product:

Distribute the tensor like multiplication:

The four two-qubit basis states are $|00\rangle, |01\rangle, |10\rangle, |11\rangle$. In column form:

So a general two-qubit state is a 4-dimensional complex unit vector:

Separable vs entangled

A two-qubit state is separable (also called a “product state”) if it can be written as a tensor product $|\psi_A\rangle \otimes |\psi_B\rangle$ of single-qubit states. Otherwise it’s entangled.

Take a concrete example. The state

is separable: it factors as $\frac{1}{\sqrt{2}}(|0\rangle + |1\rangle) \otimes \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle) = |+\rangle \otimes |+\rangle = |++\rangle$.

Now consider

This one cannot be written as $|\psi_A\rangle \otimes |\psi_B\rangle$ for any choice of single-qubit states. (Proof: if it factored, you’d need $c_{00} = \alpha\gamma$, $c_{11} = \beta\delta$, and $c_{01} = \alpha\delta = 0$, which forces either $\alpha = 0$ or $\delta = 0$, contradicting $c_{00}, c_{11} \neq 0$.) It’s entangled.

$|\Phi^+\rangle$ is one of the four famous Bell states:

All four are maximally entangled. They are the “hello world” of multi-qubit quantum computing.

Why entanglement is different from classical correlation

This is the one section most tutorials get wrong, and it’s the most important.

A classical correlated source — say, a machine that flips a single coin and sends the same result to Alice and Bob — also produces matched outputs. If it outputs 00 or 11 each 50% of the time, Alice and Bob’s measurements are perfectly correlated. So what’s the difference from a Bell state?

The difference is that entanglement gives correlated results in every measurement basis, not just one.

Prepare $|\Phi^+\rangle$ and measure both qubits in the $Z$-basis: you get 00 or 11, each with 50% probability. Perfect correlation.

Now do the same thing but measure both qubits in the $X$-basis instead. Work out the algebra. It turns out that:

So you also get perfectly correlated ++ or -- in the $X$-basis. And in the $Y$-basis too.

A classical “shared random bit” source gives correlated results in its preferred basis but uncorrelated results in any rotated basis. Bell states give correlated results in every basis. That’s impossible classically, and it’s what Bell’s theorem rules out. Every test ever done has agreed with the quantum prediction; the 2022 Nobel Prize went to three physicists for pinning down the experimental evidence.

Building a Bell state: H and CNOT

Every Bell state can be made with two gates: a Hadamard on one qubit, then a CNOT (controlled-NOT). The CNOT flips the target qubit if and only if the control qubit is $|1\rangle$. In matrix form:

Walk through it step by step. Start from $|00\rangle$. Apply $H$ to the first qubit:

Now apply CNOT (control = qubit 0, target = qubit 1). It leaves $|00\rangle$ alone and flips $|10\rangle$ to $|11\rangle$:

Do it in Qiskit

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit_aer import AerSimulator

qc = QuantumCircuit(2, 2)
qc.h(0)              # put qubit 0 in |+⟩
qc.cx(0, 1)          # CNOT: control = 0, target = 1
state = Statevector.from_instruction(qc)
print(state)
# Statevector([0.70710678+0.j, 0.+0.j, 0.+0.j, 0.70710678+0.j], dims=(2, 2))

That’s $\frac{1}{\sqrt{2}}|00\rangle + \frac{1}{\sqrt{2}}|11\rangle = |\Phi^+\rangle$. Now measure both qubits in the $Z$-basis many times:

qc.measure([0, 1], [0, 1])
sim = AerSimulator()
counts = sim.run(qc, shots=4096).result().get_counts()
print(counts)
# {'00': 2048, '11': 2048}   —   '01' and '10' never appear

Perfect correlation. Now the interesting experiment. Rewrite the circuit to measure in the $X$-basis on both qubits: apply $H$ to each before measurement.

qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)          # prepare |Φ+⟩
qc.h([0, 1])         # rotate both qubits into X-basis measurement
qc.measure([0, 1], [0, 1])

counts = sim.run(qc, shots=4096).result().get_counts()
print(counts)
# {'00': 2048, '11': 2048}   —   still perfectly correlated!

The same entangled state is perfectly correlated in the $X$-basis too. For comparison, do it with a separable state $|++\rangle$ instead:

qc = QuantumCircuit(2, 2)
qc.h([0, 1])                    # |++⟩ — separable, not entangled
qc.measure([0, 1], [0, 1])
print(sim.run(qc, shots=4096).result().get_counts())
# {'00': 1024, '01': 1024, '10': 1024, '11': 1024}  — uniform, no correlation

Measured in $Z$, $|++\rangle$ gives uniform 25/25/25/25 across all four outcomes. Measured in $X$, it gives 00 every time. The separable state is correlated in one basis and uncorrelated in another. The Bell state is correlated in both. That’s the real line between classical and quantum.

Three-qubit and beyond: GHZ

Entanglement generalizes. A famous three-qubit entangled state is the GHZ state (Greenberger–Horne–Zeilinger):

Build it with H followed by two CNOTs:

qc = QuantumCircuit(3, 3)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)
qc.measure(range(3), range(3))
print(sim.run(qc, shots=4096).result().get_counts())
# {'000': 2048, '111': 2048}

GHZ states are used in quantum-network protocols, leader-election algorithms, and as a key ingredient of quantum error correction. Quantinuum reported creating a 50-qubit GHZ state in 2024; IBM and Atom Computing have pushed even larger.

The computational picture: 2ⁿ-dimensional state space

The running theme: $n$ qubits live in $\mathbb{C}^{2^n}$. Twenty qubits already need $2^{20} = 1{,}048{,}576$ complex amplitudes to describe a general state. Fifty qubits push you past what your laptop can even store in memory. That’s the intuition behind why classical simulation of general quantum circuits is hard — and why quantum computers might do things classical ones cannot.

Measuring one qubit of an entangled pair

Here’s a cute and important phenomenon. Take $|\Phi^+\rangle$ and measure only qubit 0. The Born rule gives:

• outcome 0 with probability $1/2$; post-measurement state is $|00\rangle$, so qubit 1 is now in $|0\rangle$
• outcome 1 with probability $1/2$; post-measurement state is $|11\rangle$, so qubit 1 is now in $|1\rangle$

Measuring qubit 0 instantly “decides” the state of qubit 1. This is what Einstein famously called “spooky action at a distance,” and it’s the origin of the EPR paradox. Two important caveats:

1. No information is transmitted. The outcome on qubit 0 is still random; Alice (holding it) has no way to choose what Bob (holding qubit 1) sees. They only discover the correlation when they compare notes classically — at classical speeds.
2. This is not a measurement doing physical work at a distance. It’s what happens when you update your state description. Different interpretations of quantum mechanics disagree about what this “really means” metaphysically, but operationally the predictions are unambiguous and classical information transfer is provably impossible.

Exercises

1. Separable or entangled?

For each state, decide whether it’s separable. If separable, write it as a tensor product.

a. $\frac{1}{\sqrt{2}}(|00\rangle + |10\rangle)$ b. $\frac{1}{\sqrt{2}}(|01\rangle + |10\rangle)$ c. $\frac{1}{2}(|00\rangle - |01\rangle - |10\rangle + |11\rangle)$

2. Build all four Bell states

The H + CNOT circuit we built gives $|\Phi^+\rangle$ from input $|00\rangle$. What about inputs $|01\rangle$, $|10\rangle$, and $|11\rangle$? (Prepare them with $X$ gates before H+CNOT.) Which Bell state comes out in each case?

3. Code: measurement-correlation experiment

Write a script that prepares $|\Phi^+\rangle$, measures both qubits in the $Y$-basis (hint: SDG then H then measure), and collects 10,000 shots. Are the results still perfectly correlated? What does that tell you about the state?

qc = QuantumCircuit(2, 2)
qc.h(0); qc.cx(0, 1)
qc.sdg([0, 1]); qc.h([0, 1])
qc.measure([0, 1], [0, 1])
counts = sim.run(qc, shots=10_000).result().get_counts()
# {'01': 5000, '10': 5000} — perfectly <em>anti</em>-correlated in Y

4. Think: entanglement and Bell’s theorem

Why is it that perfectly matched measurements in two or three different bases are what force the conclusion “this can’t be explained by classical correlations”? What would a classical “shared random bit” model predict for the three-basis measurement statistics, and how does it fail?

What you should take away

• $n$ qubits live in $\mathbb{C}^{2^n}$. Combine via tensor product.
• Separable states factor as $|\psi_A\rangle \otimes |\psi_B\rangle$. Entangled states don’t.
• The four Bell states are the canonical maximally-entangled two-qubit states. Build them with H + CNOT.
• Entanglement = correlation that persists across measurement bases. That’s the real distinction from classical correlation.
• Measuring part of an entangled system affects the statistics of the other part — but never faster-than-light communication.
• The $2^n$-dimensional state space is the reason classical simulation is hard. Entanglement is the reason this size is useful.

That’s the end of the foundations arc. Next track: Gates and Circuits — unitary matrices, the universal gate set, OpenQASM, and running your first circuit on real hardware. You now have everything you need to start reading quantum algorithm papers.