È possibile eseguire calcoli esatti.Ad esempio in R

  tira <- 100
ribalta <- 600
ddice <- rep (1/6, 6)
for (n in 2: rolls) {
  ddice <- (c (0, ddice, 0,0,0,0,0)) c (0,0, ddice, 0,0,0,0) + c (0,0,0, ddice, 0,0,0) +
            c (0,0,0,0, ddice, 0,0) + c (0,0,0,0,0, ddice, 0) + c (0,0,0,0,0,0, ddice)) / 6}
sum (ddice * (1-pbinom (1: flips, flips, 1/2))) # monete di probabilità altro
# 0.00809003
sum (ddice * dbinom (1: flips, flips, 1/2)) # probabilità uguaglianza
# 0.00111972
sum (ddice * pbinom (0: (flips-1), flips, 1/2)) # dice di probabilità altro
# 0.99079025
 

con quest'ultima figura corrispondente alla simulazione di BruceET

Le parti interessanti delle funzioni di massa di probabilità hanno questo aspetto (la moneta viene lanciata in rosso, i totali dei dadi in blu)

Un altro modo è simulare un milione di corrispondenze tra $ X $ e $ Y $ per approssimare $ P (X > Y) = 0.9907 \ pm 0.0002. $ [Simulation in R.]

  set.seed (825)
d = replicate (10 ^ 6, sum (sample (1: 6,100, rep = T)) - rbinom (1,600, .5))
media (d > 0)
[1] 0.990736
2 * sd (d > 0) / 1000
[1] 0.0001916057 # aprx 95% di margine di errore di simulazione
 

Note per il commento di @ AntoniParellada:

In R, la funzione sample (1: 6, 100, rep = T) simula 100 lanci di un dado equo; la somma di questo simula $ X $ . Inoltre rbinom è codice R per la simulazione una variabile casuale binomiale; qui è $ Y. $ La differenza è $ D = X - Y. $ La procedura replicate crea un vettore di un milione di differenze d . Quindi (d > 0) è un vettore logico di un milione di TRUE se FALSE s, il mean di che è la sua proporzione di TRUE s - la nostra risposta. Infine, l'ultima affermazione fornisce il margine di errore di un intervallo di confidenza del 95% della proporzione di TRUE (utilizzando 2 invece di 1,96), come un vero e proprio controllo dell'accuratezza della risposta simulata. [Con un milione di iterazioni normalmente ci si aspetta 2 o 3 passi decimali di accuratezza per le probabilità, a volte di più per probabilità finora da 1/2.]

Un po 'più preciso:

La varianza di una somma o differenza di due variabili casuali indipendenti è la somma delle loro varianze. Quindi, hai una distribuzione con una media uguale a $ 50 $ e deviazione standard $ \ sqrt {292 + 150} \ approx 21 $ . Se vogliamo sapere quanto spesso ci aspettiamo che questa variabile sia inferiore a 0, possiamo provare ad approssimare la nostra differenza mediante una distribuzione normale e dobbiamo cercare $ z $ span> -score per $ z = \ frac {50} {21} \ approx 2,38 $ . Naturalmente, la nostra distribuzione effettiva sarà un po 'più ampia (poiché convolgiamo un pdf binomiale con un pdf di distribuzione uniforme), ma si spera che questo non sia troppo impreciso. La probabilità che il nostro totale sia positivo, secondo una tabella $ z $ -score, è di circa $ 0,992 $ span >.

Ho eseguito un rapido esperimento in Python, eseguendo 10000 iterazioni, e ho ottenuto $ \ frac {9923} {10000} $ positivi. Non troppo lontano.

Il mio codice:

  importa numpy come np
c = np.random.randint (0, 2, size = (10000, 100, 6)). sum (axis = -1)
d = np.random.randint (1, 7, size = (10000, 100))
(d.sum (asse = -1) > c.sum (asse = -1)). sum ()
--> 9923
 

La risposta esatta è abbastanza facile da calcolare numericamente, non è necessaria alcuna simulazione. Per scopi didattici, ecco uno script elementare di Python 3 per farlo, senza utilizzare librerie statistiche predefinite.

  dalle raccolte import defaultdict

# definire le distribuzioni di una singola moneta e morire
moneta = tupla ((i, 1/2) for i in (0, 1))
die = tupla ((i, 1/6) for i in (1, 2, 3, 4, 5, 6))

# una semplice funzione per calcolare la somma di due variabili casuali
def add_rv (a, b):
  sum = defaultdict (float)
  for i, p in a:
    per j, q in b:
      somma [i + j] + = p * q
  tupla di ritorno (sum.items ())

# calcola la somma di 600 monete e 100 dadi
coin_sum = dice_sum = ((0, 1),)
per _ nell'intervallo (600): coin_sum = add_rv (coin_sum, coin)
per _ nell'intervallo (100): dice_sum = add_rv (dice_sum, die)

# calcola la probabilità che la somma dei dadi sia maggiore
prob = 0
per i, p in dice_sum:
  per j, q in coin_sum:
    se io > j: prob + = p * q

print ("probabilità di 100 dadi sommati a più di 600 monete =% .10f"% prob)
 

Provalo online!

Lo script sopra rappresenta una distribuzione di probabilità discreta come un elenco di coppie (valore, probabilità) e utilizza una semplice coppia di cicli annidati per calcolare la distribuzione della somma di due variabili casuali (iterando su tutti i possibili valori di ciascuna delle le somme). Questa non è necessariamente la rappresentazione più efficiente possibile, ma è facile da lavorare e più che abbastanza veloce per questo scopo.

(FWIW, questa rappresentazione delle distribuzioni di probabilità è anche compatibile con la raccolta di funzioni di utilità per modellare tiri di dadi più complessi che ho scritto per un post sul nostro sito gemello poco fa.)

Naturalmente, ci sono anche librerie specifiche del dominio e persino interi linguaggi di programmazione per calcoli come questo. Utilizzando uno di questi strumenti online, chiamato AnyDice, lo stesso calcolo può essere scritto in modo molto più compatto:

  X: 100d6
Y: 600d {0,1}
output X > Y denominato "1 if X > Y, else 0"
 

Sotto il cofano, credo che AnyDice calcoli il risultato più o meno come fa il mio script Python, tranne forse con un po 'più di ottimizzazioni.In ogni caso, entrambi danno la stessa probabilità di 0,9907902497 per la somma dei dadi maggiore del numero di teste.

Se vuoi, AnyDice può anche tracciare le distribuzioni delle due somme per te.Per ottenere trame simili dal codice Python, dovresti alimentare gli elenchi dice_sum e coin_sum in una libreria di plottaggio grafico come pyplot.

La seguente risposta è un po 'noiosa ma sembra essere l'unica fino ad oggi che contiene la risposta veramente esatta ! La normale approssimazione o simulazione o anche solo il calcolo della risposta esatta numericamente a un livello ragionevole di accuratezza, il che non richiede molto tempo, sono probabilmente il modo migliore per procedere - ma se vuoi il modo "matematico" di ottenere la risposta esatta, allora :

Indichiamo con $ X $ la somma dei punti che vediamo nei tiri di dado $ 100 $ , con probabilità funzione di massa $ p_X (x) $ .

Indichi $ Y $ il numero di teste nei $ 600 $ lanci di monete, con funzione di massa di probabilità $ p_Y (y) $ .

Cerchiamo $ P (X > Y) = P (X - Y > 0) = P (D > 0) $ dove $ D = X - Y $ è la differenza tra la somma dei punti e il numero di teste.

Sia $ Z = -Y $ , con funzione di massa di probabilità $ p_Z (z) = p_Y (-z) $ . Quindi la differenza $ D = X - Y $ può essere riscritta come somma $ D = X + Z $ span > il che significa che, poiché $ X $ e $ Z $ sono indipendenti, possiamo trovare la funzione di massa di probabilità di $ D $ prendendo la convoluzione discreta dei PMF di $ X $ span > e $ Z $ :

$$ p_D (d) = \ Pr (X + Z = d) = \ sum_ {k = - \ infty} ^ {\ infty} \ Pr (X = k \ cap Z = d - k) = \ sum_ {k = - \ infty} ^ {\ infty} p_X (k) p_Z (dk) $$

In pratica la somma deve essere fatta solo su valori di $ k $ per i quali le probabilità sono ovviamente diverse da zero. L'idea qui è esattamente ciò che ha fatto @IlmariKaronen, volevo solo scrivere le basi matematiche per questo.

Ora non ho detto come trovare il PMF di $ X $ , che viene lasciato come esercizio, ma nota che se $ X_1, X_2, \ dots, X_ {100} $ sono il numero di punti su ciascuno dei 100 lanci di dadi indipendenti, ciascuno con PMF uniformi discreti su $ \ {1, 2, 3, 4, 5, 6 \} $ , quindi $ X = X_1 + X_2 + \ dots + X_ {100} $ span> e così ...

  # Memorizza i PMF delle variabili come frame di dati con le colonne "value" e "prob".
# Importante che i valori siano consecutivi e crescenti per coerenza quando convolgono,
# quindi includi valori intermedi con probabilità 0 se necessario!

# Funzione per verificare se il dataframe è conforme alla precedente definizione di PMF
# Usa message_intro per spiegare quale controllo sta fallendo
is.pmf <- function (x, message_intro = "") {
  if (! is.data.frame (x)) {stop (paste0 (message_intro, "Not a dataframe"))}
  if (! nrow (x) > 0) {stop (paste0 (message_intro, "Dataframe has no rows"))}
  if (! "value"% in% colnames (x)) {stop (paste0 (message_intro, "No 'value' column"))}
  if (! "prob"% in% colnames (x)) {stop (paste0 (message_intro, "No 'prob' column"))}
  if (! is.numeric (x  $ value)) {stop (paste0 (message_intro, "'value' column not numeric"))}
  if (! all (is.finite (x $  value))) {stop (paste0 (message_intro, "Does 'value' contains NA, Inf, NaN etc?"))}
  if (! all (diff (x  $ value) == 1)) {stop (paste0 (message_intro, "'value' not consecutive and ascending"))}
  if (! is.numeric (x $  prob)) {stop (paste0 (message_intro, "colonna 'prob' non numerica"))}
if (! all (is.finite (x  $ prob))) {stop (paste0 (message_intro, "Does 'prob' contains NA, Inf, NaN etc?"))}
  if (! all.equal (sum (x $  prob), 1)) {stop (paste0 (message_intro, "la colonna 'prob' non somma a 1"))}
  return (TRUE)
}

# Funzione per convolgere i PMF di x e y
# Notare che per convolgere in R è necessario invertire il secondo vettore
# nome1 e nome2 vengono utilizzati nella segnalazione degli errori per i due input
convolve.pmf <- funzione (x, y, name1 = "x", name2 = "y") {
  is.pmf (x, message_intro = paste0 ("Checking", name1, "is valid PMF:"))
  is.pmf (y, message_intro = paste0 ("Checking", name2, "is valid PMF:"))
  x_plus_y <- data.frame (
    value = seq (from = min (x  $ value) + min (y $  value),
                to = max (x  $ value) + max (y $  valore),
                di = 1),
    prob = convolve (x  $ prob, rev (y $  prob), type = "open")
  )
  return (x_plus_y)
}

# Sia x_i il punteggio dei singoli lanci di dadi i
# Nota PMF di x_i è lo stesso per ogni i = 1 fino a i = 100)
x_i <- data.frame (
  valore = 1: 6,
  prob = rep (1/6, 6)
)

# Sia t_i il totale di x_1, x_2, ..., x_i
# Memorizzeremo i PMF di t_1, t_2 ... in un elenco
t_i <- list ()
t_i [[1]] <- x_i # t_1 è solo x_1 quindi ha lo stesso PMF
# PMF di t_i è la convoluzione di PMF di t_ (i-1) e x_i
per (i in 2: 100) {
  t_i [[i]] <- convolve.pmf (t_i [[i-1]], x_i,
        nome1 = incolla0 ("t_i [[", i-1, "]]"), nome2 = "x_i")
}

# Sia x la somma dei punteggi di tutti i 100 lanci di dadi indipendenti
x <- t_i [[100]]
is.pmf (x, message_intro = "Il controllo di x è PMF valido:")

# Sia y il numero di teste in 600 lanci di monete, così ha la distribuzione binomiale (600, 0,5):
y <- data.frame (valore = 0: 600)
y  $ prob <- dbinom (y $  valore, dimensione = 600, prob = 0,5)
is.pmf (y, message_intro = "Il controllo di y è PMF valido:")
# Sia z il negativo di y (nota che invertiamo l'ordine per mantenere i valori crescenti)
z <- data.frame (value = -rev (y  $ value), prob = rev (y $  prob))
is.pmf (z, message_intro = "Il controllo di z è PMF valido:")

# Sia d la differenza, d = x - y = x + z
d <- convolve.pmf (x, z, name1 = "x", name2 = "z")
is.pmf (d, message_intro = "Il controllo di d è PMF valido:")

# Prob (X > Y) = Prob (D > 0)
somma (d [d $ valore > 0, "prob"])
# [1] 0.9907902
 

Provalo online!

Non che abbia importanza praticamente se stai solo cercando una ragionevole precisione, poiché il codice sopra viene eseguito comunque in una frazione di secondo, ma c'è una scorciatoia per eseguire le convoluzioni per la somma di 100 variabili indipendenti distribuite in modo identico: da 100 = 64 + 32 + 4 quando espresso come somma di potenze di 2, puoi continuare a convolgere il più possibile le tue risposte intermedie con se stesse. Scrivendo i subtotali per i primi $ i $ tiri dado come $ T_i = \ sum_ {k = 1} ^ {k = i} X_k $ possiamo ottenere i PMF di $ T_2 = X_1 + X_2 $ , $ T_4 = T_2 + T_2 '$ (dove $ T_2' $ è indipendente da $ T_2 $ ma ha lo stesso PMF) e in modo simile $ T_8 = T_4 + T_4 '$ , $ T_ {16} = T_8 + T_8' $ , $ T_ {32} = T_ {16} + T_ {16} '$ e $ T_ {64} = T_ {32} + T_ {32} "$ . Abbiamo bisogno di altre due convoluzioni per trovare il punteggio totale di tutti i 100 dadi come somma di tre variabili indipendenti, $ X = T_ {100} = (T_ {64} + T_ {32} '') + T_4 '' $ e una convoluzione finale per $ D = X + Z $ . Quindi penso che tu abbia bisogno solo di nove convoluzioni in tutto - e per l'ultima, puoi limitarti alle parti della convoluzione che danno un valore positivo per $ D $ . Oppure, se è meno complicato, le parti che forniscono valori non positivi per $ D $ e quindi prendono il complemento. A condizione che tu scelga il modo più efficiente, credo che ciò significhi che il tuo caso peggiore è effettivamente otto circonvoluzioni e mezzo. EDIT: e come suggerisce @whuber, anche questo non è necessariamente ottimale!

Usando il metodo a nove convoluzioni che ho identificato, con il pacchetto gmp in modo da poter lavorare con oggetti bigq e scrivere un ciclo non ottimizzato da fare le convoluzioni (dato che il metodo integrato di R non si occupa degli input di bigq ), ci sono voluti solo un paio di secondi per calcolare l'esatta frazione semplificata:

1342994286789364913259466589226414913145071640552263974478047652925028002001448330257335942966819418087658458889485712017471984746983053946540181650207455490497876104509955761041797420425037042000821811370562452822223052224332163891926447848261758144860052289/1355477899826721990460331878897812400287035152117007099242967137806414779868504848322476153909567683818236244909105993544861767898849017476783551366983047536680132501682168520276732248143444078295080865383592365060506205489222306287318639217916612944423026688

che in effetti arrotondano a 0,9907902. Ora per la risposta esatta, non avrei voluto farlo con troppe altre convoluzioni, potevo sentire gli ingranaggi del mio laptop iniziare a scricchiolare!