Equilibre de Nash OK

TP1/#Définition_des_actions_possibles.py

+# 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

TP1/Equilibre_De_Nash.py

+# 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