diff --git "a/TP1/#D\303\251finition_des_actions_possibles.py" "b/TP1/#D\303\251finition_des_actions_possibles.py"
new file mode 100644
index 0000000000000000000000000000000000000000..ebc48a0f90f81dabbe1a4172cdc52373faa56293
--- /dev/null
+++ "b/TP1/#D\303\251finition_des_actions_possibles.py"
@@ -0,0 +1,42 @@
+# Définition des actions possibles
+actions = ["avoue", "nie"]
+
+# Représentation des pertes (peines) par un dictionnaire
+pertes = {
+ ("avoue", "avoue"): (3, 3),
+ ("avoue", "nie"): (0, 10),
+ ("nie", "avoue"): (10, 0),
+ ("nie", "nie"): (1, 1)
+}
+
+# Implémentation de la fonction dilemme_prisonnier
+def dilemme_prisonnier(matrice_pertes, action_joueur1, action_joueur2):
+ """
+ Fonction qui calcule les pertes pour chaque joueur selon leurs actions.
+
+ Args:
+ matrice_pertes: dictionnaire des pertes
+ action_joueur1: action du joueur 1
+ action_joueur2: action du joueur 2
+
+ Returns:
+ tuple des pertes (perte_joueur1, perte_joueur2)
+ """
+ return matrice_pertes[(action_joueur1, action_joueur2)]
+
+# Main pour tester le code
+if __name__ == "__main__":
+ print("Dilemme du Prisonnier")
+ print("=====================")
+
+ print("\nActions possibles :", actions)
+
+ print("\nDictionnaire des pertes :")
+ for situation, peines in pertes.items():
+ print(f"Situation {situation} : Peines {peines}")
+
+ print("\nTests de la fonction dilemme_prisonnier :")
+ print(f"Les deux avouent : {dilemme_prisonnier(pertes, 'avoue', 'avoue')}")
+ print(f"Joueur 1 avoue, Joueur 2 nie : {dilemme_prisonnier(pertes, 'avoue', 'nie')}")
+ print(f"Joueur 1 nie, Joueur 2 avoue : {dilemme_prisonnier(pertes, 'nie', 'avoue')}")
+ print(f"Les deux nient : {dilemme_prisonnier(pertes, 'nie', 'nie')}")
\ No newline at end of file
diff --git a/TP1/Equilibre_De_Nash.py b/TP1/Equilibre_De_Nash.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c1a1b1bd31a96ae1de9dd0feaea4dd21ba15f96
--- /dev/null
+++ b/TP1/Equilibre_De_Nash.py
@@ -0,0 +1,123 @@
+# Définition des actions possibles
+actions = ["avoue", "nie"]
+
+# Représentation des pertes (peines) par différents dictionnaires
+pertes1 = {
+ ("avoue", "avoue"): (3, 3),
+ ("avoue", "nie"): (0, 10),
+ ("nie", "avoue"): (10, 0),
+ ("nie", "nie"): (1, 1)
+}
+
+# Deuxième matrice de pertes
+pertes2 = {
+ ("avoue", "avoue"): (5, 0),
+ ("avoue", "nie"): (5, 1),
+ ("nie", "avoue"): (4, 3),
+ ("nie", "nie"): (3, 4)
+}
+
+# Troisième matrice de pertes
+pertes3 = {
+ ("avoue", "avoue"): (2, 2),
+ ("avoue", "nie"): (5, 1),
+ ("nie", "avoue"): (1, 5),
+ ("nie", "nie"): (3, 3)
+}
+
+def dilemme_prisonnier(matrice_pertes, action_joueur1, action_joueur2):
+ """
+ Fonction qui calcule les pertes pour chaque joueur selon leurs actions.
+
+ Args:
+ matrice_pertes: dictionnaire des pertes
+ action_joueur1: action du joueur 1
+ action_joueur2: action du joueur 2
+
+ Returns:
+ tuple des pertes (perte_joueur1, perte_joueur2)
+ """
+ return matrice_pertes[(action_joueur1, action_joueur2)]
+
+def equilibre_nash(matrice_pertes, actions):
+ """
+ Fonction qui identifie les situations à l'équilibre de Nash.
+
+ Args:
+ matrice_pertes: dictionnaire des pertes
+ actions: liste des actions possibles
+
+ Returns:
+ liste des situations à l'équilibre de Nash
+ """
+ equilibres = []
+
+ # Pour chaque combinaison d'actions possible
+ for action1 in actions:
+ for action2 in actions:
+ situation = (action1, action2)
+ perte1, perte2 = matrice_pertes[situation]
+
+ # Vérifier si le joueur 1 peut améliorer sa situation en changeant d'action
+ meilleure_action_joueur1 = True
+ for autre_action1 in actions:
+ if autre_action1 != action1:
+ autre_perte1 = matrice_pertes[(autre_action1, action2)][0]
+ if autre_perte1 < perte1: # Si une autre action donne une perte plus faible
+ meilleure_action_joueur1 = False
+ break
+
+ # Vérifier si le joueur 2 peut améliorer sa situation en changeant d'action
+ meilleure_action_joueur2 = True
+ for autre_action2 in actions:
+ if autre_action2 != action2:
+ autre_perte2 = matrice_pertes[(action1, autre_action2)][1]
+ if autre_perte2 < perte2: # Si une autre action donne une perte plus faible
+ meilleure_action_joueur2 = False
+ break
+
+ # Si aucun des deux joueurs ne peut améliorer sa situation, c'est un équilibre de Nash
+ if meilleure_action_joueur1 and meilleure_action_joueur2:
+ equilibres.append(situation)
+
+ return equilibres
+
+# Main pour tester le code
+if __name__ == "__main__":
+ print("Dilemme du Prisonnier et Équilibre de Nash")
+ print("=========================================")
+
+ print("\nActions possibles :", actions)
+
+ print("\n1. Matrice de pertes initiale :")
+ for situation, peines in pertes1.items():
+ print(f"Situation {situation} : Pertes {peines}")
+
+ print("\nTests de la fonction dilemme_prisonnier (matrice 1) :")
+ print(f"Les deux avouent : {dilemme_prisonnier(pertes1, 'avoue', 'avoue')}")
+ print(f"Joueur 1 avoue, Joueur 2 nie : {dilemme_prisonnier(pertes1, 'avoue', 'nie')}")
+ print(f"Joueur 1 nie, Joueur 2 avoue : {dilemme_prisonnier(pertes1, 'nie', 'avoue')}")
+ print(f"Les deux nient : {dilemme_prisonnier(pertes1, 'nie', 'nie')}")
+
+ print("\nÉquilibres de Nash pour la matrice initiale :")
+ equilibres1 = equilibre_nash(pertes1, actions)
+ for eq in equilibres1:
+ print(f"Situation {eq} : Pertes {pertes1[eq]}")
+
+ print("\n2. Deuxième matrice de pertes :")
+ for situation, peines in pertes2.items():
+ print(f"Situation {situation} : Pertes {peines}")
+
+ print("\nÉquilibres de Nash pour la deuxième matrice :")
+ equilibres2 = equilibre_nash(pertes2, actions)
+ for eq in equilibres2:
+ print(f"Situation {eq} : Pertes {pertes2[eq]}")
+
+ print("\n3. Troisième matrice de pertes :")
+ for situation, peines in pertes3.items():
+ print(f"Situation {situation} : Pertes {peines}")
+
+ print("\nÉquilibres de Nash pour la troisième matrice :")
+ equilibres3 = equilibre_nash(pertes3, actions)
+ for eq in equilibres3:
+ print(f"Situation {eq} : Pertes {pertes3[eq]}")
\ No newline at end of file