Ich versuche, mich mit diesem Problem zu beschäftigen.
Ein Würfel wird 100 Mal gewürfelt. Wie hoch ist die Wahrscheinlichkeit, dass kein Gesicht mehr als 20 Mal erscheint? Mein erster Gedanke war die Verwendung der Binomialverteilung P (x) = 1 - 6 cmf (100, 1/6, 20), aber dies ist offensichtlich falsch, da wir einige Fälle mehr als einmal zählen. Meine zweite Idee ist es, alle möglichen Rollen x1 + x2 + x3 + x4 + x5 + x6 = 100 aufzulisten, so dass xi <= 20 und die Multinome summieren, aber dies scheint zu rechenintensiv. Ungefähre Lösungen werden auch für mich funktionieren.

Dies ist eine Verallgemeinerung des berühmten Geburtstagsproblems : Wenn Personen mit zufälligen, gleichmäßig verteilten "Geburtstagen" unter einer Reihe von d = 6 Möglichkeiten sind, wie groß ist die Wahrscheinlichkeit, dass kein Geburtstag von mehr als m = 20 Personen geteilt wird?$n=100$$d=6$$m=20$

Eine genaue Berechnung ergibt die Antwort (mit doppelter Genauigkeit). Ich werde die Theorie skizzieren und den Code für allgemeines n , m , d bereitstellen . Das asymptotische Timing des Codes ist O ( n 2 log ( d ) ) , was ihn für eine sehr große Anzahl von Geburtstagen d geeignet machtund eine angemessene Leistung bietet, bis n in den Tausenden liegt. Zu diesem Zeitpunkt sollte die Poisson-Näherung, die unterAusdehnung des Geburtstagsparadoxons auf mehr als 2 Personenerörtert wurde,in den meisten Fällen gut funktionieren.$0.267\,747\,907\,805\,267$$n, m, d.$$O(n^2\log(d))$$d$$n$

---

Erklärung der Lösung

Die Wahrscheinlichkeitserzeugungsfunktion (pgf) für die Ergebnisse von unabhängigen Würfeln eines d- seitigen Würfels ist$n$$d$

$$d^{-n}f_n(x_1,x_2,\ldots,x_d) = d^{-n}(x_1+x_2+ \cdots + x_d)^n.$$

Der Koeffizient von bei der Erweiterung dieses Multinomials gibt die Anzahl der Möglichkeiten an, wie das Gesicht i genau e i mal erscheinen kann , i = 1 , 2 , … , d $x_1^{e_1}x_2^{e_2}\cdots x_d^{e_d}$$i$$e_i$$i=1, 2, \ldots, d.$

Die Beschränkung unseres Interesses auf nicht mehr als Erscheinungen eines Gesichts ist gleichbedeutend mit der Bewertung von f n modulo, dem Ideal I, das durch x m + 1 1 , x m + 1 2 , … , x m + 1 d erzeugt wird . Um diese Auswertung durchzuführen, verwenden Sie den Binomialsatz rekursiv, um zu erhalten$m$$f_n$$\mathcal I$$x_1^{m+1}, x_2^{m+1}, \ldots, x_d^{m+1}.$

$$\eqalign{ f_n(x_1, \ldots, x_d) &= ((x_1+\cdots+x_r) + (x_{r+1}+x_{r+2} + \cdots + x_{2r}))^n \\ &= \sum_{k=0}^n \binom{n}{k} (x_1+\cdots+x_r)^k (x_{r+1}+\cdots+x_{2r})^{n-k} \\ &= \sum_{k=0}^n \binom{n}{k} f_k(x_1, \ldots, x_r) f_{n-k}(x_{r+1}, \ldots, x_{2r}) }$$

wenn ist gerade. Wenn wir f ( d ) n = f n ( 1 , 1 , … , 1 ) ( d Terme) schreiben , haben wir$d=2r$$f_n^{(d)} = f_n(1,1,\ldots, 1)$$d$

$$f_n^{(2r)} = \sum_{k=0}^n \binom{n}{k} f_k^{(r)} f_{n-k}^{(r)}.\tag{a}$$

Wenn ungerade ist, verwenden Sie eine analoge Zerlegung$d=2r+1$

$$\eqalign{ f_n(x_1, \ldots, x_d) &= ((x_1+\cdots+x_{2r}) + x_{2r+1})^n \\ &= \sum_{k=0}^n \binom{n}{k} f_k(x_1, \ldots, x_{2r}) f_{n-k}(x_{2r+1}), }$$

geben

$$f_n^{(2r+1)} = \sum_{k=0}^n \binom{n}{k} f_k^{(2r)} f_{n-k}^{(1)}.\tag{b}$$

In beiden Fällen können wir auch alles Modulo reduzieren , was von Anfang an leicht durchzuführen ist$\mathcal I$

$$f_n(x_j) \cong \left\{ \matrix{x^n & n \le m \\ 0 & n \gt m} \right. \mod \mathcal{I},$$

Bereitstellung der Startwerte für die Rekursion,

$$f_n^{(1)} = \left\{ \matrix{1 & n \le m \\ 0 & n \gt m} \right.$$

Was diese effizient macht , ist , dass die durch die Spaltung von Variablen in zwei gleich große Gruppen von r Variablen je und Einstellung aller Variablenwerte 1 , wir müssen nur alles beurteilen einmal für eine Gruppe und dann die Ergebnisse kombinieren. Dies erfordert die Berechnung von bis zu n + 1 Termen, von denen jeder eine O ( n ) -Berechnung für die Kombination benötigt. Wir brauchen nicht einmal ein 2D-Array, um f ( r ) n zu speichern , denn bei der Berechnung von f ( d ) n wird nur $d$$r$$1,$$n+1$$O(n)$$f_n^{(r)}$$f_n^{(d)},$ undf ( 1 ) n sind erforderlich.$f_n^{(r)}$$f_n^{(1)}$

Die Gesamtzahl der Schritte ist eins weniger als die Anzahl der Stellen in der binären Erweiterung von (die die Teilungen in Formel ( a ) in gleiche Gruppen zählt ) plus die Anzahl der Stellen in der Erweiterung (die alle Male ungerade zählt Wert angetroffen wird, der die Anwendung der Formel ( b ) erfordert ). Das sind immer noch nur O ( log ( d ) ) Schritte.$d$$(a)$$(b)$$O(\log(d))$

Auf Reiner zehn Jahre alten Workstation war die Arbeit in 0,007 Sekunden erledigt. Der Code ist am Ende dieses Beitrags aufgeführt. Es werden Logarithmen der Wahrscheinlichkeiten anstelle der Wahrscheinlichkeiten selbst verwendet, um mögliche Überläufe oder zu viele Unterläufe zu vermeiden. Dies ermöglicht es, den - Faktor in der Lösung zu entfernen, damit wir die Zählungen berechnen können, die den Wahrscheinlichkeiten zugrunde liegen.$d^{-n}$

Beachten Sie, dass dieses Verfahren zur Berechnung der gesamten Folge von Wahrscheinlichkeiten auf einmal führt, wodurch wir leicht untersuchen können, wie sich die Chancen mit n ändern .$f_0, f_1, \ldots, f_n$$n$

---

Anwendungen

Die Verteilung im verallgemeinerten Geburtstagsproblem wird von der Funktion berechnet tmultinom.full. Die einzige Herausforderung besteht darin, eine Obergrenze für die Anzahl der Personen zu finden, die anwesend sein müssen, bevor die Wahrscheinlichkeit einer Kollision zu groß wird. Der folgende Code tut dies mit roher Gewalt, beginnend mit kleinem n und verdoppelt es, bis es groß genug ist. Die gesamte Berechnung benötigt daher O ( n 2 log ( n ) log ( d ) ) Zeit, wobei n die Lösung ist. Die gesamte Wahrscheinlichkeitsverteilung für die Anzahl der Personen bis n wird berechnet.$m+1$$n$$O(n^2\log(n)\log(d))$$n$$n$

#
# The birthday problem: find the number of people where the chance of
# a collision of `m+1` birthdays first exceeds `alpha`.
#
birthday <- function(m=1, d=365, alpha=0.50) {
  n <- 8
  while((p <- tmultinom.full(n, m, d))[n] > alpha) n <- n * 2
  return(p)
}

$798$birthday(7)

---

$365$

---

Code

# Compute the chance that in `n` independent rolls of a `d`-sided die, 
# no side appears more than `m` times.
#
tmultinom <- function(n, m, d, count=FALSE) tmultinom.full(n, m, d, count)[n+1]
#
# Compute the chances that in 0, 1, 2, ..., `n` independent rolls of a
# `d`-sided die, no side appears more than `m` times.
#
tmultinom.full <- function(n, m, d, count=FALSE) {
  if (n < 0) return(numeric(0))
  one <- rep(1.0, n+1); names(one) <- 0:n
  if (d <= 0 || m >= n) return(one)

  if(count) log.p <- 0 else log.p <- -log(d)
  f <- function(n, m, d) {                   # The recursive solution
    if (d==1) return(one)                    # Base case
    r <- floor(d/2)
    x <- double(f(n, m, r), m)               # Combine two equal values
    if (2*r < d) x <- combine(x, one, m)     # Treat odd `d`
    return(x)
  }
  one <- c(log.p*(0:m), rep(-Inf, n-m))      # Reduction modulo x^(m+1)
  double <- function(x, m) combine(x, x, m)
  combine <- function(x, y, m) {             # The Binomial Theorem
    z <- sapply(1:length(x), function(n) {   # Need all powers 0..n
      z <- x[1:n] + lchoose(n-1, 1:n-1) + y[n:1]
      z.max <- max(z)
      log(sum(exp(z - z.max), na.rm=TRUE)) + z.max
    })
    return(z)
  }
  x <- exp(f(n, m, d)); names(x) <- 0:n
  return(x)
}

Die Antwort erhalten Sie mit

print(tmultinom(100,20,6), digits=15)

0,267747907805267

Zufallsstichprobenmethode

Ich habe diesen Code in R ausgeführt und 100 Würfel millionenfach repliziert:

y <- replizieren (1000000, alle (Tabelle (Beispiel (1: 6, Größe = 100, Ersetzen = WAHR)) <= 20))

Die Ausgabe des Codes innerhalb der Replikationsfunktion ist wahr, wenn alle Gesichter kleiner oder gleich 20 Mal erscheinen. y ist ein Vektor mit 1 Million Werten von wahr oder falsch.

Die Gesamtzahl. Die Anzahl der wahren Werte in y geteilt durch 1 Million sollte ungefähr der von Ihnen gewünschten Wahrscheinlichkeit entsprechen. In meinem Fall war es 266872/1000000, was eine Wahrscheinlichkeit von etwa 26,6% nahe legt.

Brute-Force-Berechnung

Dieser Code dauert auf meinem Laptop einige Sekunden

total = 0
pb <- txtProgressBar(min = 0, max = 20^2, style = 3)
for (i in 0:20) {
  for (j in 0:20) {
    for (k in 0:20) { 
      for (l in 0:20) {
        for (m in 0:20) {
          n = 100-sum(i,j,k,l,m)
          if (n<=20) {
            total = total+dmultinom(c(i,j,k,l,m,n),100,prob=rep(1/6,6))
          }
        }
      }
    }
    setTxtProgressBar(pb, i*20+j) # update progression bar            
  }
}
total

Ausgabe: 0,2677479

Dennoch könnte es interessant sein, eine direktere Methode zu finden, wenn Sie viele dieser Berechnungen durchführen oder höhere Werte verwenden möchten oder nur um eine elegantere Methode zu erhalten.

Zumindest ergibt diese Berechnung eine einfach berechnete, aber gültige Zahl, um andere (kompliziertere) Methoden zu überprüfen.