Exponentials, Logarithms, and Decay

Put 100 dollars in an account paying 1% interest per year. After one year, multiply by 1.01: you have 101 dollars. After another year, multiply by 1.01 again — and this time the interest earns interest.

Digit by digit: 101 × 1.01 = 101 + 1.01 = 102.01. Two years in, you have 102.01 dollars — a penny more than the "2% of the original" you might have guessed. That extra penny is the seed of an explosion.

Using the power notation from chapter 1, multiplying by 1.01 a hundred times is written 1.01^100 — "1.01 to the power 100".

Worked example 1: the doubling ladder. You never need a hundred multiplications — square your way up, since squaring a power doubles it:

• 1.01 × 1.01 = 1.0201 — that is 1.01^2
• 1.0201 × 1.0201 = 1.0406 — 1.01^4
• 1.0406 squared ≈ 1.0829 — 1.01^8
• then 1.1726 (^16), 1.3749 (^32), 1.8905 (^64)

Since 64 + 32 + 4 = 100, multiply those three rungs: 1.8905 × 1.3749 × 1.0406 ≈ 2.7048. So 1.01^100 ≈ 2.70: your 100 dollars became about 270 — not the 200 that "1% a hundred times" suggests. Growth by repeated multiplication is called exponential growth, and it outruns intuition every time, just like chapter 1's chessboard.

Now multiply repeatedly by a number slightly below 1. Think of photocopying a photocopy: if each copy keeps 99% of the quality, every generation multiplies the quality by 0.99.

Worked example 2, same ladder, going down:

• 0.99 × 0.99 = 0.9801 — 0.99^2
• 0.9801 × 0.9801 = 0.9606 — 0.99^4
• then 0.9227 (^8), 0.8515 (^16), 0.7250 (^32), 0.5256 (^64)

Multiply the rungs for 64 + 32 + 4 = 100 steps: 0.5256 × 0.7250 × 0.9606 ≈ 0.366. So 0.99^100 ≈ 0.37.

Sit with that for a second. Each step loses barely 1%. A hundred steps lose almost two thirds of everything. This is exponential decay, and it is the single number that rules quantum computing.

Here is why. On today's better hardware, a quantum gate does its job correctly roughly 99% of the time. A circuit is fully correct only if every gate succeeds — and independent events multiply, the rule from chapter 2. So a 100-gate circuit runs with no error anywhere on about 0.99^100 ≈ 37% of its runs. The other 63% carry at least one mistake.

Play the growth game with finer slices. Grow by 0.1% a thousand times: 1.001^1000 ≈ 2.7169. Grow by 0.01% ten thousand times: 1.0001^10000 ≈ 2.7181. The finer you slice, the more the answers crowd toward one particular number.

That number is e ≈ 2.71828, the natural growth constant. Like π, it is a fixed landmark that shows up wherever smooth, continuous growth or decay lives — bank interest, populations, radioactive atoms, and the decay curves of quantum hardware.

There is nothing to compute with e today. Just learn to recognize it. Later in the curriculum it appears attached to the number i from chapter 3, as the mathematician's favorite way of writing a rotation. When you see e, think: "smooth growth or decay is being described here."

A logarithm answers exactly one question: which exponent?

"10 to the power what makes 1000?" Since 10 × 10 × 10 = 1000, the answer is 3. That is all the statement log10(1000) = 3 says: the exponent you need is 3. The "log" button on a calculator answers this question for any number.

Let's use the idea once, on a question that actually matters: how many 99%-reliable gates can a circuit have before the chance of a fully correct run drops below one half?

1. From the ladder: 0.99^64 ≈ 0.5256 — still above half at 64 gates.
2. Add four more gates: 0.99^68 = 0.5256 × 0.9606 ≈ 0.5049 — barely above half.
3. One more gate: 0.5049 × 0.99 ≈ 0.4998 — below half at 69 gates.

So the answer is about 69 gates. A logarithm computes this in one step instead of ladder-hunting — it is the tool that turns "how many multiplications until…?" into a single button press.

Useful quantum algorithms do not need 100 gates. They need thousands, often millions. Run the decay that far and the numbers turn brutal: 0.99^1000 ≈ 0.000043 — about 4 flawless runs in every 100,000. Even a ten-times-better gate that succeeds 99.9% of the time only delays the wall: 0.999^1000 ≈ 0.37, the same two-thirds loss, arriving ten times later.

No achievable gate quality outruns exponential decay on its own. The escape route is quantum error correction: weaving many imperfect physical qubits into one far more reliable logical qubit, so errors are caught and repaired faster than they accumulate. The curriculum covers why qubits fail and what the repair really costs in logical qubits and overhead — and both chapters are, at heart, this chapter's arithmetic.

To see what decay is up against, we will now build something worth protecting: a three-qubit state with rigid structure. The circuit uses an H gate — chapter 2's fair coin — and two CX gates. A CX flips its second qubit exactly when its first qubit is 1; chaining two of them makes all three qubits agree, always.

You have now finished the math on-ramp — and this chapter's decay arithmetic echoes through everything ahead:

• Entanglement — the all-agree state you just built is a famous one (a GHZ state), and it cannot be written as chapter 5's entry-by-entry product.
• Why qubits fail and logical qubits and overhead — the whole error-correction course is 0.99-to-a-power, taken seriously.
• How to evaluate a quantum use case — the first honest question is always "how many gates does this need, and what does decay do to that number?"
• The Lab — rebuild the three-qubit circuit yourself and count the gates standing between a perfect simulator and a real machine.