Nombre de fois prévu pour lancer un dé jusqu'à ce que chaque camp apparaisse 3 fois

Quel est le nombre de fois que vous devez lancer un dé jusqu'à ce que chaque camp apparaisse 3 fois?

Cette question a été posée à l'école primaire en Nouvelle-Zélande et elle a été résolue à l'aide de simulations. Quelle est la solution analytique à ce problème?

Supposons que tous les côtés ont des chances égales. Généralisons et trouvons le nombre attendu de rouleaux nécessaires jusqu'à ce que le côté 1 apparaisse n 1 fois, le côté 2 apparaisse n 2 fois, ..., et le côté d apparaisse n d fois. Parce que les identités des côtés n'ont pas d'importance (elles ont toutes des chances égales), la description de cet objectif peut être condensée: supposons que i 0 côtés ne doivent pas du tout apparaître, i 1 des côtés doivent apparaître juste une fois, ... et i $d=6$$1$$n_1$$2$$n_2$$d$$n_d$$i_0$$i_1$$i_n$des côtés doivent apparaître fois. Soit i = ( i 0 , i 1 , … , e ( 0 , 0 , 0 , 6 ) : i 3$n=\max(n_1,n_2,\ldots,n_d)$ désigner cette situation et écrire e ( i ) pour le nombre attendu de rouleaux. La question demande

$$\mathbf{i}=(i_0,i_1,\ldots,i_n)$$ $$e(\mathbf{i})$$ $e(0,0,0,6)$ indique que les six côtés doivent être vus trois fois chacun.$i_3 = 6$

Une récurrence facile est disponible. Au rouleau suivant, le côté qui apparaît correspond à l'un des : c'est-à-dire que nous n'avions pas besoin de le voir, ou nous devions le voir une fois, ..., ou nous devions le voir n plus fois. j est le nombre de fois que nous avons eu besoin de le voir.$i_j$$n$$j$

• Quand , nous n'avions pas besoin de le voir et rien ne change. Cela se produit avec la probabilité i 0 / d .$j=0$$i_0/d$

• Lorsque nous devions voir ce côté. Maintenant, il y a un côté de moins qui doit être vu j fois et un autre côté qui doit être vu j - 1 fois. Ainsi, i j devient i j - 1 et i j - 1 devient i j$j \gt 0$$j$$j-1$$i_j$$i_j-1$$i_{j-1}$ . Soit cette opération sur les composantes de i désignée i ⋅ j , de sorte que$i_j+1$$\mathbf{i}$$\mathbf{i}\cdot j$

  $$\mathbf{i}\cdot j = (\color{gray}{i_0, \ldots, i_{j-2}}, i_{j-1}+1, i_j-1, \color{gray}{i_{j+1},\ldots, i_n}).$$

  Cela se produit avec la probabilité .$i_j/d$

Nous devons simplement compter ce jet de dé et utiliser la récursivité pour nous dire combien de rouleaux de plus sont attendus. Par les lois de l'espérance et de la probabilité totale,

$$e(\mathbf{i}) = 1 + \frac{i_0}{d}e(\mathbf{i}) + \sum_{j=1}^n \frac{i_j}{d}e(\mathbf{i}\cdot j)$$

(Comprenons que chaque fois que , le terme correspondant dans la somme est zéro.)$i_j=0$

Si , nous avons terminé et e ( i ) = $i_0=d$$e(\mathbf{i}) =0$ . Sinon, nous pouvons résoudre pour , en donnant la formule récursive souhaitée$e(\mathbf{i})$

$$e(\mathbf{i}) = \frac{d + i_1 e(\mathbf{i}\cdot 1) + \cdots + i_n e(\mathbf{i}\cdot n)}{d - i_0}.\tag{1}$$

Notez que est le nombre total d'événements que nous souhaitons voir. L'opération ⋅ j réduit cette quantité par une pour tout j > 0 fourni i j > 0 , ce qui est toujours le cas. Par conséquent, cette récursivité se termine à une profondeur de précisément | je | (égal à 3 ( 6 )

$$|\mathbf{i}| = 0(i_0) + 1(i_1) + \cdots + n(i_n)$$ $\cdot j$$j\gt 0$$i_j \gt 0$$|\mathbf{i}|$ dans la question). De plus (comme cela n'est pas difficile à vérifier) ​​le nombre de possibilités à chaque profondeur de récursivité dans cette question est faible (ne dépassant jamais 8 ). Par conséquent, c'est une méthode efficace, du moins lorsque les possibilités combinatoires ne sont pas trop nombreuses et que nous mémorisons les résultats intermédiaires (de sorte qu'aucune valeur de e n'est calculée plus d'une fois).$3(6) = 18$$8$$e$

Je calcule que

$$e(0,0,0,6) = \frac{2\,286\,878\,604\,508\,883}{69\,984\,000\,000\,000}\approx 32.677.$$

Cela me semblait terriblement petit, alors j'ai exécuté une simulation (en utilisant R). Après plus de trois millions de lancers de dés, ce jeu avait été joué jusqu'à son terme plus de 100 000 fois, avec une longueur moyenne de . L'erreur type de cette estimation est$32.669$ : la différence entre cette moyenne et la valeur théorique est insignifiante, confirmant l'exactitude de la valeur théorique.$0.027$

La distribution des longueurs peut être intéressante. (Évidemment, il doit commencer à , le nombre minimum de rouleaux nécessaires pour collecter les six côtés trois fois chacun.)$18$

# Specify the problem
d <- 6   # Number of faces
k <- 3   # Number of times to see each
N <- 3.26772e6 # Number of rolls

# Simulate many rolls
set.seed(17)
x <- sample(1:d, N, replace=TRUE)

# Use these rolls to play the game repeatedly.
totals <- sapply(1:d, function(i) cumsum(x==i))
n <- 0
base <- rep(0, d)
i.last <- 0
n.list <- list()
for (i in 1:N) {
  if (min(totals[i, ] - base) >= k) {
    base <- totals[i, ]
    n <- n+1
    n.list[[n]] <- i - i.last
    i.last <- i
  }
}

# Summarize the results
sim <- unlist(n.list)
mean(sim)
sd(sim) / sqrt(length(sim))
length(sim)
hist(sim, main="Simulation results", xlab="Number of rolls", freq=FALSE, breaks=0:max(sim))

---

la mise en oeuvre

Bien que le calcul récursif de soit simple, il présente certains défis dans certains environnements informatiques. Le plus important d'entre eux est le stockage des valeurs de e ( i ) lors de leur calcul. Ceci est essentiel, sinon chaque valeur sera (redondante) calculée un très grand nombre de fois. Cependant, le stockage potentiellement nécessaire pour un tableau indexé par i pourrait être énorme. Idéalement, seules les valeurs de i réellement rencontrées lors du calcul devraient être stockées. Cela nécessite une sorte de tableau associatif.$e$$e(\mathbf{i})$$\mathbf{i}$$\mathbf{i}$

Pour illustrer, voici le Rcode de travail . Les commentaires décrivent la création d'une simple classe "AA" (tableau associatif) pour stocker les résultats intermédiaires. Les vecteurs sont convertis en chaînes et ceux-ci sont utilisés pour indexer dans une liste qui contiendra toutes les valeurs. L' i ⋅ $\mathbf{i}$E$\mathbf{i}\cdot j$ opération est implémentée comme %.%.

Ces préliminaires permettent la fonction récursive $e$ de définir assez simplement d'une manière parallèle à la notation mathématique. En particulier, la ligne

x <- (d + sum(sapply(1:n, function(i) j[i+1]*e.(j %.% i))))/(d - j[1])

est directement comparable à la formule ci-dessus. Notez que tous les index ont été augmentés de 1 car commence à indexer ses tableaux à 1 plutôt qu'à $(1)$$1$R$1$$0$ .

Le timing montre qu'il faut seconde pour calculer$0.01$e(c(0,0,0,6)) ; sa valeur est

32,6771634160506

L'erreur d'arrondi à virgule flottante accumulée a détruit les deux derniers chiffres (qui devraient être 68plutôt que 06).

e <- function(i) {
  #
  # Create a data structure to "memoize" the values.
  #
  `[[<-.AA` <- function(x, i, value) {
    class(x) <- NULL
    x[[paste(i, collapse=",")]] <- value
    class(x) <- "AA"
    x
  }
  `[[.AA` <- function(x, i) {
    class(x) <- NULL
    x[[paste(i, collapse=",")]]
  }
  E <- list()
  class(E) <- "AA"
  #
  # Define the "." operation.
  #
  `%.%` <- function(i, j) {
    i[j+1] <- i[j+1]-1
    i[j] <- i[j] + 1
    return(i)
  }
  #
  # Define a recursive version of this function.
  #
  e. <- function(j) {
    #
    # Detect initial conditions and return initial values.
    #
    if (min(j) < 0 || sum(j[-1])==0) return(0)
    #
    # Look up the value (if it has already been computed).
    #
    x <- E[[j]]
    if (!is.null(x)) return(x)
    #
    # Compute the value (for the first and only time).
    #
    d <- sum(j)
    n <- length(j) - 1
    x <- (d + sum(sapply(1:n, function(i) j[i+1]*e.(j %.% i))))/(d - j[1])
    #
    # Store the value for later re-use.
    #
    E[[j]] <<- x
    return(x)
  }
  #
  # Do the calculation.
  #
  e.(i)
}
e(c(0,0,0,6))

Enfin, voici l' implémentation originale de Mathematica qui a produit la réponse exacte. La mémorisation est réalisée via l' e[i_] := e[i] = ...expression idiomatique , éliminant presque tous les Rpréliminaires. En interne, cependant, les deux programmes font les mêmes choses de la même manière.

shift[j_, x_List] /; Length[x] >= j >= 2 := Module[{i = x},
   i[[j - 1]] = i[[j - 1]] + 1;
   i[[j]] = i[[j]] - 1;
   i];
e[i_] := e[i] = With[{i0 = First@i, d = Plus @@ i},
    (d + Sum[If[i[[k]] > 0, i[[k]]  e[shift[k, i]], 0], {k, 2, Length[i]}])/(d - i0)];
e[{x_, y__}] /; Plus[y] == 0  := e[{x, y}] = 0

e[{0, 0, 0, 6}]

$\frac{2286878604508883}{69984000000000}$

La version originale de cette question a commencé sa vie en demandant:

combien de rouleaux sont nécessaires jusqu'à ce que chaque côté apparaisse 3 fois

$\rightarrow$ Pourquoi pas? Le problème se réduit à une doublure.

Répartition du nombre de rouleaux requis ... de sorte que chaque face apparaisse 3 fois

$n$$X_i$$i$$i \in \{1, \dots, 6\}$$(X_1, X_2,\dots, X_6)$$\text{Multinomial}(n,\frac16)$

$$P\left(X_1=x_1,\ldots ,X_6=x_6\right) \; = \; \frac{n! }{ x_1! \cdots x_6!} \; \frac{1}{6^n} \quad \text{ subject to: } \quad \sum _{i=1}^6 x_i=n$$

Laisser: $\quad N = \min\big\{n: \; {X_i \geq 3 \; \forall_i } \big\}. \;$$N$ est: $\quad P(N \leq n) \; = \; P\big(X_{\forall_i} \geq 3 \; \big| \; n\big)$

ie Pour trouver le cdf $P(N \leq n)$, calculez simplement pour chaque valeur de $n = \{18, 19, 20,\dots\}$:

$$P(X_1 \geq3, \dots , X_6 \geq 3) \quad \text{ where } \quad (X_1, \dots, X_6) \sim \text{Multinomial}(n,\frac16)$$

Voici, par exemple, le code Mathematica qui fait cela, comme$n$ passe de 18 à 60. Il s'agit essentiellement d'un vol simple:

 cdf = ParallelTable[ 
   Probability[x1 >= 3 && x2 >= 3 && x3 >= 3 && x4 >= 3 && x5 >= 3 &&  x6 >= 3, 
       {x1, x2, x3, x4, x5, x6} \[Distributed] MultinomialDistribution[n, Table[1/6, 6]]],
    {n, 18, 60}]

... qui donne le cdf exact comme $n$ augmente:

$$\begin{array}{cc} 18 & \frac{14889875}{11019960576} \\ 19 & \frac{282907625}{44079842304} \\ 20 & \frac{3111983875}{176319369216} \\ 21 & \frac{116840849125}{3173748645888} \\ 22 & \frac{3283142988125}{50779978334208} \\ 23 & \frac{61483465418375}{609359740010496} \\ \vdots & \vdots\\ \\ \end{array}$$

Voici un tracé du cdf $P(N\leq n)$, en tant que fonction de $n$:

Pour dériver le pmf $P(N=n)$, commencez simplement par différencier le cdf:

Bien sûr, la distribution n'a pas de limite supérieure, mais nous pouvons facilement résoudre ici autant de valeurs que cela est pratiquement nécessaire. L'approche est générale et devrait fonctionner aussi bien pour toute combinaison désirée de côtés requise.