tests for nash solvers -- enumpoly_solve, lp_solve, lcp_solve -- in behavior stratgegies

Author: rahulsavani

ChangeLog

@@ -6,6 +6,9 @@
 - In the graphical interface, removed option to configure information set link drawing; information sets
   are always drawn and indicators are always drawn if an information set spans multiple levels.
 
+### Added
+- Tests for EFG nash solvers -- `enumpoly_solve`, `lp_solve`, `lcp_solve` -- in behavior stratgegies
+
 
 ## [16.4.1] - unreleased
 

pyproject.toml

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

tests/games.py

@@ -18,6 +18,31 @@ def read_from_file(fn: str) -> gbt.Game:
         raise ValueError(f"Unknown file extension in {fn}")
 
 
+def create_efg_corresponding_to_bimatrix_game(A: np.ndarray, B: np.ndarray, title: str
+) -> gbt.Game:
+    """
+    There is not direct pygambit method to create an EFG from a stategic-form game.
+    Here we create an EFG corresponding to a bimatrix game, which is given by two numpy arrays.
+    Player 1 moves first.
+    """
+    assert A.shape == B.shape
+    m, n = A.shape
+    g = gbt.Game.new_tree(players=["1", "2"], title=title)
+    actions1 = [str(i) for i in range(m)]
+    actions2 = [str(i) for i in range(n)]
+    g.append_move(g.root, "1", actions1)
+    for node in g.root.children:
+        g.append_move(node, "2", actions2)
+    iset = g.root.children[0].infoset
+    for c in g.root.children:
+        g.set_infoset(c, iset)
+    from itertools import product
+
+    for i, j in product(range(m), range(n)):
+        g.set_outcome(g.root.children[i].children[j], g.add_outcome([A[i, j], B[i, j]]))
+    return g
+
+
 ################################################################################################
 # Normal-form (aka strategic-form) games (nfg)
 
@@ -87,10 +112,22 @@ def create_mixed_behav_game_efg() -> gbt.Game:
     Game
         Three-player extensive form game: binary tree with 3 infomation sets, one per player,
         with 1, 2, and 4 nodes respectively
+
+        Since no information is revealed this is directly equivalent to a simultaneous move game
     """
     return read_from_file("mixed_behavior_game.efg")
 
 
+def create_1_card_poker_efg() -> gbt.Game:
+    """
+    Returns
+    -------
+    Game
+        One-card two-player poker game, as used in the user guide
+    """
+    return read_from_file("poker.efg")
+
+
 def create_myerson_2_card_poker_efg() -> gbt.Game:
     """
     Returns
@@ -104,6 +141,128 @@ def create_myerson_2_card_poker_efg() -> gbt.Game:
     return read_from_file("myerson_2_card_poker.efg")
 
 
+def create_kuhn_poker_efg() -> gbt.Game:
+    """
+    Returns
+    -------
+    Game
+        Kuhn poker with 3 cards and 2 players
+    """
+    g = gbt.Game.new_tree(
+        players=["Alice", "Bob"], title="Three-card poker (J, Q, K), two-player"
+    )
+    g.append_move(g.root, g.players.chance, ["JQ", "JK", "QJ", "QK", "KJ", "KQ"])
+    g.set_chance_probs(g.root.infoset, [gbt.Rational(1, 6)]*6)
+    # For each chance outcome node, append Alice's first decision: Check or Bet.
+    for i in range(6):
+        g.append_move(g.root.children[i], "Alice", ["Check", "Bet"])
+    # After Alice checks, Bob moves: Check or Bet.
+    for i in range(6):
+        g.append_move(g.root.children[i].children[0], "Bob", ["Check", "Bet"])
+    # If Bob bets after Alice checked (Bob's second action), then Alice can Fold or Call.
+    # Append Alice's response nodes for the check-then-bet branch
+    for i in range(6):
+        g.append_move(g.root.children[i].children[0].children[1], "Alice", ["Fold", "Call"])
+    # If Alice bets initially, Bob can Fold or Call.
+    for i in range(6):
+        g.append_move(g.root.children[i].children[1], "Bob", ["Fold", "Call"])
+    # Set up information sets to represent imperfect information.
+    # Alice dealt J 
+    g.set_infoset(g.root.children[0], g.root.children[1].infoset)
+    # Alice dealt Q 
+    g.set_infoset(g.root.children[2], g.root.children[3].infoset)
+    # Alice dealt K 
+    g.set_infoset(g.root.children[4], g.root.children[5].infoset)
+    # Bob's decision after Alice checks: Bob knows his own card but not Alice's
+    # Bob dealt Q 
+    g.set_infoset(g.root.children[0].children[0], g.root.children[5].children[0].infoset)
+    # Bob dealt K
+    g.set_infoset(g.root.children[1].children[0], g.root.children[3].children[0].infoset)
+    # Bob dealt J
+    g.set_infoset(g.root.children[2].children[0], g.root.children[4].children[0].infoset)
+    # Bob's decision after Alice bets: 
+    # Bob dealt Q
+    g.set_infoset(g.root.children[0].children[1], g.root.children[5].children[1].infoset)
+    # Bob dealt K
+    g.set_infoset(g.root.children[1].children[1], g.root.children[3].children[1].infoset)
+    # Bob dealt J
+    g.set_infoset(g.root.children[2].children[1], g.root.children[4].children[1].infoset)
+    # Alice's decision after she checked and Bob then bet: 
+    # Alice dealt J 
+    g.set_infoset(g.root.children[0].children[0].children[1], 
+                  g.root.children[1].children[0].children[1].infoset)
+    # Alice dealt Q
+    g.set_infoset(g.root.children[2].children[0].children[1],
+                  g.root.children[3].children[0].children[1].infoset)
+    # Alice dealt K
+    g.set_infoset(g.root.children[4].children[0].children[1],
+                  g.root.children[5].children[0].children[1].infoset)
+    # Add outcomes at terminal nodes (net payoffs); first define four outcomes:
+    alice_wins1 = g.add_outcome([1, -1], label="Alice wins 1")
+    alice_wins2 = g.add_outcome([2, -2], label="Alice wins 2")
+    bob_wins1 = g.add_outcome([-1, 1], label="Bob wins 1")
+    bob_wins2 = g.add_outcome([-2, 2], label="Bob wins 2")
+    # Check-Check -> Bob wins 1
+    g.set_outcome(g.root.children[0].children[0].children[0], bob_wins1)
+    # Check-Bet-Fold -> Bob wins 1
+    g.set_outcome(g.root.children[0].children[0].children[1].children[0], bob_wins1)
+    # Check-Bet-Call -> showdown -> Bob wins 2
+    g.set_outcome(g.root.children[0].children[0].children[1].children[1], bob_wins2)
+    # Bet-Fold -> Alice bet, Bob folds -> Alice wins pot -> Alice wins 1
+    g.set_outcome(g.root.children[0].children[1].children[0], alice_wins1)
+    # Bet-Call -> showdown -> Bob wins 2
+    g.set_outcome(g.root.children[0].children[1].children[1], bob_wins2)
+    # JK -> Bob wins showdown
+    g.set_outcome(g.root.children[1].children[0].children[0], bob_wins1)
+    g.set_outcome(g.root.children[1].children[0].children[1].children[0], bob_wins1)
+    g.set_outcome(g.root.children[1].children[0].children[1].children[1], bob_wins2)
+    g.set_outcome(g.root.children[1].children[1].children[0], alice_wins1)
+    g.set_outcome(g.root.children[1].children[1].children[1], bob_wins2)
+    # QJ -> Alice wins showdown
+    g.set_outcome(g.root.children[2].children[0].children[0], alice_wins1)
+    g.set_outcome(g.root.children[2].children[0].children[1].children[0], bob_wins1)
+    g.set_outcome(g.root.children[2].children[0].children[1].children[1], alice_wins2)
+    g.set_outcome(g.root.children[2].children[1].children[0], alice_wins1)
+    g.set_outcome(g.root.children[2].children[1].children[1], alice_wins2)
+    # QK -> Bob wins showdown
+    g.set_outcome(g.root.children[3].children[0].children[0], bob_wins1)
+    g.set_outcome(g.root.children[3].children[0].children[1].children[0], bob_wins1)
+    g.set_outcome(g.root.children[3].children[0].children[1].children[1], bob_wins2)
+    g.set_outcome(g.root.children[3].children[1].children[0], alice_wins1)
+    g.set_outcome(g.root.children[3].children[1].children[1], bob_wins2)
+    # KJ -> Alice wins showdown
+    g.set_outcome(g.root.children[4].children[0].children[0], alice_wins1)
+    g.set_outcome(g.root.children[4].children[0].children[1].children[0], bob_wins1)
+    g.set_outcome(g.root.children[4].children[0].children[1].children[1], alice_wins2)
+    g.set_outcome(g.root.children[4].children[1].children[0], alice_wins1)
+    g.set_outcome(g.root.children[4].children[1].children[1], alice_wins2)
+    # KQ -> Alice wins showdown
+    g.set_outcome(g.root.children[5].children[0].children[0], alice_wins1)
+    g.set_outcome(g.root.children[5].children[0].children[1].children[0], bob_wins1)
+    g.set_outcome(g.root.children[5].children[0].children[1].children[1], alice_wins2)
+    g.set_outcome(g.root.children[5].children[1].children[0], alice_wins1)
+    g.set_outcome(g.root.children[5].children[1].children[1], alice_wins2)
+    # Ensure infosets are in the same order as if game was written to efg and read back in
+    g.sort_infosets()
+    return g
+
+
+def create_one_shot_trust_efg() -> gbt.Game:
+    g = gbt.Game.new_tree(
+        players=["Buyer", "Seller"], title="One-shot trust game, after Kreps (1990)"
+    )
+    g.append_move(g.root, "Buyer", ["Trust", "Not trust"])
+    g.append_move(g.root.children[0], "Seller", ["Honor", "Abuse"])
+    g.set_outcome(
+        g.root.children[0].children[0], g.add_outcome([1, 1], label="Trustworthy")
+    )
+    g.set_outcome(
+        g.root.children[0].children[1], g.add_outcome([-1, 2], label="Untrustworthy")
+    )
+    g.set_outcome(g.root.children[1], g.add_outcome([0, 0], label="Opt-out"))
+    return g
+
+
 def create_centipede_game_with_chance_efg() -> gbt.Game:
     """
     Returns
@@ -198,7 +357,6 @@ def create_reduction_generic_payoffs_efg() -> gbt.Game:
     )
 
     g.set_outcome(g.root.children[3], g.add_outcome([12, -12], label="d"))
-
     return g
 
 
@@ -236,6 +394,138 @@ def create_reduction_both_players_payoff_ties_efg() -> gbt.Game:
     return g
 
 
+def create_seq_form_STOC_paper_zero_sum_2_player_efg() -> gbt.Game:
+    """
+    Example from
+
+    Fast Algorithms for Finding Randomized Strategies in Game Trees (1994)
+    Koller, Megiddo, von Stengel
+    """
+    g = gbt.Game.new_tree(players=["1", "2"], title="From STOC'94 paper")
+    g.append_move(g.root, g.players.chance, actions=["1", "2", "3", "4"])
+    g.set_chance_probs(g.root.infoset, [0.2, 0.2, 0.2, 0.4])
+    g.append_move(g.root.children[0], player="1", actions=["l", "r"])
+    g.append_move(g.root.children[1], player="1", actions=["c", "d"])
+    g.append_infoset(g.root.children[2], g.root.children[1].infoset)
+    g.append_move(g.root.children[0].children[1], player="2", actions=["p", "q"])
+    g.append_move(
+        g.root.children[0].children[1].children[0], player="1", actions=["L", "R"]
+    )
+    g.append_infoset(
+        g.root.children[0].children[1].children[1],
+        g.root.children[0].children[1].children[0].infoset,
+    )
+    g.append_move(g.root.children[2].children[0], player="2", actions=["s", "t"])
+    g.append_infoset(
+        g.root.children[2].children[1], g.root.children[2].children[0].infoset
+    )
+
+    g.set_outcome(
+        g.root.children[0].children[0],
+        outcome=g.add_outcome(payoffs=[5, -5], label="l"),
+    )
+    g.set_outcome(
+        g.root.children[0].children[1].children[0].children[0],
+        outcome=g.add_outcome(payoffs=[10, -10], label="rpL"),
+    )
+    g.set_outcome(
+        g.root.children[0].children[1].children[0].children[1],
+        outcome=g.add_outcome(payoffs=[15, -15], label="rpR"),
+    )
+    g.set_outcome(
+        g.root.children[0].children[1].children[1].children[0],
+        outcome=g.add_outcome(payoffs=[20, -20], label="rqL"),
+    )
+    g.set_outcome(
+        g.root.children[0].children[1].children[1].children[1],
+        outcome=g.add_outcome(payoffs=[-5, 5], label="rqR"),
+    )
+    g.set_outcome(
+        g.root.children[1].children[0],
+        outcome=g.add_outcome(payoffs=[10, -10], label="c"),
+    )
+    g.set_outcome(
+        g.root.children[1].children[1],
+        outcome=g.add_outcome(payoffs=[20, -20], label="d"),
+    )
+    g.set_outcome(
+        g.root.children[2].children[0].children[0],
+        outcome=g.add_outcome(payoffs=[20, -20], label="cs"),
+    )
+    g.set_outcome(
+        g.root.children[2].children[0].children[1],
+        outcome=g.add_outcome(payoffs=[50, -50], label="ct"),
+    )
+    g.set_outcome(
+        g.root.children[2].children[1].children[0],
+        outcome=g.add_outcome(payoffs=[30, -30], label="ds"),
+    )
+    g.set_outcome(
+        g.root.children[2].children[1].children[1],
+        outcome=g.add_outcome(payoffs=[15, -15], label="dt"),
+    )
+    g.set_outcome(
+        g.root.children[3], outcome=g.add_outcome(payoffs=[5, -5], label="nothing")
+    )
+    g.root.children[0].infoset.label = "0"
+    g.root.children[1].infoset.label = "1"
+    g.root.children[0].children[1].infoset.label = "01"
+    g.root.children[2].children[0].infoset.label = "20"
+    g.root.children[0].children[1].children[0].infoset.label = "010"
+
+    return g
+
+
+def create_two_player_perfect_info_win_lose_efg() -> gbt.Game:
+    g = gbt.Game.new_tree(players=["1", "2"], title="2 player perfect info win lose")
+    g.append_move(g.root, "2", ["a", "b"])
+    g.append_move(g.root.children[0], "1", ["L", "R"])
+    g.append_move(g.root.children[1], "1", ["L", "R"])
+    g.append_move(g.root.children[0].children[0], "2", ["l", "r"])
+    g.set_outcome(
+        g.root.children[0].children[0].children[0], g.add_outcome([1, -1], label="aLl")
+    )
+    g.set_outcome(
+        g.root.children[0].children[0].children[1], g.add_outcome([-1, 1], label="aLr")
+    )
+    g.set_outcome(g.root.children[0].children[1], g.add_outcome([1, -1], label="aR"))
+    g.set_outcome(g.root.children[1].children[0], g.add_outcome([1, -1], label="bL"))
+    g.set_outcome(g.root.children[1].children[1], g.add_outcome([-1, 1], label="bR"))
+    return g
+
+
+def create_EFG_for_nxn_bimatrix_coordination_game(n: int) -> gbt.Game:
+    A = np.eye(n, dtype=int)
+    B = A
+    title = f"{n}x{n} coordination game, {2**n - 1} equilibria"
+    return create_efg_corresponding_to_bimatrix_game(A, B, title)
+
+
+def create_EFG_for_6x6_bimatrix_with_long_LH_paths_and_unique_eq() -> gbt.Game:
+    # 6 x 6 Payoff matrix A:
+    A = [
+        [-180, 72, -333, 297, -153, 270],
+        [-30, 17, -33, 42, -3, 20],
+        [-81, 36, -126, 126, -36, 90],
+        [90, -36, 126, -126, 36, -81],
+        [20, -3, 42, -33, 17, -30],
+        [270, -153, 297, -333, 72, -180],
+    ]
+    # 6 x 6 Payoff matrix B:
+    B = [
+        [72, 36, 17, -3, -36, -153],
+        [-180, -81, -30, 20, 90, 270],
+        [297, 126, 42, -33, -126, -333],
+        [-333, -126, -33, 42, 126, 297],
+        [270, 90, 20, -30, -81, -180],
+        [-153, -36, -3, 17, 36, 72],
+    ]
+    A = np.array(A)
+    B = np.array(B)
+    title = "6x6 Long Lemke-Howson Paths, unique eq"
+    return create_efg_corresponding_to_bimatrix_game(A, B, title)
+
+
 class EfgFamilyForReducedStrategicFormTests(ABC):
     """ """
 

tests/test_behav.py

@@ -229,7 +229,7 @@ def test_profile_indexing_by_infoset_and_action_labels_reference(game: gbt.Game,
                                                                  action_label: str,
                                                                  prob: typing.Union[str, float],
                                                                  rational_flag: bool):
-    """Here we use the infoset label and action label, with some exampels where the action label
+    """Here we use the infoset label and action label, with some examples where the action label
     alone throws a ValueError (checked in a separate test)
     """
     profile = game.mixed_behavior_profile(rational=rational_flag)
@@ -259,7 +259,7 @@ def test_profile_indexing_by_player_infoset_action_labels_reference(game: gbt.Ga
                                                                     action_label: str,
                                                                     prob: typing.Union[str, float],
                                                                     rational_flag: bool):
-    """Here we use the infoset label and action label, with some exampels where the action label
+    """Here we use the infoset label and action label, with some examples where the action label
     alone throws a ValueError (checked in a separate test)
     """
     profile = game.mixed_behavior_profile(rational=rational_flag)

tests/test_extensive.py

@@ -377,7 +377,7 @@ def test_outcome_index_exception_label():
     ],
 )
 def test_reduced_strategic_form(
-    game: gbt.Game, strategy_labels: list, np_arrays_of_rsf: list
+    game: gbt.Game, strategy_labels: list, np_arrays_of_rsf: typing.Union[list, None]
 ):
     """
     We test two things: