Sannolikhet i flera steg

När något händer i flera steg ritar man ett träddiagram.

En påse med 3 röda och 2 blå kulor. Du drar två, utan att lägga tillbaka.

            ┌─ röd 2/4 ──→ RR:  3/5 · 2/4 = 6/20
   röd 3/5 ─┤
            └─ blå 2/4 ──→ RB:  3/5 · 2/4 = 6/20
start ──┤
            ┌─ röd 3/4 ──→ BR:  2/5 · 3/4 = 6/20
   blå 2/5 ─┤
            └─ blå 1/4 ──→ BB:  2/5 · 1/4 = 2/20

Två regler, och de är allt du behöver:

Regel	När
Multiplicera längs en gren	händelserna sker efter varandra («och»)
Addera mellan grenar	flera olika vägar ger samma sak («eller»)

Kontroll: alla slutresultat ska summera till 1. Här: 6/20 + 6/20 + 6/20 + 2/20 = 20/20 = 1. ✓

Den kontrollen tar fem sekunder och fångar nästan alla räknefel.

Med eller utan återläggning är den avgörande skillnaden:

	Med återläggning	Utan återläggning
Nämnaren	oförändrad varje gång	minskar med 1
Händelserna är	oberoende	beroende
Exempel	tärningskast, myntkast	dra kulor, dela ut kort

I exemplet ovan ändrades nämnaren från 5 till 4 — det är vad «utan återläggning» betyder i praktiken.

Betingad sannolikhet skrivs $P(B \mid A)$ och betyder «sannolikheten för B, givet att A redan hänt». Multiplikationsregeln blir då:

$P(A \text{ och } B) = P(A) \cdot P(B \mid A)$

Är händelserna oberoende är $P(B\mid A) = P(B)$, och regeln förenklas till en vanlig produkt.

Komplementregeln sparar mycket arbete:

$P(\text{minst en}) = 1 - P(\text{ingen})$

Exempel: du kastar tre tärningar. Sannolikheten för minst en sexa?

Att räkna direkt kräver att man summerar «exakt en», «exakt två» och «exakt tre». Att räkna på motsatsen kräver ett steg:

$1 - \left(\frac{5}{6}\right)^3 = 1 - \frac{125}{216} = \frac{91}{216} \approx 0{,}42$

Regeln att komma ihåg: när frågan innehåller «minst en» — räkna på «ingen» och dra från 1.

Den vanligaste felkällan är att glömma att nämnaren ändras utan återläggning. Den näst vanligaste är att addera när man skulle multiplicera. Träddiagrammet skyddar mot båda, eftersom man ser stegen framför sig.

from fractions import Fraction as F
import random

# Utan återläggning: nämnaren minskar
rod, bla = 3, 2
vagar = {
    "RR": F(rod, 5) * F(rod - 1, 4),
    "RB": F(rod, 5) * F(bla, 4),
    "BR": F(bla, 5) * F(rod, 4),
    "BB": F(bla, 5) * F(bla - 1, 4),
}
for namn, p in vagar.items():
    print(f"  {namn}: {p} = {float(p):.3f}")
print("summa:", sum(vagar.values()))          # 1  ← kontrollen

print("minst en röd:", 1 - vagar["BB"], "=", float(1 - vagar["BB"]))   # 9/10 = 0.9
print("exakt en röd:", vagar["RB"] + vagar["BR"])                      # 3/5

# Med återläggning: nämnaren oförändrad
med = {"RR": F(3, 5) ** 2, "RB": F(3, 5) * F(2, 5),
       "BR": F(2, 5) * F(3, 5), "BB": F(2, 5) ** 2}
print("med återläggning, båda röda:", med["RR"], "mot utan:", vagar["RR"])
# 9/25 = 0.36  mot  3/10 = 0.30

# Komplementregeln: minst en sexa på tre tärningar
print("minst en sexa:", 1 - F(5, 6) ** 3, "=", float(1 - F(5, 6) ** 3))   # 91/216 = 0.421

# Simulera och kontrollera
def simulera(n=200_000, fro=0):
    rng = random.Random(fro)
    traff = 0
    for _ in range(n):
        pase = ["R"] * 3 + ["B"] * 2
        rng.shuffle(pase)
        if pase[0] == "R" and pase[1] == "R":
            traff += 1
    return traff / n

print(f"simulerat: {simulera():.4f}  teoretiskt: {float(vagar['RR']):.4f}")
# simulerat: 0.3001  teoretiskt: 0.3000

Simuleringen längst ner är värd att köra: när ett träddiagram känns osäkert går det alltid att kontrollera genom att låta datorn dra kulor tvåhundratusen gånger.