Wiki du LAMA (UMR 5127) - Contributions [fr]

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-27T23:49:38Z

Mbrunot : /* Périodicité */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram sur une ligne(jeu du domino)'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_domino.png|500px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.
- La valeur de grundy de plusieurs tas se trouve être le XOR de toutes les valeurs de Grundy de chaque tas individuel.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Notre but est de ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante.

Pour faire ceci il nous faut changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.

Jeu de Fort Boyard = 0.333 
Jeu de Cram sur une ligne = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
"Il a été conjecturé par les auteurs de Winning Ways que tous les jeux octaux seraient ultimes périodiques.

Un jeu ultimement périodique est un jeu dans lequel les valeurs des nombres de Grundy deviennent périodiques après un certain point. Cela signifie que, à partir d'une certaine position, les valeurs des nombres de Grundy se répètent de manière régulière avec une certaine période.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + k) </math> où k est le nombre de règles d'un jeu octal ou simplement le nombre de chiffres suivant le "0." du jeu.

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =
Pour finir voici un jeu interactif qui se joue soit seul contre une IA soit à deux joueurs.
L'IA fera en sorte de toujours jouer le meilleur coup possible.

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-24T14:38:32Z

Mbrunot : /* Périodicité */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram sur une ligne(jeu du domino)'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_domino.png|500px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.
- La valeur de grundy de plusieurs tas se trouve être le XOR de toutes les valeurs de Grundy de chaque tas individuel.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Notre but est de ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante.

Pour faire ceci il nous faut changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.

Jeu de Fort Boyard = 0.333 
Jeu de Cram sur une ligne = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
"Il a été conjecturé par les auteurs de Winning Ways que tous les jeux octaux seraient ultimes périodiques.

Un jeu ultimement périodique est un jeu dans lequel les valeurs des nombres de Grundy deviennent périodiques après un certain point. Cela signifie que, à partir d'une certaine position, les valeurs des nombres de Grundy se répètent de manière régulière avec une certaine période.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + k) </math> où k est le nombre de règles suivant le "0." d'un jeu octal.

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =
Pour finir voici un jeu interactif qui se joue soit seul contre une IA soit à deux joueurs.
L'IA fera en sorte de toujours jouer le meilleur coup possible.

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-24T14:35:23Z

Mbrunot : /* Périodicité */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram sur une ligne(jeu du domino)'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_domino.png|500px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.
- La valeur de grundy de plusieurs tas se trouve être le XOR de toutes les valeurs de Grundy de chaque tas individuel.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Notre but est de ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante.

Pour faire ceci il nous faut changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.

Jeu de Fort Boyard = 0.333 
Jeu de Cram sur une ligne = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
"Il a été conjecturé par les auteurs de Winning Ways que tous les jeux octaux seraient ultimes périodiques.

Un jeu ultimement périodique est un jeu dans lequel les valeurs des nombres de Grundy deviennent périodiques après un certain point. Cela signifie que, à partir d'une certaine position, les valeurs des nombres de Grundy se répètent de manière régulière avec une certaine période.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + k) </math> où k est le nombre de règles suivant le 0. d'un jeu octal.

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =
Pour finir voici un jeu interactif qui se joue soit seul contre une IA soit à deux joueurs.
L'IA fera en sorte de toujours jouer le meilleur coup possible.

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-24T14:34:15Z

Mbrunot : /* Périodicité */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram sur une ligne(jeu du domino)'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_domino.png|500px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.
- La valeur de grundy de plusieurs tas se trouve être le XOR de toutes les valeurs de Grundy de chaque tas individuel.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Notre but est de ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante.

Pour faire ceci il nous faut changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.

Jeu de Fort Boyard = 0.333 
Jeu de Cram sur une ligne = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
"Il a été conjecturé par les auteurs de Winning Ways que tous les jeux octaux seraient ultimes périodiques.

Un jeu ultimement périodique est un jeu dans lequel les valeurs des nombres de Grundy deviennent périodiques après un certain point. Cela signifie que, à partir d'une certaine position, les valeurs des nombres de Grundy se répètent de manière régulière avec une certaine période.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + i) </math>

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =
Pour finir voici un jeu interactif qui se joue soit seul contre une IA soit à deux joueurs.
L'IA fera en sorte de toujours jouer le meilleur coup possible.

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-24T14:24:43Z

Mbrunot : /* Théorème de Sprague-Grundy */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram sur une ligne(jeu du domino)'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_domino.png|500px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.
- La valeur de grundy de plusieurs tas se trouve être le XOR de toutes les valeurs de Grundy de chaque tas individuel.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Notre but est de ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante.

Pour faire ceci il nous faut changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.

Jeu de Fort Boyard = 0.333 
Jeu de Cram sur une ligne = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
Par conjecture nous pensons que tous les jeux octaux sont ultimes périodiques.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + i) </math>

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =
Pour finir voici un jeu interactif qui se joue soit seul contre une IA soit à deux joueurs.
L'IA fera en sorte de toujours jouer le meilleur coup possible.

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-24T14:21:48Z

Mbrunot : /* Représentation en jeu octal */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram sur une ligne(jeu du domino)'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_domino.png|500px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Notre but est de ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante.

Pour faire ceci il nous faut changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.

Jeu de Fort Boyard = 0.333 
Jeu de Cram sur une ligne = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
Par conjecture nous pensons que tous les jeux octaux sont ultimes périodiques.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + i) </math>

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =
Pour finir voici un jeu interactif qui se joue soit seul contre une IA soit à deux joueurs.
L'IA fera en sorte de toujours jouer le meilleur coup possible.

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-24T14:21:30Z

Mbrunot : /* Description */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram sur une ligne(jeu du domino)'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_domino.png|500px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Notre but est de ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante.

Pour faire ceci il nous faut changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.

Jeu de Fort Boyard = 0.333 
Jeu de Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
Par conjecture nous pensons que tous les jeux octaux sont ultimes périodiques.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + i) </math>

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =
Pour finir voici un jeu interactif qui se joue soit seul contre une IA soit à deux joueurs.
L'IA fera en sorte de toujours jouer le meilleur coup possible.

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-24T14:20:11Z

Mbrunot : /* Description */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram sur une ligne'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_domino.png|500px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Notre but est de ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante.

Pour faire ceci il nous faut changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.

Jeu de Fort Boyard = 0.333 
Jeu de Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
Par conjecture nous pensons que tous les jeux octaux sont ultimes périodiques.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + i) </math>

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =
Pour finir voici un jeu interactif qui se joue soit seul contre une IA soit à deux joueurs.
L'IA fera en sorte de toujours jouer le meilleur coup possible.

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-24T14:20:02Z

Mbrunot : /* Description */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram sur une ligne'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_domino.png|200px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Notre but est de ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante.

Pour faire ceci il nous faut changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.

Jeu de Fort Boyard = 0.333 
Jeu de Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
Par conjecture nous pensons que tous les jeux octaux sont ultimes périodiques.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + i) </math>

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =
Pour finir voici un jeu interactif qui se joue soit seul contre une IA soit à deux joueurs.
L'IA fera en sorte de toujours jouer le meilleur coup possible.

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Fichier:Jeu domino.png

2024-05-24T14:19:45Z

Mbrunot :

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-24T14:03:32Z

Mbrunot : /* Description */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram sur une ligne'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_cram.png|200px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Notre but est de ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante.

Pour faire ceci il nous faut changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.

Jeu de Fort Boyard = 0.333 
Jeu de Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
Par conjecture nous pensons que tous les jeux octaux sont ultimes périodiques.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + i) </math>

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =
Pour finir voici un jeu interactif qui se joue soit seul contre une IA soit à deux joueurs.
L'IA fera en sorte de toujours jouer le meilleur coup possible.

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T19:58:27Z

Mbrunot : /* Jeu de Impartiaux */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_cram.png|200px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Notre but est de ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante.

Pour faire ceci il nous faut changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.

Jeu de Fort Boyard = 0.333 
Jeu de Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
Par conjecture nous pensons que tous les jeux octaux sont ultimes périodiques.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + i) </math>

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =
Pour finir voici un jeu interactif qui se joue soit seul contre une IA soit à deux joueurs.
L'IA fera en sorte de toujours jouer le meilleur coup possible.

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T19:48:56Z

Mbrunot : /* Application */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu de Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_cram.png|200px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Notre but est de ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante.

Pour faire ceci il nous faut changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.

Jeu de Fort Boyard = 0.333 
Jeu de Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
Par conjecture nous pensons que tous les jeux octaux sont ultimes périodiques.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + i) </math>

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =
Pour finir voici un jeu interactif qui se joue soit seul contre une IA soit à deux joueurs.
L'IA fera en sorte de toujours jouer le meilleur coup possible.

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T19:30:51Z

Mbrunot : /* Représentation en jeu octal */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu de Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_cram.png|200px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Pour pouvoir ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante, il nous suffit de changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.

Jeu de Fort Boyard = 0.333 
Jeu de Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
Par conjecture nous pensons que tous les jeux octaux sont ultimes périodiques.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + i) </math>

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =
Pour finir voici un jeu interactif qui se joue soit seul contre une IA soit à deux joueurs.
L'IA fera en sorte de toujours jouer le meilleur coup possible.

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T19:30:32Z

Mbrunot : /* Représentation en jeu octal */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu de Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_cram.png|200px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Pour pouvoir ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante, il nous suffit de changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.
Jeu de Fort Boyard = 0.333 
Jeu de Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
Par conjecture nous pensons que tous les jeux octaux sont ultimes périodiques.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + i) </math>

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =
Pour finir voici un jeu interactif qui se joue soit seul contre une IA soit à deux joueurs.
L'IA fera en sorte de toujours jouer le meilleur coup possible.

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T08:55:01Z

Mbrunot : /* Bonus jeu octal contre une IA */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu de Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_cram.png|200px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Pour pouvoir ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante, il nous suffit de changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.
Jeu de Fort Boyard = 0.333 
Jeu de Fort Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
Par conjecture nous pensons que tous les jeux octaux sont ultimes périodiques.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + i) </math>

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =
Pour finir voici un jeu interactif qui se joue soit seul contre une IA soit à deux joueurs.
L'IA fera en sorte de toujours jouer le meilleur coup possible.

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T08:53:41Z

Mbrunot : /* Méthode rare/fréquentes */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu de Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_cram.png|200px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Pour pouvoir ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante, il nous suffit de changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.
Jeu de Fort Boyard = 0.333 
Jeu de Fort Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
Par conjecture nous pensons que tous les jeux octaux sont ultimes périodiques.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + i) </math>

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==
Après avoir calculé un tableau de valeurs de Grundy d'un jeu octal suffisamment grand nous voyons que des valeurs sont très récurrentes et que d'autres ne le sont quasiment jamais.

On a divisé ces valeurs en deux catégories les rares et les fréquentes.

Cette délimitation que nous avons fait à vue, peut s'automatiser par le biais d'un masque binaire.
=== Masque ===
Pour savoir si un masque convient à la division rare/fréquentes des valeurs de Grundy d'une liste, on utilise celui-ci pour déterminer les valeurs rares.
Il faut que tous les indice à 1 d'une valeur de grundy en binaire soient un nombre paires de fois au même coordonnées que les indices à 1 du masque.

Voici le code qui nous permettra de déterminer un masque pour un tableau des valeurs de Grundy d'un jeu octal.
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

Avec ce code nous avons pu ainsi calculer des tableaux de valeurs de grundy allant jusqu'à l'ordre des <math> 10^7 </math>
Maintenant le calcul des valeurs n'est plus la source du problème mais le calcul de la période est celui qui ralenti notre code.

= Bonus jeu octal contre une IA =

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T08:34:26Z

Mbrunot : /* Périodicité */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu de Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_cram.png|200px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Pour pouvoir ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante, il nous suffit de changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.
Jeu de Fort Boyard = 0.333 
Jeu de Fort Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
Par conjecture nous pensons que tous les jeux octaux sont ultimes périodiques.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode de taille s peut se manifester, il faut satisfaire <math> G(n+s) = G(n + s + P) </math>

Pour prouver cette périodicité, il nous faut voir si les valeurs de Grundy d'un jeu octal apparaissent périodiques après la dernière occurrence de la prépériode G(s) alors la dernière valeur nécessitant d'être vérifié pour prouver la période à partir d'un instant i est <math> G(2(s+p) + i) </math>

Voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisamment loin pour calculer les jeu octaux : .16, .127, .376

Il nous faut alors changer de méthode de calcul pour les valeurs de Grundy.

== Méthode rare/fréquentes ==

=== Masque ===
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

= Bonus jeu octal contre une IA =

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T08:27:14Z

Mbrunot : /* Périodicité */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu de Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_cram.png|200px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Pour pouvoir ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante, il nous suffit de changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.
Jeu de Fort Boyard = 0.333 
Jeu de Fort Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
Par conjecture nous pensons que tous les jeux octaux sont ultimes périodiques.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode s peut se manifester, il faut satisfaire <math> G(n) + s = G(n + P) </math>

Pour prouver cette périodicité voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisement loin pour calculer les jeu octaux suivants:

== Méthode rare/fréquentes ==

=== Masque ===
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

= Bonus jeu octal contre une IA =

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T08:26:53Z

Mbrunot : /* Périodicité */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu de Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_cram.png|200px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Pour pouvoir ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante, il nous suffit de changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.
Jeu de Fort Boyard = 0.333 
Jeu de Fort Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==
Par conjecture nous pensons que tous les jeux octaux sont ultimes périodiques.

C'est à dire pour toute position n suffisamment grande sachant qu'une prépériode s peut se manifester, il faut satisfaire <math> G(n) + s = G(n + P) </math>

Pour prouver cette périodicité voici le code qui nous a permis de calculer toutes les periodes des jeux octaux se trouvant dans le livre [https://fr.wikipedia.org/wiki/Winning_Ways_for_your_Mathematical_Plays| Winning ways]
<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

Notre seul problème ici, est que notre algorithme pour calculer les valeurs de Grundy ne nous permet pas d'aller suffisement loin pour calculer les jeu octaux suivants:

== Méthode rare/fréquentes ==

=== Masque ===
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

= Bonus jeu octal contre une IA =

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T08:06:58Z

Mbrunot : /* Méthode */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu de Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_cram.png|200px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Pour pouvoir ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante, il nous suffit de changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.
Jeu de Fort Boyard = 0.333 
Jeu de Fort Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux.

Le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==

<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

== Méthode rare/fréquentes ==

=== Masque ===
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

= Bonus jeu octal contre une IA =

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T08:04:24Z

Mbrunot : /* Méthode */

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu de Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_cram.png|200px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Pour pouvoir ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante, il nous suffit de changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.
Jeu de Fort Boyard = 0.333 
Jeu de Fort Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

Par le code suivant on a pu calculer les valeurs de Grundy pour tous les jeux octaux, le code est long mais simple nous faisons le calcul de toutes les zones atteignables depuis notre instant i pour en faire le minimum exclu afin de trouver sa valeur grundy et on continue ainsi pour i+1, etc...

Cependant nous n'avons pu aller dans des calcul de valeurs de Grundy n'allant que jusqu'à des éléments de l'ordre de <math> 10^4 </math> avant que ça ne devienne trop long pour cette méthode.

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==

<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

== Méthode rare/fréquentes ==

=== Masque ===
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

= Bonus jeu octal contre une IA =

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T07:59:10Z

Mbrunot :

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu de Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_cram.png|200px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Pour pouvoir ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante, il nous suffit de changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.
Jeu de Fort Boyard = 0.333 
Jeu de Fort Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

Le jeux octaux étant impartiaux la méthode des valeurs de Grundy s'applique à eux.

== Méthode ==

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
assert type(nbr_octal) == str
assert all(int(ele) in JEU_VALIDE for ele in nbr_octal), "ton jeu octal n'est pas conforme"
tab_res = []

for i in range(0, len(nbr_octal)):
tab_res += [[nbr_octal[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==

<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

== Méthode rare/fréquentes ==

=== Masque ===
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

= Bonus jeu octal contre une IA =

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T07:39:59Z

Mbrunot :

Étudiant : Mathieu BRUNOT

Tuteur : Valenti Gledel

= Jeu de Impartiaux =

== Description ==

Un jeu impartial est un jeu à 2 joueurs où les joueurs jouent à tour de rôle et leurs mouvements possibles ne dépendent pas du joueur qui joue, il n'y a donc pas de hasard ni d'égalité dans une partie.

Le perdant étant celui qui ne peut plus jouer, aussi appelé version normale.

En voici des exemples:
<ul>
<li>'''Jeu de Cram'''
Les joueurs mettent des dominos sur une grille. Le joueur qui met le dernier domino gagne.

[[Fichier:Jeu_cram.png|200px]]
</li>

<li>'''Jeu de Nim'''
Il se joue avec un ou plusieurs tas d'objets exemple des allumettes.
Chacun des joueurs joue à tour de rôle en choisissant un tas et en retirant autant d’allumettes que souhaité dans le tas,
pour que son adversaire n’ait plus la possibilité de jouer, c’est ainsi que le jeu prend fin.

[[Fichier:Jeu_de_nim.jpg|200px]]
</li>

<li>'''Jeu des bâtonnets Fort Boyard'''
Ce jeu consiste à n’avoir que le droit de retirer de 1 à 3 bâtonnets à chaque tour. Hormis la différence est que le joueur perdant est celui qui prend le dernier bâtonnet.
Cette condition de victoire est appelé version misère.

[[Fichier:Batonnets-fort-boyard.jpg|300px]]
</li>

== Stratégie Gagnante ==

En effet, l’ensemble des jeux impartiaux sont résolubles à l’aide d’outils théorique afin de connaitre l'action à faire pour être le joueur en position gagnante.

Prenons le jeu de Fort Boyard mais cette fois-ci en version normale.
Dans celui-ci la stratégie gagnante est de laisser un tas à l'adversaire qui serait un multiple de quatre.
* Pour le trouver il suffit de regarder les positions perdantes dans chaque cas:
*# Si le nombre de bâtonnets est n=1, le joueur courant gagne car il peut enlever le dernier jeton et laisser l'adversaire avec un tas vide.
*# Si n=2, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=3, le joueur courant gagne car il peut retirer les derniers bâtonnets.
*# Si n=4, le joueur courant perd car il va forcément laisser son adversaire dans une position gagnante.
*# Plus généralement, toute position où <math>n \equiv 1,2,ou 3\pmod 4</math>est une position gagnante, et toute position où <math>n \equiv 0\pmod 4</math> est une position perdante.

Ainsi on pourrait se demander la stratégie gagnant d'autres jeux tel que le jeu de Nim ou le jeu de Cram

= Valeurs de Grundy =
===Théorème de Sprague-Grundy ===

Le théorème de Sprague-Grundy nous permet de trouver la stratégie gagnante d’un jeu impartial fini en version normale (le perdant est le joueur ne pouvant plus jouer).

La valeur de Grundy ou d’un tas se calcule récursivement par ses règles :

- Un tas vide a pour valeur de Grundy 0.
- Le nombre Grundy d’une position non nulle est le plus petit entier positif ou nul qui n’est pas dans la liste des valeurs de Grundy des positions que l’on peut atteindre à partir de notre position.

Une position perdante d’un jeu celle qui donne une valeur de Grundy de 0.

== Calcul des valeurs pour le jeu de Nim ==

=== Cas à 1 tas ===

La valeur de Grundy du jeu de Nim classique d’un tas de taille ''n'' (un entier) est celle du nombre de bâtonnets dans ce tas.

On l’explique car toutes les tailles de tas strictement inférieures à ''n'' sont atteignables à partir de celui-ci. Alors le minimum exclu(mex) des valeurs atteignables est ''n''.

On appelle ce nombre précis dans le cas du jeu de Nim, un nimber.

Donc par exemple dans un tas de taille 9 du jeu Nim, on aurait une valeur de Grundy de 9, ceci est simple à comprendre.

=== Cas à plusieurs tas ===

Dans le cas de plusieurs tas, la valeur de Grundy de tous les jeux est le XOR de toutes les valeurs de Grundy de chaque tas.

Par exemple :

Voici un jeu de Nim composé de trois tas de bâtonnets:
[[Fichier:Exemple_jeu_de_nim.png|300px]]

Ce jeu a pour valeur de Grundy :
<math> 17 \oplus 6 \oplus 24 \Leftrightarrow 10001\oplus 00110\oplus 11000 \Leftrightarrow 15 </math>

== Application ==
Mettons à l’œuvre nos connaissances afin de gagner une partie dans le jeu de Nim de l'exemple précédent.

Imaginons que nous soyons les premiers joueurs à jouer.

Nous nous trouvons dans une position gagnante car la valeur de Grundy du Jeu est de <math> 15 \neq 0 </math>.

Pour pouvoir ramener celui-ci à une valeur de 0 pour que notre adversaire soit dans une position perdante, il nous suffit de changer un tas où la valeur de grundy de celui-ci possède un bit à 1 au même indice que le bit à 1 avec le plus grand exposant de 2 de la valeur de Grundy du jeu.

Dans notre cas le premier bit à 1 de 15 est celui qui est au 3eme exposant de 2.
Le nombre qu’on doit changer est 24. Pour savoir à quelle valeur on doit le baisser il suffit de faire le XOR de 24 et de la valeur de Grundy du jeu qui est 15. On obtient <math> 24 \oplus 15 = 23 </math>.

<ul>
<li> On a choisi de retirer 1 bâton au tas de 24 pour avoir une valeur de Grundy totale de 0. </li>
<li> L'adversaire est dans une position perdante, quoiqu’il fasse il ne peut pas passer en position gagnante. </li>
<li> Il nous reste plus qu'à continuer ainsi pour s'assurer de gagner. </li>
</ul>

= Jeux Octaux =
Les jeux octaux sont aussi des jeux impartiaux, assez proches du jeu de Nim. Ils se jouent aussi avec des tas d’objet. Leurs caractéristiques sont que les coups autorisés sont définis à l’aide d’un système numérique de 0 à 7 d’où le nom jeu octal.

== Règles ==

Les règles d'un jeu octal précisent les actions possibles lorsqu'un joueur retire ''n'' objets d'un tas donné, et sont encodées par une suite de chiffres entre 0 et 7 (d'où le nom jeu octal) :

Notation 0.''k''1 ''k''2 ''k''3 ''k''4 …

où chaque chiffre ''k''''n'' indique en combien de tas le joueur doit scinder le tas dans lequel il a retiré ''n'' objets. Le chiffre ''k''''n'' est la somme de :

* <math>2^0</math> si le joueur peut laisser 0 tas, 0 sinon;
* <math>2^1</math> si le joueur peut laisser 1 tas, 0 sinon;
* <math>2^2</math> si le joueur peut laisser 2 tas, 0 sinon

Par exemple, si ''k''''n''=0, les joueurs n'ont pas le droit de retirer ''n'' objets d'un tas. Si ''k''''n''=3, on retrouve la règle classique du jeu de Nim, à savoir que le joueur peut retirer ''n'' objets d'un tas de taille supérieure ou égale ''n''.

== Représentation en jeu octal ==
Comme vous l'avez compris il y a une infinité de jeux octaux.

On retrouve les jeux qu'on a introduit dans ces catégories.
Jeu de Fort Boyard = 0.333 
Jeu de Fort Cram = 0.07

Néanmoins, le jeu de Nim n'est pas un jeu octal.
Dans Nim, les mouvements sont extrêmement flexibles : un joueur peut retirer n'importe quel nombre d'objets d'une pile choisie. Cette flexibilité n'est pas présente dans les jeux octaux, où les mouvements sont prédéfinis.
Un jeu "octal" qui pourrait représenter le jeu de Nim serait 0.333... un sauf que ce n'est pas un jeu octal.

= Valeurs de Grundy pour les jeux octaux =

== Méthode ==

<pre>
JEU_VALIDE = (0,1,2,3,4,5,6,7)
TAS_0 = (1,3,5,7) #les valeurs laissant 0 tas
TAS_1 = (2,3,6,7) #les valeurs laissant 1 tas
TAS_2 = (4,5,6,7) #les valeurs laissant 2 tas

def verif_jeu(nbr_octal:str)->str:
""" renvoie nombre en str et enleve le 0. """
assert type(nbr_octal) == str, "tu dois donner une chaine de caractères en argument"
for ele in nbr_octal:
ele = int(ele)
assert (ele in JEU_VALIDE), "ton jeu octal n'est pas conforme"
return nbr_octal

def calc_mex(un_set:set)->int:
""" renvoie la plus petite valeur entière qui n'appartient pas au subset. """
mex = 0
while (mex in un_set):
mex += 1
return mex

def tab_kn_dn(nbr_octal:str)->list:
""" renvoie un tableau de tableau avec [kn:str,dn:int] pour chaque action d'un jeu octal. """
nb = verif_jeu(nbr_octal)
tab_res = []

for i in range(0, len(nb)):
tab_res += [[nb[i], i+1]]

return tab_res

def liste_action_possibles(taille_tab:int, kn:str, dn:int)->list:
""" renvoie un tableau de bool sur la possibilité des 3 actions. """
assert taille_tab > 0 , 'ton tableau est vide'

k_int = int(kn)
action = [False,False,False] #tableau des 3 actions est nous dis si elles sont possibles
if not dn > taille_tab: #lance les conditions seuleument la taille retiré est convenable
if k_int in TAS_0:
if dn == taille_tab:
action[0] = True
if k_int in TAS_1:
if dn < taille_tab:
action[1] = True
if k_int in TAS_2:
if dn+1 < taille_tab:
action[2] = True

return action

def liste_des_separations_tas_en_2(taille_tab:int, dn:int)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
dans un tableau de set. """
res = []
somme_des_taille_couple = taille_tab - dn
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
couple = (val1,val2) #crée le couple sous forme de tuple
res += [couple]
return res

def set_des_valeurs_grundy_atteignables(jeu_actions:list, tab_grundy:list, instant_i:int):
""" renvoie un set des valeurs atteignables pour le coup pour calculer la
valeur suivant du tab_grundy"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
liste_separations_possibles = liste_des_separations_tas_en_2(instant_i, actions[1])
for tab in liste_separations_possibles:
res.add(tab_grundy[tab[0]] ^ tab_grundy[tab[1]])
return res

def tab_val_grundy(taille_tab:int, nbr_octal:str)->list:
""" renvoie un tableau de valeur de Sprague Grundy pour une taille_tab donné. """
tab_grundy = [0]
jeu_actions = tab_kn_dn(nbr_octal)
for i in range(1, taille_tab+1):
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables(jeu_actions, tab_grundy, i)
tab_grundy += [calc_mex(set_valeurs_atteignables)]
return tab_grundy

def Grundy(taille_tab:int , nbr_octal:float):
""" renvoie la valeur de grundy du nombre donné"""
tab_grundy = tab_val_grundy(taille_tab, nbr_octal)
return tab_grundy[taille_tab]
</pre>

== Périodicité ==

<pre>
def est_periode(p:int,s:int,tab_grundy:list,n:int)->bool:
""" test la périodicité"""
res = True
m = n-(p+s)
for i in range(m):
if s+p+i == len(tab_grundy):
res = False
break
if tab_grundy[s+i] != tab_grundy[s+p+i]:
res = False
break
return res

def test_periodicite(n:int,k:int,tab:list)->list:
""" renvoie un tableau si on trouve la période sinon renvoie None"""
for p in range(1,n+1):#periode
s = n-p
if est_periode(p,s,tab,n*2+k):
return (s,p,tab[s:s+p])
return None

def periodicite(nbr_octal:str)->list:
""" renvoie la période , taille de la période, taille de la prépériode d'un tableau avec les valeurs de grundy d'un jeu"""
taille_test = 30000
tab_test = tab_val_grundy(taille_test, nbr_octal)[1:taille_test] #tableau où chercher la périodicité
k = len(nbr_octal)
for n in range(k+2,len(tab_test)+1,2):
res = test_periodicite(n,k,tab_test)
if res != None:
return res
return "Periode non trouvé pour .{}".format(nbr_octal)
</pre>

== Méthode rare/fréquentes ==

=== Masque ===
<pre>
def trie_dico_en_tab_croissant(dico:dict)->list:
""" renvoie un tableau de tableau trié par ordre croissant
selon les valeurs des clefs"""
res = []
dico_copy = dico.copy()
while dico_copy != {}:
clef_min = min(dico_copy, key=dico_copy.get)#cherche la clef avec la val minimale
res += [[clef_min,dico_copy[clef_min]]]
dico_copy.pop(clef_min)
return res

def cherche_id_gap_rare_freq(tab_frequences:list, nbr_echantillon:int)->int:
""" renvoie l'id du dernier element rare
d'un tableau trie de frequence de valeur """
freq = 0.1 * nbr_echantillon #frequence choisi pour determiner les valeurs rares
for i in range(len(tab_frequences)):
if tab_frequences[i] > freq:
id_gap = i-1
break
return id_gap

def cherche_rare_commun(tab_grundy:list)->list:
""" cherche les valeures rare d'un tableau en regardant leurs nombre d'apparitions
à partir d'un dico qui a pour clef le nombre et pour valeur son nombre d'apparition"""
nombre_ele = len(tab_grundy)
dico_frequence = {}
for ele in tab_grundy:
dico_frequence[ele] = dico_frequence.get(ele,0) + 1 #creer le dico de toutes les valeurs en clef et en valeurs leurs fréquences

tab_trie = trie_dico_en_tab_croissant(dico_frequence)
print(tab_trie)
tab_clef = [tab[0] for tab in tab_trie]
tab_frequences = [tab[1] for tab in tab_trie]
id_gap = cherche_id_gap_rare_freq(tab_frequences,nombre_ele)

rare = {0}
commun = set()

for i in range(len(tab_clef)):
if i <= id_gap:
rare.add(tab_clef[i])
else:
if tab_clef[i] != 0:
commun.add(tab_clef[i])

res = [rare,commun]
return res

def indice_des_bits_a_un(masque:str)->list:
""" renvoie un tableau contenant les indices des bits à 1"""
res = []
for i in range(len(masque)):
if masque[i] == '1':
res.append(i)
return res

def est_rare(ele_bin:str,ind_1_du_masque:list)->bool:
""" verfie si le nombre est rare"""
cpt_1 = 0
for ind in ind_1_du_masque:
if ele_bin[ind] == '1':#verifie que l'element à l'indice ind est bien 1 à l'indice des 1 sur le masque
cpt_1 += 1
return cpt_1 % 2 == 0

def rares_dans_masque(masque:str,val_max:int)->set:
"""Donne toutes les valeurs rares d'un masque dans un set"""
res = set()
n_bit = len(masque)
ind_des_1 = indice_des_bits_a_un(masque)
for nbr in range(val_max+1):
nbr_bin = mets_nombre_en_bin_sur_x_bits(nbr,n_bit)
if est_rare(nbr_bin,ind_des_1):
res.add(nbr)

return res

def cherche_masque_pour_un_tab_grundy(tab_grundy:list)->str:
""" va chercher un masque de n bit qui convient le mieux pour le tableau de grundy donné"""
tab_grundy = tab_grundy[1:] #enlève la première valeur qui est 0
val_max = max(tab_grundy)
taille_bit = len(bin(val_max)[2:])
masques_possibles = 2**taille_bit
tab_rare_commun= cherche_rare_commun(tab_grundy)
set_rare_cherche = tab_rare_commun[0]
set_frequent = tab_rare_commun[1]
res = 0

print("\nset_rare : {}".format(set_rare_cherche))
print("set_frequent : {}\n".format(set_frequent))

for i in range(1,masques_possibles):
masque = mets_nombre_en_bin_sur_x_bits(i,taille_bit)
set_rare_masque = rares_dans_masque(masque,val_max)

contient_rare = set_rare_cherche.issubset(set_rare_masque)
inter = set_frequent.intersection(set_rare_masque)
ne_contient_pas_frequent = inter == set()
if contient_rare and ne_contient_pas_frequent: #verifie si les rares cherchés sont biens dans le masque et qu'il ne contient pas de valeurs frequentes
res = masque
break
return f"\nle masque qui convient est {res}"
</pre>

=== Code ===

<pre>
def liste_des_id_des_rares_dans_tab(tab_grundy:list, listes_rares:set):
""" renvoie un tableau de tous les id des valeurs rares dans le tableau """
res = []
for i in range(1,len(tab_grundy)):
if tab_grundy[i] in listes_rares:
res + [i]
return res

def liste_des_separations_tas_en_2_pour_avoir_val_commune(taille_tab:int, dn:int, liste_rares:set)->list:
""" renvoie tous les couples de possibilités d'une separation en deux d'un tas
contenant uniquement une valeur rare"""
res = []
somme_des_taille_couple = taille_tab - dn

for val1_rare in liste_rares:
val2 = somme_des_taille_couple-val1_rare
if not val2 in liste_rares: #verifie que la valeur ne soit pas rares
couple = (val1_rare,val2) #crée le couple sous forme de tuple
res += [couple]

return res

def set_des_valeurs_grundy_atteignables_rares(jeu_actions:list, tab_grundy:list, instant_i:int, liste_rares:set):
""" renvoie un set des valeurs atteignables avec des couples contenant des valeurs rares"""
res = set()
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(instant_i, actions[0], actions[1])
if les_actions_possibles[0] == True:
res.add(0)

if les_actions_possibles[1] == True:
res.add(tab_grundy[instant_i - actions[1]])

if les_actions_possibles[2] == True:
global liste_separations_possibles_rares_commun
liste_separations_possibles_rares_commun = liste_des_separations_tas_en_2_pour_avoir_val_commune(instant_i, actions[1], liste_rares)
for couple in liste_separations_possibles_rares_commun:
res.add(tab_grundy[couple[0]] ^ tab_grundy[couple[1]])
return res

def tab_val_grundy_methode_masque(taille_tab_souhaite:int, nbr_octal:str, masque:str)->list:
taille_tab_inital = 10000
assert taille_tab_souhaite > taille_tab_inital, f"La taille de tableau recherché doit dépasser {taille_tab_inital}"
tab_grundy = tab_val_grundy(taille_tab_inital, nbr_octal)
jeu_actions = tab_kn_dn(nbr_octal)
listes_rares = rares_dans_masque(masque,max(tab_grundy)) #un set contant toutes les valeurs rares du masque
liste_id_rares = liste_des_id_des_rares_dans_tab(tab_grundy, listes_rares)

for taille in range(taille_tab_inital+1, taille_tab_souhaite+1):#Trouver les valeurs suivantes avec la méthode du masque
set_valeurs_atteignables = set_des_valeurs_grundy_atteignables_rares(jeu_actions, tab_grundy, taille, liste_id_rares)
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:#si le mex est commun alors
tab_grundy += [mex]

else: #on va rajouter des valeurs jusqu'à avoir un mex commun sinon on continue jusqu'au bout
for actions in jeu_actions:
les_actions_possibles = liste_action_possibles(taille, actions[0], actions[1])
if les_actions_possibles[2] == True:
somme_des_taille_couple = taille - actions[1]
for i in range(1, (somme_des_taille_couple//2)+1):
val1 = i
val2 = somme_des_taille_couple-i
if all(val1 not in couple for (couple) in liste_separations_possibles_rares_commun):#verifie que la valeur n'a pas déjà été testé
set_valeurs_atteignables.add(tab_grundy[val1] ^ tab_grundy[val2])
mex = calc_mex(set_valeurs_atteignables)
if not mex in listes_rares:
break
if not mex in listes_rares:
break
tab_grundy += [mex]

return tab_grundy
</pre>

= Bonus jeu octal contre une IA =

<pre>
from function import *
BATON = '|'

class Jeu:

def __init__(self, t_grille:int, nbr_octal:str, IA:bool=False)->None:
self.tas = [t_grille]
self.jeu = nbr_octal
self.liste_des_kn_di = tab_kn_dn(nbr_octal)
self.IA = IA
self.etat_joueur = 'IA'

def liste_des_coups_pour_un_tas(self, tas)->list:
""" Renvoie la liste des coups pour un tas donné sous forme d'un tableau
contenant des sous dictionnaires avec le message sur l'information du coup et son id"""
liste_coups = []
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])#kn = le type d'action et di = la taille sur laquelle l'action s'applique
#rajoute les id
if action[0]:
liste_coups += [f"0.{jeu[1]}"]

if action[1]:
liste_coups += [f"1.{jeu[1]}"]

if action[2]:
liste_coups += [f"2.{jeu[1]}"]

return liste_coups

def affiche_les_tas(self)->None:
""" affiche tous les tas du jeu """
for i in range(len(self.tas)):
les_batons = BATON*self.tas[i]
print(f"tas numéro {i}: {les_batons}")

def retire_tas(self, id_tas:int, id_action:str, choix_IA:list=None)->None:
""" Retire un/des elements d'un tas seulement si possible,
si il y a un reste celui est rajouté en fin de tableau"""

tas_enleve = self.tas.pop(id_tas) #retire le tas en question
type_action = id_action[0]
taille_tas_a_enlever = int(id_action[2])

#rajoute les restes s'il y en a
if type_action == '1':
self.tas.append(tas_enleve-taille_tas_a_enlever)

elif type_action == '2':
if choix_IA != None:
choix = choix_IA
else:
separation_possible = liste_des_separations_tas_en_2(tas_enleve,taille_tas_a_enlever)
choix = choix_de_la_separation_en_deux(separation_possible)

self.tas.append(choix[0])
self.tas.append(choix[1])

### INTERFACE ###

def choix_du_tas(self)->int:
self.affiche_les_tas
ind = fait_choix_id(self.tas, "Quel tas veux-tu enlever : ")
return ind

def choix_des_batons_a_enlever(self,ind_tas)->None:
""" fait la requête pour demander à l'utilisateur de changer de batons """
liste_coups = self.liste_des_coups_pour_un_tas(self.tas[ind_tas])
liste_dico_id = []
for id_coup in liste_coups:
liste_dico_id += [id_coup]
print(f'{message_sur_un_id(id_coup)} pour un id = {id_coup}')
ind = input("\nL'id que tu veux utiliser : ")
while ind not in liste_dico_id:
print("Tu t'es trompé")
ind = input("\nL'id que tu veux utiliser : ")
self.retire_tas(ind_tas,ind)

### IA ###

def tour_IA(self):
""" Ici l'IA va essayer de ramener le jeu à xor de 0
pour les valeurs de grundy des tas
Si ce n'est pas possible elle fait la première action possible"""
grundy_tas = [Grundy(taille, self.jeu) for taille in self.tas]
le_xor = xor_des_tas(grundy_tas)
coup_choisi = -1
separation_en_deux = False

if le_xor == 0:
for i in range (len(self.tas)):
coups_pour_le_tas = self.liste_des_coups_pour_un_tas(self.tas[i])
if coups_pour_le_tas != []:
coup_choisi = coups_pour_le_tas[0] #prend le premier coup parmis ceux possible
id_tas_a_changer = i
if coup_choisi[0] == '2':
taille_tas_a_changer = self.tas[id_tas_a_changer]
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup_choisi[2])) #taille du tas initial , la nombre d'ele ment qu'on lui enleve
couple_choisi = separation_possible[0]
separation_en_deux = True
break

else:#cas où l'IA peut ramener le jeu à 0 en val de grundy
taille_bit = len(bin(max(grundy_tas))[2:])
le_xor_bin = mets_nombre_en_bin_sur_x_bits(le_xor,taille_bit)
id_du_premier_1 = le_xor_bin.index('1')

tas_en_bin = mets_en_bin_tous_les_ele_dans_tab(grundy_tas)

for i in range(len(tas_en_bin)):
if tas_en_bin[i][id_du_premier_1] == '1':
id_tas_a_changer = i

taille_tas_a_changer = self.tas[id_tas_a_changer]
nombre_grundy_a_faire = le_xor ^ grundy_tas[id_tas_a_changer] #on doit pouvoir faire l'action qui enmène à cette valeur de grundy
liste_coup = self.liste_des_coups_pour_un_tas(taille_tas_a_changer)
print(liste_coup)
print(f"nombre à faire : {nombre_grundy_a_faire}")
for coup in liste_coup:
type_coup = coup[0]

if type_coup == '0' and nombre_grundy_a_faire == 0:
print('0')
coup_choisi = coup
break
elif type_coup == '1' and nombre_grundy_a_faire == Grundy(taille_tas_a_changer - int(coup[2]), self.jeu):
print('1')
coup_choisi = coup
break
else:
print('2')
separation_possible = liste_des_separations_tas_en_2(taille_tas_a_changer,int(coup[2]))
for couple in separation_possible:
if Grundy(couple[0],self.jeu) ^ Grundy(couple[1],self.jeu) == nombre_grundy_a_faire:
coup_choisi = coup
couple_choisi = couple
separation_en_deux = True
break
if coup_choisi != -1:
break

print(f"L'IA a choisi de {message_sur_un_id(coup_choisi)} pour le tas numéro {id_tas_a_changer}")
if separation_en_deux:
self.retire_tas(id_tas_a_changer, coup_choisi, couple_choisi)
print(f"en laissant un tas de {couple_choisi[0]} et de {couple_choisi[1]}")
else:
self.retire_tas(id_tas_a_changer, coup_choisi)

### Etat d'une partie###
def start(self)->None:
""" Lance la partie """
while not self.est_fini():
print(f"\n___Tour de {self.etat_joueur}___\n")
print("Voici les tas possibles")
self.affiche_les_tas()
print()
if self.etat_joueur == 'IA':
self.tour_IA()
else:
tas = self.choix_du_tas()
print("\nTu peux")
self.choix_des_batons_a_enlever(tas)
self.change_etat_joueur()

self.change_etat_joueur()
self.affiche_les_tas()
print('\nJEU FINI')
print(f'Bravo {self.etat_joueur} tu as gagné')

def est_fini(self)->bool:
""" verifie si la partie est finie. """
res = True
for tas in self.tas:
for jeu in self.liste_des_kn_di:
action = liste_action_possibles(tas, jeu[0], jeu[1])
if any(flag == True for (flag) in action):#verifie si il y a une action de possible
res = False
break
return res

### Gère la gestion du tour du joueur ###
def change_etat_joueur(self)->None:
""" """
if self.etat_joueur == 'J1':
if self.IA:
self.etat_joueur = 'IA'
else:
self.etat_joueur = 'J2'
else:
self.etat_joueur = 'J1'

######### FONTCION JEU #########

def fait_choix_id(liste:list,message:str)->int:
""" fait une proposition dans un input pour demander à l'utilisateur
l'id qu'il choisit dans la liste"""
ind = -1
while ind >= len(liste) or ind < 0:
ind = input(message)
if ind.isdigit():
ind = int(ind)
else:
ind = -1
return ind

def xor_des_tas(liste_tas:list)->int:
""" renvoie le xor de tous les elements d'un tas"""
res = 0
for ele in liste_tas:
res ^= ele
return res

def choix_de_la_separation_en_deux(liste_possibilites:list):
""" s'applique quand le joueur choisi de separer un tas en deux
_affiche la liste des choix de déparation possibles"""
print("\n Choisi la taille des deux tas que tu veux laisser dans cette liste")
for i in range(len(liste_possibilites)):
print(f"id {i} : {liste_possibilites[i]}")
ind = fait_choix_id(liste_possibilites, "Ton choix :")
return liste_possibilites[ind]

def message_sur_un_id(ind:str)->str:
"""Donne le message approprié selon l'id d'une action"""
type_action = ind[0]
if type_action == '0':
message = "retirer tout le tas"
elif type_action == '1':
message = f"retirer {ind[2]} bâton(s) sur le bord du tas"
else:
message = f"retirer {ind[2]} bâton(s) en séparant le tas en deux"
return message

def mets_en_bin_tous_les_ele_dans_tab(tab:list)->list:
taille_bit = len(bin(max(tab))[2:])
res = []
for nbr in tab:
res.append(mets_nombre_en_bin_sur_x_bits(nbr,taille_bit))
return res
</pre>

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T07:37:56Z

Mbrunot : /* Méthode */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T07:36:35Z

Mbrunot : /* Méthode rare/fréquentes */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T07:33:37Z

Mbrunot : /* Valeurs de Grundy pour les jeux octaux */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T07:30:31Z

Mbrunot : /* Valeurs de Grundy pour les jeux octaux */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T01:32:23Z

Mbrunot :

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T01:30:58Z

Mbrunot : /* Représentation en jeu octal */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T01:26:54Z

Mbrunot : /* Représentation en jeu octal */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T01:19:52Z

Mbrunot : /* Représentation des jeux en jeux octaux */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T01:17:18Z

Mbrunot : /* Jeu de Octaux */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T01:13:01Z

Mbrunot : /* Règles */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T01:07:31Z

Mbrunot : /* Règles */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T01:07:03Z

Mbrunot : /* Jeu de Octaux */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T01:02:31Z

Mbrunot : /* Règles */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T01:00:20Z

Mbrunot : /* Règles */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T00:58:49Z

Mbrunot : /* Règles */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T00:50:33Z

Mbrunot : /* Règles */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T00:49:57Z

Mbrunot : /* Cas à 1 tas */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T00:49:31Z

Mbrunot : /* Jeu de Octaux */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T00:44:39Z

Mbrunot : /* Jeu de Octaux */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T00:43:15Z

Mbrunot :

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T00:42:18Z

Mbrunot : /* Application */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T00:38:41Z

Mbrunot : /* Application */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T00:12:28Z

Mbrunot : /* Application */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T00:09:49Z

Mbrunot : /* Valeurs de Grundy */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T00:06:35Z

Mbrunot : /* Cas à plusieurs tas */

Calcul des valeurs de Grundy pour des jeux octaux

2024-05-21T00:00:32Z

Mbrunot : /* Calcul des valeurs pour le jeu de Nim */