Número esperado de veces para tirar un dado hasta que cada lado haya aparecido 3 veces

¿Cuál es el número esperado de veces que debes tirar un dado hasta que cada lado haya aparecido 3 veces?

Esta pregunta se hizo en la escuela primaria de Nueva Zelanda y se resolvió mediante simulaciones. ¿Cuál es la solución analítica para este problema?

Supongamos que todos los lados $d=6$ tienen las mismas posibilidades. Generalicemos y encontremos el número esperado de tiradas necesarias hasta que el lado $1$ haya aparecido $n_1$ veces, el lado $2$ haya aparecido $n_2$ veces, ..., y el lado $d$ haya aparecido $n_d$ veces. Debido a que las identidades de los lados no importan (todos ellos tienen las mismas posibilidades), la descripción de este objetivo se puede condensar: supongamos que $i_0$ lados no tienen que aparecer en absoluto, $i_1$ de los lados es necesario que aparezca solo una vez, ... y $i_n$$n=\max(n_1,n_2,\ldots,n_d)$

$$\mathbf{i}=(i_0,i_1,\ldots,i_n)$$ $$e(\mathbf{i})$$ $e(0,0,0,6)$$i_3 = 6$

Una recurrencia fácil está disponible. En el próximo lanzamiento, el lado que aparece corresponde a uno de los : es decir, o no necesitábamos verlo, o necesitábamos verlo una vez, ..., o necesitábamos verlo más veces . es la cantidad de veces que necesitábamos verlo.$i_j$$n$$j$

• Cuando , no necesitábamos verlo y nada cambia. Esto sucede con probabilidad .$j=0$$i_0/d$

• Cuando entonces necesitábamos ver este lado. Ahora hay un lado menos que necesita verse veces y un lado más que necesita verse veces. Por lo tanto, convierte en e convierte en . Deje que esta operación en los componentes de se designe , para quej j - 1 i j i j - 1 i j - 1 i j + 1 i i ⋅ $j \gt 0$$j$$j-1$$i_j$$i_j-1$$i_{j-1}$$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}).$$

  Esto sucede con probabilidad .$i_j/d$

Simplemente tenemos que contar esta tirada de dados y usar la recursión para decirnos cuántas tiradas más se esperan. Por las leyes de la expectativa y la probabilidad total,

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

(Comprendamos que siempre que , el término correspondiente en la suma es cero).$i_j=0$

Si , hemos terminado y . De lo contrario, podemos resolver para , dando la fórmula recursiva deseadae ( i ) = 0 e ( i$i_0=d$$e(\mathbf{i}) =0$$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}$$

Tenga en cuenta que es el número total de eventos que deseamos ver. La operación reduce esa cantidad en uno para cualquier siempre que , que es siempre el caso. Por lo tanto, esta recursión termina a una profundidad precisa(igual a en la pregunta). Además (como no es difícil de verificar) el número de posibilidades en cada profundidad de recursión en esta pregunta es pequeño (nunca excede de ). En consecuencia, este es un método eficiente, al menos cuando las posibilidades combinatorias no son demasiado numerosas y recordamos los resultados intermedios (de modo que no haya valor de⋅ j j > 0 i j > 0 | yo | 3 ( 6 ) = 18 8

$$|\mathbf{i}| = 0(i_0) + 1(i_1) + \cdots + n(i_n)$$ $\cdot j$$j\gt 0$$i_j \gt 0$$|\mathbf{i}|$$3(6) = 18$$8$$e$ se calcula más de una vez).

que

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

Eso me pareció terriblemente pequeño, así que realicé una simulación (usando R). Después de más de tres millones de tiradas de dados, este juego se jugó hasta su finalización más de 100,000 veces, con una longitud promedio de . El error estándar de esa estimación es : la diferencia entre este promedio y el valor teórico es insignificante, lo que confirma la precisión del valor teórico.$32.669$$0.027$

La distribución de longitudes puede ser de interés. (Obviamente, debe comenzar a las , el número mínimo de rollos necesarios para recoger los seis lados tres veces cada uno).$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))

---

Implementación

Aunque el cálculo recursivo de es simple, presenta algunos desafíos en algunos entornos informáticos. El principal de ellos es almacenar los valores de medida que se calculan. Esto es esencial, ya que de lo contrario cada valor se calculará (de forma redundante) una cantidad muy grande de veces. Sin embargo, el almacenamiento potencialmente necesario para una matriz indexada por podría ser enorme. Idealmente, solo los valores de que realmente se encuentran durante el cálculo deben almacenarse. Esto requiere un tipo de matriz asociativa.$e$$e(\mathbf{i})$$\mathbf{i}$$\mathbf{i}$

Para ilustrar, aquí está el Rcódigo de trabajo . Los comentarios describen la creación de una clase simple "AA" (matriz asociativa) para almacenar resultados intermedios. Los vectores se convierten en cadenas y se usan para indexar en una lista que contendrá todos los valores. La operación se implementa como .$\mathbf{i}$E$\mathbf{i}\cdot j$%.%

Estos preliminares permiten que la función recursiva se defina de manera bastante simple de forma paralela a la notación matemática. En particular, la línea$e$

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

es directamente comparable a la fórmula anterior. Tenga en cuenta que todos los índices se han incrementado en porque comienza a indexar sus matrices en lugar de .$(1)$$1$R$1$$0$

El tiempo muestra que toma segundos calcular ; su valor es$0.01$e(c(0,0,0,6))

32.6771634160506

El error de redondeo de punto flotante acumulado ha destruido los dos últimos dígitos (lo que debería ser en 68lugar de 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))

Finalmente, aquí está la implementación original de Mathematica que produjo la respuesta exacta. La memorización se realiza a través de la e[i_] := e[i] = ...expresión idiomática , eliminando casi todos los Rpreliminares. Sin embargo, internamente, los dos programas están haciendo las mismas cosas de la misma manera.

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 versión original de esta pregunta comenzó su vida preguntando:

cuántos rollos se necesitan hasta que cada lado haya aparecido 3 veces

$\rightarrow$

Distribución de la cantidad de rollos necesarios ... de modo que cada lado aparezca 3 veces

$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$$

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

$P(N \leq n)$$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)$$

$n$

 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}]

$n$

$$\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}$$

$P(N\leq n)$$n$

$P(N=n)$

Por supuesto, la distribución no tiene límite superior, pero aquí podemos resolver fácilmente tantos valores como sea prácticamente necesario. El enfoque es general y debería funcionar igual de bien para cualquier combinación deseada de lados requerida.