Exercice 1 :

Q 1.1/

Afin de tester les différentes situations possibles, nous effectuons trois tests avec trois couples différents de (a,n).
Tout d’abord, avec a > n :

a1 = 100
n1 = 15
m1 = rep(0,100000)

for (i in 1:100000) {
  x = runif(n1,0,a1)
  m1[i] = max(x)
}
mean(m1)
## [1] 93.76984

Ensuite, avec a = n :

a2 = 100
n2 = 100
m2 = rep(0,100000)

for (i in 1:100000) {
  x = runif(n2,0,a2)
  m2[i] = max(x)
}
mean(m2)
## [1] 99.01125

Enfin, avec a < n :

a3 = 10
n3 = 100
m3 = rep(0,100000)

for (i in 1:100000) {
  x = runif(n3,0,a3)
  m3[i] = max(x)
}
mean(m3)
## [1] 9.900899

On observe que dans chacun des cas, la moyenne obtenue vaut environ a - a/n. Afin d’obtenir une espérence égale à a, il nous faut donc ajouter a/n au résultat obtenu.

mean(m1) + a1/n1
## [1] 100.4365
mean(m2) + a2/n2
## [1] 100.0112
mean(m3) + a3/n3
## [1] 10.0009

Ensuite, afin d’estimer la variance, nous la calculons dans nos trois cas :

var(m1)
## [1] 34.52365
var(m2)
## [1] 0.9479248
var(m3)
## [1] 0.009608528

On observe ici que dans chacun des cas, la variance est inférieure à a²/n², et qu’il nous est difficile de pouvoir l’estimer plus précisément.

a1**2/n1**2
## [1] 44.44444
a2**2/n2**2
## [1] 1
a3**2/n3**2
## [1] 0.01

Cette estimation est très bonne dans les cas où a n’est pas supérieur à n. Dans le cas où a > n, cette estimation est par contre beaucoup moins précise.
On observe également que la variance est très faible lorsque a <= n. Notre estimateur est donc très bon dans ces cas là. Dans l’autre cas, sa valeur est assez élevée, mais n’est pas aberrante non plus. Notre estimateur est donc dans la globalité plutôt bon.

Q 1.2/

En observant cette formule, j’ai l’intuition que les résultats obtenus seront beaucoup plus proche du résultat voulu que précédemment.
Pour vérifier cela, nous effectuons nos tests dans les mêmes situations que la question précédente, afin de pouvoir bien comparer les résultats.

a1 = 100
n1 = 15
m1 = rep(0,10000)

for (i in 1:10000) {
  x = runif(n1,0,a1)
  m1[i] = 2/n1 * sum(x)
}
mean(m1)
## [1] 100.2282
a2 = 100
n2 = 100
m2 = rep(0,10000)

for (i in 1:10000) {
  x = runif(n2,0,a2)
  m2[i] = 2/n2 * sum(x)
}
mean(m2)
## [1] 100.0629
a3 = 10
n3 = 100
m3 = rep(0,10000)

for (i in 1:10000) {
  x = runif(n3,0,a3)
  m3[i] = 2/n3 * sum(x)
}
mean(m3)
## [1] 9.996402

On observe dans chacun des cas que la valeur de m est beaucoup plus proche de a que précédement, en y étant quasiment égale, ce qui suit bien mon intuition.
Cela s’explique simplement par le calcul :
E(M’) = E( 2/n * sum(Xi)) = 2/n * sum(E(Xi)) = 2/n * sum(a/2) = 2/n * n * a/2 = a

Nous calculons maintenant la variance afin de voir la qualité de cet estimateur.

var(m1)
## [1] 221.1774
var(m2)
## [1] 33.78783
var(m3)
## [1] 0.3390604

On observe que la variance est ici beaucoup plus élevée que précédement. Elle est toujours très faible pour n > a, mais dans les deux autres cas, elle est très élévée, et même immense dans le cas où a > n.
On peut ainsi en déduire que même si sur un échantillon suffisement grand, l’espérence de M’ est bien plus proche de résultat voulu que celle de M, M’ est un moins bon estimateur que M.

Exercice 2 :

Q 2.3/

Cette stratégie est intéressante puisque ce calcul n’augmentant que peu notre valeur de m, a de bonnes chances de toujours être inférieur à a. Sauf qu’il est possible que le résultat soit supérieur à 1, donc supérieur à la valeur maximale de a, ce qui rend notre réponse forcément fausse. De plus, si n est grand, on obtiendra un m assez proche de a, et donc, notre calcul nous donnera très probablement une valeur trop grande. Ici, avec notre n=10, je pense qu’il y a de grandes chances que l’on obtenienne souvent un résultat trop grand, et donc que l’on perde.

n = 10
m = rep(0,100000)
g = rep(0,100000)
defaites = 0

for (i in 1:100000) {
  a = runif(1,0,1)
  x = runif(n,0,a)
  m[i] = max(x)
  if(a >= 1.1*m[i]) g[i] = 1.1*m[i] - m[i]
  else defaites = defaites+1
}
mean(g)
## [1] 0.0158586

On observe que au final, l’argent moyen gagné par Bob est de 1 centime, ce qui est très peu.

defaites/100000
## [1] 0.61683

En observant le taux moyen de défaites au jeu, on observe qu’avec cette stratégie, il perd dans plus de 60% des cas, ce qui est énorme. La stratégie qu’il utilise est donc très peu efficace.

Q 2.4/

Afin d’observer toutes les probabilités des couples (a,m), nous allons contruire une matrice les contenant toutes. Par intuition, je dirais que les probabilités sont les plus élévées lorsque m est proche de a.

v = seq(0.0,1.0,0.1)
n = 3
nomsmat = list(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"),c("m = 0.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.0"))
res = matrix(0,nrow = 11, ncol = 11, dimnames = nomsmat)

for(i in 1:100000){
  ia = runif(1,1,12)
  a = v[ia]
  x = v[runif(n,1,ia)]
  m = max(x)
  for (j in 1:11){
    for (k in 1:11){
      if (a == v[j]) if (m == v[k]) res[j,k] = res[j,k] + 1
    }
  }
}
res/100000
##          m = 0.0 m = 0.1 m = 0.2 m = 0.3 m = 0.4 m = 0.5 m = 0.6 m = 0.7
## a = 0.0  0.09144 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000
## a = 0.1  0.03458 0.05688 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000
## a = 0.2  0.00609 0.04489 0.04057 0.00000 0.00000 0.00000 0.00000 0.00000
## a = 0.3  0.00235 0.01560 0.04064 0.03083 0.00000 0.00000 0.00000 0.00000
## a = 0.4  0.00096 0.00690 0.01907 0.03814 0.02562 0.00000 0.00000 0.00000
## a = 0.5  0.00055 0.00386 0.00995 0.02110 0.03456 0.02060 0.00000 0.00000
## a = 0.6  0.00036 0.00225 0.00582 0.01236 0.02051 0.03123 0.01882 0.00000
## a = 0.7  0.00024 0.00131 0.00414 0.00847 0.01291 0.02074 0.02680 0.01724
## a = 0.8  0.00017 0.00081 0.00283 0.00552 0.00857 0.01307 0.01894 0.02470
## a = 0.9  0.00006 0.00079 0.00205 0.00382 0.00662 0.01038 0.01315 0.01810
## a = 1.0  0.00003 0.00051 0.00159 0.00283 0.00451 0.00749 0.01049 0.01356
##          m = 0.8 m = 0.9 m = 1.0
## a = 0.0  0.00000 0.00000 0.00000
## a = 0.1  0.00000 0.00000 0.00000
## a = 0.2  0.00000 0.00000 0.00000
## a = 0.3  0.00000 0.00000 0.00000
## a = 0.4  0.00000 0.00000 0.00000
## a = 0.5  0.00000 0.00000 0.00000
## a = 0.6  0.00000 0.00000 0.00000
## a = 0.7  0.00000 0.00000 0.00000
## a = 0.8  0.01449 0.00000 0.00000
## a = 0.9  0.02359 0.01311 0.00000
## a = 1.0  0.01704 0.02097 0.01183

Tout d’abord, on peut bien voir qu’il est impossible d’avoir m > a, ce qui est normal. Ensuite, on peut voir que mon intuition était plutôt bonne, les probabilités les plus fortes sont pour les cas où m = a - 0.1 et m = a.

Nous voulons maintenant avoir les probabilités de P(A=a|m=0.5). Pour cela, nous devons lire la colonne correspondant à m=0.5 et en déduire les probabilités de la valeur de a.

res[,6]/sum(res[,6])
##   a = 0.0    a = 0.1     a = 0.2    a = 0.3    a = 0.4    a = 0.5    a = 0.6 
## 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.19901459 0.30170998 
##    a = 0.7    a = 0.8    a = 0.9    a = 1.0 
## 0.20036711 0.12626799 0.10028017 0.07236016
cumsum(res[,6]/sum(res[,6]))
##  a = 0.0   a = 0.1    a = 0.2   a = 0.3   a = 0.4   a = 0.5   a = 0.6   a = 0.7 
## 0.0000000 0.0000000 0.0000000 0.0000000 0.0000000 0.1990146 0.5007246 0.7010917 
##   a = 0.8   a = 0.9   a = 1.0 
## 0.8273597 0.9276398 1.0000000

On peut voir que la valeur ayant le plus de chances d’arriver est 0.6, c’est à dire m+0.1, et qu’il y a environ autant de probabilité que la valeur soit inférieure ou égale que supérieure à celle ci.
Nous allons à présent essayer pour d’autres valeurs de m afin de voir si cette déduction est bonne pour les autres valeurs.

res[,8]/sum(res[,8])
##  a = 0.0   a = 0.1    a = 0.2   a = 0.3   a = 0.4   a = 0.5   a = 0.6   a = 0.7 
## 0.0000000 0.0000000 0.0000000 0.0000000 0.0000000 0.0000000 0.0000000 0.2342391 
##   a = 0.8   a = 0.9   a = 1.0 
## 0.3355978 0.2459239 0.1842391
cumsum(res[,8]/sum(res[,8]))
##  a = 0.0   a = 0.1    a = 0.2   a = 0.3   a = 0.4   a = 0.5   a = 0.6   a = 0.7 
## 0.0000000 0.0000000 0.0000000 0.0000000 0.0000000 0.0000000 0.0000000 0.2342391 
##   a = 0.8   a = 0.9   a = 1.0 
## 0.5698370 0.8157609 1.0000000
res[,4]/sum(res[,4])
##   a = 0.0    a = 0.1     a = 0.2    a = 0.3    a = 0.4    a = 0.5    a = 0.6 
## 0.00000000 0.00000000 0.00000000 0.25050784 0.30990493 0.17144714 0.10043065 
##    a = 0.7    a = 0.8    a = 0.9    a = 1.0 
## 0.06882262 0.04485252 0.03103925 0.02299504
cumsum(res[,4]/sum(res[,4]))
##  a = 0.0   a = 0.1    a = 0.2   a = 0.3   a = 0.4   a = 0.5   a = 0.6   a = 0.7 
## 0.0000000 0.0000000 0.0000000 0.2505078 0.5604128 0.7318599 0.8322906 0.9011132 
##   a = 0.8   a = 0.9   a = 1.0 
## 0.9459657 0.9770050 1.0000000

On bien observe qu’il y a plus de probabilités que la valeur de a soit inférieure ou égale à m+0.1 que supérieure à m+0.1.
Donner la valeur de m est en général la seule qui nous fait gagner avec plus de 50% de probabilité, sauf que cela ne rapporte rien. Le plus intéressant est donc de donner m+0.1 afin de pouvoir maximizer nos gains.

Q 2.5/

Cette stratégie semble tout d’abord plausible, puisque en faisant ce calcul, nous obtiendront forcément un résultat inférieur à 1. Par contre, il est, comme pour la première méthode, très probable que lorsque l’on augmente n, m s’approche beaucoup de a, et donc, que le résultat du calcul soit trop grand.

n = 2
alpha1 = 0.7
alpha2 = 0.5
alpha3 = 0.3

m = rep(0,100000)
g1 = rep(0,100000)
g2 = rep(0,100000)
g3 = rep(0,100000)

for (i in 1:100000) {
  a = runif(1,0,1)
  x = runif(n,0,a)
  m[i] = max(x)
  if(a >= m[i]**alpha1) g1[i] = m[i]**alpha1 - m[i]
  if(a >= m[i]**alpha2) g2[i] = m[i]**alpha2 - m[i]
  if(a >= m[i]**alpha3) g3[i] = m[i]**alpha3 - m[i]
}
mean(g1)
## [1] 0.0562288
mean(g2)
## [1] 0.06637215
mean(g3)
## [1] 0.05608868

On observe ici que la meilleure valeur de alpha est 0.5. Le gain moyen est également 5 fois plus élévé qu’avec la première méthode.
On peut également voir que le gain avec alpha = 0.3 et alpha = 0.7 est presque identique. On peut donc en déduire qu’il n’est pas possible de trouver une autre valeur de alpha pour laquelle on obtiendrait un meilleur gain en utilisant cette méthode.

Nous allons effectuer la même chose, mais avec maintenant n = 10.

n = 10
alpha1 = 0.7
alpha2 = 0.5
alpha3 = 0.3

m = rep(0,100000)
g1 = rep(0,100000)
g2 = rep(0,100000)
g3 = rep(0,100000)

for (i in 1:100000) {
  a = runif(1,0,1)
  x = runif(n,0,a)
  m[i] = max(x)
  if(a >= m[i]**alpha1) g1[i] = m[i]**alpha1 - m[i]
  if(a >= m[i]**alpha2) g2[i] = m[i]**alpha2 - m[i]
  if(a >= m[i]**alpha3) g3[i] = m[i]**alpha3 - m[i]
}
mean(g1)
## [1] 0.01349989
mean(g2)
## [1] 0.009632943
mean(g3)
## [1] 0.005632117

On observe ici, contrairement à la fois précédente, que la valeur d’alpha la plus rentable est 0.7, mais que le gain moyen est à nouveau de 1 centime, comme pour la première méthode. On peut également voir que les gain avec alpha = 0.5 et alpha = 0.3 sont encore plus faibles.
On imagine donc qu’en augmentant un peu le alpha, il serait possible d’obtenir un gain légèrement plus important.

n = 10
alpha4 = 0.8

m = rep(0,100000)
g = rep(0,100000)

for (i in 1:100000) {
  a = runif(1,0,1)
  x = runif(n,0,a)
  m[i] = max(x)
  if(a >= m[i]**alpha4) g[i] = m[i]**alpha4 - m[i]
}
mean(g)
## [1] 0.01438514

En testant avec alpha = 0.8, on obtient en effet un gain légèrement plus important que pour alpha = 0.7, mais celui ci reste toujours bien inférieur au gain obtenu lorsque n = 2.
Cette méthode est donc optimale pour un n le plus petit possible, tout en étant bien meilleure que la première méthode testée.

Exercice 3 :

Q 3.6/

En disant tout le temps “oui”, Bob a une chance sur deux de gagner, puisque sa victoire ne dépend que de la pièce et qu’elle est non biaisée.

Q 3.7/

Afin de gagner avec plus de 50% de chances que de perdre, Bob doit dire que c’est la valeur la plus grande si la valeur donnée par Alice est supérieure à 0.5, et que c’est la plus petite dans les autres cas.
En effet, avec cette stratégie, Bob perd tout le temps si les deux valeurs sont inférieures à 0.5, et si les deux sont supérieures à 0.5 et que la valeur choisie est la plus petite. Dans tous les autres cas, Bob va gagner.

a1 = 0.4
a2 = 0.6
p = runif(1,0,1)
if(p > 0.5) a = a2
if(p <= 0.5) a = a1

if(a > 0.5) b = (a > a1)
if(a <= 0.5) b = (a < a2)

b
## [1] TRUE

Dans le cas où Alice choisit 0.4 et 0.6, Bob va gagner avec cette stratégie.

nbwin = 0
for (i in 1:100000){
  a1 = runif(1,0,1)
  a2 = runif(1,0,1)
  while(a2 < a1) a2 = runif(1,0,1)

  p = runif(1,0,1)
  if(p > 0.5) a = a2
  if(p <= 0.5) a = a1

  if(a > 0.5) b = (a > a1)
  if(a <= 0.5) b = (a < a2)

  if (b) nbwin = nbwin + 1
}
nbwin/100000
## [1] 0.67291

Dans le cas où Alice tire uniformément ses deux nombres, Bob aura 67% de chances de gagner.
On peut ainsi en déduire que cette stratégie est bien plus intéressante que la précédente, et qu’elle lui permettra de gagner plus souvent que de perdre.