What a Simulation Is

A simulation is a program that imitates a real-world process so you can study it on a computer instead of in the real world. It is a kind of abstraction: it keeps the details that matter for the question you are asking and leaves out everything else. A flight simulator does not recreate every molecule of air; it keeps just enough physics to practice flying. Because a simulation is built on assumptions and hypotheses about how the real thing behaves, it is a simplified stand-in, not a perfect copy.

Many simulations include randomness, because the real process being modeled has chance in it: a coin flip, a dice roll, whether it rains, which customer arrives next. The simulation uses a random number generator to mimic that uncertainty, and it uses a loop to run the scenario many times so it can see the range of things that could happen.

import random
random.seed(1)
heads = 0
for i in range(100):
    if random.randint(0, 1) == 1:
        heads = heads + 1
print(heads)

heads <- 0
REPEAT 100 TIMES
{
    flip <- RANDOM(0, 1)
    IF (flip = 1)
    {
        heads <- heads + 1
    }
}
DISPLAY(heads)

The code above models flipping a coin 100 times and counts the heads. The random.seed(1) line fixes the random sequence so the run is reproducible: everyone who runs it gets the same tally. Notice the AP pseudocode on the right expresses the same idea with RANDOM(0, 1) and REPEAT 100 TIMES. The two are just different spellings of one simulation.

wins = 3
games = 4
print(wins * 100 // games)

Why We Simulate

If you can flip a real coin, why write a program to flip a fake one? Because for most interesting questions the real experiment is expensive, slow, dangerous, or impossible to repeat. A simulation removes those obstacles:

• Cheaper and safer: crash-test a bridge design or a rocket engine on a computer before spending money or risking harm.
• Faster: a program can play out a hundred years of climate or a million dice games in seconds.
• Repeatable and adjustable: you can run the exact same scenario again, or change one parameter (the rain chance, the number of trials) and immediately see the effect.
• Observable: you can model things that are hard to watch directly, like the spread of a disease or the motion of galaxies.

import random
random.seed(2)
sixes = 0
trials = 600
for i in range(trials):
    if random.randint(1, 6) == 6:
        sixes = sixes + 1
print(sixes * 100 // trials)

sixes <- 0
trials <- 600
REPEAT trials TIMES
{
    roll <- RANDOM(1, 6)
    IF (roll = 6)
    {
        sixes <- sixes + 1
    }
}
DISPLAY(sixes * 100 / trials)

Here the loop runs 600 trials of rolling a die and counts how often a 6 appears, then reports that count as a percent of the trials. That percent is an estimate of the true probability of rolling a 6. This is the core pattern of a probability simulation: run many trials, tally an outcome, report the fraction.

Randomness, Seeds, and Reproducibility

Randomness is what makes a simulation feel like the real, unpredictable world, and it is also why two runs can give slightly different answers. To make a run reproducible for testing or grading, you set a seed. Seeding fixes the random sequence, so the same seed always produces the same outcomes. That is useful, but the seed has to be set in the right place.

# BUG: seed is inside the loop
for i in range(4):
    random.seed(1)
    print(random.randint(1, 6))

# FIX: seed once, before the loop
random.seed(1)
REPEAT 4 TIMES
{
    DISPLAY(RANDOM(1, 6))
}

On the left the seed is placed inside the loop, so every iteration resets the generator to the same starting point and every roll comes out identical. That is not a simulation of four different rolls, it is the same roll printed four times. The fix on the right seeds once, before the loop, so the four rolls vary as intended while the whole run stays reproducible.

import random
random.seed(1)
c = 0
for i in range(5):
    if random.randint(1, 6) == 6:
        c = c + 1
print(c)

Limitations: A Model Is Only as Good as Its Assumptions

A simulation is powerful precisely because it simplifies, and that simplification is also its weakness. Every simulation leaves things out, and its results are only as trustworthy as the assumptions built into it. If the model assumes a fair coin but the real coin is weighted, the simulation will confidently produce wrong conclusions. The output is an approximation of reality that depends entirely on the quality of the model.

The parameterized weather model below assumes a fixed 40 percent chance of rain every single day, independent of the day before. Real weather does not work that way, so this simulation is a rough abstraction. It is still useful for exploring "what if the chance were higher," but its numbers should never be mistaken for a real forecast.

import random
random.seed(4)
rainy = 0
chance = 40
for day in range(30):
    if random.randint(1, 100) <= chance:
        rainy = rainy + 1
print(rainy)

rainy <- 0
chance <- 40
REPEAT 30 TIMES
{
    IF (RANDOM(1, 100) <= chance)
    {
        rainy <- rainy + 1
    }
}
DISPLAY(rainy)

When you evaluate a simulation, ask two questions: are the assumptions reasonable for the question being asked, and were enough trials run to make the estimate stable? A well-built simulation with sound assumptions and many trials gives a useful approximation. A simulation with bad assumptions gives precise-looking numbers that are simply wrong.

heads = 120
total = 200
print(heads * 100 // total)

Key Vocabulary