Seminarul 1. Evenimente, probabilități și numărare. Primii pași în R

Fișă de lucru (fără rezolvări)

Slide-urile seminarului și laboratorului 1
Deschide slide-urile pe tot ecranul În prezentare: ← → navigare, F ecran complet, M meniu, O privire de ansamblu.

Aceasta este fișa de lucru: enunțurile, scheletele de cod R și răspunsurile finale pentru exercițiile marcate „Dacă timpul permite” și „Pentru acasă”. Rezolvările complete vor fi publicate ulterior.

Planul seminarului și laboratorului

Prima ședință are două scopuri. Pe de o parte, exersăm limbajul din Cursul 1: descriem un experiment prin spațiul stărilor, scriem evenimentele cu ajutorul operațiilor cu mulțimi și calculăm probabilități cu regulile de calcul, iar în modelul clasic prin numărare. Pe de altă parte, facem cunoștință cu limbajul R, care ne va însoți tot semestrul: fiecare problemă este rezolvată întâi „cu creionul” și apoi pe calculator, prin enumerarea spațiului stărilor sau prin simulare. Nu presupunem cunoștințe anterioare de R: secțiunea „Primii pași în R” pornește de la zero și introduce exact instrumentele folosite apoi în exerciții. Codul din note poate fi copiat și rulat ca atare; vă recomandăm totuși să îl tastați și să schimbați valorile, pentru a vedea cum se modifică rezultatele.

Obiective. La sfârșitul ședinței studentul trebuie să poată:

  1. exprima evenimente compuse („exact unul”, „cel puțin două”, „niciunul”) prin reuniuni, intersecții și complementare și aplica relațiile lui De Morgan;
  2. folosi regulile de calcul: evenimentul contrar, reuniunea a două evenimente, formula lui Poincaré pentru trei evenimente, marginile date de inegalitățile lui Boole și Bonferroni;
  3. calcula probabilități în modelul clasic prin numărare (regula produsului, extrageri cu și fără revenire, combinări, anagrame);
  4. lucra în R cu vectori, vectori logici și funcții, enumera un spațiu al stărilor cu expand.grid și calcula probabilități cu mean(conditie);
  5. simula un experiment aleator cu sample și replicate și compara frecvența relativă obținută cu probabilitatea teoretică;
  6. rezolva, exact și prin simulare, problema zilelor de naștere și problema potrivirilor.

Structura. Breviar; primii pași în R; evenimente și operații cu evenimente; reguli de calcul și formula lui Poincaré; modelul clasic și numărare; problema potrivirilor prin simulare; exerciții suplimentare; temă. Fiecare exercițiu are o rezolvare matematică (eticheta „Seminar”) și o rezolvare în R (eticheta „Laborator”), publicate ulterior, iar exercițiile sunt legate între ele: modelele și funcțiile R scrise la un exercițiu sunt refolosite la următoarele. Lecturi recomandate: (Blitzstein and Hwang 2019, cap. 1), (Bertsekas and Tsitsiklis 2008, cap. 1), iar pentru simulări în R (Wagaman and Dobrow 2021, cap. 1).

Planul ședinței

De rezolvat la seminar (în această ordine):

  • Secțiunea 2 — primii pași în R: vectori, vectori logici, expand.grid, sample, replicate, funcții proprii (exemplele rezolvate se parcurg la calculator);
  • Exercițiul 1 — evenimente compuse și relațiile lui De Morgan; spațiul stărilor cu expand.grid;
  • Exercițiul 4 (a)–(c), (e) — formula lui Poincaré; evenimentele ca vectori logici cu %%;
  • Exercițiul 6 (a)–(c), (e) — extrageri cu și fără revenire; funcțiile p_cu și p_fara;
  • Exercițiul 9 (a)–(c) — problema zilelor de naștere, exact (p_zile) și prin simulare;
  • Exercițiul 10 (a), (b), (d) — problema potrivirilor prin simulare; funcțiile potriviri și exact_k.

Dacă timpul permite:

  • Exercițiul 3 — reuniunea a două evenimente și marginile probabilității intersecției;
  • Exercițiul 5 — inegalitățile lui Boole și Bonferroni;
  • Exercițiul 7 — parole, coduri PIN și anagrame.

Pentru acasă:

  • Exercițiile 2 (două zaruri pe un spațiu enumerat) și 8 (o mână de cinci cărți);
  • exercițiile suplimentare 11, 12, 13 și 14 (Secțiunea 7);
  • enunțurile din Secțiunea 8.

Rezolvările complete vor fi publicate ulterior; scheletele de cod R se completează în locurile marcate cu ___. Exercițiile marcate „Dacă timpul permite” și „Pentru acasă” au, după enunț, răspunsurile finale, pentru verificare.

1 Breviar

Toate noțiunile și rezultatele de care avem nevoie au fost introduse în Cursul 1; le reamintim pe scurt, cu trimitere la locul în care se găsesc enunțurile complete și demonstrațiile.

Rezultate din Cursul 1 folosite azi

Evenimente. Un eveniment este o submulțime \(A\subseteq\Omega\) a spațiului stărilor (Definiția 3 din Cursul 1). Dicționarul operațiilor: \(A^c\) = „nu se realizează \(A\)”; \(A\cup B\) = „\(A\) sau \(B\)” (cel puțin unul); \(A\cap B\) = „\(A\) și \(B\)”; \(A\setminus B=A\cap B^c\) = „\(A\), dar nu \(B\)”; \(A\,\triangle\,B\) = „exact unul dintre \(A\) și \(B\)”. \(A\) și \(B\) sunt incompatibile dacă \(A\cap B=\emptyset\) (Definiția 5 din Cursul 1).

Relațiile lui De Morgan (Propoziția 4 din Cursul 1): \((A\cup B)^c=A^c\cap B^c\) și \((A\cap B)^c=A^c\cup B^c\); la fel pentru oricâte evenimente.

Reguli de calcul (Propoziția 14 din Cursul 1): \(\PP(A^c)=1-\PP(A)\); dacă \(A\cap B=\emptyset\), atunci \(\PP(A\cup B)=\PP(A)+\PP(B)\); dacă \(A\subseteq B\), atunci \(\PP(A)\le\PP(B)\); \(\PP(A\setminus B)=\PP(A)-\PP(A\cap B)\); \(\PP(A\cup B)=\PP(A)+\PP(B)-\PP(A\cap B)\).

Formula lui Poincaré (Teorema 15 din Cursul 1), pentru trei evenimente: \[ \PP(A\cup B\cup C)=\PP(A)+\PP(B)+\PP(C)-\PP(A\cap B)-\PP(A\cap C)-\PP(B\cap C)+\PP(A\cap B\cap C). \]

Margini (Propozițiile 16 din Cursul 1 și 17 din Cursul 1): \(\PP\big(\bigcup_{i=1}^nA_i\big)\le\sum_{i=1}^n\PP(A_i)\) și \(\PP\big(\bigcap_{i=1}^nA_i\big)\ge\sum_{i=1}^n\PP(A_i)-(n-1)\).

Modelul clasic (Definiția 19 din Cursul 1): dacă \(\Omega\) este finit și rezultatele sunt egal probabile, atunci \(\PP(A)=|A|/|\Omega|\) (cazuri favorabile supra cazuri posibile).

Numărare. Regula produsului (Propoziția 21 din Cursul 1); extrageri de \(k\) elemente din \(n\): cu revenire și cu ordine \(n^k\) (Propoziția 22 din Cursul 1); fără revenire și cu ordine \(A_n^k=n(n-1)\cdots(n-k+1)\), în particular \(n!\) permutări (Propoziția 23 din Cursul 1); fără revenire și fără ordine \(\binom nk=\frac{n!}{k!\,(n-k)!}\) (Propoziția 24 din Cursul 1); șiruri cu \(n_1,\dots,n_k\) elemente identice: \(\frac{n!}{n_1!\cdots n_k!}\) (Propoziția 25 din Cursul 1).

Două probleme clasice. Zile de naștere (Exemplul 16 din Cursul 1): \(\PP(\text{cel puțin o coincidență})=1-\frac{365\cdot364\cdots(365-n+1)}{365^n}\). Potriviri (Exemplul 22 din Cursul 1): \(p_n=\sum_{k=1}^n\frac{(-1)^{k+1}}{k!}\to1-\frac1e\approx0.632\).

Interpretarea frecvenționistă (Secțiunea 4 din Cursul 1): dacă repetăm experimentul de \(N\) ori, iar \(A\) se realizează de \(N(A)\) ori, atunci frecvența relativă \(N(A)/N\) se apropie de \(\PP(A)\) când \(N\) este mare. Pe această idee se bazează orice simulare.

2 Primii pași în R

R este un limbaj de programare și un mediu de lucru gratuit, dedicat calculului statistic și reprezentărilor grafice. Îl vom folosi în fiecare săptămână pentru două lucruri: să calculăm exact (formule, enumerarea tuturor rezultatelor unui experiment) și să simulăm (repetăm experimentul pe calculator de multe ori și numărăm de câte ori s-a realizat evenimentul care ne interesează). Secțiunea aceasta prezintă pe scurt tot ce ne trebuie astăzi; tastați comenzile pe măsură ce le citiți și comparați rezultatele. Mai multe detalii se găsesc în materialul „Introducere în R” de pe pagina cursului, iar pentru o prezentare pe îndelete recomandăm (Davies 2016) și (Verzani 2014).

2.1 Consola și scriptul

Vom lucra în RStudio, un mediu de dezvoltare pentru R. Fereastra RStudio are patru panouri: editorul de scripturi (stânga sus), consola (stânga jos), lista obiectelor create (Environment, dreapta sus) și panoul cu fișiere, grafice și pagini de ajutor (dreapta jos).

  • În consolă scriem o comandă după simbolul > și apăsăm Enter; R o execută și afișează rezultatul. Consola este potrivită pentru încercări rapide.
  • Într-un script (un fișier text cu extensia .R, creat din meniul File → New File → R Script) păstrăm comenzile pe care vrem să le refolosim. Linia pe care se află cursorul, sau liniile selectate, se trimit în consolă cu Ctrl + Enter (Cmd + Enter pe macOS). Lucrați întotdeauna într-un script: la sfârșitul ședinței aveți rezolvările salvate.
  • Tot ce urmează pe o linie după simbolul # este un comentariu, ignorat de R.
  • Pagina de ajutor a unei funcții se deschide cu ?nume, de exemplu ?sample.

În aceste note codul apare în casete „Cod R”, iar rezultatele afișate de R sunt precedate de #>.

2.2 R ca un calculator. Obiecte

Cel mai simplu mod de a folosi R este ca un calculator de buzunar.

2 + 3 * 4            # operațiile au prioritatea obișnuită
2^10                 # ridicare la putere
17 %/% 5             # câtul împărțirii întregi
17 %% 5              # restul împărțirii întregi
sqrt(2) * exp(1)     # funcții matematice: sqrt, exp, log, abs, ...
n <- 23              # atribuire: obiectul n primește valoarea 23
zile <- 365
n / zile             # obiectele se folosesc în calcule
nume <- "Ana"        # un șir de caractere
adevarat <- 5 > 3    # o valoare logică: TRUE sau FALSE
adevarat
#> [1] 14
#> [1] 1024
#> [1] 3
#> [1] 2
#> [1] 3.844
#> [1] 0.06301
#> [1] TRUE

Numărul [1] din fața fiecărui rezultat arată poziția primei valori afișate pe linia respectivă (aici fiecare rezultat este un vector cu un singur element). Un rezultat se păstrează într-un obiect cu operatorul de atribuire <- (în RStudio: Alt + -). Numele obiectelor pot conține litere, cifre, punct și _, nu încep cu o cifră și fac diferența între literele mari și cele mici (n și N sunt obiecte diferite). O atribuire nu afișează nimic; pentru a vedea valoarea unui obiect îi scriem numele.

2.3 Vectori

Obiectul de bază din R este vectorul: un șir de valori de același tip (numere, șiruri de caractere sau valori logice). Chiar și un număr este un vector de lungime \(1\).

x <- c(4, 8, 15, 16, 23, 42)       # c() combină valorile într-un vector
1:6                                # numerele întregi de la 1 la 6
seq(0, 1, by = 0.25)               # de la 0 la 1, cu pasul 0.25
rep(c("H", "T"), times = 3)        # repetă vectorul de 3 ori
rep(c("R", "A"), times = c(2, 3))  # de 2 ori "R", apoi de 3 ori "A"
#> [1] 1 2 3 4 5 6
#> [1] 0.00 0.25 0.50 0.75 1.00
#> [1] "H" "T" "H" "T" "H" "T"
#> [1] "R" "R" "A" "A" "A"

Operațiile aritmetice și funcțiile matematice se aplică element cu element (spunem că sunt vectorizate), deci de cele mai multe ori nu avem nevoie de bucle. Elementele unui vector se extrag cu paranteze drepte; indicii încep de la 1, nu de la 0 ca în C sau Python.

x + 1              # se adună 1 la fiecare element
x / sum(x)         # fiecare element împărțit la suma tuturor
1:6 + 6:1          # adunare element cu element
x[2]               # al doilea element
x[c(1, 3)]         # primul și al treilea
x[-1]              # toate elementele, fără primul
x[x > 15]          # elementele mai mari decât 15
length(x)          # numărul de elemente
#> [1]  5  9 16 17 24 43
#> [1] 0.03704 0.07407 0.13889 0.14815 0.21296 0.38889
#> [1] 7 7 7 7 7 7
#> [1] 8
#> [1]  4 15
#> [1]  8 15 16 23 42
#> [1] 16 23 42
#> [1] 6

2.4 Vectori logici: numărare și proporții

O comparație (==, !=, <, <=, >, >=) aplicată unui vector produce un vector de valori logice TRUE/FALSE, câte una pentru fiecare element. Atenție: testul de egalitate se scrie ==; un singur = înseamnă atribuire. În calcule, TRUE valorează \(1\) și FALSE valorează \(0\), deci suma unui vector logic numără valorile TRUE, iar media lui este proporția lor.

zar <- c(3, 6, 1, 6, 2, 5, 6, 4)   # rezultatele a opt aruncări ale unui zar
zar == 6           # pentru fiecare aruncare: a ieșit 6?
sum(zar == 6)      # de câte ori a ieșit 6
mean(zar == 6)     # proporția aruncărilor cu 6, adică 3/8
#> [1] FALSE  TRUE FALSE  TRUE FALSE FALSE  TRUE FALSE
#> [1] 3
#> [1] 0.375
Idiomul de bază al laboratorului

Dacă ev este un vector logic care arată, pentru fiecare rezultat (enumerat sau simulat), dacă evenimentul s-a realizat, atunci sum(ev) este numărul cazurilor favorabile, iar mean(ev) este proporția lor, adică

  • probabilitatea evenimentului, atunci când componentele lui ev corespund tuturor rezultatelor egal probabile ale experimentului (modelul clasic);
  • frecvența relativă a evenimentului, atunci când componentele lui ev corespund unor repetări simulate ale experimentului.

Vectorii logici se combină cu operatorii & (și), | (sau) și ! (negație), care corespund exact operațiilor cu evenimente (Tabelul 1).

Tabelul 1: Operațiile cu evenimente și operatorii logici din R (A și B sunt vectori logici de aceeași lungime).
Eveniment \(A\cap B\) \(A\cup B\) \(A^c\) \(A\setminus B\) \(A\,\triangle\,B\)
În cuvinte \(A\) și \(B\) \(A\) sau \(B\) nu \(A\) \(A\), dar nu \(B\) exact unul
În R A & B A | B !A A & !B xor(A, B)
pare <- zar %% 2 == 0      # „număr par”
mari <- zar >= 5           # „cel puțin 5”
sum(pare & mari)           # câte aruncări sunt pare ȘI cel puțin 5
mean(pare | mari)          # proporția celor pare SAU cel puțin 5
mean(!pare)                # proporția celor impare
which(zar == 6)            # pozițiile pe care apare 6
c(any(zar == 1), all(zar <= 5))   # există un 1? sunt toate cel mult 5?
#> [1] 3
#> [1] 0.75
#> [1] 0.375
#> [1] 2 4 7
#> [1]  TRUE FALSE

2.5 Funcții utile pentru numărare

Pentru formulele de numărare din Cursul 1 avem la dispoziție funcțiile următoare.

sum(1:100)             # suma 1 + 2 + ... + 100
prod(1:5)              # produsul 1 * 2 * 3 * 4 * 5
factorial(5)           # 5!, același rezultat
choose(5, 2)           # combinări de 5 luate câte 2
cumsum(1:6)            # sume parțiale: 1, 1+2, 1+2+3, ...
prod(10:8) / 10^3      # (10 * 9 * 8) / 10^3
#> [1] 5050
#> [1] 120
#> [1] 120
#> [1] 10
#> [1]  1  3  6 10 15 21
#> [1] 0.72

Pentru vectori de observații (de exemplu rezultatele unei simulări) sunt utile sort, unique și mai ales table, care numără de câte ori apare fiecare valoare.

litere <- c("b", "a", "c", "a", "b", "a")
sort(litere)                       # ordonare
unique(litere)                     # valorile distincte
table(litere)                      # de câte ori apare fiecare valoare
#> [1] "a" "a" "a" "b" "b" "c"
#> [1] "b" "a" "c"
#> litere
#> a b c 
#> 3 2 1

2.6 Mulțimi și enumerarea spațiului stărilor

Un eveniment poate fi reprezentat și ca mulțimea rezultatelor favorabile; R are funcții pentru operațiile cu mulțimi.

Omega <- 1:6             # aruncarea unui zar
A <- c(2, 4, 6)          # „număr par”
B <- c(4, 5, 6)          # „cel puțin 4”
union(A, B)              # reuniunea
intersect(A, B)          # intersecția
setdiff(A, B)            # diferența A \ B
setdiff(Omega, A)        # complementara lui A
c(3, 4) %in% A           # aparține 3 lui A? dar 4?
#> [1] 2 4 6 5
#> [1] 4 6
#> [1] 2
#> [1] 1 3 5
#> [1] FALSE  TRUE

Pentru experimente cu mai multe etape (două zaruri, trei monede) avem nevoie de toate combinațiile de rezultate. Funcția expand.grid construiește un tabel (data frame) în care fiecare linie este un rezultat posibil al experimentului; o coloană a tabelului se extrage cu $.

zaruri <- expand.grid(z1 = 1:6, z2 = 1:6)   # toate perechile (z1, z2)
nrow(zaruri)                     # numărul de linii: 36 de rezultate
head(zaruri, 3)                  # primele 3 linii
suma <- zaruri$z1 + zaruri$z2    # suma, pentru fiecare linie
mean(suma == 7)                  # P(suma este 7) = 6/36
#> [1] 36
#>   z1 z2
#> 1  1  1
#> 2  2  1
#> 3  3  1
#> [1] 0.1667
Exemplul 1 (Cel mai mare dintre două zaruri)

Aruncăm două zaruri echilibrate și notăm cu \(M\) cel mai mare dintre cele două numere. Evenimentul \(\{M\le4\}\) înseamnă că ambele zaruri arată cel mult \(4\), deci are \(4\cdot4=16\) cazuri favorabile și \(\PP(M\le4)=16/36\approx0.4444\). Apoi \(\{M=4\}=\{M\le4\}\setminus\{M\le3\}\), deci \(\PP(M=4)=\frac{16}{36}-\frac{9}{36}=\frac7{36}\approx0.1944\). În R numărăm direct pe tabelul celor \(36\) de rezultate:

M <- pmax(zaruri$z1, zaruri$z2)     # maximul de pe fiecare linie
c(cel_mult_4 = mean(M <= 4), egal_cu_4 = mean(M == 4))
table(M)                            # câte rezultate dau fiecare maxim
#> cel_mult_4  egal_cu_4 
#>     0.4444     0.1944 
#> M
#>  1  2  3  4  5  6 
#>  1  3  5  7  9 11

Valorile coincid cu cele calculate de mână, iar table(M) arată că \(M=m\) are \(m^2-(m-1)^2=2m-1\) cazuri favorabile: \(1,3,5,7,9,11\).

2.7 Experimente aleatoare: sample și set.seed

Funcția sample extrage la întâmplare elemente dintr-un vector: este „urna” noastră.

set.seed(2026)                     # fixează „sămânța” generatorului
sample(1:6, 1)                     # o aruncare a unui zar
sample(1:6, 10, replace = TRUE)    # 10 aruncări (extrageri cu revenire)
sample(1:10, 3)                    # 3 bile din 10, fără revenire
sample(5)                          # o permutare aleatoare a lui 1, ..., 5
sample(c("H", "T"), 8, replace = TRUE, prob = c(0.8, 0.2))
#> [1] 5
#>  [1] 1 1 6 5 3 4 4 5 4 2
#> [1] 2 8 3
#> [1] 5 2 1 4 3
#> [1] "H" "H" "H" "H" "H" "H" "H" "T"
  • sample(x, size) extrage size elemente din vectorul x, toate având aceeași șansă. Implicit extragerea este fără revenire (replace = FALSE); cu replace = TRUE este cu revenire.
  • sample(n), cu un singur număr n, întoarce o permutare aleatoare a lui 1:n, iar sample(n, k) este o prescurtare pentru sample(1:n, k).
  • Argumentul prob dă probabilitățile elementelor lui x atunci când ele nu sunt egal probabile (în ultimul exemplu, o monedă care arată "H" cu probabilitatea \(0.8\)).
  • Numerele produse de calculator sunt pseudo-aleatoare: set.seed(numar) fixează punctul de plecare al generatorului, astfel încât aceeași secvență de comenzi produce aceleași rezultate la fiecare rulare. Vom scrie set.seed(...) înaintea fiecărei simulări, pentru ca rezultatele să poată fi reproduse.
Exemplul 2 (Un zar aruncat de zece mii de ori)

Simulăm \(10^4\) aruncări ale unui zar echilibrat și calculăm frecvențele relative ale celor șase fețe și ale evenimentului „număr par”.

set.seed(6)
aruncari <- sample(1:6, 1e4, replace = TRUE)   # 1e4 înseamnă 10^4
frecv <- table(aruncari) / length(aruncari)    # frecvențe relative
round(frecv, 3)
mean(aruncari %% 2 == 0)                       # frecvența lui „număr par”
#> aruncari
#>     1     2     3     4     5     6 
#> 0.161 0.174 0.159 0.170 0.170 0.166 
#> [1] 0.5108

Toate frecvențele relative sunt apropiate de \(1/6\approx0.167\), iar frecvența evenimentului „număr par” este apropiată de \(1/2\): este interpretarea frecvenționistă a probabilității din Secțiunea 4 din Cursul 1.

2.8 Repetarea unui experiment și funcții proprii

În exemplul precedent am generat toate aruncările dintr-o singură comandă. Când experimentul este mai complicat, îl repetăm cu o buclă for sau, mai scurt, cu replicate. Estimăm astfel probabilitatea ca suma a două zaruri să fie \(7\).

set.seed(2026)
B <- 1e4                             # numărul de repetări
sume <- numeric(B)                   # un vector cu B zerouri
for (i in 1:B) {                     # varianta cu bucla for
  sume[i] <- sum(sample(1:6, 2, replace = TRUE))
}
mean(sume == 7)
sume <- replicate(B, sum(sample(1:6, 2, replace = TRUE)))  # cu replicate
mean(sume == 7)
#> [1] 0.1654
#> [1] 0.1656

Ambele estimări sunt apropiate de valoarea exactă \(6/36\approx0.1667\). Comanda replicate(B, expresie) evaluează expresia de B ori și adună rezultatele într-un vector. Când un experiment este folosit de mai multe ori, îl împachetăm într-o funcție.

suma_zaruri <- function(k = 2) {     # k = numărul de zaruri (implicit 2)
  z <- sample(1:6, k, replace = TRUE)
  sum(z)                             # ultima expresie este valoarea întoarsă
}
suma_zaruri()                        # suma a două zaruri
suma_zaruri(5)                       # suma a cinci zaruri
mean(replicate(B, suma_zaruri(3)) >= 12)
sapply(1:3, function(k) mean(replicate(B, suma_zaruri(k)) >= 4 * k))
#> [1] 8
#> [1] 22
#> [1] 0.3797
#> [1] 0.4976 0.4230 0.3777

A treia linie de rezultate estimează probabilitatea ca suma a trei zaruri să fie cel puțin \(12\); valoarea exactă este \(81/216=0.375\). Funcția sapply(valori, f) aplică funcția f fiecărui element al unui vector și adună rezultatele: ultima linie estimează probabilitatea ca suma a \(k\) zaruri să fie cel puțin \(4k\), pentru \(k=1,2,3\). Valorile exacte sunt \(0.5\), \(15/36\approx0.4167\) și \(0.375\), iar estimările diferă de ele cu mai puțin de \(0.01\).

Schema unei simulări
  1. Scriem o funcție (sau o expresie) care efectuează o dată experimentul și întoarce mărimea care ne interesează (un număr sau TRUE/FALSE).
  2. Repetăm experimentul de B ori: rezultate <- replicate(B, experiment()).
  3. Estimăm probabilitatea prin frecvența relativă: mean(conditie).

Estimarea nu este exactă: pentru B = 1e4 eroarea este, de regulă, mai mică decât \(0.01\), iar pentru B = 1e5 mai mică decât \(0.003\) (vom vedea de ce în Cursul 7). De aceea comparăm doar primele două zecimale ale unei simulări cu valoarea teoretică.

2.9 Grafice simple

Funcția plot(x, y) reprezintă punctele de coordonate (x[i], y[i]); barplot(inaltimi) desenează o diagramă cu bare. Peste un grafic existent adăugăm elemente cu lines (o linie frântă), points (puncte) și abline (o dreaptă: h = orizontală, v = verticală). Culorile se dau prin nume ("red") sau prin coduri; în aceste note folosim mereu aceleași culori, păstrate într-un vector cu nume. Pentru a rula codul notelor pe calculatorul propriu, copiați definiția lui la începutul scriptului.

Ca exemplu, reprezentăm frecvențele relative din Exemplul 2 și le comparăm cu valoarea teoretică \(1/6\); un element al vectorului culori se extrage după nume, cu [[ ]].

culori <- c(albastru = "#2B6CB0", rosu = "#9B2335", verde = "#2F7D4A",
            portocaliu = "#C0661A", mov = "#7A3E8E", teal = "#1F7A7A",
            gri = "#6B7785", bleumarin = "#1B3A5C")
barplot(frecv, col = culori[["albastru"]],
        xlab = "fața zarului", ylab = "frecvența relativă")
abline(h = 1/6, lty = 2, col = culori[["rosu"]])   # dreapta y = 1/6

Cele mai folosite argumente ale funcției plot sunt: type ("p" puncte, "l" linie, "b" ambele, "h" bare verticale), col (culoarea), pch (forma punctelor; 19 = disc plin), lty și lwd (tipul și grosimea liniei), xlab, ylab, main (etichetele axelor și titlul), xlim, ylim (limitele axelor).

Exemplul 3 (Stabilizarea frecvenței relative)

Aruncăm o monedă echilibrată de \(N=5000\) de ori și urmărim frecvența relativă a capului după primele \(1,2,\dots,N\) aruncări. Dacă moneda este vectorul rezultatelor (\(1\) = cap, \(0\) = pajură), atunci cumsum(moneda) este numărul de capete obținute până la fiecare aruncare, iar împărțirea la 1:N dă frecvențele relative.

set.seed(1654)
N <- 5000
moneda <- sample(c(1, 0), N, replace = TRUE)    # 1 = cap, 0 = pajură
f <- cumsum(moneda) / (1:N)                     # frecvențele relative
round(f[c(10, 100, 1000, 5000)], 3)             # după 10, 100, ... aruncări
#> [1] 0.700 0.510 0.494 0.504
plot(1:N, f, type = "l", log = "x", ylim = c(0, 1),
     col = culori[["albastru"]],
     xlab = "numărul de aruncări (scară logaritmică)",
     ylab = "frecvența relativă a capului")
moneda2 <- sample(c(1, 0), N, replace = TRUE)   # o a doua serie
lines(1:N, cumsum(moneda2) / (1:N), col = culori[["verde"]])
abline(h = 0.5, lty = 2, col = culori[["rosu"]])

La început frecvența relativă oscilează mult, apoi ambele serii se stabilizează în jurul valorii \(0.5\), ca în figura corespunzătoare din Secțiunea 4 din Cursul 1.

3 Evenimente și operații cu evenimente

Începem cu „traducerea” afirmațiilor despre un experiment în operații cu mulțimi. În R, spațiul stărilor va fi un tabel construit cu expand.grid, evenimentele vor fi vectori logici, iar probabilitățile se vor calcula cu mean (Secțiunea 2.4).

Exercițiul 1 (Trei servere)

La seminar Un serviciu web rulează pe trei servere. La un moment dat, fiecare server fie funcționează, fie este căzut. Notăm cu \(A_i\) evenimentul „serverul \(i\) funcționează”, \(i=1,2,3\).

  1. Exprimați, cu ajutorul evenimentelor \(A_1,A_2,A_3\) și al operațiilor cu evenimente: \(E_1\) = „toate cele trei servere funcționează”; \(E_2\) = „cel puțin un server funcționează”; \(E_3\) = „niciun server nu funcționează”; \(E_4\) = „funcționează exact un server”; \(E_5\) = „funcționează cel puțin două servere”; \(E_6\) = „funcționează cel mult un server”.

  2. Care dintre evenimentele de la punctul (a) sunt contrare unul altuia? Justificați cu relațiile lui De Morgan.

  3. Serviciul este disponibil dacă funcționează serverul \(1\) (serverul de aplicație) și cel puțin unul dintre serverele \(2\) și \(3\) (serverele de date). Scrieți evenimentul \(S\) = „serviciul este disponibil” și evenimentul contrar \(S^c\).

  4. Descriem starea sistemului prin tripletul \((x_1,x_2,x_3)\), unde \(x_i=1\) dacă serverul \(i\) funcționează și \(x_i=0\) dacă este căzut. Presupunând că toate stările sunt egal probabile, calculați probabilitățile evenimentelor \(E_1,\dots,E_6\) și \(S\).

  5. Construiți în R spațiul stărilor și evenimentele de mai sus; verificați răspunsurile de la (b), (c) și (d).

Laborator Schelet de cod pentru (e) — completați locurile marcate cu ___ (fiecare eveniment este un vector logic cu \(8\) componente, câte una pentru fiecare stare):

stari <- expand.grid(x1 = 0:1, x2 = 0:1, x3 = 0:1)   # cele 8 stări
A1 <- stari$x1 == 1          # stările în care funcționează serverul 1
A2 <- stari$x2 == 1
A3 <- stari$x3 == 1
E1 <- A1 & A2 & A3
E2 <- ___
E3 <- ___
E4 <- ___                    # exact un server
E5 <- ___                    # cel puțin două servere
E6 <- ___                    # cel mult un server
S  <- ___                    # serviciul este disponibil
cbind(stari, E4, E5, E6, S)  # stările și câteva dintre evenimente
c(E1 = mean(E1), E2 = mean(E2), E3 = mean(E3), E4 = mean(E4),
  E5 = mean(E5), E6 = mean(E6), S = mean(S))
c(all(___ == !E2), all(___ == !E5),        # perechile de evenimente contrare, (b)
  all(!S == ___))                          # formula pentru contrarul lui S, (c)

Al doilea exercițiu folosește același tipar pentru aruncarea a două zaruri: enumerăm cele \(36\) de rezultate, numărăm cazurile favorabile și verificăm numeric relațiile lui De Morgan și formula reuniunii, pe care o vom folosi sistematic în secțiunea următoare.

Exercițiul 2 (Două zaruri pe un spațiu enumerat)

Pentru acasă Aruncăm două zaruri echilibrate, unul roșu și unul albastru. Considerăm evenimentele \(A\) = „suma celor două numere este pară” și \(B\) = „cel puțin un zar arată \(6\)”.

  1. Descrieți spațiul stărilor și determinați numărul de elemente ale evenimentelor \(A\), \(B\) și \(A\cap B\).

  2. Calculați \(\PP(A)\), \(\PP(B)\), \(\PP(A\cap B)\) și \(\PP(A\cup B)\).

  3. Descrieți în cuvinte evenimentele \(A^c\cap B^c\), \(A\setminus B\) și \(A\,\triangle\,B\) și calculați-le probabilitățile.

  4. Sunt \(A\) și \(B\) incompatibile? Arătați că evenimentul \(C\) = „suma este cel mult \(6\)” este incompatibil cu \(B\) și calculați \(\PP(B\cup C)\).

  5. Verificați rezultatele în R, prin enumerare și printr-o simulare cu \(10^5\) aruncări.

Răspunsuri
  1. \(\Omega=\{1,\dots,6\}^2\), \(|\Omega|=36\) (rezultate egal probabile); \(|A|=18\), \(|B|=11\), \(|A\cap B|=5\).

  2. \(\PP(A)=\frac12\), \(\PP(B)=\frac{11}{36}\approx0.3056\), \(\PP(A\cap B)=\frac5{36}\approx0.1389\), \(\PP(A\cup B)=\frac{24}{36}=\frac23\approx0.6667\).

  3. \(A^c\cap B^c\) = „suma este impară și niciun zar nu arată \(6\)”, \(\PP=\frac13\); \(A\setminus B\) = „suma este pară și niciun zar nu arată \(6\)”, \(\PP=\frac{13}{36}\approx0.3611\); \(A\,\triangle\,B\) = „se realizează exact unul dintre \(A\) și \(B\)”, \(\PP=\frac{19}{36}\approx0.5278\).

  4. \(A\) și \(B\) nu sunt incompatibile (de exemplu, \((6,6)\in A\cap B\)); \(B\cap C=\emptyset\), \(|C|=15\) și \(\PP(B\cup C)=\frac{26}{36}\approx0.7222\).

  5. Enumerarea dă exact valorile de mai sus; frecvențele simulate ale evenimentelor \(A\cup B\) și \(A\,\triangle\,B\) sunt apropiate de \(0.6667\) și \(0.5278\).

4 Reguli de calcul și formula lui Poincaré

În exercițiile precedente am putut enumera spațiul stărilor. De multe ori însă cunoaștem doar probabilitățile câtorva evenimente și trebuie să le deducem pe ale altora cu regulile de calcul din Propoziția 14 din Cursul 1. Următoarele trei exerciții parcurg, în ordine, reuniunea a două evenimente, formula lui Poincaré pentru trei evenimente și marginile care se pot da atunci când nu cunoaștem probabilitățile intersecțiilor.

Exercițiul 3 (Python și Java)

Dacă timpul permite Alegem la întâmplare un student al unei facultăți. Probabilitatea ca studentul să știe Python este \(0.70\), probabilitatea să știe Java este \(0.45\), iar probabilitatea să știe ambele limbaje este \(0.30\).

  1. Care este probabilitatea ca studentul să știe cel puțin unul dintre cele două limbaje?

  2. Care este probabilitatea să nu știe niciunul?

  3. Care este probabilitatea să știe Python, dar nu și Java?

  4. Care este probabilitatea să știe exact unul dintre cele două limbaje?

  5. Să presupunem că nu am cunoaște probabilitatea de a ști ambele limbaje. Între ce valori s-ar putea afla ea, dacă știm doar că \(70\%\) dintre studenți știu Python și \(45\%\) știu Java?

  6. În R: construiți o facultate cu \(200\) de studenți care respectă datele din enunț și verificați, prin numărare și prin simulare, răspunsurile de la (a)–(d).

Laborator Schelet de cod pentru (f) — completați locurile marcate cu ___ (studenții sunt împărțiți în patru grupe: știu ambele limbaje, doar Python, doar Java, niciunul; fiecărui student îi corespunde o poziție în vectorii logici python și java):

grupe  <- ___                  # ambele, doar Python, doar Java, niciunul
python <- rep(c(TRUE, TRUE, FALSE, FALSE), times = grupe)
java   <- ___
c(P_A = mean(python), P_B = mean(java), P_A_si_B = mean(python & java))
c(cel_putin_unul = mean(___), niciunul = mean(___),
  doar_python = mean(___), exact_unul = mean(xor(python, java)))
table(python, java)            # cele patru regiuni, ca numere de studenți
set.seed(200)
ales <- sample(200, 1e5, replace = TRUE)   # indicii studenților aleși
c(cel_putin_unul = mean(___),
  exact_unul = mean(xor(python[ales], java[ales])))
Răspunsuri
  1. \(\PP(A\cup B)=0.85\), unde \(A\) = „știe Python” și \(B\) = „știe Java”.

  2. \(0.15\).

  3. \(0.40\).

  4. \(0.55\).

  5. \(0.15\le\PP(A\cap B)\le0.45\).

  6. Populația are \(60\) de studenți care știu ambele limbaje, \(80\) doar Python, \(30\) doar Java și \(30\) niciunul; numărarea dă exact \(0.85\), \(0.15\), \(0.40\) și \(0.55\), iar frecvențele simulate sunt apropiate de \(0.85\) și \(0.55\).

Pentru trei evenimente, corecția „scădem ce am numărat de două ori” trebuie continuată: adunăm înapoi ce am scăzut de prea multe ori. Exercițiul următor aplică formula lui Poincaré într-o situație în care toate probabilitățile se obțin prin numărare, iar verificarea în R este imediată.

Exercițiul 4 (Numere divizibile cu 2, 3 sau 5)

La seminar Alegem la întâmplare un număr din mulțimea \(\{1,2,\dots,1000\}\), toate numerele fiind egal probabile. Notăm cu \(D_k\) evenimentul „numărul ales este divizibil cu \(k\)”.

  1. Calculați \(\PP(D_2)\), \(\PP(D_3)\), \(\PP(D_5)\) și probabilitățile intersecțiilor \(D_2\cap D_3\), \(D_2\cap D_5\), \(D_3\cap D_5\) și \(D_2\cap D_3\cap D_5\).

  2. Care este probabilitatea ca numărul ales să fie divizibil cu cel puțin unul dintre numerele \(2\), \(3\) și \(5\)?

  3. Care este probabilitatea ca numărul să nu fie divizibil cu niciunul dintre ele?

  4. Care este probabilitatea ca numărul să fie divizibil cu exact unul dintre numerele \(2\), \(3\) și \(5\)?

  5. Verificați în R, folosind operatorul %% pe vectorul 1:1000. Cum se schimbă răspunsul de la (b) dacă alegem numărul din \(\{1,\dots,N\}\), pentru \(N=10\), \(100\), \(1000\) și \(10^6\)?

Laborator Schelet de cod pentru (e) — completați locurile marcate cu ___ (vectorul 1:1000 este spațiul stărilor, iar x %% k == 0 este vectorul logic al evenimentului \(D_k\)):

x <- 1:1000
D2 <- x %% 2 == 0
D3 <- ___
D5 <- ___
c(D2 = sum(D2), D3 = sum(D3), D5 = sum(D5), D6 = sum(___),
  D10 = sum(D2 & D5), D15 = sum(D3 & D5), D30 = sum(___))
c(numarare = mean(___),                       # punctul (b), direct
  poincare = ___)                             # punctul (b), formula lui Poincaré
table(D2 + D3 + D5)     # cu câte dintre numerele 2, 3, 5 este divizibil x
p_div <- function(N) {  # P(divizibil cu 2, 3 sau 5) pe 1, ..., N
  x <- 1:N
  ___
}
sapply(c(10, 100, 1000, 1e6), p_div)

În Exercițiul 3 (e) am văzut că, fără a cunoaște probabilitatea intersecției, putem da doar margini pentru probabilitatea reuniunii. Aceeași idee, pentru mai multe evenimente, este conținutul inegalităților lui Boole și Bonferroni.

Exercițiul 5 (Teste automate: margini pentru probabilități)

Dacă timpul permite O aplicație este livrată numai dacă trece toate cele \(n=5\) teste automate. Din istoricul proiectului se știe că fiecare test, luat separat, este trecut cu probabilitatea \(0.98\); nu se știe însă nimic despre legătura dintre teste. Fie \(T_i\) evenimentul „testul \(i\) este trecut”, \(i=1,\dots,5\).

  1. Scrieți evenimentul \(L\) = „aplicația este livrată” și contrarul său cu ajutorul evenimentelor \(T_i\).

  2. Arătați că \(0.90\le\PP(L)\le0.98\).

  3. Cel mult câte teste de acest fel poate avea aplicația, astfel încât să putem garanta că este livrată cu probabilitate cel puțin \(1/2\)?

  4. Construiți în R, pe spațiul \(\Omega=\{1,2,\dots,100\}\) cu rezultate egal probabile, două situații în care marginile de la (b) sunt atinse. Estimați apoi \(\PP(L)\) prin simulare în cazul în care testele „nu se influențează” unul pe altul.

Laborator Schelet de cod pentru (d) — completați locurile marcate cu ___ (fiecare scenariu este un tabel logic cu \(100\) de linii, rezultatele din \(\Omega\), și \(5\) coloane, testele; TRUE înseamnă „testul pică”; colMeans calculează media fiecărei coloane, iar rowSums suma fiecărei linii):

omega <- 1:100                     # 100 de rezultate egal probabile
# scenariul 1: testul i pică pentru două rezultate, altele pentru fiecare test
pica1 <- sapply(1:5, function(i) omega %in% ___)
# scenariul 2: toate testele pică pentru aceleași două rezultate
pica2 <- sapply(1:5, function(i) omega %in% ___)
rbind(scenariul_1 = colMeans(pica1), scenariul_2 = colMeans(pica2))
livrat1 <- ___                     # livrare = niciun test nu pică
livrat2 <- rowSums(pica2) == 0
c(scenariul_1 = mean(livrat1), scenariul_2 = mean(livrat2))
set.seed(98)
teste <- function() sample(c(TRUE, FALSE), 5, replace = TRUE,
                           prob = ___)    # TRUE = test trecut
livrat3 <- replicate(1e5, ___)            # trec toate cele 5 teste?
mean(livrat3)
Răspunsuri
  1. \(L=T_1\cap T_2\cap\dots\cap T_5\), \(L^c=T_1^c\cup T_2^c\cup\dots\cup T_5^c\).

  2. (demonstrație) \(0.90\le\PP(L)\le0.98\).

  3. \(n\le25\) teste.

  4. Marginea inferioară, \(0.90\), este atinsă pentru \(T_i^c=\{2i-1,\,2i\}\) (evenimentele \(T_i^c\) sunt incompatibile două câte două); marginea superioară, \(0.98\), pentru \(T_i^c=\{1,2\}\), oricare ar fi \(i\). Frecvența simulată în cazul testelor care nu se influențează este \(\approx0.905\), apropiată de \(0.98^5\approx0.9039\) (valoare justificată în Cursul 2).

5 Modelul clasic și numărare

Când rezultatele sunt egal probabile, dar prea multe pentru a fi enumerate de mână, le numărăm cu regulile de combinatorică din Secțiunea 7 din Cursul 1. În R avem două căi de verificare: enumerarea completă (când \(|\Omega|\) este de ordinul miilor) și simularea. Exercițiile acestei secțiuni sunt legate între ele: schemele de extragere din primul exercițiu reapar la parole, la cărțile de joc și, în final, în problema zilelor de naștere.

Exercițiul 6 (Extrageri cu și fără revenire)

La seminar O urnă conține \(10\) bile: \(6\) roșii și \(4\) albastre. Extragem la întâmplare \(3\) bile.

  1. Extragerea se face cu revenire. Calculați probabilitatea de a obține exact două bile roșii și probabilitatea de a obține cel puțin o bilă albastră.

  2. Aceleași întrebări dacă extragerea se face fără revenire. Numărați în două moduri: ținând cont de ordinea extragerii și fără a ține cont de ea.

  3. În care dintre cele două scheme este mai probabil ca toate cele trei bile să aibă aceeași culoare?

  4. Dintr-un grup de \(6\) fete și \(4\) băieți se alege la întâmplare o comisie de \(3\) persoane. Care este probabilitatea ca din comisie să facă parte exact două fete?

  5. Verificați rezultatele în R prin simulare și prin enumerare completă.

Laborator Schelet de cod pentru (e) — completați locurile marcate cu ___ (urna este un vector cu \(10\) elemente; repetăm fiecare experiment de \(10^5\) ori și reținem numărul de bile roșii; funcțiile p_cu și p_fara generalizează calculele de la (a) și (b) la o urnă cu \(r\) bile roșii și \(a\) albastre din care extragem \(n\) bile, iar p_fara va fi folosită și în Exercițiul 8; combn(10, 3) produce cele \(\binom{10}3\) submulțimi, câte una pe fiecare coloană):

urna <- rep(c("R", "A"), times = c(6, 4))     # R = roșie, A = albastră
set.seed(64)
B <- 1e5
rosii_cu   <- replicate(B, sum(___ == "R"))   # 3 bile, cu revenire
rosii_fara <- replicate(B, sum(___ == "R"))   # 3 bile, fără revenire
rbind(cu_revenire   = table(rosii_cu) / B,
      fara_revenire = table(rosii_fara) / B)
p_cu   <- function(k, n, r, a) ___            # P(exact k roșii), cu revenire
p_fara <- function(k, n, r, a) ___            # P(exact k roșii), fără revenire
rbind(cu_revenire = p_cu(0:3, 3, 6, 4), fara_revenire = p_fara(0:3, 3, 6, 4))
cu <- ___                                # cele 10^3 șiruri, cu expand.grid
table(rowSums(cu <= 6)) / nrow(cu)       # bilele 1, ..., 6 sunt roșii
fara <- combn(10, 3)                     # submulțimile, pe coloane
table(colSums(fara <= 6)) / ncol(fara)

Aceleași două scheme, cu și fără revenire, apar ori de câte ori formăm șiruri de simboluri: parole, coduri PIN, cuvinte. Când unele simboluri se repetă, intervine și coeficientul multinomial.

Exercițiul 7 (Parole, coduri PIN și anagrame)

Dacă timpul permite (a) O parolă este formată din \(4\) litere mici ale alfabetului englez (\(26\) de litere). Câte parole există? Câte dintre ele au toate literele diferite?

  1. Un cod PIN este format din \(4\) cifre alese la întâmplare (toate codurile de la \(0000\) la \(9999\) sunt egal probabile). Care este probabilitatea ca cifrele codului să fie toate diferite? Dar ca măcar o cifră să se repete?

  2. Câte anagrame (cuvinte diferite, nu neapărat cu sens) are cuvântul ANANAS?

  3. Cele șase litere ale cuvântului ANANAS sunt scrise pe șase cartonașe, care se amestecă și se așază în linie la întâmplare. Care este probabilitatea ca cele trei litere A să fie alăturate? Dar ca șirul obținut să înceapă cu A și să se termine cu S?

  4. Verificați în R punctul (b) prin enumerare și punctele (c) și (d) prin simulare.

Laborator Schelet de cod pentru (e) — completați locurile marcate cu ___ (apply(tabel, 1, f) aplică funcția f fiecărei linii a tabelului; paste(..., collapse = "") lipește literele într-un singur cuvânt; grepl(sablon, text) verifică dacă un text conține un șablon, iar substr(text, i, j) extrage caracterele de la poziția i la poziția j):

pin <- expand.grid(c1 = 0:9, c2 = 0:9, c3 = 0:9, c4 = 0:9)  # 10^4 coduri
distincte <- apply(pin, 1, function(r) ___)  # 4 cifre distincte?
c(coduri = nrow(pin), cu_cifre_distincte = sum(distincte))
mean(distincte)                              # probabilitatea de la (b)
litere <- c("A", "N", "A", "N", "A", "S")
amesteca <- function() paste(___, collapse = "")   # o așezare la întâmplare
set.seed(60)
amesteca()                                   # o așezare la întâmplare
cuvinte <- replicate(1e5, amesteca())
length(unique(cuvinte))                      # câte cuvinte diferite apar
c(AAA = mean(grepl("AAA", cuvinte)),         # conține șirul "AAA"?
  A_S = mean(___))                           # începe cu A, se termină cu S
range(table(cuvinte) / 1e5)                  # frecvențele cuvintelor apărute
Răspunsuri
  1. \(26^4=456\,976\) de parole, dintre care \(26\cdot25\cdot24\cdot23=358\,800\) cu toate literele diferite.

  2. \(\PP(\text{cifre distincte})=0.504\); \(\PP(\text{o cifră repetată})=0.496\).

  3. \(\frac{6!}{3!\,2!\,1!}=60\) de anagrame.

  4. \(\PP(\text{AAA alăturate})=0.2\); \(\PP(\text{începe cu A, se termină cu S})=0.1\).

  5. Enumerarea găsește \(5040\) de coduri cu cifre distincte (probabilitatea \(0.504\)); în \(10^5\) amestecări apar exact \(60\) de cuvinte diferite, frecvențele celor două evenimente sunt apropiate de \(0.2\) și \(0.1\), iar frecvențele anagramelor sunt toate apropiate de \(1/60\approx0.0167\).

Trecem la cărțile de joc. Modelul este cel din Exemplul 17 din Cursul 1: o mână este o submulțime de \(5\) cărți, deci o extragere fără revenire în care ordinea nu contează, exact ca în Exercițiul 6 (b).

Exercițiul 8 (O mână de cinci cărți)

Pentru acasă Dintr-un pachet bine amestecat de \(52\) de cărți (\(13\) figuri, fiecare în \(4\) culori) se extrag \(5\) cărți. Calculați probabilitatea ca mâna obținută:

  1. să conțină exact doi ași;

  2. să conțină cel puțin un as;

  3. să conțină cinci cărți de figuri diferite (nicio figură nu se repetă).

  4. Construiți pachetul în R cu expand.grid și verificați rezultatele prin simulare.

Răspunsuri
  1. \(\binom42\binom{48}3\big/\binom{52}5=\frac{103\,776}{2\,598\,960}\approx0.0399\).

  2. \(1-\binom{48}5\big/\binom{52}5\approx1-0.6588=0.3412\).

  3. \(\binom{13}5\cdot4^5\big/\binom{52}5=\frac{1\,317\,888}{2\,598\,960}\approx0.5071\).

  4. Frecvențele simulate sunt apropiate de \(0.0399\), \(0.3412\) și \(0.5071\).

Punctul (b) al Exercițiului 7 și punctul (c) al Exercițiului 8 au aceeași structură: alegem mai multe obiecte și ne întrebăm dacă apare vreo repetare. Cea mai cunoscută problemă de acest tip este problema zilelor de naștere.

Exercițiul 9 (Zile de naștere)

La seminar Într-o grupă de laborator sunt \(n\) studenți. Ca în Exemplul 16 din Cursul 1, presupunem că anul are \(365\) de zile, la fel de probabile ca zi de naștere, și notăm cu \(q_n\) probabilitatea ca cel puțin doi studenți să aibă aceeași zi de naștere.

  1. Scrieți formula lui \(q_n\) ca produs și calculați de mână \(q_4\).

  2. Scrieți în R o funcție p_zile(n, zile = 365) care calculează \(q_n\) cu ajutorul lui prod. Calculați \(q_{25}\) și determinați cel mai mic \(n\) pentru care \(q_n\ge1/2\), respectiv \(q_n\ge0.99\).

  3. Estimați prin simulare \(q_{10}\), \(q_{25}\) și \(q_{40}\) și reprezentați grafic \(q_n\) pentru \(n=1,\dots,60\), împreună cu valorile simulate.

  4. Variante cu alt număr de „zile”. Care este probabilitatea ca, dintre \(5\) studenți, cel puțin doi să fie născuți în aceeași lună (presupunem cele \(12\) luni egal probabile)? Ce legătură are problema cu codul PIN din Exercițiul 7?

  5. Trei studenți cu aceeași zi de naștere. Estimați prin simulare probabilitatea ca cel puțin trei studenți să aibă aceeași zi de naștere, pentru \(n\in\{25,50,88,120\}\).

Laborator Schelet de cod pentru (b), (c) — completați locurile marcate cu ___ (duplicated(z) marchează elementele lui z care au mai apărut, iar any întreabă dacă există măcar unul; vectorul culori este cel din Secțiunea 2.9):

p_zile <- function(n, zile = 365) {
  if (n > zile) return(1)               # mai multe persoane decât zile
  ___                                   # 1 - produsul rapoartelor, cu prod
}
c(q_4 = p_zile(4), q_25 = p_zile(25))
q <- sapply(1:60, p_zile)               # q_1, ..., q_60
c(prag_0.5 = ___, prag_0.99 = ___)      # cel mai mic n cu q_n >= 0.5, >= 0.99
sim_zile <- function(n, zile = 365) {
  z <- ___                              # zilele de naștere ale celor n
  any(duplicated(z))                    # există o zi repetată?
}
set.seed(23)
n_sim <- c(10, 25, 40)
q_sim <- sapply(n_sim, function(n) mean(replicate(2e4, sim_zile(n))))
data.frame(n = n_sim, simulare = q_sim, exact = q[n_sim])
plot(1:60, q, type = "l", lwd = 2, col = culori[["albastru"]],
     xlab = "numărul de studenți n", ylab = "probabilitatea")
points(___, ___, pch = 19, col = culori[["portocaliu"]])   # valorile simulate

6 Problema potrivirilor prin simulare

Încheiem partea principală a ședinței cu problema potrivirilor, rezolvată la curs cu formula lui Poincaré (Exemplul 22 din Cursul 1). Calculul teoretic cere o idee; simularea, în schimb, este o singură linie de cod, iar aceeași simulare răspunde și la întrebări mai fine, cum ar fi repartiția numărului de potriviri.

Exercițiul 10 (Problema potrivirilor prin simulare)

La seminar La intrarea într-un examen, cei \(n\) studenți își lasă telefoanele într-o cutie. La ieșire, telefoanele sunt împărțite la întâmplare, câte unul fiecărui student (toate cele \(n!\) împărțiri sunt egal probabile). Spunem că avem o potrivire atunci când un student își primește propriul telefon și notăm cu \(N\) numărul de potriviri. Conform Exemplului 22 din Cursul 1, probabilitatea de a avea cel puțin o potrivire este \(p_n=\sum_{k=1}^n\frac{(-1)^{k+1}}{k!}\).

  1. Pentru \(n=3\), enumerați toate împărțirile posibile și numărul de potriviri al fiecăreia. Deduceți \(\PP(N\ge1)\) și probabilitățile \(\PP(N=k)\), \(k=0,1,2,3\), și comparați cu formula lui \(p_3\).

  2. Scrieți în R o funcție potriviri(n) care simulează o împărțire și întoarce numărul de potriviri. Estimați \(\PP(N\ge1)\) pentru \(n=10\) și comparați cu \(p_{10}\) și cu limita \(1-1/e\).

  3. Reprezentați grafic, pentru \(n=1,\dots,12\), valoarea exactă \(p_n\) și estimarea ei prin simulare.

  4. Pentru \(n=10\), determinați prin simulare frecvențele relative ale evenimentelor „exact \(k\) potriviri”, \(k=0,1,\dots,6\), și comparați-le cu formula din Exercițiul 8 din Cursul 1 și cu valorile limită \(e^{-1}/k!\).

  5. Estimați numărul mediu de potriviri pentru \(n=5\), \(n=10\) și \(n=100\). Ce observați? Explicați.

Laborator Schelet de cod pentru (b), (d) — completați locurile marcate cu ___ (o împărțire la întâmplare este sample(n); funcțiile potriviri și exact_k vor fi folosite și în Exercițiul 14 și în temă):

potriviri <- function(n) ___            # numărul de potriviri
p_potriviri <- function(n) ___          # p_n, formula din Exemplul potrivirilor
set.seed(1708)
sample(5) == 1:5                        # un exemplu: potrivirile pentru n = 5
N <- replicate(1e5, potriviri(10))      # numărul de potriviri în 10^5 împărțiri
c(simulare = mean(___), exact = p_potriviri(10), limita = ___)
exact_k <- function(n, k) {             # P(exact k potriviri), formula exactă
  j <- 0:(n - k)
  ___
}
k <- 0:6
rep_N <- rbind(simulare = sapply(k, function(i) mean(N == i)),
               exact    = sapply(k, function(i) exact_k(10, i)),
               limita   = ___)          # valorile limită e^(-1) / k!
colnames(rep_N) <- k
round(rep_N, 4)

7 Exerciții suplimentare

Exercițiile de mai jos, cu răspunsuri finale, sunt destinate studiului individual și reiau, în ordine, temele ședinței.

Exercițiul 11 (Șiruri de biți)

Pentru acasă Un generator produce un șir de \(n\) biți, toate cele \(2^n\) șiruri fiind egal probabile (echivalent: aruncăm de \(n\) ori o monedă echilibrată, ca în Exemplul 6 din Cursul 1, și scriem \(1\) pentru cap și \(0\) pentru pajură). Fie \(A_j\) evenimentul „bitul de pe poziția \(j\) este \(1\)”.

  1. Pentru \(n=4\), scrieți cu ajutorul evenimentelor \(A_j\): \(U\) = „cel puțin un bit este \(1\)” și \(V\) = „există doi biți consecutivi egali cu \(1\)”. Calculați \(\PP(U)\) și \(\PP(V)\).

  2. Pentru \(n\) oarecare, calculați probabilitatea ca exact \(k\) biți să fie egali cu \(1\).

  3. În R, pentru \(n=10\): enumerați toate șirurile, verificați formula de la (b) și calculați \(\PP(V)\).

Răspunsuri
  1. \(U=A_1\cup A_2\cup A_3\cup A_4\), \(\PP(U)=\frac{15}{16}=0.9375\); \(V=(A_1\cap A_2)\cup(A_2\cap A_3)\cup(A_3\cap A_4)\), \(\PP(V)=\frac12\).

  2. \(\binom nk\big/2^n\).

  3. Numărul șirurilor cu exact \(k\) biți egali cu \(1\) este \(\binom{10}k\); \(\PP(V)=1-\frac{144}{1024}\approx0.8594\).

Exercițiul 12 (Două zaruri contra unui zar cu 12 fețe)

Pentru acasă Ana aruncă două zaruri obișnuite și adună punctele; Barbu aruncă un zar cu \(12\) fețe, numerotate de la \(1\) la \(12\). Câștigă cel cu punctajul mai mare; la egalitate este remiză.

  1. Calculați probabilitatea ca Ana să câștige, probabilitatea unei remize și probabilitatea ca Barbu să câștige. Este jocul echitabil?

  2. Verificați în R prin enumerare. Ce se întâmplă dacă Ana aruncă trei zaruri, iar Barbu un zar cu \(20\) de fețe?

Răspunsuri
  1. \(\PP(\text{Ana})=\frac{216}{432}=\frac12\), \(\PP(\text{remiză})=\frac{36}{432}=\frac1{12}\), \(\PP(\text{Barbu})=\frac{180}{432}=\frac5{12}\); jocul nu este echitabil.

  2. Enumerarea confirmă valorile de la (a); cu trei zaruri contra unui zar cu \(20\) de fețe, Ana și Barbu câștigă fiecare cu probabilitatea \(0.475\), iar remiza are probabilitatea \(0.05\): jocul devine echitabil.

Exercițiul 13 (Pasageri și vagoane)

Pentru acasă Nouă pasageri urcă într-un tren cu trei vagoane; fiecare alege la întâmplare unul dintre vagoane (toate cele \(3^9\) moduri de alegere sunt egal probabile). Calculați probabilitatea ca:

  1. în primul vagon să urce exact trei pasageri;

  2. în fiecare vagon să urce câte trei pasageri;

  3. într-un vagon să urce doi pasageri, în altul trei și în cel rămas patru;

  4. niciun vagon să nu rămână gol.

  5. Verificați în R prin enumerarea tuturor celor \(3^9\) rezultate.

Răspunsuri
  1. \(\binom93\cdot2^6\big/3^9=\frac{5376}{19\,683}\approx0.2731\).

  2. \(\frac{9!}{3!\,3!\,3!}\big/3^9=\frac{1680}{19\,683}\approx0.0854\).

  3. \(3!\cdot\frac{9!}{2!\,3!\,4!}\big/3^9=\frac{7560}{19\,683}\approx0.3841\).

  4. \(1-\frac{3\cdot2^9-3}{3^9}=1-\frac{1533}{19\,683}\approx0.9221\).

  5. Enumerarea dă aceleași valori: \(0.2731\), \(0.0854\), \(0.3841\) și \(0.9221\).

Exercițiul 14 (Punctele fixe ale permutărilor prin enumerare)

Pentru acasă În problema potrivirilor (Exercițiul 10) numărul de potriviri este numărul de puncte fixe ale unei permutări alese la întâmplare.

  1. Pentru \(n=4\), determinați prin numărare câte dintre cele \(24\) de permutări au exact \(0\), \(1\), \(2\), \(3\) și \(4\) puncte fixe.

  2. Scrieți în R o funcție permutari(n) care întoarce toate permutările lui \(\{1,\dots,n\}\) (pentru \(n\le6\)) și verificați punctul (a).

  3. Pentru \(n=6\), comparați probabilitățile exacte obținute prin enumerare cu formula exact_k și calculați numărul mediu de puncte fixe.

Răspunsuri
  1. \(9\), \(8\), \(6\), \(0\) și \(1\) permutări cu \(0\), \(1\), \(2\), \(3\), respectiv \(4\) puncte fixe (probabilitățile \(0.375\), \(0.3333\), \(0.25\), \(0\) și \(0.0417\)); în particular, \(\PP(\text{cel puțin un punct fix})=\frac{15}{24}=0.625=p_4\).

  2. Funcția întoarce o matrice cu \(24\) de linii; numărătorile coincid cu cele de la (a).

  3. Enumerarea celor \(720\) de permutări coincide cu formula: \(0.3681\), \(0.3667\), \(0.1875\), \(0.0556\), \(0.0208\), \(0\) și \(0.0014\) pentru \(k=0,1,\dots,6\); numărul mediu de puncte fixe este exact \(1\).

8 Temă

  1. Fie \(A\), \(B\), \(C\) trei evenimente. Exprimați cu ajutorul operațiilor cu evenimente: „se realizează exact două dintre ele”, „se realizează cel mult două dintre ele” și „se realizează \(A\) sau \(B\), dar nu \(C\)”. Răspuns: \((A\cap B\cap C^c)\cup(A\cap B^c\cap C)\cup(A^c\cap B\cap C)\); \((A\cap B\cap C)^c=A^c\cup B^c\cup C^c\); \((A\cup B)\cap C^c\).

  2. Fie \(A\) și \(B\) două evenimente cu \(\PP(A)=0.6\) și \(\PP(B)=0.7\). Arătați că \(0.3\le\PP(A\cap B)\le0.6\). Dacă \(\PP(A\cap B)=0.4\), calculați probabilitatea să se realizeze cel puțin unul, exact unul, respectiv niciunul dintre cele două evenimente. Răspuns: \(0.9\); \(0.5\); \(0.1\).

  3. Câte numere din mulțimea \(\{1,\dots,500\}\) sunt divizibile cu \(3\) sau cu \(7\)? Care este probabilitatea ca un număr ales la întâmplare din această mulțime să nu fie divizibil nici cu \(3\), nici cu \(7\)? Verificați în R cu operatorul %%. Răspuns: \(166+71-23=214\); \(286/500=0.572\).

  4. Dintr-un grup format din \(8\) programatori și \(5\) testeri se alege la întâmplare o echipă de \(4\) persoane. Care este probabilitatea ca echipa să conțină exact \(2\) testeri? Dar cel puțin un tester? Răspuns: \(\binom52\binom82/\binom{13}4=280/715\approx0.3916\); \(1-\binom84/\binom{13}4=1-70/715\approx0.9021\).

  5. Câte anagrame are cuvântul PROBABILITATE? Dacă literele lui sunt amestecate la întâmplare, care este probabilitatea ca șirul obținut să înceapă cu o vocală? Răspuns: \(13!/(2!\,2!\,2!\,2!)=389\,188\,800\); \(6/13\approx0.4615\) (șase dintre cele \(13\) litere sunt vocale).

  6. Aruncăm trei zaruri echilibrate. Calculați probabilitatea ca suma lor să fie cel puțin \(15\), enumerând în R cele \(216\) rezultate cu expand.grid, apoi estimați aceeași probabilitate printr-o simulare cu \(10^5\) repetări. Răspuns: \(20/216\approx0.0926\).

  7. Pe câte persoane trebuie să întrebați pentru ca, cu probabilitate cel puțin \(1/2\), măcar una dintre ele să fie născută în aceeași zi cu dumneavoastră? Comparați cu pragul \(n=23\) din problema zilelor de naștere și explicați diferența. Indicație: probabilitatea este \(1-(364/365)^n\); în R, min(which(1 - (364/365)^(1:400) >= 0.5)). Răspuns: \(n=253\).

  8. Doisprezece colegi organizează un schimb de cadouri: fiecare extrage la întâmplare un bilet cu numele unui coleg (toate împărțirile biletelor sunt egal probabile). Estimați prin simulare, cu funcția potriviri din Exercițiul 10, probabilitatea ca nimeni să nu își extragă propriul nume și probabilitatea ca exact două persoane să își extragă propriul nume; comparați cu valorile date de exact_k. Răspuns: \(\approx0.3679\) și \(\approx0.1839\).

Bibliografie

Bertsekas, Dimitri P., and John N. Tsitsiklis. 2008. Introduction to Probability. 2nd ed. Athena Scientific.
Blitzstein, Joseph K., and Jessica Hwang. 2019. Introduction to Probability. 2nd ed. CRC Press.
Davies, Tilman M. 2016. The Book of R: A First Course in Programming and Statistics. No Starch Press.
Verzani, John. 2014. Using R for Introductory Statistics. 2nd ed. CRC Press.
Wagaman, Amy S., and Robert P. Dobrow. 2021. Probability with Applications and R. 2nd ed. Wiley.