Lesson 14: Why Flipping a Coin 1000 Times Reveals the Truth

Part 1

Randomness Has a Secret

Flip a coin. You can't predict whether it'll be heads or tails. It's random. Totally unpredictable.

Now flip it 10 times. You might get 7 heads and 3 tails. That doesn't seem like 50/50 at all. Random, right?

But flip it 1,000 times. Something strange happens: you'll get very close to 500 heads and 500 tails. Flip it 10,000 times? Even closer to exactly 50/50.

The more you repeat a random process, the closer the results get to the "true" probability. This is one of the most important ideas in all of mathematics. It's called the Law of Large Numbers, and it's why casinos always win in the long run, why polls can predict elections, and why insurance companies stay in business.

Today, we're going to see it happen with our own eyes — by making Python flip coins thousands of times.

Part 2

A Few Flips: Chaos

Let's start small. Flip a coin 10 times and see what happens:

import random

flips = 10
heads = 0

results = []
for i in range(flips):
    coin = random.choice(["H", "T"])
    results.append(coin)
    if coin == "H":
        heads = heads + 1

tails = flips - heads
pct = int(heads / flips * 100)

print(f"Flipped {flips} times: {' '.join(results)}")
print(f"Heads: {heads} ({pct}%)")
print(f"Tails: {tails} ({100 - pct}%)")
print()
print("Is it close to 50/50? Run it again and see!")

Run it 5 or 6 times. Sometimes you'll get 70% heads. Sometimes 30%. Sometimes exactly 50%. With only 10 flips, anything can happen. The results are all over the place.

This is what randomness looks like in small doses: unpredictable, messy, unreliable.

Part 3

A Thousand Flips: Order From Chaos

Now let's go big. Same coin, same randomness — but way more flips:

import random

# Try different numbers: 10, 100, 1000, 10000
flips = 1000

heads = 0
for i in range(flips):
    if random.choice(["H", "T"]) == "H":
        heads = heads + 1

tails = flips - heads
pct_heads = heads / flips * 100

print(f"COIN FLIP EXPERIMENT: {flips} flips")
print("═" * 35)
print(f"  Heads: {heads:5d} ({pct_heads:.1f}%)")
print(f"  Tails: {tails:5d} ({100 - pct_heads:.1f}%)")
print()

# How far from 50%?
distance = abs(pct_heads - 50)
print(f"  Distance from 50%: {distance:.1f}%")
print()

if distance < 2:
    print("  🎯 Very close to the true 50/50!")
elif distance < 5:
    print("  👍 Pretty close!")
else:
    print("  🤔 A bit off — try more flips!")

New Things

{pct_heads:.1f} inside an f-string formats the number to 1 decimal place. So 49.7283 becomes 49.7.

{heads:5d} pads the number to 5 characters wide, right-aligned. Makes columns line up.

abs() gives the absolute value — the distance from zero. abs(-3.2) is 3.2. We use it to measure how far from 50% we are, regardless of direction.

Now try changing flips to 10, then 100, then 1000, then 10000. Watch the distance from 50% shrink as you add more flips. That's the Law of Large Numbers in action.

Part 4

Watching It Converge

Let's track the percentage after every batch of flips and watch it settle toward 50%:

import random

total_flips = 0
total_heads = 0

checkpoints = [10, 25, 50, 100, 250, 500, 1000, 2500, 5000]

print("CONVERGENCE TRACKER")
print("Watching heads% approach 50% as flips increase")
print("═" * 50)
print(f"{'Flips':>8s}  {'Heads%':>7s}  {'Distance':>8s}  Chart")
print("─" * 50)

for target in checkpoints:
    # Flip until we reach this checkpoint
    while total_flips < target:
        if random.choice(["H", "T"]) == "H":
            total_heads = total_heads + 1
        total_flips = total_flips + 1
    
    pct = total_heads / total_flips * 100
    dist = abs(pct - 50)
    
    # Visual: show where the percentage falls
    # 0% on the left, 50% in the middle, 100% on the right
    pos = int(pct / 100 * 30)
    chart = "·" * pos + "●" + "·" * (30 - pos)
    mid = "·" * 15 + "|" + "·" * 14
    
    print(f"{total_flips:>8d}  {pct:>6.1f}%  {dist:>7.1f}%  {chart}")

print("─" * 50)
print(f"{'':>8s}  {'':>7s}  {'':>8s}  0%{' ' * 12}50%{' ' * 11}100%")
print()
print("Notice how the ● gets closer to the | (50%) as flips increase!")

Run it several times. With 10 flips, the dot bounces all over. With 5000 flips, it's always right near the center line. More repetition = more truth.

Part 5

Drawing the Convergence

Let's build an actual chart that shows the heads percentage over time. This is like a graph turned sideways:

import random

heads = 0
total = 0

print("HEADS % OVER TIME")
print("Each row = 50 more flips")
print()
print("      0%        25%        50%        75%      100%")
print("      |·········|·········|·········|·········|")

# Flip in batches of 50, chart after each batch
for batch in range(20):
    # Flip 50 coins
    for i in range(50):
        if random.choice(["H", "T"]) == "H":
            heads = heads + 1
        total = total + 1
    
    pct = heads / total * 100
    
    # Build the chart row
    # The chart is 40 characters wide, representing 0-100%
    pos = int(pct / 100 * 40)
    
    # Draw the 50% marker and the current position
    row = ""
    for col in range(41):
        if col == pos:
            row = row + "●"
        elif col == 20:
            row = row + "│"
        else:
            row = row + " "
    
    label = f"{total:>5d}"
    print(f"{label} {row} {pct:.1f}%")

print()
print("      |·········|·········|·········|·········|")
print("      0%        25%        50%        75%      100%")
print()
print("The ● should settle near the │ (50%) line!")
print("Top rows (few flips) = wild. Bottom rows = stable.")

The top of the chart (fewer total flips) shows the dot jumping around. The bottom (more flips) shows it hugging the 50% line. That visual IS the Law of Large Numbers.

Part 6

Beyond Coins: Dice

The Law of Large Numbers works for any random process, not just coins. Let's try dice — each face should show up about 1/6 of the time (16.67%):

import random

rolls = int(input("How many dice rolls? (try 100, then 10000) "))

# Count each face
counts = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0}

for i in range(rolls):
    face = random.randint(1, 6)
    counts[face] = counts[face] + 1

# Display results
expected = 100 / 6  # 16.67%

print()
print(f"DICE EXPERIMENT: {rolls} rolls")
print(f"Expected each face: {expected:.1f}%")
print("═" * 40)

for face in range(1, 7):
    count = counts[face]
    pct = count / rolls * 100
    dist = abs(pct - expected)
    
    # Bar chart
    bar_len = int(pct / 100 * 40)
    bar = "█" * bar_len
    
    # Color code: close to expected = good
    marker = "✓" if dist < 2 else "~" if dist < 5 else "✗"
    
    print(f"  Face {face}: {bar} {pct:.1f}% ({count}) {marker}")

print("═" * 40)
print("  ✓ = within 2% of expected")
print("  ~ = within 5%")
print("  ✗ = more than 5% off")
print()
if rolls >= 1000:
    print("  With enough rolls, everything converges!")
else:
    print("  Try more rolls to see convergence!")

Try 100 rolls — the faces will be uneven. Try 10000 — they'll all be close to 16.7%. The die isn't changing. The randomness isn't changing. But the larger sample reveals the truth that was there all along.

Part 7

Discovering a Cheat

Here's where it gets really interesting. What if the coin isn't fair? What if someone rigged it to land on heads 60% of the time? Could you detect that?

import random

# SECRET: This coin is rigged!
# It lands heads 60% of the time, not 50%
def flip_rigged_coin():
    if random.randint(1, 100) <= 60:
        return "H"
    else:
        return "T"

# Run the experiment at different sample sizes
print("DETECTIVE CHALLENGE: Is this coin fair?")
print("═" * 45)
print()

for num_flips in [10, 50, 100, 500, 2000, 10000]:
    heads = 0
    for i in range(num_flips):
        if flip_rigged_coin() == "H":
            heads = heads + 1
    
    pct = heads / num_flips * 100
    dist_from_50 = abs(pct - 50)
    
    # Verdict
    if dist_from_50 < 5:
        verdict = "Looks fair 🤷"
    elif dist_from_50 < 8:
        verdict = "Suspicious... 🤔"
    else:
        verdict = "RIGGED! 🚨"
    
    bar_pos = int(pct / 100 * 20)
    bar = " " * bar_pos + "●" + " " * (20 - bar_pos)
    
    print(f"  {num_flips:>6d} flips: {pct:5.1f}% heads  [{bar}]  {verdict}")

print()
print("─" * 45)
print("With few flips, you can't tell.")
print("With many flips, the truth becomes OBVIOUS.")
print("The coin is biased toward heads (60%)!")
print()
print("This is how casinos, scientists, and")
print("detectives discover hidden truths.")

The Power of Large Samples

With 10 flips, a rigged coin looks normal — you can't tell it from a fair one.

With 100 flips, it starts to look suspicious.

With 10,000 flips, the bias is unmistakable — it's clearly landing on heads way more than 50%.

More data = more truth. This is why scientists run experiments hundreds of times, why polls survey thousands of people, and why "I tried it once and it didn't work" isn't a reliable conclusion.

Part 8

Simulation: The Birthday Surprise

Here's a famous puzzle: in a class of 23 students, what's the probability that two students share a birthday? Most people guess around 5-10%. The real answer? Over 50%.

That sounds wrong. Let's use simulation to check:

import random

def has_shared_birthday(num_people):
    """Simulate a room of people and check for shared birthdays."""
    birthdays = []
    for i in range(num_people):
        birthday = random.randint(1, 365)
        if birthday in birthdays:
            return True
        birthdays.append(birthday)
    return False

# Run the simulation many times
num_people = 23
experiments = 5000

matches = 0
for i in range(experiments):
    if has_shared_birthday(num_people):
        matches = matches + 1

probability = matches / experiments * 100

print(f"THE BIRTHDAY PROBLEM")
print(f"═" * 35)
print(f"  People in the room: {num_people}")
print(f"  Simulations run:    {experiments}")
print(f"  Shared birthday:    {matches} times")
print(f"  Probability:        {probability:.1f}%")
print()

bar = "█" * int(probability / 5) + "░" * (20 - int(probability / 5))
print(f"  [{bar}] {probability:.1f}%")
print()

if probability > 45:
    print("  😲 More than 50%! Most people find this")
    print("     hard to believe, but the math (and the")
    print("     simulation) don't lie.")
    print()
    print("  With only 23 people, there's a BETTER")
    print("  than even chance two share a birthday!")

We couldn't easily calculate this probability with basic math. But we can simulate it thousands of times and observe the answer. This is the power of combining programming with the Law of Large Numbers — you can discover truths that are hard to figure out any other way.

Part 9

The Probability Lab

Time to put everything together. This is an interactive lab that lets you choose any experiment from this lesson and run it yourself. Pick an experiment, enter a number, and watch the Law of Large Numbers do its work.

Try each one — start with a small number, then go bigger. Notice how the results get more predictable every time you increase the sample size.

import random

def header(text, char="═", width=45):
    print(char * width)
    print(f"  {text}")
    print(char * width)

def bar(pct, width=20):
    fill = int(pct / 100 * width)
    if fill > width: fill = width
    if fill < 0: fill = 0
    return "█" * fill + "░" * (width - fill)

header("🔬 THE PROBABILITY LAB")
print()
print("Choose an experiment:")
print("  1 — Coin flip (is it fair?)")
print("  2 — Dice roll (equal faces?)")
print("  3 — Birthday problem")
print("  4 — Custom probability")
print()
choice = input("Your choice (1-4): ")

if choice == "1":
    flips = int(input("How many flips? "))
    heads = sum(1 for _ in range(flips) if random.choice(["H", "T"]) == "H")
    pct = heads / flips * 100
    
    print()
    header(f"COIN FLIP: {flips} flips")
    print()
    print(f"  Heads: {bar(pct)} {pct:.1f}% ({heads})")
    print(f"  Tails: {bar(100-pct)} {100-pct:.1f}% ({flips-heads})")
    print()
    
    # Convergence chart
    print("  CONVERGENCE:")
    h = 0
    for batch in range(min(20, flips // 10)):
        for _ in range(flips // 20):
            if random.choice(["H","T"]) == "H":
                h += 1
        t = (batch + 1) * (flips // 20)
        p = h / t * 100
        pos = int(p / 100 * 30)
        row = " " * pos + "●" + " " * (30 - pos)
        print(f"  {t:>6d} |{row}|")
    print(f"         0%{' ' * 11}50%{' ' * 11}100%")

elif choice == "2":
    rolls = int(input("How many rolls? "))
    counts = {i: 0 for i in range(1, 7)}
    for _ in range(rolls):
        counts[random.randint(1, 6)] += 1
    
    print()
    header(f"DICE ROLL: {rolls} rolls")
    print(f"  Expected: {100/6:.1f}% per face")
    print()
    for face, count in counts.items():
        pct = count / rolls * 100
        print(f"  Face {face}: {bar(pct, 15)} {pct:.1f}%")

elif choice == "3":
    people = int(input("People in room (try 23): "))
    sims = 5000
    matches = sum(1 for _ in range(sims) if has_birthday_match(people))
    prob = matches / sims * 100
    
    print()
    header(f"BIRTHDAY PROBLEM: {people} people")
    print(f"  Simulations: {sims}")
    print(f"  Matches:     {matches}")
    print(f"  Probability: {bar(prob)} {prob:.1f}%")

elif choice == "4":
    prob = int(input("True probability % (e.g. 30 for 30%): "))
    trials = int(input("How many trials? "))
    
    successes = sum(1 for _ in range(trials) if random.randint(1, 100) <= prob)
    observed = successes / trials * 100
    
    print()
    header(f"CUSTOM: {prob}% true, {trials} trials")
    print(f"  Expected: {prob}%")
    print(f"  Observed: {observed:.1f}%")
    print(f"  Distance: {abs(observed - prob):.1f}%")
    print(f"  {bar(observed)} observed")
    print(f"  {bar(prob)} expected")

print()
header("More trials = closer to the truth!", char="─")

Note: option 3 requires the birthday function from Part 8. If you want it to work standalone, you can copy the has_shared_birthday function to the top of this code cell and rename it has_birthday_match.

Part 10

Why This Matters in Real Life

The Law of Large Numbers isn't just a math trick. It's one of the most important ideas for understanding the world:

Real-World Applications

Medicine: A drug is tested on thousands of patients — not just one — because small samples are unreliable.

Polls: Asking 1,000 people predicts an election better than asking 10 friends.

Insurance: Companies can't predict when ONE person will get sick, but they can predict what percentage of a million people will.

Games: One hand of poker is luck. A thousand hands reveal who's actually skilled.

Science: A single experiment proves nothing. Repeated experiments reveal the truth.

And the flip side is equally important: small samples are misleading. "I tried that diet for a week and it didn't work" is like flipping a coin 5 times and concluding it's biased. You need more data.

Part 11

What You Just Did

You used Python to simulate thousands of random experiments and watched something remarkable: chaos became order. Individual coin flips are unpredictable, but thousands of coin flips are almost perfectly predictable.

You also learned to use simulation as a tool for discovery — when you can't calculate an answer with math (like the birthday problem), you can run the experiment 10,000 times and observe the answer.

The Big Idea

Never draw big conclusions from small samples. One trial, one test, one experience doesn't tell you the truth. But repeat it enough times, and the truth emerges. The more data you have, the clearer reality becomes. That's the Law of Large Numbers — and it applies to everything from coin flips to life decisions.

Thinking Questions

If you flip a coin 10 times and get 8 heads, does that prove the coin is unfair? What about 100 flips with 80 heads? Where do you draw the line?
Why do casinos always win in the long run, even though individual players sometimes win?
Can you think of a time someone drew a big conclusion from a small sample? ("I tried X once and it didn't work, so X is bad.")

Challenges

Level Up

Challenge 1 · Monty Hall Problem

There are 3 doors. Behind one is a prize. You pick a door. The host opens a different door (one without the prize). Should you switch? Simulate 10,000 games — one where you always switch, one where you always stay. Compare win rates. The answer surprises everyone.

Challenge 2 · Dice Unfairness Detector

Create a rigged die that favors the number 6 (30% instead of 16.7%). Then build a detector that rolls the die N times and reports whether it seems fair. How many rolls does it take to reliably detect the cheat?

Challenge 3 · Convergence Racer

Run 5 separate coin flip experiments simultaneously. Track each one's heads percentage at checkpoints (100, 500, 1000, 5000 flips). Display all 5 converging toward 50%. It's like watching 5 runners all finish at the same place!

Summary

What You Learned

Thinking Skill

Statistical Thinking — understanding that random events become predictable over many repetitions. Small samples are unreliable; large samples reveal truth. Ask: "Is this based on enough data to be meaningful?"

Key Concept

The Law of Large Numbers: The more times you repeat a random experiment, the closer the observed results get to the true underlying probability. 10 flips = chaos. 10,000 flips = truth.

Python Concepts

Simulation — using loops + randomness to run experiments thousands of times

random.randint(a, b) — random integer between a and b

abs() — absolute value (distance from zero)

f"{value:.1f}" — format to 1 decimal place

f"{value:>5d}" — right-align in 5 characters

ASCII charts — using position calculations to draw data visually