11.2 Simulering av tilfeldige forsøk

La datamaskinen kaste terningen

Forestill deg at du vil finne ut hvor sannsynlig det er a sla to seksere med to terninger. Du kan selvfolgelig sette deg ned og beregne det teoretisk -- men du kan ogsa la datamaskinen gjore forsokat for deg. Ikke bare en gang, men hundre tusen ganger.

Denne metoden kalles simulering, og den er et av de kraftigste verktoyene i moderne matematikk og vitenskap. Vaermeldinger, medisinsk forskning, okonomiske prognoser -- alt bruker simulering. Og det beste er at det er overraskende enkelt a komme i gang med Python.

random-modulen -- tilfeldighetens verktoy

For a simulere tilfeldige forsok trenger vi tilfeldige tall. Python har en innebygd modul for dette som heter random:

import random

# Simuler et terningkast
terning = random.randint(1, 6)
print(f"Du slo {terning}")

random.randint(1, 6) gir et tilfeldig heltall mellom 1 og 6 -- akkurat som en ekte terning. Hver gang du kjorer programmet, far du (sannsynligvis) et annet tall.

Na kan vi simulere mange kast og telle hvor ofte en bestemt hendelse inntreffer:

import random

antall_kast = 10000
antall_seksere = 0

for i in range(antall_kast):
    kast = random.randint(1, 6)
    if kast == 6:
        antall_seksere += 1

simulert = antall_seksere / antall_kast
print(f"Simulert P(sekser) = {simulert:.4f}")
print(f"Teoretisk P(sekser) = {1/6:.4f}")

Den simulerte sannsynligheten er antall gunstige utfall delt pa totalt antall forsok:

$$P(A) \approx \frac{k}{n}$$

Med 10 000 kast far vi typisk noe naert $\displaystyle \frac{1}{6} \approx 0{,}1667$, men ikke eksakt likt. Og det er helt normalt -- simulering gir et estimat, ikke et eksakt svar.

Store talls lov -- jo flere, jo bedre

Her er et viktig poeng: med bare 10 kast kan du fa helt ville resultater. Kanskje 0 seksere, kanskje 4. Men med 100 000 kast vil den simulerte sannsynligheten nesten alltid ligge veldig naert den teoretiske.

Dette kalles store talls lov: nar du gjentar et tilfeldig forsok mange nok ganger, vil den relative frekvensen nærme seg den teoretiske sannsynligheten.

$$\frac{k}{n} \to P(A) \quad \text{nar } n \to \infty$$

Vi kan demonstrere dette med myntkast:

import random

for antall_kast in [10, 100, 1000, 10000, 100000]:
    mynt = 0
    for i in range(antall_kast):
        if random.randint(0, 1) == 1:
            mynt += 1
    print(f"n = {antall_kast:>7}: P(mynt) = {mynt/antall_kast:.4f}")

Typisk resultat:

n =      10: P(mynt) = 0.6000
n =     100: P(mynt) = 0.4700
n =    1000: P(mynt) = 0.5130
n =   10000: P(mynt) = 0.4987
n =  100000: P(mynt) = 0.5003

Med 10 kast svinger det mye. Med 100 000 kast er vi nesten noyaktig pa 0,5. Store talls lov i aksjon!

Sammensatte forsok -- nar det blir spennende

Simulering er spesielt nyttig for sammensatte forsok der det er vanskelig a beregne sannsynligheten teoretisk. La oss se pa et klassisk eksempel: summen av to terninger.

import random

antall_forsok = 100000
antall_sju = 0

for i in range(antall_forsok):
    terning1 = random.randint(1, 6)
    terning2 = random.randint(1, 6)
    if terning1 + terning2 == 7:
        antall_sju += 1

print(f"P(sum = 7) = {antall_sju/antall_forsok:.4f}")

Resultatet blir omtrent $0{,}1667$, som stemmer med den teoretiske verdien $\displaystyle \frac{6}{36} = \frac{1}{6}$. Det finnes nemlig 6 kombinasjoner som gir summen 7: $(1,6), (2,5), (3,4), (4,3), (5,2), (6,1)$, av totalt $36$ mulige utfall.

Men hva med virkelig kompliserte problemer? Ta bursdagsparadokset: I en klasse med 23 elever, hva er sannsynligheten for at minst to deler bursdag? Svaret er over 50 % -- noe de fleste finner helt utrolig. Med simulering kan vi verifisere dette:

import random

treff = 0
for i in range(100000):
    bursdager = [random.randint(1, 365) for _ in range(23)]
    if len(bursdager) != len(set(bursdager)):
        treff += 1

print(f"P(felles bursdag) = {treff/100000:.4f}")

Resultatet? Omtrent $0{,}507$ -- altså rett over 50 %. Simuleringen bekrefter det overraskende teoretiske svaret!

Oppsummering

Vi har utforsket hvordan Python kan brukes til a simulere tilfeldige forsok:

- random-modulen gir oss tilfeldige tall (random.randint(a, b))
- En simulering gjentar et forsok mange ganger og estimerer sannsynligheter
- Simulert sannsynlighet $\displaystyle \approx \frac{\text{gunstige utfall}}{\text{totalt antall forsok}}$
- Store talls lov garanterer at estimatet blir bedre jo flere forsok vi gjor
- Sammensatte forsok (to terninger, kuletrekking, bursdagsparadokset) er enkle a simulere men kan være vanskelige a beregne teoretisk

Simulering er et uunnværlig verktoy i moderne vitenskap. Vaermeldinger, medisinsk forskning og finansanalyse -- alt bruker simulering for a handtere usikkerhet. Du har na verktoyene til a gjore det samme!