Lists, Vectors, and Normalization

You already use vectors every week. A shopping list — 2 apples, 3 eggs, 1 loaf — is a list of numbers in a fixed order. The order matters: swap the 2 and the 3 and you come home with the wrong bag.

A GPS location is one too: (28.61, 77.21) is two numbers in a fixed order, latitude first, longitude second. Swap them and you are in the ocean.

That is the entire definition. A vector is a list of numbers in a fixed order. Nothing else. When math books draw arrows, they are drawing a picture of a vector; the vector itself is just the list. We will write lists in square brackets, like [0.6, 0.8].

Measure a qubit and you get 0 or 1. Before you measure, the qubit carries one amplitude for each possible reading. An amplitude is a number you square to get a chance. These are the "amounts that can cancel" from chapter 3. So a qubit's state is a two-entry vector: [amplitude for reading 0, amplitude for reading 1].

A fresh qubit is [1, 0]. All of the amount sits on 0 and none on 1, so every shot reads 0. After the fair-coin H gate from chapter 2, the state is [0.7071, 0.7071]. After the RY(π/3) turn from chapter 4, it is [0.8660, 0.5].

More qubits just means a longer list, with one entry per possible reading. Two qubits have four readings (00, 01, 10, 11), so the list has four entries. Three qubits need eight entries. In general, n qubits need a list with 2^n entries. That is the doubling explosion from chapter 1.

So 30 qubits already need a list about a billion entries long. That long list is part of what makes quantum computers interesting. It is also why ordinary computers that imitate them (called simulators) hit a wall.

Chapter 2 opened with one bedrock fact: the probabilities of all possible outcomes add up to 100%, that is, to 1. And squaring an amplitude gives that outcome's probability. Put those together and every legal state vector must pass one test:

Square every entry. The squares must add up to exactly 1.

This rule is called normalization. It is not a new law of nature — it is "probabilities total 100%" wearing vector clothes.

Worked example 1, digit by digit. Is [0.6, 0.8] a legal qubit state?

• 0.6 × 0.6 = 0.36
• 0.8 × 0.8 = 0.64
• 0.36 + 0.64 = 1.00 — legal. This qubit reads 0 on about 36% of shots and 1 on about 64%.

Check the fair coin [0.7071, 0.7071] too: 0.7071 × 0.7071 = 0.4999904…, which is exactly 0.5 once you use the full unrounded value 0.70710678… So the squares give 0.5 + 0.5 = 1. Legal.

One more thing squares are good at: ignoring signs. (−0.7071) × (−0.7071) is also +0.5, because a negative times a negative is positive — chapter 3's rule. The negative amplitudes that made cancellation possible are fully legal citizens of these lists.

The list [0.5, 0.5] looks innocent. Test it: 0.5 × 0.5 = 0.25, and 0.25 + 0.25 = 0.50. The squares total only 50%. Half the probability is missing, so this is not a legal state.

The repair is always the same: divide every entry by the list's length. The length is the square root — the un-squaring operation from chapter 1 — of the sum of the squares.

Worked example 2, digit by digit:

1. Sum of squares: 0.25 + 0.25 = 0.50.
2. Length: the square root of 0.50 is 0.7071, because 0.7071 × 0.7071 = 0.4999904… ≈ 0.50.
3. Divide each entry by the length: 0.5 ÷ 0.7071 = 0.7071. (A charming habit of this particular number: dividing 0.5 by it hands it right back, precisely because its square is 0.5.)
4. The repaired list is [0.7071, 0.7071]. Check: 0.5 + 0.5 = 1.00. Fixed.

This repair is called normalizing the vector. It is the same move as converting raw vote counts into percentages: you divide by the total so that everything accounts for exactly 100%.

Remember the two coins in chapter 2: independent events multiply, so heads-heads had probability 0.5 × 0.5 = 0.25, one cell of a 2-by-2 table. Amplitudes follow the same multiplication when qubits are independent.

Give each of two qubits the fair-coin treatment, so each is [0.7071, 0.7071]. The combined state lists all four readings — 00, 01, 10, 11 — and each entry is the product of the matching single-qubit amplitudes: 0.7071 × 0.7071 = 0.5, every time. The combined vector is [0.5, 0.5, 0.5, 0.5]. It is chapter 2's table again, flattened into a list.

Normalization check: each square is 0.5 × 0.5 = 0.25, and four of them make 0.25 + 0.25 + 0.25 + 0.25 = 1.00. Legal.

So the prediction writes itself: each of the four readings has probability exactly 0.25, which means about 250 of each in 1000 shots. Let's measure the list.

From now on, "the state" always means "the list". Normalization is the first check on any state you write down. You will use this in:

• Probability amplitudes, which tells the full story of the entries in these lists.
• Multiple qubits, where the 2^n-entry list becomes the main character. That chapter includes states that cannot be built by entry-by-entry multiplying.
• The next chapter, where repeated multiplying stops being a handy trick. It becomes the reason quantum hardware is hard to build.
• Amplitudes and phase, a quick summary you can come back to any time.
• The Lab, where you can look at the state list of any circuit you build. Watch the squares add up to 1.