PALOMO_Rémy_DM1

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

1. Espérance de M

set.seed(4)
# Test 1
a = 15
n = 5
k = 1000
# On génère k fois M 
M = replicate(k,max(as.integer(runif(n, 0, a+1))))
E1 = mean(M)
E1

## [1] 12.725

# On observe les valeurs de M les plus fréquentes
hist(M)

# Test 2
a = 200
n = 50
k = 1000
# On génère encore k fois M
M2 = replicate(k,max(as.integer(runif(n, 0, a+1))))
E2 = mean(M2)
E2

## [1] 196.467

# On applique le même histogramme
hist(M2)

• On remarque que plus n est grand, plus l’espérance E est proche de a. Cela est plutôt logique car plus l’on tire de valeurs entre 0 et a plus on a de chances de tomber sur la valeur de a en question !
• Empiriquement, on observe que E[M] = a - (a/n)

• Il faut donc modifier M : M = maxi Xi + (a/n) pour que E[M] ait pour valeur a.

• Donc on peut estimer empiriquement la valeur de la variance : var(M) = (a/n)

2. Espérance de M’

set.seed(2)
# On réalise des jeux de test identique à la question 1. afin de remarquer plus facilement les différences
# Test 1
a = 15
n = 5
k = 1000
M = replicate(k, (2/n)*sum(as.integer(runif(n, 0, a+1))))
E1 = mean(M)
E1

## [1] 15.0804

hist(M)

# Test 2
a = 200
n = 50
k = 1000

M2 = replicate(k, (2/n)*sum(as.integer(runif(n, 0, a+1))))
E2 = mean(M2);
E2

## [1] 200.1924

hist(M2)

• On remarque que les valeurs générées sont en moyenne très proche de a, bien plus que la méthode précédente avant modification.
• L’espérance de M’ semble valoir alors a.

• On peut calculer E[M’] à partir de E[sum(Xi)] :

    On sait que E[M'] = (2/n)*E[sum(Xi)] = (2/n)*sum(E[Xi]) pour i allant de 1 à n, car X1, X2,..., Xn indépendants
  
    De plus :
        E[Xi] = 0*(1/a+1) + 1*(1/a+1) + (...) + a*(1/a+1)
              = (1/a+1)*sum(k) pour k allant de 1 à a.
              = (1/a+1)*((a*(a+1))/2)
        E[Xi] = a/2; 
  
    D'où :
        E[M'] = (2/n)*sum(E[Xi]) pour i allant de 1 à n
              = (2/n)*sum(a/2) pour i allant de 1 à n
              = (2/n)*(n*(a/2)) car chaque Xi possède la même espérance
              = a
  
    Donc :   E[M'] = a

• Variance de M’ :

    On sait : 
                  var(M') = E[M'²] - E[M']²
  
    D'une part : 
                  E[M']² = a²
  
    D'autre part : (en se basant sur les calculs précédents)
                  E[M'²] = (2/n)*sum(E[Xi²]) pour i allant de 1 à n, car chaque Xi indépendants
  
    Or : 
                  E[Xi²] = 1²*(1/a+1) + 2²*(1/a+1) +...+ a²*(1/a+1)
                         = (1/a+1)*sum(k²) pour k allant de 1 à a
                         = (1/a+1)*((a*(a+1)*(2a+1))/6)
                  E[Xi²] = (a*(2a+1))/6
  
    D'où :
                  E[M'²] = (2/n)*sum(E[Xi²])
                         = (2/n)*sum((a*(2a+1))/6)
                         = (2/n)*n*((a*(2a+1))/6) car chaque Xi possède la même espérance
                  E[M'²] = (a*(2a+1))/3
  
    Donc : 
                  var(M') = ((a*(2a+1))/3) - a²
                          = (2a² + a - 3a²)/3
                  var(M') = (a(1-a))/3

• Cet estimateur semble alors de meilleure qualité que le précédent car en plus d’avoir pour espérance la valeur exacte de a, sa variance reste la même, peu importe le nombre de Xi que l’on génère.

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

1.

• Avant tout test, la stratégie de Bob semble correcte car en augmentant peu la valeur de M, il s’assure de ne pas dépasser A souvent et ainsi augmenter ses chances de gagner. Cependant, l’écart entre r(M) et M étant faible, son gain moyen ne sera pas très élevé.

set.seed(44)
G <- NULL
n=10

for(i in 1:1000){
    # On génère A et M selon les règles du jeu :
    A = runif(1, 0, 1)
    M = max((runif(n, 0, A)))
    # On calcule r(M)
    rM = 1.1*M
    # On calcule G :
    if(rM <= A){
      G[i] = rM - M
    }
    else{
      G[i] = 0
    }
}

# On en déduit l'Éspérance de G :
EG = mean(G)
EG

## [1] 0.01703559

• D’après la simulation ci-dessus, l’espérance de gain vaut 0.017 euros. Cette espérance est certe faible, mais elle est avant tout positive. Donc même sans avoir beaucoup réfléchi, Bob a trouvé une tactique efficace, bravo à lui ! (En réalité ce jeu ne faisant pas perdre d’argent, l’espérance de gain est alors forcément >= à 0, mais donc Bob a bien choisi une technique efficace car E[G] > 0, mais on peut certainement faire mieux)

2.

• Code R simulant P[A=a & M=m] :

set.seed(7)
# Initialise le tableau quiva repertorier les réussites/echecs de l'expérience
cpt <- NULL
# On fixe les valeurs de a et m, que l'on peut choisir comme on le souhaite
a = 0.7
m = 0.6
n = 3

for(i in 1:1000){
  # On génère A et M selon les règles indiquées :
  A = ((as.integer(runif(1,0,11)))/10)
  M = max(as.integer(runif(n,0,(A*10)+1))/10)
  
  # On test si on a bien les conditions voulues
  if(A == a && M == m){
    cpt[i] <- 1
  } 
  else {
    cpt[i] <- 0
  }
}
# On renvoie la moyenne de reussite de l'expérience
# Plus i sera grand plus le résultat sera proche de la réalité
mean(cpt)

## [1] 0.024

3.

• En reprenant le code précédent, on calcule la proba P[A=a | M=0.5] :

set.seed(2)
res <- NULL
n=3
for(i in 1:11){
  cpt <- NULL
  a = (i-1)/10
  for(j in 1:1000){
    A = ((as.integer(runif(1,0,11)))/10)
    M = max(as.integer(runif(n,0,(A*10)+1))/10)
    
    # On test si on a bien les conditions voulues
    if(A == a && M == 0.5){
      cpt[j] <- 1
    } 
    else {
      cpt[j] <- 0
    }
  }
  # P[A | B] = P[A et B] / P[B]
  # Ici, P[A] <=> P[A=a] et P[B] <=> P[M=0.5]
  # Pour plus de clarté on arrondit le résultat
  res[i] <- round(mean(cpt)/(1/(10*a)+1),3)
}

# On stocke tous les résultats dans une data.frame
resultats <- data.frame(Proba=c(res[1],res[2],res[3],res[4],res[5],res[6],res[7],res[8],res[9],res[10],res[11]), row.names=c("A=0.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.0"))
resultats

##       Proba
## A=0.0 0.000
## A=0.1 0.000
## A=0.2 0.000
## A=0.3 0.000
## A=0.4 0.000
## A=0.5 0.032
## A=0.6 0.018
## A=0.7 0.017
## A=0.8 0.008
## A=0.9 0.012
## A=1.0 0.006

• Donc d’après le simulateur ci-dessus, si Alice nous indique que M=0.5 alors on devrait lui proposer une valeur de A égale, soit 0.5 !

• On osberve les mêmes résultats pour d’autres valeurs de M.

4.

• Cette stratégie est potentiellement bonne, car mettre un nombre à la puissance α avec α<1 va alors augmenter légèrement la valeur de ce nombre puisqu’il est lui-même compris entre 0 et 1. Plus α sera grand, moins la valeur de M va augmenter. Or, la méthode vu précédement consistant à répondre 1.1*M, qui donne un résultat légèrement plus grand que M, était efficace. L’efficacité va alors dépendre de la valeur de α !

• Simulation de l’expérience pour n=2 :

set.seed(4)
n = 2
k = 1000
G <- NULL
Res <- NULL
x <- NULL
y <- NULL

for(j in 1:11){
  α = (j-1)/10
  for(i in 1:1000){
    # On génère A et M selon les règles du jeu :
    A = runif(1, 0, 1)
    M = max((runif(n, 0, A)))
    # On calcule r(M)
    rM = M^α
    # On calcule G :
    if(rM <= A){
      G[i] = rM - M
    }
    else{
      G[i] = 0
    }
  }
  Res[j] <- round(mean(G),3)
  x[j] <- α
  y[j] <- Res[j]
}
plot(x,y)

# On stocke tous les résultats dans une data.frame
resultats <- data.frame(Proba=c(Res[1],Res[2],Res[3],Res[4],Res[5],Res[6],Res[7],Res[8],Res[9],Res[10],Res[11]), row.names=c("α=0.0","α=0.1","α=0.2","α=0.3","α=0.4","α=0.5","α=0.6","α=0.7","α=0.8","α=0.9","α=1.0"))
resultats

##       Proba
## α=0.0 0.000
## α=0.1 0.019
## α=0.2 0.039
## α=0.3 0.055
## α=0.4 0.062
## α=0.5 0.071
## α=0.6 0.066
## α=0.7 0.056
## α=0.8 0.044
## α=0.9 0.024
## α=1.0 0.000

• Donc parmis ces 3 valeurs, la meilleure valeur pour α est 0.5 car c’est avec cette valeur que l’on obtient l’espérance de gain la plus grande.

• Après plusieurs tests, on observe une symétrie pour E[G], avec pour pic α=0.5, qui possède donc la meilleure espérance de gain !

• Simulation de l’expérience pour n=10 :

set.seed(5)
n = 10
k = 1000
G <- NULL
Res <- NULL
x <- NULL
y <- NULL

for(j in 1:11){
  α = (j-1)/10
  for(i in 1:1000){
    # On génère A et M selon les règles du jeu :
    A = runif(1, 0, 1)
    M = max((runif(n, 0, A)))
    # On calcule r(M)
    rM = M^α
    # On calcule G :
    if(rM <= A){
      G[i] = rM - M
    }
    else{
      G[i] = 0
    }
  }
  Res[j] <- round(mean(G),3)
  x[j] <- α
  y[j] <- Res[j]
}
plot(x,y)

# On stocke tous les résultats dans une data.frame
resultats <- data.frame(Proba=c(Res[1],Res[2],Res[3],Res[4],Res[5],Res[6],Res[7],Res[8],Res[9],Res[10],Res[11]), row.names=c("α=0.0","α=0.1","α=0.2","α=0.3","α=0.4","α=0.5","α=0.6","α=0.7","α=0.8","α=0.9","α=1.0"))
resultats

##       Proba
## α=0.0 0.000
## α=0.1 0.002
## α=0.2 0.003
## α=0.3 0.006
## α=0.4 0.007
## α=0.5 0.010
## α=0.6 0.010
## α=0.7 0.013
## α=0.8 0.014
## α=0.9 0.013
## α=1.0 0.000

• Donc parmis les 3 valeurs {0.7, 0.5, 0.3}, la meilleure valeur pour α est 0.7 car c’est avec cette valeur que l’on obtient l’espérance de gain la plus grande.

• Après plusieurs tests, on observe encore une symétrie pour E[G], avec pour pic α=0.8, qui possède donc la meilleure espérance de gain !

• Cependant, la valeur du gain potentiel est nettement inférieure comparé à n=2

• Conclusion : Ainsi, au travers de ces deux expèriences on peut faire le constat suivant : Si l’on tire “peut de fois” des nombres entre 0 et A alors l’écart entre M et A sera en moyenne plus grand, ainsi le facteur d’augmentation qu’on peut appliquer à M sans dépasser A sera plus important (d’où le fait que α=0.5), et également l’écart entre r(M) et M en sera d’autant plus grand. Inversement, plus on va tirer de Xi alors la valeur de M sera bien plus proche de A, donc si l’on veut gagner il faudra très peu modifier M et donc avoir un α plus grand (ici α=0.8). L’écart entre r(M) et M étant faible l’espérance de gain baisse nettement. Donc, étonnament, moins on tire de Xi plus cette technique est efficace !

Exercice 3 :

1 :

• Peu importe les valeurs que Alice va choisir pour A1 et A2, au final il y a 1 chance sur 2 qu’elle indique à Bob la valeur de A2. Donc la probablité de gagner pour Bob est de 0.5.