Ty i ja decydujemy się zagrać w grę, w której na zmianę podrzucamy monetę. Pierwszy gracz, który rzuci łącznie 10 głów, wygrywa. Oczywiście istnieje spór o to, kto powinien iść pierwszy.
Symulacje tej gry pokazują, że gracz, który przerzuca pierwszy, wygrywa o 6% więcej niż gracz, który przerzuca drugi (pierwszy gracz wygrywa przez około 53% czasu). Jestem zainteresowany modelowaniem tego w sposób analityczny.
To nie jest losowa zmienna dwumianowa, ponieważ nie ma ustalonej liczby prób (odwróć, aż ktoś zdobędzie 10 głów). Jak mogę to wymodelować? Czy to ujemny rozkład dwumianowy?
Aby móc odtworzyć moje wyniki, oto mój kod python:
import numpy as np
from numba import jit
@jit
def sim(N):
P1_wins = 0
P2_wins = 0
for i in range(N):
P1_heads = 0
P2_heads = 0
while True:
P1_heads += np.random.randint(0,2)
if P1_heads == 10:
P1_wins+=1
break
P2_heads+= np.random.randint(0,2)
if P2_heads==10:
P2_wins+=1
break
return P1_wins/N, P2_wins/N
a,b = sim(1000000)
probability
python
binomial
negative-binomial
Demetri Pananos
źródło
źródło
Odpowiedzi:
Rozkład liczby ogony przed osiągnięciem głowic ujemna dwumianowego parametrów 10 i 1 / 2 . Niech f będzie funkcją prawdopodobieństwa, a G funkcją przetrwania: dla każdego n ≥ 0 , f ( n ) oznacza szansę gracza na n- ogona przed 10 główami, a G ( n ) oznacza szansę gracza na n lub więcej ogonów przed 10 głowami.10 10 1/2 f G n≥0 f(n) n 10 G(n) n 10
Ponieważ gracze rzucają niezależnie, szansę, którą pierwszy gracz wygrywa, rzucając dokładnie ogonami, uzyskuje się, mnożąc tę szansę przez szansę, że drugi gracz rzuca n lub więcej ogonami, równą f ( n ) G ( n ) .n n f(n)G(n)
Zsumowanie wszystkich możliwych daje szanse wygranej pierwszego gracza jakon
To około więcej niż połowa czasu.3%
Zasadniczo, zastępując dowolną dodatnią liczbą całkowitą m , odpowiedź można podać w kategoriach funkcji hipergeometrycznej: jest równa10 m
Gdy używa się stronniczej monety z szansą głów, uogólnia się nap
Oto0.5325 −0.843
R
symulacja miliona takich gier. Podaje szacunkową wartość . Dwumianowy test hipotezy, aby porównać go z wynikiem teoretycznym, ma wynik Z wynoszący - 0,843 , co jest nieznaczną różnicą.źródło
Możemy wymodelować grę w następujący sposób:
Różnica w stawkach wygranych wynosi zatemPr(X=Y)=∑kPr(X=k,Y=k)=∑kPr(X=k)2.
Jak podejrzewasz,X (i Y ) są rozmieszczone zasadniczo zgodnie z ujemnym rozkładem dwumianowym. Oznaczenia tego są różne, ale w parametryzacji Wikipedii mamy głowy jako „porażkę”, a ogony jako „sukces”; potrzebujemy r=10 „awarii” (głów), zanim eksperyment zostanie zatrzymany, a prawdopodobieństwo sukcesu p=12 . Wtedy liczba „sukcesów”, która wynosiX−10 , maPr(X−10=k)=(k+9k)2−10−k,
a prawdopodobieństwo zderzenia wynosi
Pr(X=Y)=∑k=0∞(k+9k)22−2k−20,
co Mathematica mówi nam, że ma764995251162261467≈6.6% .
Tak więc wskaźnik wygranych Gracza B wynosiPr(Y>X)≈46.7% , a Gracza A wynosi 6193804961162261467≈53.3%
źródło
LetEij be the event that the player on roll flips i heads before the other player flips j heads, and let X be the first two flips having sample space {hh,ht,th,tt} where h means heads and t tails, and let pij≡Pr(Eij) .
Thenpij=Pr(Ei−1j−1|X=hh)∗Pr(X=hh)+Pr(Ei−1j|X=ht)∗Pr(X=ht)+Pr(Eij−1|X=th)∗Pr(X=th)+Pr(Eij|X=tt)∗Pr(X=tt)
Assuming a standard coinPr(X=∗)=1/4 means that pij=1/4∗[pi−1j−1+pi−1j+pij−1+pij]
solving forpij , =1/3∗[pi−1j−1+pi−1j+pij−1]
Butp0j=p00=1 and pi0=0 , implying that the recursion fully terminates. However, a direct naive recursive implementation will yield poor performance because the branches intersect.
An efficient implementation will have complexityO(i∗j) and memory complexity O(min(i,j)) . Here's a simple fold implemented in Haskell:
UPDATE: Someone in the comments above asked whether one was suppose to roll 10 heads in a row or not. So letEkl be the event that the player on roll flips i heads in a row before the other player flips i heads in a row, given that they already flipped k and l consecutive heads respectively.
Proceeding as before above, but this time conditioning on the first flip only,pk,l=1−1/2∗[pl,k+1+pl,0] where pil=pii=1,pki=0
This is a linear system withi2 unknowns and one unique solution.
To convert it into an iterative scheme, simply add an iterate numbern and a sensitivity factor ϵ :
Chooseϵ and pk,l,0 wisely and run the iteration for a few steps and monitor the correction term.
źródło