Q1

Ci-dessous nous définissons plusieurs fonctions et constantes qui vont nous être utiles principalement dans la première partie.

Nt = 1000 # Nombre d'occurence lorsque nous chercherons l'espérance

Ab = function(N = Nt){ # Représente le comportement du joueur A lorsque 
                       # P(A) = (1/4, 1/4, 1/2) (Q1.1)
  t = floor(runif(N, min = 0, max = 4))
  for(i in 1:N) {
    if (t[i] == 3) {t[i] = 2}
  }
  t
}

Anb = function(N = Nt){ # Représente le comportement non-biaisé du joueur A (Q1.2)
  floor(runif(N, min = 0, max = 3))
}

Bb = function(N = Nt){ # Représente le comportement du joueur B lorsque 
                       # P(B) = (1/4, 1/4, 1/2) (Q1.1.1 et Q1.2.1)
  t = floor(runif(N, min = 0, max = 4))
  for(i in 1:N) {
    if (t[i] == 3) {t[i] = 2}
  }
  t
}

Bnb = function(N = Nt){ # Représente le comportement non-biaisé du joueur B (Q1.1.2 et Q1.2.2)
  floor(runif(N, min = 0, max = 3))
}

Bxy = function(N = Nt, x, y){ # Représente le comportement du joueur B lorsque que son vecteur
                              # probabilité est définie par P(B) = (x, y, 1-x-y)
  prob = c()
  tab = c()
  if(x != 0){
    for(i in 1:(10*x)){
      prob[i] = 0
    }
  }
  if(y != 0){
    for(i in (10*x + 1):(10*(x+y))){
      prob[i] = 1
    }
  }
  if(x+y != 1){
    for(i in (10*(x+y) + 1):10){
      prob[i] = 2
    }
  }
  for(i in 1:N){
    tab[i] = sample(prob,1)
  }
  tab
}

Gain = function(j1, j2){ # Renvoie un tableau comportant le gain du joueur 1 et 
                         # celui du joueur 2 selon les signes qu'ils jouent
  res = c()
  if(j1 == j2){
    res[1] = 0
    res[2] = 0
  }
  if((j1 == j2+1) || (j2 == j1+2)){
    res[1] = 1
    res[2] = -1
  } 
  if((j2 == j1+1) || (j1 == j2+2)){
    res[1] = -1
    res[2] = 1
  }
  res
}

# rown et coln contiennent les noms des lignes et colonnes que l'on donnera 
# aux tableaux à deux dimensions (Q1.1.3 et Q1.2.3)

rown = c("X = 0.", "X = 0.1", "X = 0.2", "X = 0.3", "X = 0.4", "X = 0.5", "X = 0.6",
         "X = 0.7", "X = 0.8", "X = 0.9", "X = 1.0")
coln = c("Y = 0.", "0.1", "0.2", "0.3","0.4", "0.5", "0.6", "0.7", "0.8", "0.9", "1.0")

Q1.1.1

q111 = function(N = Nt){
  e = c()
  for(j in 1:100){
    j1 = Bb()
    j2 = Ab()
    B = 0
    A = 0
    for(i in 1:N){
      manche = Gain(j1[i],j2[i])
      B = B + manche[1]
      A = A + manche[2]
    }
    e[j] = B/N
  }
  mean(e)
}

q111()
## [1] 0.00069

Dans le cas où A et B sont biaisés le joueur B a une espérance de gain estimable à 0.

Q1.1.2

q112 = function(N = Nt){
  e = c()
  for(j in 1:100){
    j1 = Bnb()
    j2 = Ab()
    B = 0
    A = 0
    for(i in 1:N){
      manche = Gain(j1[i],j2[i])
      B = B + manche[1]
      A = A + manche[2]
    }
    e[j] = B/N
  }
  mean(e)
}

q112()
## [1] 0.00147

Dans le cas où A est biaisé et B non-biaisé le joueur B a une espérance de gain proche de 0.

Q1.1.3

q113 = function(N = Nt){
  Res = matrix(nrow = 11, ncol = 11, dimnames = list(rown,coln))
  for(ix in 0:10){
    for(iy in 0:10){
      if(ix+iy <= 10){
        moy = c()
        for(j in 1:10){
          j1 = Bxy(x = ix/10, y = iy/10)
          j2 = Ab()
          B = 0
          A = 0
          for(i in 1:N){
            manche = Gain(j1[i],j2[i])
            B = B + manche[1]
            A = A + manche[2]
          }
          moy[j] = B/N
        }
        Res[ix+1, iy+1] = round(mean(moy),2)
      }
    }
  }
  Res
}

q113()
##         Y = 0.   0.1   0.2   0.3   0.4   0.5   0.6   0.7   0.8   0.9   1.0
## X = 0.   -0.01 -0.02 -0.04 -0.08 -0.09 -0.12 -0.15 -0.18 -0.20 -0.23 -0.25
## X = 0.1   0.02  0.00 -0.04 -0.04 -0.08 -0.09 -0.12 -0.15 -0.18 -0.20    NA
## X = 0.2   0.05  0.02  0.00 -0.02 -0.06 -0.08 -0.09 -0.12 -0.15    NA    NA
## X = 0.3   0.08  0.05  0.03  0.00 -0.03 -0.05 -0.07 -0.10    NA    NA    NA
## X = 0.4   0.10  0.08  0.06  0.03  0.01 -0.03 -0.06    NA    NA    NA    NA
## X = 0.5   0.11  0.10  0.07  0.05  0.01 -0.02    NA    NA    NA    NA    NA
## X = 0.6   0.14  0.13  0.10  0.07  0.03    NA    NA    NA    NA    NA    NA
## X = 0.7   0.16  0.15  0.13  0.09    NA    NA    NA    NA    NA    NA    NA
## X = 0.8   0.20  0.16  0.15    NA    NA    NA    NA    NA    NA    NA    NA
## X = 0.9   0.22  0.21    NA    NA    NA    NA    NA    NA    NA    NA    NA
## X = 1.0   0.27    NA    NA    NA    NA    NA    NA    NA    NA    NA    NA

Ce tableau représente l’espérance de gain du joueur B contre un joueur A biaisé tel que P(B)=(x, y, 1-x-y) lorsque x et y varient entre 0 et 1.

Q1.1.4

D’après les résultats obtenus à la question précédente la stratégie optimale pour le joueur B consiste à joueur tout le temps “pierre” il aura alors une espérance de gain de 0.25.

Q1.1.5

On note X l’évènement le joueur B, avec P(B)=(x, y, 1-x-y), gagne contre le joueur A, avec P(A)=(1/4, 1/4, 1/2), si B perd X=0, X vaut 1 s’il y a match nul et X=2 en cas de victoire. On note G le gain du joueur B. On cherche E(G):

E(G) = -1 * P(X=0) + 0 * P(X=1) + 1 * P(X=2)
E(G) = P(X=2) - P(X=0)
E(G) = (x/2 + y/4 + (1-x-y)/4) - (x/4 + y/2 + (1-x-y)/4)
E(G) = (1/4 + x/4) - (1/4 + y/4)

E(G) = x/4 - y/4

On retrouve bien les mêmes résultats que lors des deux questions précédentes, le gain augmente avec x et diminue lorsque y augmente. Pour maximiser le gain il faut alors que le joueur B joue tout le temps pierre (c’est-à-dire x=1) et l’espérance du gain est alors de 0,25.

Q1.2.1

q121 = function(N = Nt){
  e = c()
  for(j in 1:100){
    j1 = Bb()
    j2 = Anb()
    B = 0
    A = 0
    for(i in 1:N){
      manche = Gain(j1[i],j2[i])
      B = B + manche[1]
      A = A + manche[2]
    }
    e[j] = B/N
  }
  mean(e)
}

q121()
## [1] 0.00164

Dans le cas où A et non biaisé et B est biaisé le joueur B a une espérance de gain qui peut être estimée à 0.

Q1.2.2

q122 = function(N = Nt){
  e = c()
  for(j in 1:100){
    j1 = Bnb()
    j2 = Anb()
    B = 0
    A = 0
    for(i in 1:N){
      manche = Gain(j1[i],j2[i])
      B = B + manche[1]
      A = A + manche[2]
    }
    e[j] = B/N
  }
  mean(e)
}

q122()
## [1] -0.00126

Dans le cas où A et B sont non-biaisés le joueur B a une espérance de gain proche de 0.

Q1.2.3

q123 = function(N = Nt){
  Res = matrix(nrow = 11, ncol = 11, dimnames = list(rown,coln))
  for(ix in 0:10){
    for(iy in 0:10){
      if(ix+iy <= 10){
        moy = c()
        for(j in 1:10){
          j1 = Bxy(x = ix/10, y = iy/10)
          j2 = Anb()
          B = 0
          A = 0
          for(i in 1:N){
            manche = Gain(j1[i],j2[i])
            B = B + manche[1]
            A = A + manche[2]
          }
          moy[j] = B/N
        }
        Res[ix+1, iy+1] = round(mean(moy),2)
      }
    }
  }
  Res
}

q123()
##         Y = 0.   0.1  0.2   0.3   0.4   0.5 0.6   0.7   0.8   0.9   1.0
## X = 0.    0.00  0.00 0.00 -0.01 -0.01  0.00   0 -0.01  0.02 -0.01 -0.01
## X = 0.1   0.00  0.01 0.00 -0.01 -0.01 -0.02   0  0.00 -0.01 -0.01    NA
## X = 0.2  -0.01 -0.01 0.01 -0.01  0.00 -0.01   0  0.01  0.01    NA    NA
## X = 0.3  -0.01  0.00 0.00  0.01  0.02  0.00   0  0.01    NA    NA    NA
## X = 0.4  -0.01  0.00 0.01  0.01 -0.01  0.01   0    NA    NA    NA    NA
## X = 0.5  -0.01 -0.01 0.01 -0.01 -0.01 -0.01  NA    NA    NA    NA    NA
## X = 0.6  -0.01  0.00 0.01  0.00 -0.01    NA  NA    NA    NA    NA    NA
## X = 0.7   0.01 -0.01 0.00  0.01    NA    NA  NA    NA    NA    NA    NA
## X = 0.8   0.00  0.01 0.00    NA    NA    NA  NA    NA    NA    NA    NA
## X = 0.9  -0.01  0.00   NA    NA    NA    NA  NA    NA    NA    NA    NA
## X = 1.0   0.00    NA   NA    NA    NA    NA  NA    NA    NA    NA    NA

Ce tableau représente l’espérance de gain du joueur B contre un joueur A non-biaisé tel que P(B)=(x,y,1-x-y) lorsque x et y varient entre 0 et 1.

Q1.2.4

D’après les résultats obtenus à la question précédente il n’y a pas vraiment de stratégie optimale pour le joueur B puisque quoiqu’il choisisse le joueur A aura un tiers de chance de le battre, se faire battre ou faire égalité. Cela se voit sur la matrice obtenu à la question précédente où toutes les valeurs sont proches de 0.

Q1.2.5

On note X l’évènement le joueur B, avec P(B)=(x, y, 1-x-y), gagne contre le joueur A, avec P(A)=(1/3, 1/3, 1/3), si B perd X=0, X vaut 1 s’il y a match nul et X=2 en cas de victoire. On note G le gain du joueur B. On cherche E(G):

E(G) = -1 * P(X=0) + 0 * P(X=1) + 1 * P(X=2)
E(G) = P(X=2) - P(X=0)
E(G) = (x/3 + y/3 + (1-x-y)/3) - (x/3 + y/3 + (1-x-y)/3)

E(G) = 0

On retombe sur la même conclusion que lors des questions précédentes, l’espérance du gain est de 0 et ne dépend pas de x ou de y.

Q2

Q2.1

Pour adapter notre façon de jouer aux fréquences d’apparition des différents signes de notre adversaire on peut simplement garder en mémoire dans un tableau de taille 3 le nombre de fois que chaque signe a été joué. Il nous suffit alors de jouer celui qui apparait le plus, en cas d’égalité du nombre d’apparitions maximal (notamment pour le début) on joue les deux à égalité avec la probabilité 1/2 ou les 3 à égalité avec la probabilité 1/3.

Q2.2

j2 = function(){
  t = floor(runif(n = 1, min = 1, max = 5))
  if (t[1] == 4) {t[1] = 3}
  return(t[1])
}

triplEgal = function(){
  floor(runif(n = 1, min = 1, max = 4))[1]
}

doublEgal = function(p){
  t = floor(runif(n = 1, min = 1, max = 3))[1]
  if (p == 1){
    t
  }
  if (p == 2 && t == 2){
    3
  }
}

supp = function(x){
  x = x-1
  x = (x+1)%%3
  x = x+1
  return(x)
}

q22 = function(N = Nt){
  mem = c(0,0,0)
  esp = 0
  espT = c()
  m = 0
  for(i in 1:N){
    if(mem[1] == mem[2] && mem[2] == mem[3]){
      m = triplEgal()
    }
    else{
      maxi = max(which(mem == max(mem)))
      if(maxi != 3){
        if(mem[maxi] == mem[maxi+1]){
        m = doublEgal(p = 1) + maxi - 1
        }
      }
      if(maxi == 1){
        if(mem[maxi] == mem[maxi+2]){
          m = doublEgal(p = 2)
        }
      }
      else{
        m = maxi
      }
    }
    j2 = j2()
    mem[j2] = mem[j2] + 1
    esp = esp + (Gain(supp(m),j2))[1]
    espT[i] = esp/i
  }
  espT
}

plot(q22(N = 1000), ylim = c(-0.5, 0.5),  type = "l")

Q2.3

Un humain pas trop bête ne se laissera pas berner longtemps par cet algorithme et ce sera alors difficile de le battre. Pour améliorer ça on pourrait remplacer les coups de probabilité 1 par des coups de probabilité similaire à la fréquence d’apparition des signes de l’adversaire. Il n’y aurait ainsi aucun coup de probabilité 1 (sauf les quelques premiers). Par exemple si on constate par l’expérience que l’adversaire a joué 1/8 pierre, 1/2 feuille et 3/8 ciseaux notre coup suivant sera déterminé par la vecteur de probabilité (3/8, 1/8, 1/2).

Q2.4

j2 = function(){
  t = floor(runif(n = 1, min = 1, max = 5))
  if (t[1] == 4) {t[1] = 3}
  return(t[1])
}

q24 = function(N = Nt){
  mem = c()
  esp = 0
  espT = c()
  m = 0
  for(i in 1:N){
    if (length(mem) == 0) {
      m = triplEgal()
    }
    else{
      m = sample(mem, 1)
    }
    j2 = j2()
    mem[i] = j2
    esp = esp + (Gain(supp(m),j2))[1]
    espT[i] = esp/i
  }
  espT
}

plot(q24(N = 1000), ylim = c(-0.5, 0.5),  type = "l")

En jouant contre un adversaire A avec P(A) = (1/4, 1/4, 1/2) cet algorithme obtiendrait un gain proche de 0. Cependant son comportement est plus approprié s’il joue contre un humain qui ne raisonne pas avec des probabilités fixées. Si son gain est plus faible ici contre un ordinateur c’est contre un humain qu’il prendrait l’avantage sur l’algorithme basique qui consiste à jouer ce qui bat ce que l’adversaire a la plus joué.