updated to lowercase

Author: isatyamks

game_theory/best_response_dynamics.py

@@ -1,27 +1,26 @@
-def best_response_dynamics(payoff_matrix_A, payoff_matrix_B, iterations=10):
-    n = payoff_matrix_A.shape[0]
-    m = payoff_matrix_A.shape[1]
-
-    # Initialize strategies
-    strategy_A = np.ones(n) / n
-    strategy_B = np.ones(m) / m
-
-    for _ in range(iterations):
-        # Update strategy A
-        response_A = np.argmax(payoff_matrix_A @ strategy_B)
-        strategy_A = np.zeros(n)
-        strategy_A[response_A] = 1
-
-        # Update strategy B
-        response_B = np.argmax(payoff_matrix_B.T @ strategy_A)
-        strategy_B = np.zeros(m)
-        strategy_B[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 = best_response_dynamics(payoff_A, payoff_B)
-print("Final strategies:", strategies)
+def best_response_dynamics(payoff_matrix_a, payoff_matrix_b, iterations=10):
+    n = payoff_matrix_a.shape[0]
+    m = payoff_matrix_a.shape[1]
+
+    # Initialize strategies
+    strategy_a = np.ones(n) / n
+    strategy_b = np.ones(m) / m
+
+    for _ in range(iterations):
+        # Update strategy A
+        response_a = np.argmax(payoff_matrix_a @ strategy_b)
+        strategy_a = np.zeros(n)
+        strategy_a[response_a] = 1
+
+        # Update strategy B
+        response_b = np.argmax(payoff_matrix_b.T @ strategy_a)
+        strategy_b = np.zeros(m)
+        strategy_b[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 = best_response_dynamics(payoff_a, payoff_b)
+print("Final strategies:", strategies)

game_theory/fictitious_play.py

@@ -1,33 +1,33 @@
-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)
+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

@@ -1,29 +1,29 @@
-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)
+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_equilibrium.py

@@ -1,3 +1,35 @@
+<<<<<<< HEAD
+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)
+=======
 import numpy as np
 from scipy.optimize import linprog
 
@@ -30,3 +62,4 @@ def find_nash_equilibrium(payoff_matrix_A, payoff_matrix_B):
 payoff_B = np.array([[2, 4], [0, 2]])
 equilibrium = find_nash_equilibrium(payoff_A, payoff_B)
 print("Nash Equilibrium strategies:", equilibrium)
+>>>>>>> 51cf80c355f4a1fbfba6aa04bbb0fdf1292dcb2f

game_theory/shapley_value.py

@@ -1,24 +1,30 @@
-def shapley_value(payoff_matrix):
-    n = payoff_matrix.shape[0]
-    shapley_values = np.zeros(n)
-
-    for i in range(n):
-        for S in range(1 << n):  # All subsets of players
-            if (S & (1 << i)) == 0:  # i not in S
-                continue
-
-            S_without_i = S & ~(1 << i)
-            marginal_contribution = payoff_matrix[S][i] - (
-                payoff_matrix[S_without_i][i] if S_without_i else 0
-            )
-            shapley_values[i] += marginal_contribution / (
-                len(bin(S)) - 2
-            )  # Normalize by size of S
-
-    return shapley_values
-
-
-# Example usage
-payoff_matrix = np.array([[1, 2], [3, 4]])
-shapley_vals = shapley_value(payoff_matrix)
-print("Shapley Values:", shapley_vals)
+def shapley_value(payoff_matrix):
+    n = payoff_matrix.shape[0]
+    shapley_values = np.zeros(n)
+
+    for i in range(n):
+        for s in range(1 << n):  # All subsets of players
+            if (s & (1 << i)) == 0:  # i not in S
+                continue
+
+<<<<<<< HEAD
+            s_without_i = s & ~(1 << i)
+            marginal_contribution = payoff_matrix[s][i] - (payoff_matrix[s_without_i][i] if s_without_i else 0)
+            shapley_values[i] += marginal_contribution / (len(bin(s)) - 2)  # Normalize by size of S
+=======
+            S_without_i = S & ~(1 << i)
+            marginal_contribution = payoff_matrix[S][i] - (
+                payoff_matrix[S_without_i][i] if S_without_i else 0
+            )
+            shapley_values[i] += marginal_contribution / (
+                len(bin(S)) - 2
+            )  # Normalize by size of S
+>>>>>>> 51cf80c355f4a1fbfba6aa04bbb0fdf1292dcb2f
+
+    return shapley_values
+
+
+# Example usage
+payoff_matrix = np.array([[1, 2], [3, 4]])
+shapley_vals = shapley_value(payoff_matrix)
+print("Shapley Values:", shapley_vals)