new tests for enumpure_solve in pure strategies and behaviors

Author: rahulsavani

pyproject.toml

@@ -76,12 +76,14 @@ max-line-length = 99
 [tool.pytest.ini_options]
 addopts = "--strict-markers"
 markers = [
+    "nash_enumpure_strategy: tests of enumpure_solve in pure strategies",
+    "nash_enumpure_agent: tests of enumpure_solve in pure behaviors",
     "nash_enummixed_strategy: tests of enummixed_solve in mixed strategies",
-    "nash_enumpoly_behavior: tests of enumpoly_solve in behavior strategies",
+    "nash_enumpoly_behavior: tests of enumpoly_solve in mixed behaviors",
     "nash_lcp_strategy: tests of lcp_solve in mixed strategies",
-    "nash_lcp_behavior: tests of lcp_solve in behavior strategies",
+    "nash_lcp_behavior: tests of lcp_solve in mixed behaviors",
     "nash_lp_strategy: tests of lp_solve in mixed strategies",
-    "nash_lp_behavior: tests of lp_solve in behavior strategies",
+    "nash_lp_behavior: tests of lp_solve in mixed behaviors",
     "nash: all tests of Nash equilibrium solvers",
     "slow: all time-consuming tests",
 ]

tests/test_nash.py

@@ -17,16 +17,110 @@
 TOL = 1e-13  # tolerance for floating point assertions
 
 
-def test_enumpure_strategy():
-    """Test calls of enumeration of pure strategies."""
-    game = games.read_from_file("poker.efg")
-    assert len(gbt.nash.enumpure_solve(game, use_strategic=True).equilibria) == 0
+@pytest.mark.nash
+@pytest.mark.nash_enumpure_strategy
+@pytest.mark.parametrize(
+    "game,pure_strategy_prof_data",
+    [
+        # Zero-sum games
+        (
+            games.create_two_player_perfect_info_win_lose_efg(),
+            [
+                [[0, 0, 1, 0], [1, 0, 0]],
+                [[0, 0, 1, 0], [0, 1, 0]],
+                [[0, 0, 1, 0], [0, 0, 1]],
+            ]
+        ),
+        (games.create_myerson_2_card_poker_efg(), []),
+        # Non-zero-sum 2-player games
+        (games.create_one_shot_trust_efg(), [[[0, 1], [0, 1]]]),
+        (
+            games.create_EFG_for_nxn_bimatrix_coordination_game(3),
+            [
+                [[1, 0, 0], [1, 0, 0]],
+                [[0, 1, 0], [0, 1, 0]],
+                [[0, 0, 1], [0, 0, 1]],
+            ],
+        ),
+        (games.create_EFG_for_6x6_bimatrix_with_long_LH_paths_and_unique_eq(), []),
+        # 3-player game
+        (
+            games.create_mixed_behav_game_efg(),
+            [
+                [[1, 0], [1, 0], [1, 0]],
+                [[0, 1], [0, 1], [1, 0]],
+                [[0, 1], [1, 0], [0, 1]],
+                [[1, 0], [0, 1], [0, 1]],
+            ],
+        ),
+    ]
+)
+def test_enumpure_strategy(game: gbt.Game, pure_strategy_prof_data: list):
+    """Test calls of enumeration of pure strategy equilibria
 
+       Tests max regret being zero (internal consistency) and compares the computed sequence of
+       pure strategy equilibria to a previosuly computed sequence (regression test)
+    """
+    result = gbt.nash.enumpure_solve(game, use_strategic=True)
+    assert len(result.equilibria) == len(pure_strategy_prof_data)
+    for eq, exp in zip(result.equilibria, pure_strategy_prof_data):
+        assert eq.max_regret() == 0
+        expected = game.mixed_strategy_profile(rational=True, data=exp)
+        assert eq == expected
 
-def test_enumpure_agent():
-    """Test calls of enumeration of pure agent strategies."""
-    game = games.read_from_file("poker.efg")
-    assert len(gbt.nash.enumpure_solve(game, use_strategic=False).equilibria) == 0
+
+@pytest.mark.nash
+@pytest.mark.nash_enumpure_agent
+@pytest.mark.parametrize(
+    "game,pure_behav_prof_data",
+    [
+        # Zero-sum games
+        (
+            games.create_two_player_perfect_info_win_lose_efg(),
+            [
+                [[[1, 0], [1, 0]], [[0, 1], [1, 0]]],
+                [[[0, 1], [1, 0]], [[1, 0], [1, 0]]],
+                [[[0, 1], [1, 0]], [[1, 0], [0, 1]]],
+                [[[0, 1], [1, 0]], [[0, 1], [1, 0]]],
+                [[[0, 1], [1, 0]], [[0, 1], [0, 1]]]
+            ]
+        ),
+        (games.create_myerson_2_card_poker_efg(), []),
+        # Non-zero-sum 2-player games
+        (games.create_one_shot_trust_efg(), [[[[0, 1]], [[0, 1]]]]),
+        (
+            games.create_EFG_for_nxn_bimatrix_coordination_game(3),
+            [
+                [[[1, 0, 0]], [[1, 0, 0]]],
+                [[[0, 1, 0]], [[0, 1, 0]]],
+                [[[0, 0, 1]], [[0, 0, 1]]],
+            ],
+        ),
+        (games.create_EFG_for_6x6_bimatrix_with_long_LH_paths_and_unique_eq(), []),
+        # 3-player game
+        (
+            games.create_mixed_behav_game_efg(),
+            [
+                [[[1, 0]], [[1, 0]], [[1, 0]]],
+                [[[1, 0]], [[0, 1]], [[0, 1]]],
+                [[[0, 1]], [[1, 0]], [[0, 1]]],
+                [[[0, 1]], [[0, 1]], [[1, 0]]],
+            ],
+        ),
+    ]
+)
+def test_enumpure_agent(game: gbt.Game, pure_behav_prof_data: list):
+    """Test calls of enumeration of pure agent (behavior) equilibria
+
+       Tests max regret being zero (internal consistency) and compares the computed sequence of
+       pure agent equilibria to a previosuly computed sequence (regression test)
+    """
+    result = gbt.nash.enumpure_solve(game, use_strategic=False)
+    assert len(result.equilibria) == len(pure_behav_prof_data)
+    for eq, exp in zip(result.equilibria, pure_behav_prof_data):
+        assert eq.max_regret() == 0
+        expected = game.mixed_behavior_profile(rational=True, data=exp)
+        assert eq == expected
 
 
 def test_enummixed_double():

tests/test_players.py

@@ -39,7 +39,6 @@ def test_player_index_by_string():
 
 def test_player_index_out_of_range():
     game = gbt.Game.new_table([2, 2])
-    print(f"Number of players: {len(game.players)}")
     assert len(game.players) == 2
     with pytest.raises(IndexError):
         _ = game.players[2]