9.1-dars: Ehtimollik tili

9-QISM — EHTIMOLLIK · 1-dars

1. Kirish va motivatsiya

4.11-darsda ehtimollik bilan qisqacha tanishdik: 0 dan 1 gacha son, VA/YOKI qoidalari, Bayes g'oyasi. Bu qismda uni chuqur o'rganamiz, chunki Machine Learning — aslida ehtimollik tilida gapiradi: klassifikator "bu rasm mushuk" demaydi, "mushuk bo'lish ehtimoli 0.93" deydi; spam filtri — Bayes teoremasi; regressiya xatosi — normal taqsimot; A/B test — binomial taqsimot. Ehtimollikni bilmasdan ML modelini ishlatish mumkin, lekin tushunish va to'g'ri talqin qilish mumkin emas.

Bu dars — qismning poydevori: tajriba, natijalar fazosi, hodisa, ehtimollik aksiomalari (uchta oddiy qoida — qolgan hamma narsa ulardan kelib chiqadi), to'ldiruvchi hodisa ("kamida bitta" masalalarining siri), umumiy qo'shish qoidasi (kesishuvchi hodisalar) va Monte Carlo simulyatsiya — formulani kompyuterda tekshirish usuli.

Real vaziyat. Onlayn do'kon tahlilchisi so'raydi: "Saytga kirgan 5 ta mijozdan kamida bittasi xarid qilish ehtimoli qancha, agar har biri 12% ehtimol bilan xarid qilsa?". Birinchi fikr: 5 × 0.12 = 0.60. Noto'g'ri! (10 mijoz bo'lsa 1.2 — ehtimol 1 dan katta bo'la olmaydi.) To'g'ri yo'l — to'ldiruvchi: "hech kim xarid qilmaydi" ehtimoli 0.88^5 ≈ 0.53, demak "kamida bittasi" = 1 - 0.53 ≈ 0.47. Tahlilchi javobni 100 000 martalik simulyatsiya bilan tekshiradi — 0.47 chiqadi. Ehtimollik tili — shunday xatolardan saqlaydi.

Bu darsda ehtimollikning asosiy tilini o'rganamiz.

Bu darsda:

• Tajriba, natijalar fazosi, hodisa
• Ehtimollik aksiomalari
• To'ldiruvchi hodisa ("kamida bitta")
• Umumiy qo'shish qoidasi
• Klassik va chastotali ehtimollik
• Monte Carlo simulyatsiya
• Ehtimollik tuzoqlari
• Amaliy: formulani simulyatsiya bilan tekshirish

ℹ Misollar real numpy bilan (Python 3.14), deterministik (default_rng(seed)).

2. Nazariya — chuqur tushuntirish

2.1. Tajriba, natijalar fazosi, hodisa

TAJRIBA           — natijasi oldindan noma'lum jarayon (zar tashlash)
NATIJALAR FAZOSI  — barcha mumkin natijalar: S = {1, 2, 3, 4, 5, 6}
HODISA            — natijalar to'plami (S ning qismi):
                     A = "juft son"   = {2, 4, 6}
                     B = "4 dan katta" = {5, 6}
AMALLAR:
  A VA B  (kesishma)   = {6}
  A YOKI B (birlashma) = {2, 4, 5, 6}
  A EMAS (to'ldiruvchi) = {1, 3, 5}

Tajriba — natijasi oldindan noma'lum jarayon (tanga, zar, mijoz tashrifi, model bashorati). Natijalar fazosi S — barcha mumkin natijalar to'plami. Hodisa — S ning qismi ("juft son tushdi"). Hodisalar bilan to'plam amallari bajariladi: kesishma (ikkalasi ham), birlashma (kamida bittasi), to'ldiruvchi (hodisa ro'y bermadi). Bu til muhim, chunki murakkab savolni ("5 mijozdan kamida bittasi") aniq hodisaga aylantirish — yechimning yarmi. Python'da hodisalar — set bilan modellanadi.

2.2. Ehtimollik aksiomalari

1. 0 <= P(A) <= 1          — ehtimol manfiy emas va 1 dan oshmaydi
2. P(S) = 1                — biror natija albatta ro'y beradi
3. A va B kesishmasa:       — bir vaqtda ro'y bera olmaydigan hodisalar
   P(A YOKI B) = P(A) + P(B)

Aksiomalar — uchta oddiy qoida (Kolmogorov, 1933); ehtimollik nazariyasining hammasi shulardan kelib chiqadi. Amaliy foydasi — tekshiruv: agar hisobingizda ehtimol 1.2 yoki -0.1 chiqsa, yoki barcha natijalar ehtimollari yig'indisi 1 bo'lmasa — xato bor. ML'da ham xuddi shunday: klassifikatorning predict_proba natijasi har qatorda yig'indisi 1 ga teng (softmax) — bu 2-aksioma.

2.3. To'ldiruvchi hodisa ("kamida bitta")

To'ldiruvchi qoida: P(A emas) = 1 - P(A). Eng kuchli qo'llanilishi — "kamida bitta" savollari: to'g'ridan-to'g'ri hisoblash qiyin (bitta, ikkita, ... hammasi — ko'p holat), lekin teskarisi oddiy — "hech biri". n ta mustaqil urinish, har birida muvaffaqiyat ehtimoli p bo'lsa:

P(kamida bitta) = 1 - P(hech biri) = 1 - (1 - p)^n

Misol: p = 0.12, n = 5 → 1 - 0.88^5 ≈ 0.47. Tuzoq: p × n 0.60-bob — noto'g'ri, chunki "ikki mijoz xarid qildi" holatlari ikki marta sanaladi.

2.4. Umumiy qo'shish qoidasi

Hodisalar kesishsa (bir vaqtda ro'y berishi mumkin), oddiy qo'shish ikki marta sanaydi. Umumiy qoida:

P(A YOKI B) = P(A) + P(B) - P(A VA B)

Zar: A = juft (3/6), B = 4 dan katta (2/6), A VA B = {6} (1/6) → P(A YOKI B) = 3/6 + 2/6 - 1/6 = 4/6. Tekshiruv: {2, 4, 5, 6} — 4 ta natija. Biznesda: "mijoz email ochdi YOKI ilovadan kirdi" — ikkalasini qilganlar bor, ularni bir marta sanash kerak.

2.5. Klassik va chastotali ehtimollik

Ehtimollikni aniqlashning ikki amaliy yo'li: klassik (teng ehtimolli natijalar: qulay / jami — zar 6 tushishi 1/6; faqat simmetrik tajribalarda) va chastotali (ko'p takrorlashdagi nisbiy chastota — 10 000 tashrifdan 1 200 xarid → 0.12; real ma'lumotda deyarli har doim shu). Katta sonlar qonuni: takrorlash ko'paygan sari nisbiy chastota haqiqiy ehtimolga yaqinlashadi — lekin kichik namunada chastota ancha adashishi mumkin (10 tashrifdan 3 xarid — 0.30, bu haqiqiy 0.12 dan uzoq). Uchinchi yo'l — Bayescha (ishonch darajasi) — 9.4-darsda.

2.6. Monte Carlo simulyatsiya

Monte Carlo — ehtimolni tajribani kompyuterda ko'p marta simulyatsiya qilib baholash: (1) bitta tajribani kod bilan yozish (rng.random() < 0.12), (2) N marta takrorlash (vektorlashtirilgan — numpy), (3) hodisa ro'y bergan ulushni hisoblash. Foydasi: formulani tekshirish (hisob to'g'rimi?), formula yo'q masalalar (murakkab jarayonlar — navbat, zaxira, portfel). Aniqlik N ga bog'liq: xato taxminan 1/sqrt(N) — 10 000 simulyatsiya ≈ ±0.01, 1 000 000 ≈ ±0.001. Har doim seed bering — natija takrorlanadigan bo'lsin.

2.7. Ehtimollik tuzoqlari

Asosiy tuzoqlar: "kamida bitta" = p × n (ikki marta sanash; 1 - (1 - p)^n kerak); kesishmani unutish (P(A) + P(B) — faqat kesishmaydigan hodisalar uchun); o'yinchi xatosi (5 marta "gerb" tushdi → endi "raqam" tushishi kerak — yo'q, tanga xotirasiz, har safar 0.5); kichik namuna chastotasi (10 kuzatuvdan ehtimol — ishonchsiz); ehtimollar yig'indisi ≠ 1 (hisob xatosi belgisi); teng ehtimollik farazi (klassik usul faqat simmetrik holatda — "ertaga yomg'ir yog'adi yoki yo'q → 0.5" noto'g'ri); seedsiz simulyatsiya (natija har safar boshqacha).

2.8. Ehtimollik tili — ML'ning poydevori

Ehtimollik tili: tajriba → natijalar fazosi → hodisa (to'plam: kesishma, birlashma, to'ldiruvchi); aksiomalar (0-1, P(S) = 1, kesishmaydiganlar qo'shiladi); to'ldiruvchi ("kamida bitta" = 1 - "hech biri"); umumiy qo'shish (kesishmani ayirish); klassik va chastotali ehtimollik (katta sonlar qonuni); Monte Carlo (simulyatsiya bilan tekshirish). Keyingi darslar shu tilga quriladi: kombinatorika (sanash, 9.2), shartli ehtimollik 9.3-bob, Bayes 9.4-bob, tasodifiy o'zgaruvchi va taqsimotlar (9.5-9.8), ML'da ehtimollik 9.9-bob.

3. Tez ma'lumotnoma

import numpy as np

rng = np.random.default_rng(0)          # takrorlanadigan generator

# HODISALAR — set bilan
S = {1, 2, 3, 4, 5, 6}
A = {x for x in S if x % 2 == 0}         # juft
B = {x for x in S if x > 4}
p = lambda h: len(h) / len(S)             # klassik ehtimol
p(A & B), p(A | B), p(S - A)              # kesishma, birlashma, to'ldiruvchi

# UMUMIY QO'SHISH
p(A) + p(B) - p(A & B)                    # = p(A | B)

# "KAMIDA BITTA"
1 - (1 - 0.12) ** 5                       # ≈ 0.47

# MONTE CARLO
x = rng.random((100_000, 5)) < 0.12       # 100k tajriba × 5 mijoz
(x.any(axis=1)).mean()                    # ≈ 0.47
QOIDA: hodisani aniqla · to'ldiruvchini o'yla · kesishmani ayir · simulyatsiya bilan tekshir

Ehtimollik tili xulosasi

Hodisa — natijalar to'plami (kesishma, birlashma, to'ldiruvchi)
Aksiomalar — 0 <= P <= 1, P(S) = 1, kesishmaydiganlar qo'shiladi
Kamida bitta — 1 - (1 - p)^n (p*n emas)
Umumiy qo'shish — P(A) + P(B) - P(A VA B)
Monte Carlo — simulyatsiya; xato ~ 1/sqrt(N); seed bering

4. Batafsil misollar

Misollar real numpy bilan (Python 3.14).

Misol 1 — Hodisalar va klassik ehtimollik

"""Hodisalar set bilan: kesishma, birlashma, to'ldiruvchi (real Python)."""

from fractions import Fraction


def main() -> None:
    S = {1, 2, 3, 4, 5, 6}
    A = {x for x in S if x % 2 == 0}
    B = {x for x in S if x > 4}

    def p(h: set) -> Fraction:
        return Fraction(len(h), len(S))

    print("=== 1. Hodisalar ===")
    print(f"  A (juft) = {sorted(A)}, B (>4) = {sorted(B)}")

    print("\n=== 2. Amallar ===")
    print(f"  A VA B   = {sorted(A & B)}  P = {p(A & B)}")
    print(f"  A YOKI B = {sorted(A | B)}  P = {p(A | B)}")
    print(f"  A EMAS   = {sorted(S - A)}  P = {p(S - A)}")

    print("\n=== 3. Umumiy qo'shish qoidasi ===")
    print(f"  P(A) + P(B) - P(A VA B) = {p(A)} + {p(B)} - {p(A & B)} = {p(A) + p(B) - p(A & B)}")
    print(f"  oddiy qo'shish (xato): {p(A) + p(B)}")

    print("\n=== 4. Aksioma tekshiruvi ===")
    print(f"  barcha natijalar yig'indisi: {sum(p({x}) for x in S)}")
    print("  ⭐ Hodisa — to'plam; kesishmani ayir")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Hodisalar ===
  A (juft) = [2, 4, 6], B (>4) = [5, 6]

=== 2. Amallar ===
  A VA B   = [6]  P = 1/6
  A YOKI B = [2, 4, 5, 6]  P = 2/3
  A EMAS   = [1, 3, 5]  P = 1/2

=== 3. Umumiy qo'shish qoidasi ===
  P(A) + P(B) - P(A VA B) = 1/2 + 1/3 - 1/6 = 2/3
  oddiy qo'shish (xato): 5/6

=== 4. Aksioma tekshiruvi ===
  barcha natijalar yig'indisi: 1
  ⭐ Hodisa — to'plam; kesishmani ayir

Nima ko'rsatdi: 2.1, 2.2, 2.4-bo'limlar.

Misol 2 — "Kamida bitta": formula va simulyatsiya

"""'Kamida bitta' — to'ldiruvchi qoida va Monte Carlo (real numpy)."""

import numpy as np


def main() -> None:
    p, n = 0.12, 5
    rng = np.random.default_rng(0)

    print("=== 1. Xato yondashuv ===")
    print(f"  p * n = {p * n:.2f}  (10 mijozda {p * 10:.2f} — 1 dan katta!)")

    print("\n=== 2. To'ldiruvchi ===")
    hech_biri = (1 - p) ** n
    print(f"  P(hech biri) = 0.88^5 = {hech_biri:.4f}")
    print(f"  P(kamida bitta) = {1 - hech_biri:.4f}")

    print("\n=== 3. Monte Carlo (100 000 tajriba) ===")
    xarid = rng.random((100_000, n)) < p
    print(f"  simulyatsiya: {xarid.any(axis=1).mean():.4f}")

    print("\n=== 4. n oshganda ===")
    for k in [1, 5, 10, 20]:
        print(f"  n={k:>2}: {1 - (1 - p) ** k:.3f}")
    print("  ⭐ Kamida bitta = 1 - (1 - p)^n")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Xato yondashuv ===
  p * n = 0.60  (10 mijozda 1.20 — 1 dan katta!)

=== 2. To'ldiruvchi ===
  P(hech biri) = 0.88^5 = 0.5277
  P(kamida bitta) = 0.4723

=== 3. Monte Carlo (100 000 tajriba) ===
  simulyatsiya: 0.4748

=== 4. n oshganda ===
  n= 1: 0.120
  n= 5: 0.472
  n=10: 0.721
  n=20: 0.922
  ⭐ Kamida bitta = 1 - (1 - p)^n

Nima ko'rsatdi: 2.3, 2.6-bo'limlar.

Misol 3 — Katta sonlar qonuni

"""Katta sonlar qonuni: chastota ehtimolga yaqinlashadi (real numpy)."""

import numpy as np


def main() -> None:
    rng = np.random.default_rng(1)
    haqiqiy = 0.12
    tashrif = rng.random(100_000) < haqiqiy

    print("=== 1. Namuna oshgan sari ===")
    for n in [10, 100, 1_000, 10_000, 100_000]:
        ch = tashrif[:n].mean()
        print(f"  n={n:>6}: chastota {ch:.4f}, xato {abs(ch - haqiqiy):.4f}")

    print("\n=== 2. Kichik namunalar qanchalik adashadi ===")
    kichik = (rng.random((1_000, 10)) < haqiqiy).mean(axis=1)
    print(f"  10 tashrifli 1000 ta namuna: min {kichik.min():.1f}, max {kichik.max():.1f}")
    print(f"  0.3 va undan katta chiqqanlar: {(kichik >= 0.3).mean():.1%}")

    print("\n  ⭐ Kichik namuna chastotasi — ishonchsiz")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Namuna oshgan sari ===
  n=    10: chastota 0.1000, xato 0.0200
  n=   100: chastota 0.1000, xato 0.0200
  n=  1000: chastota 0.1110, xato 0.0090
  n= 10000: chastota 0.1210, xato 0.0010
  n=100000: chastota 0.1198, xato 0.0002

=== 2. Kichik namunalar qanchalik adashadi ===
  10 tashrifli 1000 ta namuna: min 0.0, max 0.5
  0.3 va undan katta chiqqanlar: 10.7%

  ⭐ Kichik namuna chastotasi — ishonchsiz

Nima ko'rsatdi: 2.5, 2.7-bo'limlar.

Misol 4 — Monte Carlo aniqligi va o'yinchi xatosi

"""Monte Carlo aniqligi (1/sqrt(N)) va o'yinchi xatosi (real numpy)."""

import numpy as np


def main() -> None:
    rng = np.random.default_rng(2)

    print("=== 1. Aniqlik N ga bog'liq (P(zar=6) = 0.1667) ===")
    for n in [100, 10_000, 1_000_000]:
        baho = (rng.integers(1, 7, n) == 6).mean()
        print(f"  N={n:>9}: baho {baho:.4f}, ~xato 1/sqrt(N) = {1 / np.sqrt(n):.4f}")

    print("\n=== 2. O'yinchi xatosi: 5 gerbdan keyin ===")
    t = rng.integers(0, 2, 1_000_000)        # 1 = gerb
    keyingi = []
    for i in range(5, len(t)):
        if t[i - 5:i].sum() == 5:
            keyingi.append(t[i])
    keyingi = np.array(keyingi)
    print(f"  5 gerb ketma-ket: {len(keyingi)} marta uchradi")
    print(f"  keyingisi gerb: {keyingi.mean():.3f}  (0.5 atrofida — tanga xotirasiz)")

    print("\n  ⭐ Simulyatsiya — formulani va intuitsiyani tekshiradi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Aniqlik N ga bog'liq (P(zar=6) = 0.1667) ===
  N=      100: baho 0.1700, ~xato 1/sqrt(N) = 0.1000
  N=    10000: baho 0.1696, ~xato 1/sqrt(N) = 0.0100
  N=  1000000: baho 0.1668, ~xato 1/sqrt(N) = 0.0010

=== 2. O'yinchi xatosi: 5 gerbdan keyin ===
  5 gerb ketma-ket: 31461 marta uchradi
  keyingisi gerb: 0.504  (0.5 atrofida — tanga xotirasiz)

  ⭐ Simulyatsiya — formulani va intuitsiyani tekshiradi

Nima ko'rsatdi: 2.6, 2.7-bo'limlar.

5. To'g'ri va noto'g'ri tushunishlar

6. Keng tarqalgan xatolar va yechimlari

1. "Kamida bitta" ni ko'paytirish

p_kamida = 0.12 * 5                                               # ⚠️
p_kamida = 1 - (1 - 0.12) ** 5                                    # ✅

2. Kesishmani unutish

p_birlashma = p(A) + p(B)                                         # ⚠️
p_birlashma = p(A) + p(B) - p(A & B)                              # ✅

3. Seedsiz simulyatsiya

x = np.random.random(1000)                                        # ⚠️
rng = np.random.default_rng(0); x = rng.random(1000)              # ✅

4. Siklda sekin simulyatsiya

natija = [random.random() < p for _ in range(1_000_000)]         # ⚠️
natija = rng.random(1_000_000) < p                                # ✅

5. Kam simulyatsiya

baho = (rng.random(100) < p).mean()   # xato ~0.1                 # ⚠️
baho = (rng.random(1_000_000) < p).mean()   # xato ~0.001         # ✅

6. Float bilan aniq kasr

print(0.1 + 0.2 == 0.3)               # False (float xatosi)       # ⚠️
from fractions import Fraction; print(Fraction(1, 10) + Fraction(2, 10) == Fraction(3, 10))  # ✅

7. Yig'indini tekshirmaslik

ehtimollar = {"A": 0.5, "B": 0.3, "C": 0.3}                       # ⚠️
assert abs(sum(ehtimollar.values()) - 1) < 1e-9                    # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 4.11-dars (o'tilgan): Ehtimollik asoslari
• 2.10-dars (o'tilgan): NumPy tasodifiy sonlar
• 9.2-dars: Kombinatorika (klassik ehtimol uchun sanash)
• 9.3-9.4-darslar: Shartli ehtimollik va Bayes
• ML qismlari: predict_proba, softmax (aksiomalar)

8. Eng yaxshi amaliyotlar

1. Savolni aniq hodisaga aylantiring.

2. "Kamida bitta" — to'ldiruvchi orqali.

3. Kesishmani tekshiring.

4. Ehtimollar yig'indisi = 1 ni tekshiring.

5. Formulani simulyatsiya bilan tekshiring.

6. Simulyatsiyani vektorlashtiring (numpy).

7. Har doim seed bering.

8. Kichik namuna chastotasiga ishonmang.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # natijalar fazosi nima?
2.  # hodisa nima?
3.  # P(S) = ?
4.  # P(A emas) = ?
5.  # kamida bitta (p=0.1, n=3)?
6.  # P(A YOKI B) umumiy formula?
7.  # zar: P(juft YOKI >4)?
8.  # o'yinchi xatosi nima?
9.  # katta sonlar qonuni?
10. # Monte Carlo xatosi N=10000 da?
11. # nega seed?
12. # predict_proba yig'indisi?

Vazifa 2: Xatolarni tuzating

1.  p = 0.05 * 30   # 30 kunda kamida bir marta nosozlik

2.  p = p(A) + p(B)   # A va B kesishadi

3.  x = np.random.random(100)

4.  natija = [random.random() < p for _ in range(10**6)]

5.  print(0.1 + 0.2 == 0.3)   # aniq kasr kerak

1.  p = 1 - (1 - 0.05) ** 30

2.  p = p(A) + p(B) - p(A & B)

3.  rng = np.random.default_rng(0); x = rng.random(100)

4.  natija = rng.random(10**6) < p

5.  print(Fraction(1, 10) + Fraction(2, 10) == Fraction(3, 10))

Vazifa 3: Hodisalar

Modellang:

1. Ikki zar tashlash — natijalar fazosi (36 ta)
2. "Yig'indi 7" hodisasi
3. "Kamida bitta 6" hodisasi (to'ldiruvchi orqali)
4. Simulyatsiya bilan tekshirish

Vazifa 4: Kamida bitta

Modellang:

1. Server kuniga 2% ehtimol bilan to'xtaydi
2. 30 kunda kamida bir marta to'xtash ehtimoli
3. Monte Carlo bilan tekshirish
4. 99% ishonch uchun kunlik ehtimol qancha bo'lishi kerak

Vazifa 5: Monte Carlo

Modellang:

1. Tug'ilgan kun paradoksi (23 kishi)
2. Simulyatsiya (100 000)
3. Formula bilan solishtirish
4. N ga qarab xato

Vazifa 6: Integratsiya

Modellang:

1. NumPy generator (2.10)
2. Ehtimollik asoslari (4.11)
3. Hodisa amallari (set)
4. Vektorlashtirilgan simulyatsiya

Vazifa 7: O'ylash

Tug'ilgan kun paradoksi: 23 kishilik guruhda kamida ikki kishining tug'ilgan kuni bir kunga tushish ehtimoli 50% dan oshadi. Ko'pchilik buni ishonib bo'lmaydigan deb biladi (365 kun bor-ku!). Nima uchun intuitsiya bu yerda adashadi, va bu Data Science'da (masalan, ko'p taqqoslash, hash to'qnashuvlari, "g'ayrioddiy" tasodiflar) qanday ahamiyatga ega?

Nimani mustahkamlaydi: 2.3, 2.6, 2.7-bo'limlar.

Xulosa

Bu darsda ehtimollikning asosiy tilini o'rgandik.

Eng muhim uch fikr:

1. Hodisa va aksiomalar. Tajriba → natijalar fazosi S → hodisa (S ning qismi); hodisalar bilan to'plam amallari (kesishma, birlashma, to'ldiruvchi — Python set). Aksiomalar: ehtimol 0 dan 1 gacha, P(S) = 1, kesishmaydiganlar qo'shiladi — hisobni tekshirish vositasi (predict_proba yig'indisi = 1).

2. To'ldiruvchi va umumiy qo'shish. "Kamida bitta" = 1 - (1 - p)^n (p × n emas — ikki marta sanash). Umumiy qo'shish: P(A YOKI B) = P(A) + P(B) - P(A VA B). Tug'ilgan kun paradoksi — juftliklar kvadratik o'sadi.

3. Chastota va simulyatsiya. Real ma'lumotda ehtimol — chastota; katta sonlar qonuni bo'yicha u haqiqiy ehtimolga yaqinlashadi, lekin kichik namunada adashadi. Monte Carlo — formulani va intuitsiyani tekshiradi (xato ~ 1/sqrt(N), vektorlashtirilgan, seed bilan). O'yinchi xatosi — mustaqil tajribada "navbat" yo'q.

Keyingi darsda kombinatorikani o'rganamiz: klassik ehtimol uchun natijalarni sanash — o'rin almashtirish, kombinatsiya, math.comb, va nega "lotereya yutish" yoki "parolni topish" ehtimoli shunchalik kichik.