Superposition, Entanglement and Measurement Explained Without Heavy Mathematics

Three words come up in every explanation of quantum computing: superposition, entanglement and measurement. They're usually explained with a one-line slogan each. "A qubit is 0 and 1 at the same time." "Entangled particles are mysteriously connected." "Looking at it collapses it."

The slogans aren't exactly wrong, but they don't let you reason with the ideas. You can't use them to predict what a circuit will do, see why an algorithm works, or understand why quantum key distribution is secure. This post replaces each slogan with a concept you can actually use, and does it with probabilities, simple experiments and a little arithmetic, not linear algebra.

One Idea Underneath All Three: The Quantum State

Before the three concepts, one word that ties them together: the quantum state.

For a classical bit, the "state" is just its value: 0 or 1. For a quantum system, the state is something richer. The most useful way to think about it:

A quantum state is a complete recipe for predicting the result of any measurement you could make on the system.

It doesn't say "the qubit is 0". It says "if you ask this question, you'll get 0 with this probability and 1 with that probability; if you ask a different question, here are the probabilities for that one." Everything that can be known about the system is in that recipe, and nothing else is hidden underneath.

Superposition, entanglement and measurement are three different aspects of this one object:

• Superposition is about what the state of one system can look like: its state space.
• Entanglement is about what happens when several systems share one state: correlation.
• Measurement is about turning the state into something you can read: a result.

Part 1: Superposition, and Thinking in State Probabilities

Start with probabilities, not with "both at once"

Forget "the qubit is both 0 and 1" for a moment. Start with something concrete: a qubit's state tells you the probability of each measurement result.

Here are some valid single-qubit states, described purely by what you'd see if you measured them many times:

Behind each probability is a number called an amplitude. The rule connecting them is the only formula in this post:

probability of a result = (amplitude of that result)²
 
Example: amplitude 0.6 for "0" and 0.8 for "1"
         chance of 0 = 0.6 × 0.6 = 0.36  (36%)
         chance of 1 = 0.8 × 0.8 = 0.64  (64%)
         36% + 64% = 100%

So far, superposition looks like nothing more than a biased coin. If that were the whole story, quantum computing would be pointless. The next experiment shows why it isn't.

The two-box experiment: superposition is not hidden randomness

Imagine someone hands you two sealed boxes, each holding one qubit.

• Box A holds a qubit in an equal superposition (both amplitudes the same size, same sign).
• Box B holds a qubit that someone prepared by secretly flipping a coin: heads, they set it to 0; tails, they set it to 1. You don't know which.

Measure each box many times (with fresh boxes each time) and you see exactly the same thing: 50% zeros, 50% ones. By measuring directly, you cannot tell the boxes apart. This is the situation the "both 0 and 1" slogan describes, and it's also the situation "it's secretly one or the other, we just don't know" describes. So which is right?

Now change the experiment. Before measuring, apply one Hadamard gate to the qubit (the gate from the beginner's guide that turns a definite 0 into an equal superposition, and back again).

• Box A now gives 0 every single time. The two amplitudes recombined and the "1" paths cancelled out.
• Box B still gives 50/50. Whichever value the coin chose, the Hadamard turns it into a superposition, so the result is random again.

That's the most important fact about superposition: it is a definite state, not ignorance about a hidden value. Box B really is "secretly 0 or 1, we don't know which". Box A isn't; it's a single, exact state that just happens to give random results for one particular question. Ask a different question (apply H first) and Box A answers with certainty.

You can run Box A yourself in Qiskit or in IBM's browser-based Composer:

from qiskit import QuantumCircuit
 
box_a = QuantumCircuit(1)
box_a.h(0)        # prepare Box A: an equal superposition
box_a.h(0)        # the "different question": Hadamard again
box_a.measure_all()
# Result over 1,000 shots: '0' about 1,000 times. Remove the second h(0) and you get ~50/50.

The hidden ingredient: phase

Why did Box A give 0 every time? Because amplitudes aren't just sizes; they also have a sign (more generally a phase). Two states can have exactly the same probabilities but different signs:

(0.71 is roughly 1 divided by the square root of 2, so 0.71² is 0.5, or 50%.)

Plus and minus are indistinguishable if you measure directly, and perfectly distinguishable after one Hadamard. The sign is invisible to one question and decisive for another. Phase is where quantum information hides, and interference is how algorithms use it: they arrange signs so that wrong answers cancel and right answers reinforce.

State space: a map of every possible qubit

Put sizes and phases together and you can draw every possible state of one qubit as a point on a sphere, called the Bloch sphere (it's the sphere on this post's cover).

• Latitude is probability. The north pole is "always 0", the south pole is "always 1", and the equator is every 50/50 state. A point a quarter of the way down gives roughly 85% / 15%.
• Longitude is phase. Plus and minus both sit on the equator, on opposite sides. Measuring "0 or 1" only tells you the latitude; the longitude is invisible to that question.
• Gates are rotations. Every single-qubit gate moves the point around the sphere. The Hadamard, for example, swaps the poles with the plus and minus points on the equator, which is exactly why it "reveals" the phase in the two-box experiment.

This is the state space of a single qubit: a whole continuous surface of possible states, not two points. The "0 and 1" slogan reduces that sphere to its two poles and loses everything in between.

The state space grows fast as you add qubits, because a group of qubits needs one amplitude for every combination of results:

Part 2: Entanglement, and Correlations No Classical Bits Can Copy

Two qubits, one joint state

Take two qubits, A and B. Their joint state has four amplitudes, one for each combination of results: 00, 01, 10 and 11.

Sometimes that joint state is just "A's state alongside B's state". If A is in an equal superposition and B is definitely 0, then the pair gives 00 half the time and 10 half the time, and you can describe each qubit completely on its own. This is called a product state: two independent systems that happen to sit next to each other.

Other joint states can't be split up like that. The famous example is the Bell state you build with a Hadamard and a CNOT (the circuit in the beginner's guide):

Each qubit on its own is a perfect 50/50 coin. But the pair always agrees. That's entanglement: a joint state of two systems that cannot be described as a state of A plus a separate state of B.

Test 1: can two independent bits do this?

Here's a simple check you can do with nothing but multiplication. If A and B were independent, each with its own chances of 0 and 1, then the four probabilities would always satisfy this rule:

For any two independent bits:
 
    P(00) × P(11)  =  P(01) × P(10)
 
Bell state:   0.5 × 0.5 = 0.25     but     0 × 0 = 0
 
0.25 is not 0, so the two qubits are not independent.

(Why the rule holds: if A gives 0 with chance a and B gives 0 with chance b, both sides work out to the same four numbers multiplied together. You don't need the algebra; try any example, such as a = 0.3 and b = 0.8, and the two sides always match.)

So two independent bits can't reproduce the Bell state. But that alone doesn't prove anything quantum. Classical systems can be correlated too.

The glove objection

Put a left glove in one box and a right glove in another, shuffle them, and send one to Amsterdam and one to Tokyo. Open the Amsterdam box, see a left glove, and you instantly know Tokyo has the right one. Perfect correlation, nothing mysterious: the answer was decided when the boxes were packed.

Couldn't entangled qubits be the same? Maybe each pair carries a hidden "plan" from the moment it's created, such as "both answer 0", and measurement just reveals it.

For measurements of "0 or 1" alone, a glove-style plan does reproduce the table above perfectly. Even adding a second question (the plus/minus one) doesn't break it, because a plan can carry answers to both. To see the difference, you need a cleverer test, and it's one of the most important experiments in physics.

Test 2: the CHSH game

Two players, Alice and Bob, are put in separate rooms. They can agree a strategy beforehand, but once the game starts they can't communicate at all. Each round:

1. A referee gives Alice a random question bit, x (0 or 1), and Bob a random question bit, y (0 or 1).
2. Each answers with a bit: Alice says a, Bob says b.
3. They win if their answers match, except when both got question 1, in which case they win only if their answers differ.

The best any classical strategy can do is win 75% of rounds. A classical strategy is just a pre-agreed plan: what Alice answers to question 0 and to question 1, and the same for Bob, possibly chosen with shared random numbers. Try to win all four rows. The first three rows force Alice's answers to both questions to match Bob's answer to question 0, and Bob's answer to question 1 to match Alice's answer to question 0. Put those together and Alice's answer to question 1 must equal Bob's answer to question 1. The fourth row demands they differ. So every plan fails at least one row in four. Shared randomness only mixes plans; it can't beat the best single one. 75% is the ceiling for anything that works like gloves.

With a shared entangled pair, they can win about 85% of rounds. Each player keeps one qubit of a Bell pair. Instead of answering from a plan, each measures their qubit with a setting chosen by their question, like turning a polarising filter to a particular angle, and answers with the result:

For this entangled pair, the chance that Alice's and Bob's results match depends only on the angle between their two settings: the smaller the angle, the more likely they agree. In the three "must match" rows the settings are 22.5° apart, so they usually agree. In the "must differ" row they're 67.5° apart, so they usually disagree. Each row is won about 85.4% of the time, beating the classical 75% ceiling.

This result is Bell's theorem, in the version by Clauser, Horne, Shimony and Holt. Experiments have confirmed the quantum prediction many times, including "loophole-free" tests in 2015, and the work earned the 2022 Nobel Prize in Physics. The conclusion is precise: the correlations in an entangled state cannot be reproduced by any classical system, not even one with a shared hidden plan, as long as the two sides don't communicate.

That is what entanglement is: a joint state containing correlations that no description of two separate classical systems, independent or pre-arranged, can match.

What entanglement is not

Seeing it yourself

Build the Bell pair, then measure it in the "0 or 1" question and in the "plus or minus" question (by applying a Hadamard to each qubit before measuring):

from qiskit import QuantumCircuit
 
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)        # entangle: the Bell state
 
# Question 1: measure directly -> results are only '00' and '11'
# Question 2: add these two lines first -> results are still only '00' and '11'
bell.h(0)
bell.h(1)
bell.measure_all()

A pair of independent random bits would scatter across all four results in the second version. The entangled pair agrees in both questions. Agreement in two questions can still be faked by a glove-style plan; it's the CHSH settings above that no plan can fake. Stage 04, Quantum Programming, runs the full CHSH test on real hardware.

Part 3: Measurement, Where Quantum Becomes Classical

Every quantum computation ends the same way. However rich the state was, what comes out is ordinary bits:

This one step is where a lot of quantum computing's difficulty and power comes from. Five rules describe it.

Rule 1: the result is random, with chances set by the state

Measurement gives one definite answer, 0 or 1, chosen at random with the probabilities from the amplitudes (amplitude squared, the rule from Part 1, known as the Born rule). Nothing about the state tells you in advance which way a single run will go, only how often each result happens over many runs.

Rule 2: measuring changes the state

After measurement, the qubit is simply in the state you saw. The superposition is gone, and measuring again immediately gives the same answer. In the two-box experiment, if you measured Box A before applying the Hadamard, it would behave exactly like Box B afterwards. Measurement is not looking; it's an interaction that changes the system.

Rule 3: one bit out per qubit

However many amplitudes describe the state, measuring n qubits gives you exactly n bits. A 300-qubit state may involve more amplitudes than there are atoms in the universe, but a single readout returns a 300-character string of 0s and 1s. (Physicists have proved that you can't do better than that, on average, however cleverly you measure.) This is why quantum computers are not giant hard drives: the state is enormous, but what you can read from it is not.

Rule 4: you choose the question

Every measurement asks a particular question. The usual one is "0 or 1?", but you can ask "plus or minus?" just as well, by rotating the qubit with a gate before measuring. Different questions give different probabilities for the same state, as both the two-box experiment and the CHSH game show. Choosing the question is part of the algorithm.

Rule 5: you can't undo it

Gates are reversible; measurement isn't. Once the result is out, the amplitudes and phases that produced it can't be recovered from the qubit. And because unknown states can't be copied, you can't make a backup first.

Why you always need many shots

Because one run gives one random sample, quantum programs are run many times (shots) and the probabilities are estimated from the counts. More shots give a more precise estimate, but precision improves slowly:

Ten times more precision costs a hundred times more shots. That's a real cost on cloud quantum hardware, where you pay for time, and it's one reason good algorithms are designed so the right answer comes out with a high probability, not just a slightly higher one.

The environment is always measuring

Measurement doesn't need a scientist or a detector. Any interaction that leaks information about the qubit into its surroundings (a stray photon, a vibration, a bit of heat) acts like a small, uncontrolled measurement. That's decoherence: the environment slowly measuring the qubit, washing out its superposition and entanglement before the computation finishes. It's why qubits are kept so cold and isolated, and it links measurement directly to the error models in Classical Computer vs Quantum Computer: What Is Actually Different?.

Putting the Three Together: One Circuit, Three Ideas

The two-qubit Bell circuit uses all three concepts, one after another:

And here's how each idea carries into the rest of the learning path:

Five Misconceptions, Corrected

Quick Recap

• Quantum state: a complete recipe for the probabilities of every possible measurement, with nothing hidden underneath.
• Superposition: a qubit's state is a point in a continuous state space. Latitude is probability, longitude is phase, and phase is invisible to some questions but decisive for others.
• Entanglement: a joint state of several qubits that can't be split into separate states, producing correlations no classical system, independent or pre-arranged, can reproduce.
• Measurement: asks one question, returns one random bit per qubit, changes the state, and can't be undone. Results are estimated from many shots.

With these three in place, the rest of quantum computing becomes much easier to follow: algorithms arrange phases to interfere, hardware fights the environment's unwanted measurements, and security and networking are built on what measurement and entanglement allow and forbid.

What's Next on the Learning Path

Next, stage 02, How Quantum Computers Work, compares classical and quantum machines layer by layer, from processors and memory to measurement and error models, and its flagship, How Does a Quantum Computer Actually Work?, shows how the five measurement rules above are implemented in real hardware. After that, stage 03, Quantum Hardware, looks at how real qubits are built. The full 11-stage path is listed at the end of the beginner's guide.