⚡️ Speed up method LocalInteraction.play by 137%

[codeflash-ai]

📄 137% (1.37x) speedup for LocalInteraction.play in quantecon/game_theory/localint.py

⏱️ Runtime : 280 milliseconds → 118 milliseconds (best of 47 runs)

📝 Explanation and details

The optimized code achieves a 136% speedup (from 280ms to 118ms) by eliminating expensive sparse matrix operations in the hot path of the _play method.

Key Optimization

What changed:
The original code constructs a temporary sparse CSR matrix (actions_matrix) on every call to _play, then performs a sparse matrix multiplication (adj_matrix @ actions_matrix) followed by a .toarray() conversion to dense format. The optimized version directly traverses the CSR matrix internals using indptr, indices, and data arrays, and uses np.bincount to aggregate weighted neighbor actions.

Why it's faster:

1. Eliminates per-iteration allocations: The original creates two temporary sparse matrices per update (one for actions, one for the product), plus a dense array conversion. Line profiler shows the sparse matrix construction takes ~15% of runtime and the matrix multiplication takes ~57%.

2. Reduces memory operations: The optimized version preallocates a single opponent_act array and fills it incrementally using fast NumPy operations (np.bincount with weights), avoiding the overhead of sparse matrix arithmetic and format conversions.

3. Better cache locality: Direct array indexing (actions_arr[neigh]) followed by bincount operates on contiguous memory, whereas sparse matrix multiplication involves pointer chasing through CSR structures.

Performance Characteristics

From the annotated tests, the optimization shows:

• 3-5x speedup on small simultaneous updates (e.g., 223μs → 50μs)
• 8-9x speedup on large asynchronous workloads (e.g., 17.2ms → 1.8ms, 33.5ms → 3.2ms)
• Scales better with iterations: 500 reps test shows 350% speedup (95.7ms → 21.3ms)

The gains are most pronounced when:

• Many iterations occur (asynchronous revision with large num_reps)
• Networks are sparse (fewer neighbors = less bincount overhead)
• Player updates are frequent relative to setup cost

One test case shows a 12.5% slowdown for a large N=200 simultaneous update, likely because the overhead of bincount setup doesn't amortize well when all players update once in a dense configuration, but this is an outlier among overwhelmingly positive results.

Impact on Workloads

Since LocalInteraction.play is a core simulation method for evolutionary game dynamics on networks, this optimization significantly accelerates:

• Monte Carlo simulations requiring thousands of game iterations
• Parameter sweeps over network structures
• Asynchronous best-response dynamics (where individual players update sequentially)

The optimization preserves exact numerical behavior—all tests pass with identical outputs.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import numpy as np
# imports
import pytest  # used for our unit tests
from quantecon.game_theory.localint import LocalInteraction
from quantecon.game_theory.normal_form_game import Player

def test_simultaneous_update_swaps_actions_in_coordination_game():
    # Coordination payoff: players prefer to match opponents' actions.
    # Payoff matrix is 2x2 and square as required.
    payoff = np.array([[1, 0],
                       [0, 1]], dtype=float)
    # Two-player complete graph: each player connected to the other
    adj = np.array([[0, 1],
                    [1, 0]], dtype=float)

    # Create local interaction model
    li = LocalInteraction(payoff, adj)

    # Starting profile: player 0 chooses 0, player 1 chooses 1.
    start = (0, 1)

    # Simultaneous revision: both players update at once and therefore
    # each best-responds to the other player's original action.
    codeflash_output = li.play(revision='simultaneous', actions=start, num_reps=1); result = codeflash_output # 223μs -> 50.7μs (341% faster)

def test_asynchronous_single_player_update_changes_only_that_player():
    # Same coordination payoff as before
    payoff = np.array([[1, 0],
                       [0, 1]], dtype=float)
    adj = np.array([[0, 1],
                    [1, 0]], dtype=float)

    li = LocalInteraction(payoff, adj)

    # Starting profile: player 0 chooses 0, player 1 chooses 1.
    start = (0, 1)

    # Asynchronous update of player 0 only
    codeflash_output = li.play(revision='asynchronous', actions=start,
                     player_ind_seq=0, num_reps=1); result = codeflash_output # 214μs -> 39.5μs (444% faster)

def test_invalid_adj_matrix_raises_value_error():
    # Non-square adjacency matrix should raise on construction
    payoff = np.array([[1, 0],
                       [0, 1]], dtype=float)
    # 2x3 adjacency (non-square)
    bad_adj = np.ones((2, 3))

    with pytest.raises(ValueError):
        LocalInteraction(payoff, bad_adj)

def test_invalid_payoff_matrix_raises_value_error():
    # Non-square payoff matrix should raise on construction
    bad_payoff = np.array([[1, 0, 0],
                           [0, 1, 0]], dtype=float)  # 2x3, not square
    adj = np.eye(2)

    with pytest.raises(ValueError):
        LocalInteraction(bad_payoff, adj)

def test_invalid_revision_string_raises_value_error():
    # Valid payoff and adjacency for a 2-player game
    payoff = np.array([[1, 0],
                       [0, 1]], dtype=float)
    adj = np.array([[0, 1],
                    [1, 0]], dtype=float)

    li = LocalInteraction(payoff, adj)

    # Passing an invalid revision string should raise ValueError
    with pytest.raises(ValueError):
        li.play(revision='invalid_revision', actions=(0, 0), num_reps=1) # 3.51μs -> 3.17μs (10.7% faster)

def test_actions_none_produces_reproducible_random_actions_with_seed():
    # Use a 3-action, 4-player game. Payoff can be anything square.
    payoff = np.eye(3)  # 3x3 square payoff, valid
    N = 4
    # Fully disconnected adjacency (no influence) for simplicity
    adj = np.zeros((N, N))

    li = LocalInteraction(payoff, adj)

    # Request actions to be sampled randomly; fix random_state for reproducibility
    seed = 12345
    codeflash_output = li.play(actions=None, num_reps=1, random_state=seed); actions1 = codeflash_output # 440μs -> 239μs (84.2% faster)
    codeflash_output = li.play(actions=None, num_reps=1, random_state=seed); actions2 = codeflash_output # 424μs -> 228μs (85.7% faster)

    # Each action must be a valid action index in {0,1,2}
    for a in actions1:
        pass

def test_tie_breaking_random_is_reproducible_with_fixed_seed():
    # Construct a payoff that creates ties for every possible opponent action:
    # rows identical -> equal payoffs for both actions.
    payoff = np.array([[1, 1],
                       [1, 1]], dtype=float)
    # Two players connected to each other
    adj = np.array([[0, 1],
                    [1, 0]], dtype=float)

    li = LocalInteraction(payoff, adj)

    # Start with both players choosing action 0 (ties everywhere)
    start = (0, 0)

    # Use random tie-breaking with fixed seed; two runs must match
    codeflash_output = li.play(revision='asynchronous', actions=start,
                   player_ind_seq=0, num_reps=1, tie_breaking='random',
                   random_state=42); res1 = codeflash_output # 421μs -> 242μs (73.6% faster)
    codeflash_output = li.play(revision='asynchronous', actions=start,
                   player_ind_seq=0, num_reps=1, tie_breaking='random',
                   random_state=42); res2 = codeflash_output # 396μs -> 210μs (88.0% faster)

def test_large_scale_simultaneous_converges_to_dominant_action():
    # Large scale test within constraints: N = 200 (well under 1000)
    N = 200
    # Create payoff where action 0 strictly dominates others:
    # A 3x3 payoff array where first row > others irrespective of opponent.
    payoff = np.array([[10, 10, 10],
                       [0, 0, 0],
                       [0, 0, 0]], dtype=float)
    # Create a simple adjacency (e.g., line graph) but it's fine: all zeros except
    # connect each node to its right neighbor to keep sparse interactions.
    adj = np.zeros((N, N), dtype=float)
    for i in range(N - 1):
        adj[i, i + 1] = 1.0
        adj[i + 1, i] = 1.0

    li = LocalInteraction(payoff, adj)

    # Start with everyone choosing action 2 (a poor action)
    start = tuple([2] * N)

    # Single simultaneous update should make every player pick action 0
    # because action 0 strictly dominates others.
    codeflash_output = li.play(revision='simultaneous', actions=start, num_reps=1); result = codeflash_output # 1.45ms -> 1.66ms (12.5% slower)
    # All entries should be 0 after update
    for a in result:
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import numpy as np
# imports
import pytest
from quantecon.game_theory.localint import LocalInteraction
from quantecon.game_theory.normal_form_game import Player

class TestLocalInteractionPlayBasic:
    """Basic functionality tests for LocalInteraction.play"""
    
    def test_play_simultaneous_with_random_actions(self):
        """Test simultaneous revision with randomly initialized actions"""
        # Create a simple 2x2 payoff matrix for a coordination game
        payoff_matrix = np.array([[4, 0], [3, 3]])
        # Create a simple adjacency matrix for 3 players in a line
        adj_matrix = np.array([[0, 1, 0],
                               [1, 0, 1],
                               [0, 1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        # Play one round with simultaneous revision and random initial actions
        codeflash_output = local_int.play(revision='simultaneous', num_reps=1, random_state=42); result = codeflash_output # 448μs -> 276μs (62.0% faster)
    
    def test_play_with_initial_actions(self):
        """Test play with explicitly provided initial actions"""
        payoff_matrix = np.array([[2, 0], [1, 1]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        # Provide explicit initial actions
        initial_actions = (0, 1)
        codeflash_output = local_int.play(revision='simultaneous', actions=initial_actions, num_reps=1); result = codeflash_output # 226μs -> 54.1μs (318% faster)
    
    def test_play_asynchronous_single_player(self):
        """Test asynchronous revision with single player update"""
        payoff_matrix = np.array([[3, 0], [0, 2]])
        adj_matrix = np.array([[0, 1, 0],
                               [1, 0, 1],
                               [0, 1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        # Play with asynchronous revision, updating single player (index 0)
        codeflash_output = local_int.play(revision='asynchronous', actions=(0, 0, 0),
                               player_ind_seq=[0], num_reps=1); result = codeflash_output # 216μs -> 41.4μs (423% faster)
    
    def test_play_asynchronous_multiple_updates(self):
        """Test asynchronous revision with multiple player updates per round"""
        payoff_matrix = np.array([[2, 0], [0, 1]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        # Specify specific player indices for updates
        codeflash_output = local_int.play(revision='asynchronous', actions=(0, 1),
                               player_ind_seq=[0, 1], num_reps=2); result = codeflash_output # 397μs -> 63.3μs (529% faster)
    
    def test_play_multiple_repetitions(self):
        """Test that multiple repetitions work correctly"""
        payoff_matrix = np.array([[1, 0], [0, 1]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        # Play multiple rounds
        codeflash_output = local_int.play(revision='simultaneous', actions=(0, 0),
                               num_reps=5, random_state=42); result = codeflash_output # 1.16ms -> 350μs (231% faster)
    
    def test_play_returns_tuple(self):
        """Test that play always returns a tuple"""
        payoff_matrix = np.array([[1, 1], [1, 1]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='simultaneous', actions=[0, 1]); result = codeflash_output # 226μs -> 54.4μs (317% faster)
    
    def test_play_with_list_actions_input(self):
        """Test that list inputs for actions are handled correctly"""
        payoff_matrix = np.array([[2, 1], [1, 2]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        # Provide actions as a list instead of tuple
        codeflash_output = local_int.play(revision='simultaneous', actions=[0, 1], num_reps=1); result = codeflash_output # 226μs -> 54.6μs (315% faster)

class TestLocalInteractionPlayEdgeCases:
    """Edge case tests for LocalInteraction.play"""
    
    def test_play_single_player(self):
        """Test with a single player (degenerate case)"""
        payoff_matrix = np.array([[1, 0], [0, 1]])
        adj_matrix = np.array([[0]])  # Single player, no neighbors
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='simultaneous', actions=(0,), num_reps=1); result = codeflash_output # 214μs -> 28.4μs (655% faster)
    
    def test_play_disconnected_graph(self):
        """Test with disconnected network (isolated players)"""
        payoff_matrix = np.array([[2, 0], [0, 1]])
        # Adjacency matrix with isolated players
        adj_matrix = np.array([[0, 0, 0],
                               [0, 0, 0],
                               [0, 0, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='simultaneous', actions=(0, 1, 0), num_reps=1); result = codeflash_output # 240μs -> 44.2μs (444% faster)
    
    def test_play_zero_repetitions_with_none_actions(self):
        """Test that zero repetitions with None actions still initializes actions"""
        payoff_matrix = np.array([[1, 0], [0, 1]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        # With num_reps=0, the function should return initialized actions
        codeflash_output = local_int.play(revision='simultaneous', actions=None, num_reps=0, random_state=42); result = codeflash_output # 203μs -> 210μs (3.62% slower)
    
    def test_play_asynchronous_with_integer_player_ind(self):
        """Test asynchronous revision with integer player index"""
        payoff_matrix = np.array([[1, 0], [0, 1]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        # Pass integer player index as player_ind_seq
        codeflash_output = local_int.play(revision='asynchronous', actions=(0, 1),
                               player_ind_seq=1, num_reps=1); result = codeflash_output # 217μs -> 42.1μs (417% faster)
    
    def test_play_large_payoff_values(self):
        """Test with large payoff values"""
        payoff_matrix = np.array([[1000, 0], [0, 1000]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='simultaneous', actions=(0, 1), num_reps=1); result = codeflash_output # 227μs -> 55.0μs (314% faster)
    
    def test_play_negative_payoff_values(self):
        """Test with negative payoff values"""
        payoff_matrix = np.array([[-1, -10], [-10, -1]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='simultaneous', actions=(0, 1), num_reps=1); result = codeflash_output # 227μs -> 54.3μs (319% faster)
    
    def test_play_repeated_valid_states(self):
        """Test that playing on same stable state returns same state"""
        # Coordination game where (0,0) and (1,1) are equilibria
        payoff_matrix = np.array([[4, 0], [3, 3]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        # Start from (0, 0) which might be stable
        codeflash_output = local_int.play(revision='simultaneous', actions=(0, 0), num_reps=1); result1 = codeflash_output # 225μs -> 54.1μs (317% faster)
    
    def test_play_all_players_same_initial_action(self):
        """Test with all players starting with same action"""
        payoff_matrix = np.array([[5, 1], [1, 5]])
        adj_matrix = np.array([[0, 1, 1],
                               [1, 0, 1],
                               [1, 1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        # All players start with action 1
        codeflash_output = local_int.play(revision='simultaneous', actions=(1, 1, 1), num_reps=1); result = codeflash_output # 234μs -> 65.0μs (260% faster)
    
    def test_play_with_random_state_reproducibility(self):
        """Test that same random_state produces same results"""
        payoff_matrix = np.array([[2, 0], [0, 1]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        # Play with same random state
        codeflash_output = local_int.play(revision='simultaneous', actions=None, 
                                num_reps=1, random_state=42); result1 = codeflash_output # 439μs -> 261μs (67.8% faster)
        codeflash_output = local_int.play(revision='simultaneous', actions=None, 
                                num_reps=1, random_state=42); result2 = codeflash_output # 416μs -> 225μs (84.7% faster)
    
    def test_play_invalid_revision_type(self):
        """Test that invalid revision type raises ValueError"""
        payoff_matrix = np.array([[1, 0], [0, 1]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        with pytest.raises(ValueError, match="revision must be"):
            local_int.play(revision='invalid', actions=(0, 1)) # 3.24μs -> 2.94μs (9.92% faster)
    
    def test_play_three_action_game(self):
        """Test with more than 2 actions"""
        payoff_matrix = np.array([[3, 0, 0],
                                  [0, 3, 0],
                                  [0, 0, 3]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='simultaneous', actions=(0, 1), num_reps=1); result = codeflash_output # 229μs -> 55.5μs (314% faster)
    
    def test_play_weighted_adjacency_matrix(self):
        """Test with weighted adjacency matrix (non-binary weights)"""
        payoff_matrix = np.array([[1, 0], [0, 1]])
        # Weighted adjacency matrix
        adj_matrix = np.array([[0, 0.5], [0.5, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='simultaneous', actions=(0, 1), num_reps=1); result = codeflash_output # 228μs -> 52.8μs (332% faster)
    
    def test_play_asymmetric_adjacency(self):
        """Test with asymmetric adjacency matrix"""
        payoff_matrix = np.array([[2, 0], [0, 1]])
        # Asymmetric adjacency
        adj_matrix = np.array([[0, 1, 0],
                               [0, 0, 1],
                               [1, 0, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='simultaneous', actions=(0, 1, 0), num_reps=1); result = codeflash_output # 236μs -> 66.3μs (256% faster)

class TestLocalInteractionPlayLargeScale:
    """Large scale and performance tests for LocalInteraction.play"""
    
    def test_play_large_network_simultaneous(self):
        """Test simultaneous revision on a large network"""
        # Create a larger network with 50 players
        payoff_matrix = np.array([[2, 0], [0, 1]])
        # Random adjacency matrix (connected graph)
        np.random.seed(42)
        adj_matrix = np.random.rand(50, 50) > 0.8
        np.fill_diagonal(adj_matrix, 0)  # No self-loops
        
        local_int = LocalInteraction(payoff_matrix, adj_matrix.astype(float))
        
        # Play one round
        codeflash_output = local_int.play(revision='simultaneous', num_reps=1, random_state=42); result = codeflash_output # 886μs -> 795μs (11.4% faster)
    
    def test_play_large_network_asynchronous(self):
        """Test asynchronous revision on a large network"""
        payoff_matrix = np.array([[3, 0], [0, 2]])
        np.random.seed(42)
        adj_matrix = np.random.rand(30, 30) > 0.7
        np.fill_diagonal(adj_matrix, 0)
        
        local_int = LocalInteraction(payoff_matrix, adj_matrix.astype(float))
        
        # Play with asynchronous updates over multiple rounds
        codeflash_output = local_int.play(revision='asynchronous', num_reps=100, random_state=42); result = codeflash_output # 17.2ms -> 1.80ms (856% faster)
    
    def test_play_many_repetitions(self):
        """Test with many repetitions to check stability"""
        payoff_matrix = np.array([[4, 0], [3, 3]])
        adj_matrix = np.array([[0, 1, 0, 1],
                               [1, 0, 1, 0],
                               [0, 1, 0, 1],
                               [1, 0, 1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        # Run for 500 repetitions
        codeflash_output = local_int.play(revision='simultaneous', actions=(0, 1, 0, 1),
                               num_reps=500); result = codeflash_output # 95.7ms -> 21.3ms (350% faster)
    
    def test_play_large_action_space(self):
        """Test with a larger action space"""
        # 5x5 payoff matrix for 5-action game
        payoff_matrix = np.eye(5)  # Identity matrix for coordination
        adj_matrix = np.array([[0, 1, 0],
                               [1, 0, 1],
                               [0, 1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='simultaneous', 
                               actions=(0, 2, 4), num_reps=10); result = codeflash_output # 1.88ms -> 350μs (437% faster)
    
    def test_play_high_density_network(self):
        """Test on a highly connected network"""
        payoff_matrix = np.array([[2, 0], [0, 1]])
        # Dense network - almost all players connected
        adj_matrix = np.ones((25, 25))
        np.fill_diagonal(adj_matrix, 0)
        
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='simultaneous', num_reps=20, random_state=42); result = codeflash_output # 7.42ms -> 5.07ms (46.3% faster)
    
    def test_play_sparse_network(self):
        """Test on a sparsely connected network"""
        payoff_matrix = np.array([[1, 0], [0, 1]])
        # Sparse network - few connections
        adj_matrix = np.eye(20, k=1) + np.eye(20, k=-1)  # Tridiagonal
        
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='simultaneous', num_reps=50, random_state=42); result = codeflash_output # 15.7ms -> 9.69ms (62.1% faster)
    
    def test_play_mixed_asynchronous_updates(self):
        """Test many asynchronous updates over many repetitions"""
        payoff_matrix = np.array([[2, 0], [0, 1]])
        np.random.seed(42)
        adj_matrix = np.random.rand(20, 20) > 0.7
        np.fill_diagonal(adj_matrix, 0)
        
        local_int = LocalInteraction(payoff_matrix, adj_matrix.astype(float))
        
        # Play 200 asynchronous rounds
        codeflash_output = local_int.play(revision='asynchronous', num_reps=200, random_state=42); result = codeflash_output # 33.5ms -> 3.19ms (950% faster)
    
    def test_play_convergence_behavior(self):
        """Test that actions don't exceed bounds over many iterations"""
        payoff_matrix = np.array([[5, 0, 0],
                                  [0, 5, 0],
                                  [0, 0, 5]])
        np.random.seed(42)
        adj_matrix = np.random.rand(15, 15) > 0.6
        np.fill_diagonal(adj_matrix, 0)
        
        local_int = LocalInteraction(payoff_matrix, adj_matrix.astype(float))
        
        codeflash_output = local_int.play(revision='simultaneous', num_reps=100, random_state=42); result = codeflash_output # 27.5ms -> 14.5ms (89.5% faster)
    
    def test_play_integer_preservation(self):
        """Test that actions remain integers throughout large scale simulation"""
        payoff_matrix = np.array([[3, 0], [0, 2]])
        np.random.seed(123)
        adj_matrix = np.random.rand(40, 40) > 0.75
        np.fill_diagonal(adj_matrix, 0)
        
        local_int = LocalInteraction(payoff_matrix, adj_matrix.astype(float))
        
        codeflash_output = local_int.play(revision='simultaneous', num_reps=150, random_state=42); result = codeflash_output # 69.1ms -> 56.4ms (22.5% faster)

class TestLocalInteractionPlayOptionsAndKeywords:
    """Tests for options and keyword arguments to play function"""
    
    def test_play_with_tie_breaking_smallest(self):
        """Test explicit tie_breaking='smallest' option"""
        payoff_matrix = np.array([[2, 0], [0, 1]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='simultaneous', actions=(0, 1),
                               tie_breaking='smallest', num_reps=1); result = codeflash_output # 229μs -> 54.8μs (319% faster)
    
    def test_play_with_tie_breaking_random(self):
        """Test tie_breaking='random' option"""
        payoff_matrix = np.array([[2, 0], [0, 1]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='simultaneous', actions=(0, 1),
                               tie_breaking='random', random_state=42, num_reps=1); result = codeflash_output # 432μs -> 252μs (71.6% faster)
    
    def test_play_with_tolerance_option(self):
        """Test with tolerance option for best response"""
        payoff_matrix = np.array([[2.0, 0.0], [0.0, 1.0]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='simultaneous', actions=(0, 1),
                               tol=1e-8, num_reps=1); result = codeflash_output # 223μs -> 52.1μs (329% faster)
    
    def test_play_with_custom_random_state(self):
        """Test with custom random state object"""
        payoff_matrix = np.array([[1, 0], [0, 1]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        # Create a RandomState object
        rng = np.random.RandomState(123)
        codeflash_output = local_int.play(revision='simultaneous', actions=None,
                               random_state=rng, num_reps=1); result = codeflash_output # 257μs -> 71.8μs (258% faster)
    
    def test_play_simultaneous_explicit(self):
        """Test explicit simultaneous revision string"""
        payoff_matrix = np.array([[2, 0], [0, 1]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='simultaneous', actions=(0, 1), num_reps=1); result = codeflash_output # 227μs -> 54.7μs (315% faster)
    
    def test_play_asynchronous_explicit(self):
        """Test explicit asynchronous revision string"""
        payoff_matrix = np.array([[2, 0], [0, 1]])
        adj_matrix = np.array([[0, 1], [1, 0]])
        local_int = LocalInteraction(payoff_matrix, adj_matrix)
        
        codeflash_output = local_int.play(revision='asynchronous', actions=(0, 1),
                               player_ind_seq=[0], num_reps=1); result = codeflash_output # 217μs -> 41.5μs (424% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-LocalInteraction.play-mkp7k202 and push.