Game Theory and Strategic Reasoning

The Basics: Players, Strategies, and Payoffs

At the core of game theory are three fundamental concepts: players, strategies, and payoffs. Players are the decision-makers in the game, which could be individuals, companies, or even algorithms. Each player has a set of strategies—possible actions they can take. Payoffs represent the outcomes for each player based on the combination of strategies chosen by all players. For example, in a simple two-player game like Rock-Paper-Scissors, each player has three strategies, and the payoff is either a win, loss, or tie. The key insight here is that a player's optimal strategy depends not just on their own choices but on what others do. This interdependence is what makes game theory distinct from single-agent decision problems. By modeling these elements explicitly, you can analyze how rational players will behave and what outcomes are likely to emerge. The code below simulates a basic payoff matrix for a two-player game, where each player's strategy affects the other's outcome.

# Define a simple two-player payoff matrix for a game like Prisoner's Dilemma
# Rows: Player 1's strategies (Cooperate, Defect)
# Columns: Player 2's strategies (Cooperate, Defect)
# Payoffs are tuples: (Player 1's payoff, Player 2's payoff)
payoff_matrix = {
    ('Cooperate', 'Cooperate'): (3, 3),  # Both cooperate, moderate reward
    ('Cooperate', 'Defect'): (0, 5),     # Player 1 cooperates, Player 2 defects
    ('Defect', 'Cooperate'): (5, 0),     # Player 1 defects, Player 2 cooperates
    ('Defect', 'Defect'): (1, 1)         # Both defect, minimal reward
}

def get_payoff(player1_strategy, player2_strategy):
    """Return the payoff for both players given their strategies."""
    return payoff_matrix.get((player1_strategy, player2_strategy), (0, 0))

# Example: What happens if Player 1 cooperates and Player 2 defects?
player1_payoff, player2_payoff = get_payoff('Cooperate', 'Defect')
print(f"Player 1 payoff: {player1_payoff}, Player 2 payoff: {player2_payoff}")

Dominant Strategies and Rationality

A dominant strategy is one that yields the highest payoff for a player, regardless of what the other players do. Identifying dominant strategies simplifies analysis because rational players will always choose them. For example, in the Prisoner's Dilemma, defecting is a dominant strategy for both players, even though mutual cooperation would lead to a better collective outcome. This illustrates a key tension in game theory: individual rationality can lead to collectively suboptimal outcomes. The concept of dominance helps you predict behavior in one-shot games where players act simultaneously without communication. However, not all games have dominant strategies, and in such cases, you must consider more nuanced equilibrium concepts. The code below checks for dominant strategies by comparing payoffs across all possible opponent strategies.

# Check if a strategy is dominant for a player in a two-player game
def is_dominant_strategy(player, strategy, payoff_matrix):
    """Check if `strategy` is dominant for `player` (1 or 2)."""
    for opponent_strategy in ['Cooperate', 'Defect']:
        # Compare payoffs for all possible opponent strategies
        for other_strategy in ['Cooperate', 'Defect']:
            if strategy == other_strategy:
                continue
            # Get payoffs for current and alternative strategy
            if player == 1:
                current_payoff = payoff_matrix[(strategy, opponent_strategy)][0]
                other_payoff = payoff_matrix[(other_strategy, opponent_strategy)][0]
            else:
                current_payoff = payoff_matrix[(opponent_strategy, strategy)][1]
                other_payoff = payoff_matrix[(opponent_strategy, other_strategy)][1]
            
            if current_payoff < other_payoff:
                return False
    return True

# Example: Is 'Defect' a dominant strategy for Player 1?
is_dominant = is_dominant_strategy(1, 'Defect', payoff_matrix)
print(f"Is 'Defect' dominant for Player 1? {is_dominant}")

Nash Equilibrium: The Core Concept

A Nash Equilibrium is a set of strategies where no player can unilaterally improve their payoff by changing their strategy, assuming all other players' strategies remain fixed. This concept is central to game theory because it predicts stable outcomes in strategic interactions. For example, in the Prisoner's Dilemma, the Nash Equilibrium is (Defect, Defect), even though (Cooperate, Cooperate) would be better for both. The power of Nash Equilibrium lies in its generality: it applies to any finite game with rational players. To find a Nash Equilibrium, you check each possible strategy profile to see if any player has an incentive to deviate. The code below implements this check for a two-player game by iterating through all strategy combinations and verifying if any player can benefit from switching strategies.

# Find all Nash Equilibria in a two-player game
def find_nash_equilibria(payoff_matrix):
    """Return all strategy pairs where neither player can improve by deviating."""
    equilibria = []
    strategies = ['Cooperate', 'Defect']
    
    for p1_strategy in strategies:
        for p2_strategy in strategies:
            is_equilibrium = True
            # Check if Player 1 can improve by switching
            for alt_p1_strategy in strategies:
                if alt_p1_strategy == p1_strategy:
                    continue
                current_payoff = payoff_matrix[(p1_strategy, p2_strategy)][0]
                alt_payoff = payoff_matrix[(alt_p1_strategy, p2_strategy)][0]
                if alt_payoff > current_payoff:
                    is_equilibrium = False
                    break
            if not is_equilibrium:
                continue
            
            # Check if Player 2 can improve by switching
            for alt_p2_strategy in strategies:
                if alt_p2_strategy == p2_strategy:
                    continue
                current_payoff = payoff_matrix[(p1_strategy, p2_strategy)][1]
                alt_payoff = payoff_matrix[(p1_strategy, alt_p2_strategy)][1]
                if alt_payoff > current_payoff:
                    is_equilibrium = False
                    break
            
            if is_equilibrium:
                equilibria.append((p1_strategy, p2_strategy))
    
    return equilibria

# Example: Find Nash Equilibria in the Prisoner's Dilemma
nash_equilibria = find_nash_equilibria(payoff_matrix)
print(f"Nash Equilibria: {nash_equilibria}")

Repeated Games and Long-Term Strategies

In repeated games, players interact multiple times, allowing for strategies that consider past behavior. This changes the dynamics significantly because players can punish or reward each other over time, enabling cooperation even in scenarios where one-shot interactions would lead to defection. For example, the 'Tit-for-Tat' strategy—where a player starts by cooperating and then mirrors the opponent's last move—has been shown to perform well in repeated Prisoner's Dilemma games. The key insight is that repetition introduces reputation and future consequences, which can stabilize cooperative outcomes. However, the effectiveness of such strategies depends on the discount factor (how much players value future payoffs relative to immediate ones). The code below simulates a repeated game where players use Tit-for-Tat, demonstrating how cooperation can emerge over time.

# Simulate a repeated Prisoner's Dilemma with Tit-for-Tat strategy
def simulate_repeated_game(rounds, initial_strategy='Cooperate'):
    """Simulate a repeated game where both players use Tit-for-Tat."""
    p1_history = []
    p2_history = []
    p1_strategy = initial_strategy
    p2_strategy = initial_strategy
    
    for round_num in range(rounds):
        # Determine current strategies (Tit-for-Tat: mirror opponent's last move)
        if round_num > 0:
            p1_strategy = p2_history[-1]  # Player 1 mirrors Player 2's last move
            p2_strategy = p1_history[-1]  # Player 2 mirrors Player 1's last move
        
        # Record payoffs
        payoff = payoff_matrix[(p1_strategy, p2_strategy)]
        p1_history.append(p1_strategy)
        p2_history.append(p2_strategy)
        
        print(f"Round {round_num + 1}: P1={p1_strategy}, P2={p2_strategy}, Payoffs={payoff}")
    
    return p1_history, p2_history

# Example: Simulate 5 rounds of Tit-for-Tat
print("Simulating repeated Prisoner's Dilemma with Tit-for-Tat:")
simulate_repeated_game(5)

Mixed Strategies and Probabilistic Play

In some games, no pure strategy (a deterministic choice) yields a Nash Equilibrium, and players must randomize their actions. A mixed strategy assigns probabilities to each pure strategy, and the Nash Equilibrium in such cases involves players choosing probabilities that make their opponents indifferent between their own strategies. For example, in Rock-Paper-Scissors, the Nash Equilibrium is for each player to choose each option with equal probability (1/3). The rationale is that if one player deviates from this distribution, the other can exploit the bias. Mixed strategies are particularly useful in zero-sum games, where one player's gain is the other's loss. The code below calculates the Nash Equilibrium for a simplified zero-sum game by solving for the probabilities that make the opponent's expected payoff equal across all strategies.

# Calculate mixed-strategy Nash Equilibrium for a zero-sum game
import numpy as np

def solve_mixed_strategy(payoff_matrix_p1):
    """Solve for mixed-strategy Nash Equilibrium in a 2x2 zero-sum game.
    
    Args:
        payoff_matrix_p1: 2x2 matrix of Player 1's payoffs (Player 2's are negatives).
    
    Returns:
        Tuple of (p1_probabilities, p2_probabilities).
    """
    # Player 2's payoff matrix is the negative of Player 1's
    payoff_matrix_p2 = -np.array(payoff_matrix_p1)
    
    # Solve for Player 1's probabilities (p, 1-p) that make Player 2 indifferent
    # between their strategies
    a, b = payoff_matrix_p2[0, 0], payoff_matrix_p2[0, 1]
    c, d = payoff_matrix_p2[1, 0], payoff_matrix_p2[1, 1]
    p = (d - c) / (a - b - c + d)
    
    # Solve for Player 2's probabilities (q, 1-q) that make Player 1 indifferent
    e, f = payoff_matrix_p1[0, 0], payoff_matrix_p1[0, 1]
    g, h = payoff_matrix_p1[1, 0], payoff_matrix_p1[1, 1]
    q = (h - g) / (e - f - g + h)
    
    return (p, 1 - p), (q, 1 - q)

# Example: Rock-Paper-Scissors simplified to 2x2 (Rock vs. Paper)
payoff_matrix_p1 = [
    [0, -1],  # Player 1 plays Rock: tie (0) or lose (-1)
    [1, 0]     # Player 1 plays Paper: win (1) or tie (0)
]

p1_probs, p2_probs = solve_mixed_strategy(payoff_matrix_p1)
print(f"Player 1's mixed strategy: {p1_probs}")
print(f"Player 2's mixed strategy: {p2_probs}")

Interview questions

All Reasoning interview questions →

Check yourself

Take the full Reasoning quiz →