⚡️ Speed up function pure_nash_brute by 104%

[codeflash-ai]

📄 104% (1.04x) speedup for pure_nash_brute in quantecon/game_theory/pure_nash.py

⏱️ Runtime : 9.67 milliseconds → 4.74 milliseconds (best of 116 runs)

📝 Explanation and details

The optimized code achieves a 104% speedup (9.67ms → 4.74ms) by inlining the Nash equilibrium check instead of calling g.is_nash() for every action profile.

Key Optimizations

1. Direct payoff array access

• Original: Calls g.is_nash(a, tol=tol) which internally calls player.is_best_response() for each player
• Optimized: Directly accesses g.payoff_profile_array and performs vectorized NumPy operations
• Impact: Eliminates multiple method call overheads (~88% of original runtime was in g.is_nash())

2. Pre-computed tolerances

• Moved tolerance lookup (player.tol attribute access) outside the main loop
• For games with many action profiles to check (e.g., 1,438 iterations in the line profiler), this avoids thousands of repeated attribute accesses

3. Early termination with break

• When a player finds a better response, immediately sets is_nash = False and breaks out of the player loop
• Avoids checking remaining players once we know it's not a Nash equilibrium

Performance Analysis

From the line profiler data:

• Original: 33.4ms spent in g.is_nash() calls (88.2% of generator time)
• Optimized: Direct array operations distributed across multiple lines, with the most expensive being payoffs.max() at 5.5ms (35% of generator time)
• The optimization transforms O(N) method calls per action profile into direct array indexing

Test Case Performance

The optimization performs consistently well across all test cases:

• 20-46% faster on 2-player games (Prisoners' Dilemma, Coordination, Battle of Sexes)
• 96.6% faster on 3-player games where the method call overhead compounds with more players
• Best gains on games with more actions (Rock-Paper-Scissors: 46.5% faster with 3×3 actions)

Impact on Workloads

Based on function_references, this function is used in:

1. Unit tests for game generators - checking that generated games have expected Nash equilibria properties
2. Tolerance-based equilibrium detection - finding epsilon-Nash equilibria with varying tolerance levels

The optimization is particularly beneficial when:

• Checking many games in test suites or Monte Carlo simulations
• Games have larger action spaces (combinatorial explosion means more is_nash checks)
• Multi-player games (N ≥ 3) where the overhead multiplies with each player check

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 27 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Click to see Generated Regression Tests

import numpy as np
import pytest
from quantecon.game_theory.normal_form_game import NormalFormGame
from quantecon.game_theory.pure_nash import pure_nash_brute

class TestPureNashBruteBasic:
    """Basic test cases for pure_nash_brute function."""

    def test_prisoners_dilemma(self):
        """Test pure_nash_brute on Prisoners' Dilemma game.
        
        The Prisoners' Dilemma has a unique pure Nash equilibrium at (1, 1)
        where both players defect.
        """
        PD_bimatrix = [[(1, 1), (-2, 3)],
                       [(3, -2), (0, 0)]]
        g = NormalFormGame(PD_bimatrix)
        codeflash_output = pure_nash_brute(g); result = codeflash_output # 86.1μs -> 71.4μs (20.6% faster)

    def test_matching_pennies_no_pure_nash(self):
        """Test pure_nash_brute on Matching Pennies game.
        
        Matching Pennies has no pure Nash equilibrium, only mixed strategy equilibria.
        """
        MP_bimatrix = [[(1, -1), (-1, 1)],
                       [(-1, 1), (1, -1)]]
        g = NormalFormGame(MP_bimatrix)
        codeflash_output = pure_nash_brute(g); result = codeflash_output # 95.7μs -> 70.8μs (35.2% faster)

    def test_coordination_game(self):
        """Test pure_nash_brute on a coordination game.
        
        A coordination game has multiple pure Nash equilibria where players
        coordinate on the same action.
        """
        coord_bimatrix = [[(2, 2), (0, 1)],
                          [(1, 0), (1, 1)]]
        g = NormalFormGame(coord_bimatrix)
        codeflash_output = pure_nash_brute(g); result = codeflash_output # 95.9μs -> 70.7μs (35.6% faster)

    def test_two_player_one_action_each(self):
        """Test pure_nash_brute on a trivial 1x1 game.
        
        A game where each player has exactly one action should have
        exactly one pure Nash equilibrium.
        """
        # Create a simple 1x1 game where payoffs are (1, 2)
        game_data = np.array([[[1, 2]]])
        g = NormalFormGame(game_data)
        codeflash_output = pure_nash_brute(g); result = codeflash_output # 57.3μs -> 53.0μs (8.16% faster)

    def test_battle_of_sexes(self):
        """Test pure_nash_brute on Battle of the Sexes game.
        
        This game has two pure Nash equilibria where players coordinate
        on different preferences.
        """
        BoS_bimatrix = [[(2, 1), (0, 0)],
                        [(0, 0), (1, 2)]]
        g = NormalFormGame(BoS_bimatrix)
        codeflash_output = pure_nash_brute(g); result = codeflash_output # 95.9μs -> 70.3μs (36.4% faster)

    def test_rock_paper_scissors(self):
        """Test pure_nash_brute on Rock-Paper-Scissors game.
        
        Rock-Paper-Scissors has no pure Nash equilibrium.
        """
        # Zero-sum game payoff matrix
        RPS_bimatrix = [[(0, 0), (-1, 1), (1, -1)],
                        [(1, -1), (0, 0), (-1, 1)],
                        [(-1, 1), (1, -1), (0, 0)]]
        g = NormalFormGame(RPS_bimatrix)
        codeflash_output = pure_nash_brute(g); result = codeflash_output # 135μs -> 92.5μs (46.5% faster)

    def test_return_type_is_list_of_tuples(self):
        """Test that pure_nash_brute returns a list of tuples."""
        PD_bimatrix = [[(1, 1), (-2, 3)],
                       [(3, -2), (0, 0)]]
        g = NormalFormGame(PD_bimatrix)
        codeflash_output = pure_nash_brute(g); result = codeflash_output # 93.6μs -> 70.2μs (33.3% faster)
        # All elements should be tuples
        for element in result:
            pass

    def test_three_player_game(self):
        """Test pure_nash_brute on a three-player game.
        
        Tests that the function correctly handles games with more than
        two players.
        """
        # Create a simple 2x2x2 game with payoff shape (2, 2, 2, 3)
        # Each entry contains a 3-element payoff profile
        payoff_data = np.zeros((2, 2, 2, 3), dtype=float)
        
        # Set some specific payoff profiles
        payoff_data[0, 0, 0] = [1.0, 1.0, 1.0]
        payoff_data[1, 1, 1] = [2.0, 2.0, 2.0]
        payoff_data[0, 1, 0] = [0.0, 0.0, 0.0]
        payoff_data[1, 0, 1] = [0.0, 0.0, 0.0]
        payoff_data[0, 0, 1] = [0.0, 0.0, 0.0]
        payoff_data[0, 1, 1] = [0.0, 0.0, 0.0]
        payoff_data[1, 0, 0] = [0.0, 0.0, 0.0]
        payoff_data[1, 1, 0] = [0.0, 0.0, 0.0]
        
        g = NormalFormGame(payoff_data)
        codeflash_output = pure_nash_brute(g); result = codeflash_output # 158μs -> 80.6μs (96.6% faster)
        for equilibrium in result:
            pass

class TestPureNashBruteEdgeCases:
    """Edge case test cases for pure_nash_brute function."""

    def test_all_payoffs_zero(self):
        """Test pure_nash_brute when all payoffs are zero.
        
        In this case, every action profile should be a Nash equilibrium
        since no player can improve by deviating.
        """
        zero_bimatrix = [[(0, 0), (0, 0)],
                         [(0, 0), (0, 0)]]
        g = NormalFormGame(zero_bimatrix)
        codeflash_output = pure_nash_brute(g); result = codeflash_output # 106μs -> 77.1μs (37.6% faster)

    def test_dominant_strategy_for_both_players(self):
        """Test pure_nash_brute when both players have dominant strategies.
        
        A dominant strategy equilibrium is always a unique pure Nash equilibrium.
        """
        dominant_bimatrix = [[(5, 5), (0, 8)],
                             [(8, 0), (1, 1)]]
        g = NormalFormGame(dominant_bimatrix)
        codeflash_output = pure_nash_brute(g); result = codeflash_output # 92.9μs -> 70.1μs (32.6% faster)

    

To edit these changes git checkout codeflash/optimize-pure_nash_brute-mkp2t49l and push.