set.seed(0);

Exercice 1 : Question préliminaire à propos d’estimation

Q1.1.

  • On peut intuiter que plus \(n\) grandit, plus \(M\) estimera précisément la valeur de \(a\). Pour cela, nous allons construire quelques graphes :
a = 10;
size = 100;
n = 1:size;
EM <- vector(mode = "double", length = size);
for(i in n) {
    # pour chaque valeur de n, on estime une valeur de l'espérance de M
    EM[i] = mean(replicate(1000, max(runif(i, 0, a))));
}
plot(n, EM, title(paste("Espérance de M en fonction de n (pour a = ", a, ")", sep="")));

Comme on peut le remarquer ci-dessus, pour un \(a\) fixé, plus \(n\) grandit, plus l’espérance de \(M\) se “rapproche” de la valeur \(a\) qu’a choisi Alice. On remarque aussi que pour toutes les valeurs de \(n\), l’espérance de \(M\) est plus grande ou égale à \(\frac{a}{2}\) ; en effet, car l’espérance de n’importe quel tirage \(X_i\) est égale à \(\frac{a}{2}\) (car on tire uniformément entre \(0\) et \(a\)).

size = 100;
a = 1:size;
n = 10;
EM <- vector(mode = "double", length = size);
for(i in a) {
    # pour chaque valeur de a, on estime une valeur de l'espérance de M
    EM[i] = mean(replicate(1000, max(runif(n, 0, i))));
}
plot(a, a - EM, title(paste("Écart entre a et l'espérance de M en fonction de a (pour n = ", n, ")", sep="")));

À l’inverse du graphe précédent, on remarque ici que pour un \(n\) fixé, plus \(a\) grandit, plus l’écart entre \(a\) et l’espérance de \(M\) s’agrandit. Cet écart est proportionnel à la valeur de \(a\).

  • Estimation de l’espérance de \(M\) :

    • Pour \(n=1\), \(\mathbf{E}(M)=\mathbf{E}(X)=\frac{a}{2}\), car l’expérience consiste d’une seule valeur générée uniformément entre \(0\) et \(a\).

    • Pour \(n=2\) et \(n=3\), nous allons approximer l’espérance de \(M\) avec R :

rep = 100000;
a = 10;
n = 2;
# on réplique rep fois l'expérience
Ms2 = replicate(rep, max(runif(n, 0, a)));
# on change n et on répète
n = 3;
Ms3 = replicate(rep, max(runif(n, 0, a)));
# on affiche les moyenne des rep expériences pour n=2 et n=3
mean(Ms2); mean(Ms3);
## [1] 6.655804
## [1] 7.504056

Ici, \(a=10\). Pour \(n=2\), \(\mathbf{E}(M)=\frac{2}{3}a\). Pour \(n=3\), \(\mathbf{E}(M)=\frac{3}{4}a\).

À partir des cas \(n\in\{1,2,3\}\), on peut déduire une formule pour l’espérance contenant à la fois \(a\) et \(n\) :

\[\mathbf{E}(M) = a\frac{n}{n+1}\]

Pour “corriger” \(M\) pour que son espérance soit égale à \(a\), il faudrait la définir de la façon suivante :

\[M=\text{max}_iX_i+a\frac{1}{n+1}\]

L’espérance de cette nouvelle variable aléatoire \(M\) vaudrait donc :

\[\mathbf{E}(M) = a\frac{n}{n+1}+a\frac{1}{n+1}=a\frac{n+1}{n+1}=a\]

  • Estimation de la variance de \(M\) :

Pour trouver la formule de la variance, on calcule la fonction de répartition de \(M\). Les tirages des \(X_i\) sont indépendants les uns des autres, d’où :

\[F(x)=P(M\leq x)=P(X_1\leq x)\ldots P(X_n\leq x)=\frac{x}{a}\ldots\frac{x}{a}=\left(\frac{x}{a}\right)^n\]

À partir de cette formule, on peut dériver pour obtenir la densité de répartition :

\[f(x)=F'(x)=\left(\left(\frac{x}{a}\right)^n\right)'=\left(\left(\frac{x^n}{a^n}\right)\right)'=\frac{nx^{n-1}}{a^n}\]

Nous pouvons ensuite calculer la variance à partir de la densité de probabilité et de l’espérance de \(M\) grâce au théorème de König-Huygens :

\[ \mathbf{V}(M)=\mathbf{E}(M^2)-\mathbf{E}(M)^2 =\int_{0}^{a}x^2f(x)\text{d}x-\mathbf{E}(M)^2 =\int_{0}^{a}x^2\frac{nx^{n-1}}{a^n}\text{d}x-\left(a\frac{n}{n+1}\right)^2 \]

\[ =a^2\frac{n}{n+2}-a^2\frac{n^2}{(n+1)^2} =a^2\left(\frac{n}{n+2}-\frac{n^2}{(n+1)^2}\right) =a^2\frac{4n^2+1}{(n+1)^2(n+2)} \]

Q1.2.

a = 10;
size = 10000;
n = 1:size;
EM <- vector(mode = "double", length = size);
for(i in n) {
    # pour chaque valeur de n, on estime une valeur de l'espérance de M'
    EM[i] = 2/i * sum(runif(i, 0, a));
}
plot(n, EM, title(paste("Espérance de M' en fonction de n (pour a = ", a, ")", sep="")));

On remarque sur le graphe ci-dessus que pour un \(a\) fixé, plus la valeur de \(a\) est grande, plus l’espérance de \(M'\) se rapproche de la valeur \(a\) qu’on cherche. Cependant, contrairement à l’estimateur \(M\), l’espérance de \(M'\) n’est plus strictement inférieure à la valeur \(a\) recherchée.

size = 10000;
a = 1:size;
n = 10;
EM <- vector(mode = "double", length = size);
for(i in a) {
    # pour chaque valeur de a, on estime une valeur de l'espérance de M'
    EM[i] = 2/n * sum(runif(n, 0, i));
}
plot(a, a - EM, title(paste("Écart entre a et l'espérance de M' en fonction de a (pour n = ", n, ")", sep="")));

Ici, on remarque que pour un \(n\) fixé, plus la valeur recherchée \(a\) grandit, moins l’espérance de \(M'\) permet d’estimer précisément la valeur de \(a\), car l’écart entre \(a\) et l’espérance de \(M'\) s’agrandit.

On peut donc intuiter que la variance sera plus élevée que pour l’estimateur précédent, \(M\).

  • Estimation de la variance de \(M'\) :

On peut calculer la variance de \(M'\) à partir de l’espérance de \(M'\) grâce au théorème de König-Huygens :

\[ \mathbf{V}(M')=\mathbf{E}(M'^2)-\mathbf{E}(M')^2 \]

Exercice 2 : Un deuxième jeu à base de max

Q2.3.

  • Oui, c’est une bonne stratégie, car Bob ne perdra pas d’argent s’il perd le jeu, tandis qu’il en gagnera si la valeur qu’il a donnée est plus petite que \(A\). Donc, l’espérance du gain que Bob peut recevoir est obligatoirement strictement positive. Cependant, sa stratégie est loin d’être optimale, ainsi, il ne maximisera pas ses gains à chaque partie.

r <- function(M) {
    return(1.1 * M);
}
jeu <- function() {
    n = 10;
    A = runif(1);
    M = max(runif(n, 0, A));
    return(ifelse(r(M) <= A, r(M) - M, 0));
}
rep = 100000;

espG = mean(replicate(rep, jeu()));
espG;
## [1] 0.01602531

Le gain espéré \(\mathbf{E}(G)\) de Bob pour chaque partie est d’environ 0.016€, soit 1.6 centimes, ce qui confirme donc notre intuition initiale.

Q2.4.

  • Nous allons générer une matrice de la façon suivante : pour chaque valeur possible de \(A\), nous allons faire un certain nombre de parties et regarder les valeurs que prend \(M\). Grâce à celà, nous obtiendrons, pour chaque valeur de \(A\), une estimation de la probabilité d’avoir \(M=m\). Voici le code pour effectuer cette expérience en R :
jeux <- function(n, a) {
    # cette fonction effectue rep parties avec A = a et estime les probabilités d'avoir chaque m
    rep = 10000;
    A = a;
    P = vector(mode = "numeric", length = 11);
    for(i in 1:rep) {
        # on fait une partie
        X = sample(seq(0, A, by=0.1), n, replace = T);
        M = max(X);
        # on incrémente la case M * 10 + 1 de un
        P[M * 10 + 1] <- P[M * 10 + 1] + 1;
    }
    # on divise par le nombre de répétitions pour obtenir une probabilité
    P <- P/rep;
    return(P);
}

n = 3;

# on déclare la matrice
exp = matrix(nrow = 11, ncol = 11, dimnames = list(
    c("M=0", "M=0.1", "M=0.2", "M=0.3", "M=0.4", "M=0.5", "M=0.6", "M=0.7", "M=0.8", "M=0.9", "M=1"),
    c("A=0", "A=0.1", "A=0.2", "A=0.3", "A=0.4", "A=0.5", "A=0.6", "A=0.7", "A=0.8", "A=0.9", "A=1")
));

# on fait des parties pour chaque valeur de A
for(j in 0:10)
    exp[,j+1] <- jeux(n, j/10);

# on arrondit à 3 chiffres significatifs pour que le résultat soit plus lisible
exp <- round(exp, digits = 3);

exp;
##       A=0 A=0.1 A=0.2 A=0.3 A=0.4 A=0.5 A=0.6 A=0.7 A=0.8 A=0.9   A=1
## M=0     1 0.125 0.035 0.017 0.008 0.004 0.003 0.002 0.002 0.001 0.001
## M=0.1   0 0.875 0.263 0.112 0.057 0.031 0.021 0.012 0.009 0.009 0.005
## M=0.2   0 0.000 0.703 0.296 0.156 0.088 0.054 0.037 0.024 0.020 0.014
## M=0.3   0 0.000 0.000 0.575 0.289 0.171 0.115 0.072 0.051 0.040 0.031
## M=0.4   0 0.000 0.000 0.000 0.490 0.281 0.182 0.120 0.086 0.060 0.044
## M=0.5   0 0.000 0.000 0.000 0.000 0.426 0.261 0.178 0.125 0.090 0.069
## M=0.6   0 0.000 0.000 0.000 0.000 0.000 0.363 0.248 0.172 0.123 0.101
## M=0.7   0 0.000 0.000 0.000 0.000 0.000 0.000 0.331 0.230 0.172 0.128
## M=0.8   0 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.301 0.217 0.160
## M=0.9   0 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.270 0.205
## M=1     0 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.242

Grâce à cette matrice, on remarque que peu importe la valeur de \(M\), Bob a tout intérêt à donner comme réponse que \(A\) vaut le \(M\) que Alice lui a donné. En effet, pour chaque valeur de \(M\), la colonne qui possède la plus grande probabilité est celle où \(M=A\).

On remarque aussi que la partie sous la diagonale de la matrice est nulle, en effet, car \(M\) est toujours inférieur à \(A\).

  • Grâce au tableau qu’on a généré ci-dessus, il suffit de regarder la ligne \(M=0.5\) pour obtenir un ordre de grandeur de \(P(A=a|M=0.5)\) (même si ce n’est pas vraiment sa valeur, car la somme de chaque ligne ne vaut pas \(1\)). Comme expliqué à lors de la question précédente, on a tout intérêt à proposer à Alice que \(A=M=0.5\), car parmi la ligne \(M=0.5\), \(A=0.5\) est la colonne qui possède la plus grande des probabilités de la ligne.

  • Comme expliqué précédemment, lorsqu’Alice nous donne la valeur \(M\), on maximise nos chances de gagner la partie en donnant comme réponse que \(A=M\), car c’est le choix qui possède la plus grande probabilité quelle que soit la valeur de \(A\).

Q2.5.

  • Cette stratégie peut être bonne, car, étant donné que \(M\lt1\) et \(\alpha\lt1\), alors \(M\lt M^\alpha\leq1\). La valeur \(r(m)\) que proposera Bob sera donc valide. Cependant, l’efficacité de cette stratégie dépendra fortement de la valeur de \(\alpha\) : plus \(\alpha\) sera petit, plus la valeur \(M^\alpha\) se rapprochera de \(1\). Comme Bob ne perd pas d’argent quand il perd le jeu, cette stratégie sera obligatoirement gagnante. Mais plus \(\alpha\) sera petit, plus Bob prendra de risques et pourra plus souvent perdre la partie ; néanmoins, il gagnera un peu plus d’argent s’il gagne la partie avec un petit \(\alpha\), car l’écart entre sa proposition et \(M\) sera plus grand.

  • Nous allons calculer avec R pour chaque valeur de \(\alpha\) l’espérance du gain de Bob à chaque partie :

r <- function(M, alpha) {
    return(M**alpha);
}
jeu <- function(n, alpha) {
    A = runif(1);
    M = max(runif(n, 0, A));
    return(ifelse(r(M, alpha) <= A, r(M, alpha) - M, 0));
}
rep = 100000;
alphas = c(0.7, 0.5, 0.3);

# on déclare le vecteur dans lequel on stockera les espérances
espG = vector(mode = "numeric", length = length(alphas));
# on estime pour chaque valeur de alpha l'espérance du gain de Bob
for(i in 1:length(espG))
    espG[i] <- mean(replicate(rep, jeu(2, alphas[i])));

espG;
## [1] 0.05635085 0.06687158 0.05654122

Pour les trois valeurs de \(\alpha\) que nous avons testé, cette stratégie est déjà beaucoup plus rentable que la première que Bob a proposé plus tôt. La meilleure valeur de \(\alpha\) parmi \(\{0.7,0.5,0.3\}\) semble être \(0.5\), avec un gain espéré d’environ 0.067€, soit 6.7 centimes.

Comme le gain pour \(\alpha\in\{0.7,0.3\}\) est plus faible que le gain pour \(\alpha=0.5\), on peut imaginer que \(\alpha=0.5\) est la valeur optimale pour maximiser le gain espéré. En effet :

\(\rightarrow\) Si \(\alpha\) devient trop grand, la valeur \(r(M)\) que proposera Bob sera à peine plus grande que la valeur \(M\), ce qui signifie que même si Bob a plus de chances de gagner, le gain sera très faible.

\(\rightarrow\) Si \(\alpha\) devient trop petit, la valeur \(r(M)\) que proposera Bob se rapprochera beaucoup de \(1\) ; ainsi, même si Bob gagnera plus d’argent s’il gagne la partie, il perdra bien plus souvent.

\(\alpha=0.5\) semble donc être le meilleur choix pour que Bob puisse maximiser ses gains. Nous allons voir avec R si ce raisonnement est correct :

r <- function(M, alpha) {
    return(M**alpha);
}
jeu <- function(n, alpha) {
    A = runif(1);
    M = max(runif(n, 0, A));
    return(ifelse(r(M, alpha) <= A, r(M, alpha) - M, 0));
}
rep = 10000;
# on stocke maintenant beaucoup de valeurs pour alpha
alphas = seq(0.1, 0.9, by=0.025);

# on déclare le vecteur dans lequel on stockera les espérances
espG = vector(mode = "numeric", length = length(alphas));
# on estime pour chaque valeur de alpha l'espérance du gain de Bob
for(i in 1:length(espG))
    espG[i] <- mean(replicate(rep, jeu(2, alphas[i])));

plot(alphas, espG, main = "Gain espéré en fonction de la valeur de alpha");

Le graphe ci-dessus confirme donc notre intuition ; ainsi, \(\alpha=0.5\) maximise bien le gain espéré de Bob à chaque partie.

  • Nous allons procéder de la même manière que précédemment ; seulement, cette fois-ci, \(n=10\).
r <- function(M, alpha) {
    return(M**alpha);
}
jeu <- function(n, alpha) {
    A = runif(1);
    M = max(runif(n, 0, A));
    return(ifelse(r(M, alpha) <= A, r(M, alpha) - M, 0));
}
rep = 100000;
alphas = c(0.7, 0.5, 0.3);

# on déclare le vecteur dans lequel on stockera les espérances
espG = vector(mode = "numeric", length = length(alphas));
# on estime pour chaque valeur de alpha l'espérance du gain de Bob
for(i in 1:length(espG))
    espG[i] <- mean(replicate(rep, jeu(10, alphas[i])));

espG;
## [1] 0.013500860 0.009446486 0.005439480

Les valeurs sont bien différentes de ce qu’on a observé pour \(n=3\). Ici, la meilleure valeur de \(alpha\) est \(0.7\), qui permet un gain espéré de 0.013€, soit 1.3 centimes. Ce gain moyen est cependant plus petit que la première stratégie de Bob. On voit aussi que plus \(alpha\) devient petit, moins Bob peut espérer de gain.

Regardons pour quelle valeur de \(alpha\) le gain espéré est maximal :

r <- function(M, alpha) {
    return(M**alpha);
}
jeu <- function(n, alpha) {
    A = runif(1);
    M = max(runif(n, 0, A));
    return(ifelse(r(M, alpha) <= A, r(M, alpha) - M, 0));
}
rep = 25000;
# on stocke maintenant beaucoup de valeurs pour alpha
alphas = seq(0.1, 0.9, by=0.025);

# on déclare le vecteur dans lequel on stockera les espérances
espG = vector(mode = "numeric", length = length(alphas));
# on estime pour chaque valeur de alpha l'espérance du gain de Bob
for(i in 1:length(espG))
    espG[i] <- mean(replicate(rep, jeu(10, alphas[i])));

plot(alphas, espG, main = "Gain espéré en fonction de la valeur de alpha");

On voit ici que le \(alpha\) qui permet un gain maximal pour le jeu est d’environ \(0.8\), qui donne un gain espéré d’environ 0.014€, soit 1.4 centimes. Ce gain reste très faible par rapport à ce qu’on a pu voir précédemment.

On conseillera donc plutôt à Bob d’utiliser cette stratégie seulement quand Alice et Bob choisissent un \(n\) à faible valeur, comme \(3\) par exemple. Si Alice et Bob choisissent un \(n\geq10\), on conseillera plutôt à Bob d’utiliser sa première stratégie, où \(r(M)=1.1M\).

Exercice 3 : Question bonus : un dernier jeu à base de max et de pile ou face

Q3.6.

Comme Alice choisit ses nombres, la seule part d’aléatoire dans le jeu est le lancer de pièce. Ainsi, comme la pièce est non biaisée, Alice a une chance sur deux de tomber sur pile (et donner \(A_2\), la plus grande des deux valeurs), et une chance sur deux de tomber sur face (et donner \(A_1\), la plus petite des deux valeurs).

n = 1000000;
# on simule un certain nombre de lancers de pièce
lancers = sample(0:1, n, replace = T);
# on compte le nombre de faces
esp = mean(lancers);
esp;
## [1] 0.500723

Grâce au code précédent, on confirme donc notre intuition. Ainsi, Bob, s’il répond toujours “oui” à Alice, aura une chance sur deux de gagner la partie.

Q3.7.

Une stratégie possible est la suivante : les nombres \(A_1\) et \(A_2\) étant choisis par Alice, si Alice donne à Bob un nombre supérieur à \(0.5\), il y a plus de chances que ce soit le plus grand des deux nombres. Réciproquement, si Alice donne à Bob un nombre inférieur à \(0.5\), il y a plus de chances que ce soit le plus petit des deux nombres.

La stratégie consiste donc pour Bob de répondre “oui” quand Alice donne un nombre supérieur à \(0.5\), et répondre “non” quand Alice donne un nombre inférieur à \(0.5\). Si le nombre qu’Alice donne est égal à \(0.5\), on laissera Bob choisir “oui” ou “non”.

  • Lorsque Alice choisira \(A_1=0.4\) et \(A_2=0.6\), Bob répondra “non” si Alice donne \(A_1\), car \(A_1\lt0.5\), et il répondra “oui” si Alice donne \(A_2\), car \(A_2\gt0.5\). Ainsi, dans cette situation, Bob gagnera à tous les coups.

  • Évaluons avec R le gain de cette stratégie lorsque Alice choisit \(A_1\) et \(A_2\) uniformément dans l’intervalle \([0,1]\) :

n = 1000000;
A1 = runif(n, 0, 1);
A2 = runif(n, A1, 1);
# on lance un certain nombre de pièces
# 0: pile, 1: face
lancers = sample(0:1, n, replace = T);

# vecteur qui stockera 0 si la partie est perdue, 1 si elle est gagnée
gagne = replicate(n, 0);
for(i in 1:n)
    # on regarde pour chaque lancer si notre stratégie aurait fonctionné
    # à noter : si Alice donne exactement 0.5, Bob répondra au hasard "oui" ou "non"
  if(lancers[i] == 0 && A2[i]> 0.5 || lancers[i] == 1 && A1[i] <= 0.5 || lancers[i] == 0 && A2[i] == 0.5 && sample(0:1) == 1 || lancers[i] == 1 && A1[i] == 0.5 && sample(0:1) == 1 )
    gagne[i] = 1;

# on estime la probabilité de gagner une partie avec cette stratégie
mean(gagne);
## [1] 0.673478

Cette stratégie permet donc à Bob de gagner deux fois sur trois, ce qui est considérablement mieux que la stratégie précédente de Bob, qui avait seulement une chance sur deux de gagner.