Add game theory algorithms: fictitious play, minimax algorithm, and Nash equilibrium

Author: isatyamks

game_theory/fictitious_play.py

@@ -0,0 +1,32 @@
+def fictitious_play(payoff_matrix_a, payoff_matrix_b, iterations=100):
+    n = payoff_matrix_a.shape[0]
+    m = payoff_matrix_a.shape[1]
+
+    # Initialize counts and strategies
+    counts_a = np.zeros(n)
+    counts_b = np.zeros(m)
+    strategy_a = np.ones(n) / n
+    strategy_b = np.ones(m) / m
+
+    for _ in range(iterations):
+        # Update counts
+        counts_a += strategy_a
+        counts_b += strategy_b
+
+        # Calculate best responses
+        best_response_a = np.argmax(payoff_matrix_a @ strategy_b)
+        best_response_b = np.argmax(payoff_matrix_b.T @ strategy_a)
+
+        # Update strategies
+        strategy_a = np.zeros(n)
+        strategy_a[best_response_a] = 1
+        strategy_b = np.zeros(m)
+        strategy_b[best_response_b] = 1
+
+    return strategy_a, strategy_b
+
+# Example usage
+payoff_a = np.array([[3, 0], [5, 1]])
+payoff_b = np.array([[2, 4], [0, 2]])
+strategies = fictitious_play(payoff_a, payoff_b)
+print("Fictitious Play strategies:", strategies)

game_theory/minimax_algorithm.py

@@ -0,0 +1,28 @@
+def minimax(depth, node_index, is_maximizing_player, values, alpha, beta):
+    if depth == 0:
+        return values[node_index]
+
+    if is_maximizing_player:
+        best_value = float('-inf')
+        for i in range(2):  # Two children (0 and 1)
+            value = minimax(depth - 1, node_index * 2 + i, False, values, alpha, beta)
+            best_value = max(best_value, value)
+            alpha = max(alpha, best_value)
+            if beta <= alpha:
+                break  # Beta cut-off
+        return best_value
+    else:
+        best_value = float('inf')
+        for i in range(2):  # Two children (0 and 1)
+            value = minimax(depth - 1, node_index * 2 + i, True, values, alpha, beta)
+            best_value = min(best_value, value)
+            beta = min(beta, best_value)
+            if beta <= alpha:
+                break  # Alpha cut-off
+        return best_value
+
+# Example usage
+values = [3, 5, 2, 9, 0, 1, 8, 6]  # Leaf node values
+depth = 3  # Depth of the game tree
+result = minimax(depth, 0, True, values, float('-inf'), float('inf'))
+print("The optimal value is:", result)

game_theory/nash_equlibrium.py

@@ -0,0 +1,30 @@
+import numpy as np
+from scipy.optimize import linprog
+
+def find_nash_equilibrium(payoff_matrix_a, payoff_matrix_b):
+    n = payoff_matrix_a.shape[0]
+    m = payoff_matrix_a.shape[1]
+
+    # Solve for player A
+    c = [-1] * n  # Objective: maximize A's payoff
+    a_ub = -payoff_matrix_a  # A's constraints
+    b_ub = [-1] * m
+
+    result_a = linprog(c, A_ub=a_ub, b_ub=b_ub, bounds=(0, None))
+    p_a = result_a.x
+
+    # Solve for player B
+    c = [-1] * m  # Objective: maximize B's payoff
+    a_ub = -payoff_matrix_b.T  # B's constraints
+    b_ub = [-1] * n
+
+    result_b = linprog(c, A_ub=a_ub, b_ub=b_ub, bounds=(0, None))
+    p_b = result_b.x
+
+    return p_a, p_b
+
+# Example usage
+payoff_a = np.array([[3, 0], [5, 1]])
+payoff_b = np.array([[2, 4], [0, 2]])
+equilibrium = find_nash_equilibrium(payoff_a, payoff_b)
+print("Nash Equilibrium strategies:", equilibrium)