diff --git a/game_theory/best_response_dynamics.py b/game_theory/best_response_dynamics.py new file mode 100644 index 000000000000..cc1dcb5775a4 --- /dev/null +++ b/game_theory/best_response_dynamics.py @@ -0,0 +1,30 @@ +import numpy as np + + +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) diff --git a/game_theory/fictitious_play.py b/game_theory/fictitious_play.py new file mode 100644 index 000000000000..3b64a2d08120 --- /dev/null +++ b/game_theory/fictitious_play.py @@ -0,0 +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) diff --git a/game_theory/minimax_algorithm.py b/game_theory/minimax_algorithm.py new file mode 100644 index 000000000000..988091485f35 --- /dev/null +++ b/game_theory/minimax_algorithm.py @@ -0,0 +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) diff --git a/game_theory/nash_equilibrium.py b/game_theory/nash_equilibrium.py new file mode 100644 index 000000000000..d584aa5507c3 --- /dev/null +++ b/game_theory/nash_equilibrium.py @@ -0,0 +1,65 @@ +<<<<<<< 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 + + +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) +>>>>>>> 51cf80c355f4a1fbfba6aa04bbb0fdf1292dcb2f diff --git a/game_theory/shapley_value.py b/game_theory/shapley_value.py new file mode 100644 index 000000000000..8adea4bdd425 --- /dev/null +++ b/game_theory/shapley_value.py @@ -0,0 +1,24 @@ +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)