DM

Exercice 1 :

Q1.1/

n = 20
a = runif(1,max = 10000)
N = 100
x = runif(n,max =a)

M = max(x)
mean1 = c()
mean2= c()

Mprime = sum(x)*(2/n)

for(a in 1:10)
{
M = replicate(N,max(runif(n,max =a)))
mean1[a] = mean(M)
mean2[a] = sum(M)*(2/n)
}


plot(mean1)

plot(mean2)

M est généralement proche de a. Il est quasiement tout le temps plus grand que a/2. Au plus on augemente n, au plus la valeur M est proche de a. Au plus on diminue a, au plus la valeur M est proche de a.

M est donc proportionel à a et inversement proportionel à n. Au plus n est grand, au plus E[M] tend vers a.

E[M] = (a*n) / (n-a).

Pour que E[M] = a, il faudrait que a soit égal à 0.

var(M) = ((a*n) / (n-a) - a/2)^2.

Q1.2/

M’ = 2NM/n, avec N le nombre de replicate que l’on fait pour M.

En effet, On retrouve le 2/n dans la formule. le N*M est la somme des Xi.

var(M’) = var(2NM/n) = 2N var(M)/n = 2N ((a*n) / (n-a) - a/2)^2 /n

L’estimateur M’ est un meilleur estimateur que M.

Exercice 2 :

Q2.3/

A = runif(1)
n = 10
X = runif(n = n, max = A)
G = c()
M = max(X)

r = 1.1*M  

for (i in 1:100)
{
  A = runif(1)
  M = max(runif(n = n, max = A))
  r = 1.1*M
  if(r <= A)
  {
    G[i] = (r - M)  
  }
  if(r > A)
  {
    G[i] = 0
  }
}
mean(G)

## [1] 0.01756959

Selon moi ce n’est pas une bonne stratégie. En faisant quelques essais, on remarque que la valeur r(M) dépasse souvent la valeure de A. Bob perdra donc beaucoup au jeu. Si Bob ne perd pas d’argent quand il se trompe, alors la stratégie peut être bonne car il arrive quand même de temps en temps à être en dessous de A.

Q2.4/

n = 3
e = seq(0,1, by = 0.1)
A = e[sample.int(n=11,1)]

e2 = seq(0,A,by=0.1)
X = e2[sample.int(n=length(e2), n,replace=T)]

M = max(X)
M1 = c()
for(j in 0:99)
{
  for(i in  0:10)
  {
    A = i/10
  
    e2 = seq(0,A,by=0.1)
    X = e2[sample.int(n=length(e2), n,replace=T)]
    M1[i+j*10] = max(X)
  }
}



a = 0.5
m = 0.5
P = 0;
N = 1000


for(j in 1:N)
{
    e = seq(0,1, by = 0.1)
    A = e[sample.int(n=11,1)]
  
    e2 = seq(0,A,by=0.1)
    X = e2[sample.int(n=length(e2), n,replace=T)]
    M = max(X)

    if(A == a && M == m)
    {
      P = P + 1
    }
}

P = P / N

P

## [1] 0.043

Avec le code du bas on calcule P, la probabilité que A = a et M = m. On fixe les valeurs de a et m que l’on souhaite, on fait un nombre N d’essais, et on regarde le nombre de ces essais où A = a et M = m. Par exemple, avec a et m = 0.5, on trouve que P est environ égal à O.O4

On cherche P(A = a, M = 0.5) <=> P(A >= 0.5, M = 0.5) car P(A < 0.5, M = 0.5) = 0.

n = 3
a = 0.6
m = 0.5
P = 0;
N = 1000
i = 0
Pr = c()

for(a in 5:10)
{
  for(j in 1:N)
  {
    e = seq(0,1, by = 0.1)
    A = e[sample.int(n=11,1)]
  
    e2 = seq(0,A,by=0.1)
    X = e2[sample.int(n=length(e2), n,replace=T)]
    M = max(X)

    if(A == a/10 && M == m)
    {
      P = P + 1
    }
  }
  Pr[i] = P / N
  i = i + 1
}

Pr

## [1] 0.034 0.034 0.048 0.063 0.071

Avec ce code, on additione les probabilités cumulées d’avoir M = 0.5, et A compris entre 0.5 et 1. On trouve en moyenne une probabilité de 0.065. Dans la plupart des cas, on trouve la plus forte probabilité de gagner pour M = 0.5 si A = 0.5 également. Il faut donc proposer cette valeur

Q2.5/

Vu que M <= 1 et que alpha < 1 alors r(M) >= M. Cela peut être une bonne stratégie en fonction de la valeur alpha.

n = 2
alpha = seq(0.3,0.7, by = 0.2)
G = 0
N = 10000
gain = c()

for(i in 1:length(alpha))
{
  for(j in 1:N)
  {
    e = seq(0,1, by = 0.1)
    A = e[sample.int(n=11,1)]
  
    e2 = seq(0,A,by=0.1)
    X = e2[sample.int(n=length(e2), n,replace=T)]
    M = max(X)

    r = M**alpha[i]
    if(r < A)
    {
      G = G + r - M
    }
  }
  gain[i] = G/N
  G = 0
}

gain

## [1] 0.05415186 0.05713167 0.04709359

Avec le code si dessus, on calcul dans gain la valeur de l’esperance du gain G en fonction de alpha. On remarque en faisant des tests que parmis ces 3 valeurs, le gain est meilleur si alpha = 0.5.

En essayant avec plusieurs valeurs, on trouve que l’on a un meilleur gain avec alpha = 0.4

n = 10
alpha = seq(0.1,0.9, by = 0.1)
G = 0
N = 10000
gain = c()

for(i in 1:length(alpha))
{
  for(j in 1:N)
  {
    e = seq(0,1, by = 0.1)
    A = e[sample.int(n=11,1)]
  
    e2 = seq(0,A,by=0.1)
    X = e2[sample.int(n=length(e2), n,replace=T)]
    M = max(X)

    r = M**alpha[i]
    if(r < A)
    {
      G = G + r - M
    }
  }
  gain[i] = G/N
  G = 0
}

gain

## [1] 0.004239504 0.004516718 0.005430074 0.005247178 0.007635381 0.007719349
## [7] 0.009060458 0.009074138 0.004477961

Pour n = 10, il y a plus de chances que M = A, et donc que Bob perde avec cette stratégie. Parmis les valeurs 0.3, 0.5, 0.7 pour alpha, la meilleure est 0.7. Parmis plus de valeurs, la meilleure est 0.8.

Q3.6/

La probabilité que Bob gagne avec cette stratégie est la probabilité que Alice fasse Pile, donc 0.5.

Q3.7/

On pourrait choisir une autre stratégie simple, par exemple dire oui si la valeur est supérieure à 0.5.

Avec cette stratégie, si A1 = 0.4 et A2 = 0.6, alors Bob à 100% de chances de gagner.

N = 10000
G = 0

for(i in 1:N)
{
  A1 = runif(1)
  A2 = runif(1)
  while(A2 < A1){A2 = runif(1)}
  
  PF = runif(1)
  if(PF >= 0.5)
  {
    if(A2 >= 0.5)
    {
     G = G + 1 
    }
  }
  else{
    if(A1 <= 0.5)
    {
      G = G + 1
    }
  }
  
}

G/N

## [1] 0.6726

Lorsque Alice tire A1 et A2 uniformement, la probabilité de gagner est de 0.67, ce qui est plus qu’une chance sur 2.