Chore: Game Theory algorithms are missing #11804

computer_vision/README.md

@@ -8,4 +8,4 @@ Image processing and computer vision are a little different from each other. Ima
 While computer vision comes from modelling image processing using the techniques of machine learning, computer vision applies machine learning to recognize patterns for interpretation of images (much like the process of visual reasoning of human vision).
 
 * <https://en.wikipedia.org/wiki/Computer_vision>
-* <https://www.datarobot.com/blog/introduction-to-computer-vision-what-it-is-and-how-it-works/>
+* <https://docs.opencv.org/4.x/>

game_theory/best_response_dynamics.py

@@ -0,0 +1,27 @@
+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

@@ -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/shapley_value.py

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