Manon CHAIX - INFO4
Ce devoir a été fait avec Leila MICHELARD et Baptiste BOLEAT. Nos estimations ne sont pas toujours vérifiés par nos simulations et je ne parviens pas a expliquer pourquoi nous obtenons de tels résultats. Nous n’avons pas eu de difficultés à coder, mais il semblerait que les résultats ne soient pas toujours concluant.

EXERCICE 1 : QUESTION PRELIMINAIRE A PROPOS D’ESTIMATION

Q1.1.

Estimation de l’espérance de \(M\) pour \(a\) = 10 et \(n\) = 4

set.seed(1)
a = 10
n = 4
k = 100
r = replicate(k, max(as.integer(runif(n,0,a))))
mean(r)
## [1] 7.37

Estimation de l’espérance de \(M\) pour \(a\) = 10 et \(n\) = 40

set.seed(1)
a = 10
n = 40
k = 100
r = replicate(k, max(as.integer(runif(n,0,a))))
mean(r)
## [1] 9

Estimation de l’espérance de \(M\) pour \(a\) = 100 et \(n\) = 4

set.seed(1)
a = 100
n = 4
k = 100
r = replicate(k, max(as.integer(runif(n,0,a))))
mean(r)
## [1] 78.65

Estimation de l’espérance de \(M\) pour \(a\) = 100 et \(n\) = 400

set.seed(1)
a = 100
n = 400
k = 100
r = replicate(k, max(as.integer(runif(n,0,a))))
mean(r)
## [1] 98.97

En effectuant beaucoup de tirage, on remarque que l’espérance de \(M\) se rapproche de \(a\). Cette simulation nous permet donc de voir que l’espérance de \(M\) se rapproche de \(a\) lorsque \(n\) est grand. Néanmoins la moyenne est toujours plus petite que a. On suppose donc que l’espérance est \(E[M] = a - \frac{a}{n}\).

Par exemple pour \(a\) = 100 et \(n\) = 40

set.seed(1)
a = 100
n = 40
k = 100
r = replicate(k, max(as.integer(runif(n,0,a)+a/n)))
mean(r)
## [1] 99.81

On peut voir la variance comme l’écart moyen que l’on peut avoir dans l’espérance. Avec les calculs précédents et l’estimation de l’espérance, on peut en déduire que la variance est égale à \(Var(M) = \frac{a}{n}\).

Q1.2.

Estimation de l’espérance de \(M'\) pour \(a\) = 10 et \(n\) = 4

set.seed(1)
a = 10
n = 4
k = 100
r = replicate(k, 2/n*sum(as.integer(runif(n,0,a))))
mean(r)
## [1] 8.825

Estimation de l’espérance de \(M'\) pour \(a\) = 10 et \(n\) = 40

set.seed(2)
a = 10
n = 40
k = 100
r = replicate(k, 2/n*sum(as.integer(runif(n,0,a))))
mean(r)
## [1] 9.0455

Estimation de l’espérance de \(M'\) pour \(a\) = 100 et \(n\) = 4

set.seed(1)
a = 100
n = 4
k = 100
r = replicate(k, 2/n*sum(as.integer(runif(n,0,a))))
mean(r)
## [1] 97.685

Estimation de l’espérance de \(M'\) pour \(a\) = 100 et \(n\) = 400

set.seed(1)
a = 100
n = 400
k = 100
r = replicate(k, 2/n*sum(as.integer(runif(n,0,a))))
mean(r)
## [1] 98.8674

On peut constater que \(M'\) est plus juste \(M\).
Calcul de l’espérance de \(E[M']\) :
\(E[M']=E[\frac{2}{n}\sum_i{Xi}]\)
\(E[M']=\frac{2}{n}\sum_i{E[Xi}]\)
\(E[M']=\frac{2}{n}\sum_i{\frac{2a}{2}}\)
\(E[M']=\frac{2}{n}\sum_i{a}\)
\(E[M']=\frac{na}{n}\)
\(E[M']=a\)
Calcul de la variance de \(V[M']\) :
\(V[M'] = E[M'-E[M']]²\)
\(= E[\frac{2}{n}\sum_i{Xi} - a]*E[\frac{2}{n}\sum_i{Xi} - a]\)
\(= (E[\frac{2}{n}\sum_i{Xi}] - E[a])²\)
\(= (a -E[a])²\)
\(= a² - 2aE[a]+E[a]²\)
\(= a² - 2a² + a²\)
\(= 0\)
La variance est bien égale à 0 car l’espérance est égale à a.

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

Q2.3 : Cette stratégie n’est pas gagnante pour Bob, il va souvent tomber sur une valeur au dessus de A étant donné que sa réponse est une valeur légèrement au dessus du max. Néanmoins comme il n’engage pas d’argent, il ne prend pas de risque.

Code permettant d’estimer l’espérance du gain de Bob :

set.seed(1)
A = runif(1)
n = 10
k = 100
i = 0
G = vector(mode = "double", length = k)
repeat {
  X = runif(n,0,A)
  M = max(X)
  if(1.1*M <= A){
    G[i] = 0.1*M 
  }
  else {
    G[i] = 0
  }
  i = i + 1
  if(i==k){
    break;
  }
}
sum(G)
## [1] 0.8707465
mean(G)
## [1] 0.008707465

On voit que pour 100 tirages, Bob ne gagne qu’environ 1 euro et l’espérance de son gain ne s’élève qu’à 0,87%.

Q2.4 : Nous avons choisis de tester toutes les fois où \(A=a\) et de tracer sur un histogramme le nombre de fois où chaque M apparait.

Estimation des probabilités que \(A = 0.3\) :

set.seed(1)
n = 3
k = 1000
i = 0
a = 0.3
i = 0
res = vector(mode="integer", length = 11)
repeat {
  A = as.integer(runif(1,0,11))/10
  X = as.integer(runif(n,0,A*10+1))/10
  M = max(X)
  if(A == a){
    res[M*10] = res[M*10] + 1
  }
  i = i+1
  if(i == k){
    break
  }
}
nom_barres <- c("0.0", "0.1", "0.2", "0.3", "0.4", "0.5", "0.6", "0.7", "0.8", "0.9", "1.0")
barplot(res/k, names.arg=nom_barres)

La probabilité que \(A = 0.3\) et \(M = 0.2\) est plus importante que la probabilité que \(A = 0.3\) et \(M = 0.1\), ce qui est logique : en tirant 3 nombre entre 0 et 0.3 le maximum est plus souvent 0.2

Estimation des probabilités que \(A = 0.6\) :

set.seed(1)
n = 3
k = 1000
i = 0
a = 0.6
i = 0
res = vector(mode="integer", length = 11)
repeat {
  A = as.integer(runif(1,0,11))/10
  X = as.integer(runif(n,0,A*10+1))/10
  M = max(X)
  if(A == a){
    res[M*10] = res[M*10] + 1
  }
  i = i+1
  if(i == k){
    break
  }
}
nom_barres <- c("0.0", "0.1", "0.2", "0.3", "0.4", "0.5", "0.6", "0.7", "0.8", "0.9", "1.0")
barplot(res/k, names.arg=nom_barres)

La encore on peut constater que le plus souvent M = 0.5 donc, 0.1 en dessous de A.

Estimation des probabilités que \(A = 0.9\) :

set.seed(1)
n = 3
k = 1000
i = 0
a = 0.9
i = 0
res = vector(mode="integer", length = 11)
repeat {
  A = as.integer(runif(1,0,11))/10
  X = as.integer(runif(n,0,A*10+1))/10
  M = max(X)
  if(A == a){
    res[M*10]= res[M*10] + 1
  }
  i = i+1
  if(i == k){
    break
  }
}
nom_barres <- c("0.0", "0.1", "0.2", "0.3", "0.4", "0.5", "0.6", "0.7", "0.8", "0.9", "1.0")
barplot(res/k, names.arg=nom_barres)

On cherche maintenant à calculer \(P[A=a | M=m]\). Il est plus facile de calculer \(P[M=m|A=a]\). Nous allons donc partir de cette constation pour estimer le meilleur A possible.

set.seed(1)
resf <- NULL
for (j in 0:10){
  n = 3
  a = 0.1 *j
  m = 0.5
  res<- NULL
  for (i in 0:10){
      A = as.integer(runif(1,0,11))/10
      X = replicate(n,as.integer(runif(1,0,A*10+1))/10)
      M = max(X)
      if(A == a && M==m){
        res[i]<- 1
      }else{
        res[i]<-0
      }
  }
  resf[j]<-mean(res)
}
plot(resf)

nom_barres <- c("0.0", "0.1", "0.2", "0.3", "0.4", "0.5", "0.6", "0.7", "0.8", "0.9", "1.0")


Avec ce schéma on peut facilement constater que le A pour lequel on a le plus M = 0.5 est 0.5. Donc on devrait proposer à Bob A = 0.5.

Q2.5 :

Cette stratégie va dépendre de la valeur d’alpha qu’on va choisir. On peut donc supposer que si alpha est proche de 1, cette stratégie sera gagnante car on tombera sur un nombre proche de M mais légèrement supérieur. Au plus le alpha sera loin de 1, au plus le stratégie sera perdante. Au plus alpha grandit, au plus on s’éloigne de M. On a vu que cette stratégie fonctionnait pour 1.1*M donc on peut supposer qu’elle fonctionnera ici aussi.

Test pour n = 2 et alpha = 0.3 :

set.seed(1)
A = runif(1)
alpha = 0.3
n = 2
k = 100
i = 0
M = vector(mode = "double", length = k)
repeat {
  X = runif(n,0,A)
  m = max(X)
  if((m^alpha) <= A){
    M[i] = (m^alpha) - m 
  }
  else {
    M[i] = 0
  }
  i = i + 1
  if(i==k){
    break;
  }
}
mean(M)
## [1] 0

Test pour n = 2 et alpha = 0.5 :

set.seed(0)
A = runif(1)
alpha = 0.5
n = 2
k = 100
i = 0
M = vector(mode="double", length = k)
repeat {
  X = runif(n,0,A)
  m = max(X)
  if((m^alpha) <= A){
    M[i] = (m^alpha) - m 
  }
  else {
    M[i] = 0
  }
  i = i + 1
  if(i==k){
    break;
  }
}
mean(M)
## [1] 0.1430963

Test pour n = 2 et alpha = 0.7 :

set.seed(1)
A = runif(1)
alpha = 0.7
n = 2
k = 100
i = 0
M = vector(mode="double", length = k)
repeat {
  X = runif(n,0,A)
  m = max(X)
  if((m^0.7) <= A){
    M[i] = (m^alpha) - m 
  }
  else {
    M[i] = 0
  }
  i = i + 1
  if(i==k){
    break;
  }
}
mean(M)
## [1] 0.02808171

Avec cette simulation, on constate que la meilleure valeur de alpha serait 0.5. En choisissant 0.3, r(M) serait supérieur à A car il augmente trop. En choisissant 0.5, r(M) a plus de chance d’être inférieur à A et le gain est important car la valeur choisie reste grande. En choisissant 0.7, r(M) a plus de chance d’être inférieure à A mais le gain n’est pas très important car la valeur choisie reste trop proche de M. On peut donc supposé que 0.5 est le meilleur alpha si le nombre de lancé est petit (ici 2).

Nous allons refaire cette simulation mais avec n = 10.

Test pour n = 10 et alpha = 0.3

set.seed(1)
A = runif(1)
alpha = 0.3
n = 10
k = 100
i = 0
M = vector(mode="double", length = k)
repeat {
  X = runif(n,0,A)
  m = max(X)
  if((m^0.3) <= A){
    M[i] = (m^alpha) - m 
  }
  else {
    M[i] = 0
  }
  i = i + 1
  if(i==k){
    break;
  }
}
mean(M)
## [1] 0
set.seed(1)
A = runif(1)
alpha = 0.5
n = 10
k = 100
i = 0
M = vector(mode="double", length = k)
repeat {
  X = runif(n,0,A)
  m = max(X)
  if((m^0.5) <= A){
    M[i] = (m^alpha) - m 
  }
  else {
    M[i] = 0
  }
  i = i + 1
  if(i==k){
    break;
  }
}
mean(M)
## [1] 0
set.seed(1)
A = runif(1)
alpha = 0.7
n = 10
k = 100
i = 0
M = vector(mode="double", length = k)
repeat {
  X = runif(n,0,A)
  m = max(X)
  if((m^0.7) <= A){
    M[i] = (m^alpha) - m 
  }
  else {
    M[i] = 0
  }
  i = i + 1
  if(i==k){
    break;
  }
}
mean(M)
## [1] 0.001145158

Avec n = 10, il semblerait que la meilleure valeur soit 0.7. En effet, plus la valeur de n est grande, plus le M tiré à de chance d’être proche de A. Donc si on veut gagner, notre r(M) ne doit pas beaucoup varier, le alpha doit donc être plus proche de 1.