Fold a Paper to the Moon

A single sheet of paper, folded in half again and again until the stack outreaches the Moon. This lesson does the arithmetic behind that stack, then the arithmetic that stops you ever building it.

Before you start. You need to be comfortable doubling a number in your head, again and again - 2, 4, 8, 16 - and nothing else. That’s the whole of the maths in the story half: no fractions, no algebra, nothing with a Greek letter in it.

1969: a physicist gives the same lecture seventeen hundred times

Albert Bartlett joined the physics faculty at the University of Colorado Boulder in 1950. In September 1969 he started giving a public lecture called Arithmetic, Population, and Energy - by 2001 he’d given it more than 1,700 times, almost unchanged. He opened every one with the same sentence: “The greatest shortcoming of the human race is our inability to understand the exponential function.”

He wasn’t being dramatic. Ask a room to guess what a number does when it doubles again and again, and almost everyone guesses low - not by a little, but by whole orders of magnitude. The mistake isn’t a lack of intelligence. A doubling number does something your gut has no real practice with: each new step is bigger than every step before it, put together. Your gut knows things that add a fixed amount each time - a paycheque, a bus ride, a flight of stairs. It knows almost nothing that multiplies.

Bartlett made his point with bacteria in a bottle. Here is the same trick, with something you can hold: a single sheet of paper.

The bet: fold this paper 42 times and you reach the Moon

Here is the bet. Take an ordinary sheet of office paper - about a tenth of a millimetre thick, roughly the thickness of a human hair. Fold it in half. Fold it again. Keep going. How many folds until the stack is taller than the distance from the Earth to the Moon, 384,400 kilometres away?

Guess a number before you read on. Almost everyone guesses in the hundreds, or gives up. The real answer is 42.

Here’s why, and the whole trick is one habit: a fold doesn’t add to the stack. It doubles it.

Fold it ten times and you have 1,024 layers - about the thickness across your hand. Fold it twenty times and you have over a million layers - roughly the height of a stadium. Fold it thirty times and the stack has already cleared 100 kilometres, the usual edge-of-space line. Each extra ten folds is roughly another thousand-fold jump, because ten doublings comes out to almost exactly a thousand - a shortcut the second read puts to more use.

Keep going and the last stretch gets strange. Fold it 41 times and the stack reaches 219,902 kilometres - just over half the distance to the Moon. Fold it 42 times, one fold more, and it reaches 439,805 kilometres - comfortably past it. That isn’t a coincidence of the numbers. Because every fold doubles everything stacked so far, the very last fold adds more height by itself than all 41 folds before it, added together. The Moon isn’t approached gradually. It’s missed by a wide margin, and then cleared in a single step.

flowchart LR
  F1["fold 1: 0.2 mm"] --> F10["fold 10: 10 cm, a hand"]
  F10 --> F30["fold 30: 107 km, past the edge of space"]
  F30 --> F41["fold 41: 219,902 km, still short"]
  F41 --> F42["fold 42: 439,805 km, past the Moon"]

This is called exponential growth: instead of adding a fixed amount at each step, you multiply by a fixed amount at each step. It’s the reason Bartlett spent a career on one sentence, and it’s the reason the answer to “how many folds” feels wrong right up until you check it.

Knowing the answer is 42 is one thing. Finding it without guessing needs a different kind of question.

The question that actually works: not “how big”, but “how many doublings”

Multiplying by two forty-two times, checking the answer each time, would take forever to search by hand. The question you actually want runs the other way: given a distance, how many doublings does it take to get there? That reverse question has a name - a logarithm - though you don’t need the name to use the trick, only the habit of asking it.

There is one shortcut worth memorising, because it turns any “how big” question into a small, manageable one: ten doublings very nearly multiplies by a thousand (1,024, to be exact - close enough to use as a rule of thumb). So every extra factor of a thousand costs about ten more doublings. A million is about twenty doublings. A billion is about thirty. Now the Moon. Measured in sheets of paper, a tenth of a millimetre each, it is a little under four trillion sheets away. A trillion is a thousand, times a thousand, times a thousand, times a thousand: four thousands, so forty doublings. The leftover four is two more doublings, because two doublings make four. Forty plus two: forty-two.

That’s the whole reflex, and it works on anything that doubles, not just paper: never ask how big the thing will get. Ask how many doublings you can afford, and how long one doubling takes. Both of those numbers are small enough to hold in your head. What they describe usually isn’t.

So the arithmetic says 42 folds gets you to the Moon. Go find a big enough sheet of paper and try it - you will fail, and not for the reason you’d guess.

The catch: a second doubling, working against you

Old folklore says paper can’t be folded more than seven or eight times. Not quite. In 2002, a high-school student named Britney Gallivan folded a 1,219-metre roll of toilet paper in half twelve times in a single direction - on purpose, having worked out in advance exactly how much paper she’d need. You can fold much further than seven, but you can never fold all the way to 42, because a second doubling runs the opposite way.

Every fold’s crease has to bend around every layer already stacked there. That bend eats into the length of the sheet, and it eats into more of it each time, because there are more layers to bend around. The height you’re building doubles with every fold, same as before. But the paper you need to build it grows even faster - roughly four times over with every fold, not two. You are losing that race, by a widening margin every single fold.

flowchart LR
  A["12 folds: 879 m of paper needed"] --> B["20 folds: 57,570 km needed"]
  B --> C["42 folds: wider than the galaxy"]

The numbers make the gap obvious. Twelve folds already needs 879 metres of paper - nearly a kilometre, just to get to twelve. Twenty folds needs 57,570 kilometres, more than the Earth is wide, many times over. Forty-two folds needs a strip of paper wider than the entire Milky Way galaxy. The height is easy to reach on paper. The material to reach it does not exist, and never will.

So the shock was never really “fold it 42 times and reach the Moon.” Two different doublings were racing the whole time - one building height, one eating material - and the one working against you was always going to win. That’s worth remembering, because paper is not the only place this race runs.

You now know

• Folding a sheet of paper in half doubles its thickness. Do it 42 times and the stack clears the Moon.
• That’s exponential growth: each step multiplies the last instead of adding to it, so the very last step outweighs every step before it, combined.
• The useful question about something doubling isn’t “how big will it get” - it’s “how many doublings”, a logarithm. It turns huge numbers into small, memorable ones.
• Ten doublings is close enough to a thousand-fold jump to use as a shortcut for any doubling number.
• You can never actually fold paper 42 times: the crease eats into the sheet faster than the height you gain, so the paper required always wins the race.
• The real record isn’t “seven folds” - it’s twelve, set by someone who worked out the arithmetic first.

Stop here if you want. What follows is the same doubling trick wearing other names - money, computer chips, epidemics, computer code - and the one honest question worth asking whenever you meet it again.

Second read: the same curve, in numbers, wearing other names

The full progression.

Getting to 42 exactly. Doubling from 0.1 mm to 384,400 km asks “how many times do I double 0.1 mm to reach 384,400,000,000 mm?” - a logarithm answers it directly:

n = log₂(384,400,000 m / 0.0001 m) = log₂(3.844 × 10¹²) = 41.81

In plain terms: 3.844 trillion sits between 2⁴¹ and 2⁴², so the first whole fold that clears the distance is 42, overshooting by 14% (439,805 km against 384,400 km). Two caveats: 384,400 km is the mean Earth–Moon distance (the real orbit runs 363,300–405,500 km, and fold 42 clears even the far end), and “edge of space” uses the 100 km Kármán line, though the US military and NASA have historically used 80 km - fold 30 clears both. The ten-doublings-is-a-thousand shortcut is also why a kilobyte is 10 doublings, a megabyte 20, a gigabyte 30 - the same fact as Everything Is a Number (bits & bytes)‘s binary and Bit Manipulation (thinking in bits)‘s shifts, where doubling a number is just shifting its binary digits one place left.

Compound interest, and the Rule of 72. Money growing at a steady rate each year doubles after a fixed number of years. The exact count is ln 2 / ln(1+r) for a rate r, which nobody works out in their head, so bankers use the Rule of 72: divide 72 by the percentage rate. At 6% a year, money doubles in about 12 years:

Near-exact at 8%, drifting both ways elsewhere - use it up to ~15%, 69 or 70 below 3%. At 7%, money doubles in about ten years, so 40 years is roughly four doublings, sixteen times the original amount, and the last doubling outweighs the first three combined - the same structure as fold 42. Debt is the identical curve pointed the other way, which is why credit-card interest is a different kind of object from a loan. See Mental Models & Decision-Making (thinking about thinking).

Moore’s law. Gordon Moore’s 1965 paper observed transistor counts doubling roughly every year; he revised that to every two years in 1975 (the familiar “eighteen months” is a later blend, credited to Intel’s David House). It held about fifty years - twenty-five doublings, a factor of roughly 33 million. What stopped is more instructive than what continued: counts kept doubling past 2005, but single-thread speed decoupled once Dennard scaling ended - shrinking transistors stopped getting proportionally more efficient, so clock speeds flattened and the extra transistors went into cores and cache instead. The exponential didn’t break; a different one riding alongside it did. Related: The Memory Hierarchy (cache, locality, the memory wall).

Epidemics. R₀ is the average number of people one case infects with no immunity around. After g generations you have R₀ᵍ cases - doubling is the R₀ = 2 case. With R₀ = 2 and everyone alive susceptible, log₂(8 billion) ≈ 33 generations exhausts the planet, about 165 days at five days a generation. Moving R₀ from 1.2 to 0.9 differs categorically from halving case counts once: one changes the exponent’s base, the other the starting number.

The one that bills you: O(2ⁿ). An algorithm trying every subset of n items does 2ⁿ units of work, at a billion operations a second:

Forty items is a coffee break; sixty outlives the project, and no faster hardware closes that gap - a thousand-fold speedup at n = 60 still leaves 13 days, and n = 70 undoes the purchase (Complexity & Big-O, Foundations #01 - Complexity (Big-O ka poora naksha), Complexity Theory (when problems are hard)). Two escapes, both attacking the exponent: memoisation caches repeated subproblems, so naive Fibonacci goes from O(2ⁿ) to O(n) (Recursion & Dynamic Programming, Foundations #10 - Dynamic Programming (1D & 2D in practice)); meet in the middle enumerates each half separately, so n = 60 becomes 2³⁰ ≈ 1.07 seconds instead of 36.5 years - the same square-root structure behind the birthday-paradox bound 2^(b/2) in The Birthday Paradox. Exponential isn’t a synonym for impossible: Held–Karp solves travelling salesman exactly in O(n²·2ⁿ), fine at n = 20 (4 × 10⁸ ops). It means know your ceiling on n before you deploy.

The flip side: halving. Repeated halving reaches 1 in log₂(n) steps, which is small - the whole reason these feel like cheating. Binary search discards half the candidates per comparison: a million sorted items take 20 comparisons, a billion take 30, all 8 billion people alive take 33 (Sorting & Searching, Foundations #05 - Sorting & Searching, Clinic #11 - Binary Search). Trees and indexes: a balanced binary tree over n keys is log₂(n) deep; a B-tree widens the branching factor so depth in disk pages drops to three or four (Trees (BST, balancing, heaps, tries), Storage Engines). Half-lives: after 10, 0.098% remains; carbon-14’s half-life is 5,730 years, so 10 of them is 57,300 years, roughly why radiocarbon dating runs out near 50,000 - signal drops below background. Spaced repetition is deliberate halving the other way: expanding intervals exploit a small number of doublings covering a lifetime (Spaced Repetition).

The physical limit, exactly. Britney Gallivan derived the loss-of-material formula in 2001, in high school. Folding in one direction, the minimum length of a sheet of thickness t for n folds is:

L = (π t / 6) (2ⁿ + 4)(2ⁿ − 1)

In plain terms: paper required grows like 4ⁿ while height gained grows like 2ⁿ - you lose by squaring. For t = 0.1 mm:

That last row is longer than the Milky Way is wide (~100,000 light years). Gallivan’s 2002 record - a 1,219 m roll folded 12 times - matches this table: 0.1 mm paper needs 879 m for 12 folds, and tissue is thicker, so 1,219 m is the right order. Later attempts reached 13.

Where it stops. Nothing grows exponentially for long; the question is never “how big” but “which constraint, and when”. Paper hit its constraint immediately: material. Bacteria in a flask double every 20 minutes until nutrients run out. Compound returns meet market size. Moore’s law met atoms and thermodynamics. An epidemic meets susceptible people - for R₀ = 3, growth stops once 1 − 1/R₀ = 67% are immune, well before everyone has caught it.

The shape describing a finished process is the logistic curve, not the exponential:

dN/dt = r·N·(1 − N/K)

In plain terms: growth slows in proportion to how close the total is to a ceiling, K, the carrying capacity. While N is far below K the slowing barely matters, so a logistic curve looks exponential for the whole first half of its life - you cannot tell them apart from early data, only from the mechanism (Verhulst, 1838). Don’t argue about the growth rate: ask what K is. Paper’s K was the strip’s length; an epidemic’s is the susceptible population; Moore’s law’s was the size of an atom.

Two smaller notes. Real sheets have air between layers and finite crease radius, so even a 12-fold stack is thicker than the formula alone predicts. And the intuition failure is measurable, not folklore: psychologists call it exponential growth bias, reproduced since Wagenaar’s 1970s experiments asking people to extrapolate a doubling series - they produce something close to linear instead. Perception is also roughly logarithmic (Weber–Fechner): number compresses, change stays linear, and this problem punishes both. See Decision-Making Under Uncertainty and The 99 Percent Test That Is Usually Wrong.

Try it

No code? Do this. Ten minutes, one sheet of printer paper, a ruler and a pencil.

1. Fold until you can’t. Fold the sheet in half, again and again, always the same way of halving. Write down how many layers you have after each fold (2, 4, 8, …) and stop when the paper refuses. Most people stop at six or seven, which is the folklore number, and now you know why: by then the crease has to bend around 64 or 128 layers.
2. Measure the stack. Press your last folded block flat and measure its thickness with the ruler. At a tenth of a millimetre a sheet, predict it first: how thick should 128 layers be? Your measurement will come out a little thicker, because folded paper traps air.
3. Everest by the shortcut. Everest is about 8.8 km tall. Using only “ten doublings is about a thousand”, estimate how many folds of a 0.1 mm sheet would reach its summit. (Hint: turn 8.8 km into tenths of a millimetre first.)
4. The last fold. Fold 41 reaches 219,902 km. How much height does fold 42 add by itself, and how does that compare with everything folds 1 to 41 built together?
5. The paper race. Twelve folds in one direction need 879 metres of paper. If the paper needed grows about four times with each fold, roughly how much does a thirteenth fold need?

With Python, the block below reproduces every number in the lesson.

import math

t_mm = 0.1                                    # sheet thickness, mm
def height_km(n): return t_mm * 2**n / 1e6    # mm -> km

for n in (7, 10, 17, 20, 27, 30, 40, 41, 42):
    print(f"fold {n:2d}  {2**n:>18,}  {height_km(n):>14,.4f} km")
# fold 41 -> 219,902 km (short);  fold 42 -> 439,805 km (past the Moon at 384,400)

moon_mm = 384_400 * 1e6
print("exact folds needed:", math.log2(moon_mm / t_mm))       # 41.81 -> 42

# the structural fact: the last fold beats the whole history
print(2**42 - 2**41 == 2**41, sum(2**k for k in range(42)) == 2**42 - 1)

# Rule of 72 vs the truth
for r in (0.02, 0.06, 0.08, 0.12, 0.20):
    print(f"{r:.0%}  exact {math.log(2)/math.log(1+r):6.2f}   72/r {72/(r*100):6.2f}")
# nearly exact at 8%, drifts high below and low above

# O(2^n) at a billion ops/sec
for n in (20, 30, 40, 50, 60):
    s = 2**n / 1e9
    print(f"n={n:2d}  {2**n:.3e} ops  {s:,.1f} s  = {s/3.15576e7:,.2f} yr")
# n=40 -> 18.3 min ;  n=60 -> 36.5 yr ;  meet-in-the-middle 2**30 -> 1.07 s

# Gallivan: paper needed grows like 4^n while height grows like 2^n
L = lambda n, t=0.1e-3: (math.pi * t / 6) * (2**n + 4) * (2**n - 1)
for n in (12, 13, 20, 42):
    print(f"{n} folds needs {L(n):.4g} m  ({L(n)/9.4607e15:.3g} light years)")
# 42 folds -> 1.01e21 m -> 107,000 ly, wider than the galaxy

# logistic vs exponential: identical until they are not
r, K = 0.6, 1e6
N_log, N_exp = 1.0, 1.0
for step in range(1, 41):
    N_log += r * N_log * (1 - N_log / K)
    N_exp *= (1 + r)
    if step % 10 == 0:
        print(f"t={step:2d}  logistic {N_log:12,.0f}   exponential {N_exp:14,.0f}")

Run the last block and watch the two columns separate. At t = 10 they are identical (110 and 110). At t = 20 they are still within 1% (11,998 vs 12,089) - indistinguishable from noisy data. At t = 30 the gap is 2× (677,081 vs 1,329,228), and by t = 40 the logistic has levelled at its carrying capacity (999,917) while the exponential is at 146,150,164 and climbing. That indistinguishable early stretch is the whole forecasting problem.

Go deeper

• Britney Gallivan’s folding paper in half (Historical Society of Pomona Valley - the original formula)
• Folding paper in half (Wikipedia - both formulas and the record attempts)
• Moore’s original 1965 paper, “Cramming more components onto integrated circuits” (PDF)
• Rule of 72
• Logistic function and the Verhulst model
• Basic reproduction number R₀ and the herd immunity threshold
• Exponential growth bias
• 3Blue1Brown - Exponential growth and epidemics.

Related

Compound Interest, the 8th Wonder · Why You Cannot Fold Paper Past Seven Times · Some Infinities Are Bigger Than Others · CURRICULUM

Retrieval practice

8 questions. Answer each one before you open it.