La historieta de Martin y Gala: lo esperado no es tan probable.

Tras contar la historieta de Martin y Gala dediqué dos entradas a mostrar dos posibles resoluciones de la misma: desde un enfoque probabilístico y utilizando una simulación por ordenador. Ambas sendas nos conducían a la solución de que se espera que el invitado tenga que contestar 255 preguntas de Martin antes de poder pasar a Gala.

Pero, ¿existen muchas probabilidades de que sean exactamente 255 preguntas las que conteste y acierte en mi previsión? Y es que, lo esperado no necesariamente coincide con lo más probable. Son conceptos que responden a preguntas diferentes.

Imaginemos un dado trucado de manera que la probabilidad de cada una de sus caras es 1/7, salvo la probabilidad de la cara con un 6 marcado que es igual a 2/7. La esperanza matemática de dicho dado es:

1·(1/7) + 2·(1/7) + 3·(1/7) + 4·(1/7) + 5·(1/7) + 6·(2/7) = 15/7 + 12/7 = 27/7 que redondeando a las centésimas queda 3'86.

Es decir, que si jugamos muchas (pero que muchas) veces, la media de las puntuaciones obtenidas en las tiradas tiende a 3,86. Pero eso no significa que el 4 sea el valor más probable (de hecho en nuestra situación imaginaria el más probable es el 6).

Volvemos a nuestra historia de Martin y Gala. ¿Cuál es la probabilidad de que el invitado tenga que contestar exactamente 255 preguntas antes de pasar a Gala? ¿Cuál es la probabilidad de que el invitado se libre de ese calvario y pueda pasar antes de contestar 255 preguntas?

La situación de la primera pregunta, la probabilidad de contestar exactamente 255 preguntas, se da cuando se pasa a Gala en el juego número 256, por lo que la probabilidad es (con p=(1/2)^8 y q=1-p):

p(contestar exactamente 255 preguntas) = q^255 · p = 0'00143984217604524.

Vemos que la probabilidad de contestar exactamente 255 preguntas es bastante pequeña, no llega ni al 15 ‱.

Y para abordar la segunda pregunta, la probabilidad de tener que contestar menos preguntas, podemos plantearlo de la siguiente manera:

p(contestar menos de 255 preguntas) = p(contestar exactamente 0 preguntas) + p(contestar exactamente 1 pregunta) + ... + p(contestar exactamente 254 preguntas) =

= p + q · p + q^2 · p + ... + q^254 · p = p · (1+q+q^2+...+q^254) = p · (q^255 - 1) / (q - 1) = 1 - q^255 = 0'6314004029324185.

Es decir, hay más de un 63% de probabilidad de que el invitado pase a Gala antes de contestar las 255 preguntas que se espera que conteste.

¿Y la simulación por ordenador qué nos dice? Añadimos unas pocas líneas más (ver código al final de la entrada) y ejecutamos el programa:

Media de preguntas antes de pasar: 255'193
Frecuencia relativa de coincidencia con preguntas esperadas: 0'001457
Frecuencia relativa de menos preguntas de las esperadas: 0'63112

La aproximación que devuelve una simulación de 1.000.000 de repeticiones es bastante buena.

Podemos concluir que lo más probable es que el invitado tenga que contestar menos preguntas de las "esperadas".

Ver siguiente entrada relacionada con MartinGala.

//////////////////////////////////////////////////////////////////////////////////////////////////////

Código fuente del programa en C (en negrita lo añadido):

#include < stdlib.h >
#include < iostream >
#include < time.h >
#include < math.h >
 

main()
{
    srand(time(NULL));
    unsigned int puntos=0, aleatorio=0, puntosNecesarios=8;
    unsigned long int preguntas=0, sumaPreguntas=0, vecesSimulacion=1000000;
    unsigned long int preguntasEsperadas=pow(2,puntosNecesarios)-1, coincidePreguntasEsperadas=0, menorPreguntasEsperadas=0;
    for(unsigned int n=0; n < vecesSimulacion; n++)
    {
        puntos=0;
        preguntas=0;
        while(puntos < puntosNecesarios)
        {
            aleatorio=rand()%2;
            if(aleatorio==0)
            {
                puntos=0;
                preguntas++;
            }
            else
            {
                puntos++;
            }
        } //while
        if(preguntas==preguntasEsperadas)
        {
            coincidePreguntasEsperadas++;
        }
        if(preguntas < preguntasEsperadas)
        {
            menorPreguntasEsperadas++;
        }
        sumaPreguntas+=preguntas;
    } //for n
    std::cout < < "Media de preguntas antes de pasar: " < < (float)sumaPreguntas/(float)vecesSimulacion < < std::endl;
    std::cout < < "Frecuencia relativa de coincidencia con preguntas esperadas: " < < (float)coincidePreguntasEsperadas/(float)vecesSimulacion < < std::endl;
    std::cout < < "Frecuencia relativa de menos preguntas de las esperadas: " < < (float)menorPreguntasEsperadas/(float)vecesSimulacion < < std::endl;
    return 0;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////