Extended test suite for the PR-checker

Author: d-kad

src/games/gametree.cc

@@ -25,6 +25,7 @@
 #include <numeric>
 #include <stack>
 #include <set>
+#include <variant>
 
 #include "gambit.h"
 #include "gametree.h"
@@ -736,48 +737,9 @@ bool GameTreeRep::IsConstSum() const
 
 bool GameTreeRep::IsPerfectRecall() const
 {
-  if (m_infosetParents.empty() && !GetRoot()->IsTerminal()) {
-    const_cast<GameTreeRep *>(this)->BuildInfosetParents();
-  }
-
-  // ====================================================================
-
-  std::cerr << "\n--- m_infosetParents ---\n";
-
   if (m_infosetParents.empty() && !m_root->IsTerminal()) {
-    std::cerr << "  (Cache is empty or game is trivial)\n";
-  }
-
-  // Iterate through the map to print its contents.
-  // Assumes m_infosetParents uses raw pointers as keys/values now.
-  for (const auto &[infoset_ptr, parent_actions_set] : m_infosetParents) {
-    // Print the information set identifier.
-    std::cerr << "  - Infoset " << infoset_ptr->GetPlayer()->GetNumber() << "."
-              << infoset_ptr->GetNumber() << " (Player '" << infoset_ptr->GetPlayer()->GetLabel()
-              << "'):\n";
-
-    if (parent_actions_set.empty()) {
-      std::cerr << "    - (No parent actions recorded)\n";
-    }
-
-    // Print each recorded parent action for this infoset.
-    for (const auto &action_ptr : parent_actions_set) {
-      if (action_ptr) {
-        // If the action is not null, print its label and the infoset it belongs to.
-        std::cerr << "    - Reached via Action '" << action_ptr->GetLabel() << "' (from Infoset "
-                  << action_ptr->GetInfoset()->GetPlayer()->GetNumber() << "."
-                  << action_ptr->GetInfoset()->GetNumber() << ")\n";
-      }
-      else {
-        // This case is for the root or for players who haven't acted yet on a path.
-        std::cerr << "    - Reached via null action\n";
-      }
-    }
+    const_cast<GameTreeRep *>(this)->BuildInfosetParents();
   }
-  std::cerr << "---------------------------\n";
-  // ====================================================================
-  //                 DEBUGGING PRINTS END HERE
-  // ====================================================================
 
   if (GetRoot()->IsTerminal()) {
     return true;
@@ -901,76 +863,71 @@ std::vector<GameNodeRep *> GameTreeRep::BuildConsistentPlaysRecursiveImpl(GameNo
 
 void GameTreeRep::BuildInfosetParents()
 {
-  // The main traversal stack. It holds iterators that explore the children nodes.
-  // It does not contain entries for the nodes that are skipped over
-  // or where the previously taken decision is taken again due to absent-mindedness.
-  std::stack<GameNodeRep::Actions::iterator> position;
-  // tracks actions taken by each player on the current path
-  std::map<GamePlayer, std::stack<GameAction>> prior_actions;
-  // stores the first action choice made for an infoset on a given exploration path
-  std::map<GameInfoset, std::pair<GameNode, GameAction>> initial_choice;
-
   if (m_root->IsTerminal()) {
-    m_infosetParents[m_root->GetInfoset()].insert(nullptr);
+    m_infosetParents[m_root->m_infoset].insert(nullptr);
     return;
   }
 
-  for (auto player : m_players) {
-    prior_actions[player].emplace(nullptr);
+  using AbsentMindedEdge = std::pair<GameAction, GameNode>;
+  using ActiveEdge = std::variant<GameNodeRep::Actions::iterator, AbsentMindedEdge>;
+  std::stack<ActiveEdge> position;
+
+  std::map<GamePlayer, std::stack<GameAction>> prior_actions;
+  std::map<GameInfoset, GameAction> path_choices;
+
+  for (auto player_rep : m_players) {
+    prior_actions[GamePlayer(player_rep)].emplace(nullptr);
   }
-  prior_actions[m_chance].emplace(nullptr);
+  prior_actions[GamePlayer(m_chance)].emplace(nullptr);
 
   position.emplace(m_root->GetActions().begin());
-  prior_actions[m_root->GetPlayer()].emplace(nullptr);
-  m_infosetParents[m_root->GetInfoset()].insert(nullptr);
+  prior_actions[m_root->m_infoset->m_player].emplace(nullptr);
+  if (m_root->m_infoset) {
+    m_infosetParents[m_root->m_infoset].insert(nullptr);
+  }
 
   while (!position.empty()) {
-    auto &current_it = position.top();
-    auto parent = current_it.GetOwner();
-
-    if (current_it != parent->GetActions().end()) {
-      auto [action, child] = *current_it;
-
-      prior_actions[parent->GetPlayer()].top() = action;
-      initial_choice[parent->GetInfoset()] = {parent, action};
-
-      // records every emplace made onto the prior_actions stack during a fast-forward.
-      std::vector<GamePlayer> fast_forward_history;
-
-      // fast forward absent-minded child nodes
-      auto initial_choice_it = initial_choice.find(child->GetInfoset());
-      while (initial_choice_it != initial_choice.end()) {
-        auto initial_action = initial_choice_it->second.second;
-        auto prior_action_ff = prior_actions[child->GetPlayer()].top();
-        m_infosetParents[child->GetInfoset()].insert(prior_action_ff);
+    ActiveEdge &current_edge = position.top();
+    GameNode child, node;
+    GameAction action;
+
+    if (std::holds_alternative<GameNodeRep::Actions::iterator>(current_edge)) {
+      auto &current_it = std::get<GameNodeRep::Actions::iterator>(current_edge);
+      node = current_it.GetOwner();
+
+      if (current_it == node->GetActions().end()) {
+        prior_actions.at(node->m_infoset->m_player).pop();
+        position.pop();
+        path_choices.erase(node->m_infoset);
+        continue;
+      }
+      else {
+        std::tie(action, child) = *current_it;
+        ++current_it;
+        path_choices[node->m_infoset] = action;
+      }
+    }
+    else {
+      std::tie(action, node) = std::get<AbsentMindedEdge>(current_edge);
+      position.pop();
+      child = node->GetChild(action);
+    }
 
-        auto newchild = child->GetChild(initial_action);
+    prior_actions.at(node->m_infoset->m_player).top() = action;
 
-        prior_actions[child->GetPlayer()].emplace(initial_action);
-        fast_forward_history.emplace_back(child->GetPlayer());
+    if (!child->IsTerminal()) {
+      auto child_player = child->m_infoset->m_player;
+      auto prior_action = prior_actions.at(child_player).top();
+      m_infosetParents[child->m_infoset].insert(prior_action);
 
-        child = newchild;
-        initial_choice_it = initial_choice.find(newchild->GetInfoset());
+      if (path_choices.find(child->m_infoset) != path_choices.end()) {
+        const GameAction replay_action = path_choices.at(child->m_infoset);
+        position.emplace(AbsentMindedEdge{replay_action, child});
       }
-
-      if (!child->IsTerminal()) {
-        auto child_player = child->GetPlayer();
-        auto prior_action_desc = prior_actions[child_player].top();
-        m_infosetParents[child->GetInfoset()].insert(prior_action_desc);
+      else {
         position.emplace(child->GetActions().begin());
-        prior_actions[child_player].emplace(nullptr);
-      }
-
-      ++current_it;
-
-      for (auto it = fast_forward_history.rbegin(); it != fast_forward_history.rend(); ++it) {
-        prior_actions.at(*it).pop();
       }
-    }
-    else {
-      prior_actions.at(parent->GetPlayer()).pop();
-      position.pop();
-      initial_choice.erase(parent->GetInfoset());
+      prior_actions.at(child_player).emplace(nullptr);
     }
   }
 }

tests/test_extensive.py

@@ -49,27 +49,55 @@ def test_game_add_players_nolabel():
     game.add_player()
 
 
-@pytest.mark.parametrize("game_filename,expected_result", [
-    # Games that have perfect recall
+@pytest.mark.parametrize("game_input,expected_result", [
+    # Games with perfect recall from files (game_input is a string)
     ("e01.efg", True),
     ("e02.efg", True),
     ("cent3.efg", True),
     ("poker.efg", True),
     ("basic_extensive_game.efg", True),
 
-    # Games that do not have perfect recall
-    ("wichardt.efg", False),  # forgetting past action
+    # Games with perfect recall from generated games (game_input is a gbt.Game object)
+    # - Centipede games
+    (games.Centipede.get_test_data(N=3, m0=2, m1=7)[0], True),
+    (games.Centipede.get_test_data(N=4, m0=2, m1=7)[0], True),
+    # - Two-player binary tree games
+    (games.BinEfgTwoPlayer.get_test_data(level=3)[0], True),
+    (games.BinEfgTwoPlayer.get_test_data(level=4)[0], True),
+    # - Three-player binary tree games
+    (games.BinEfgThreePlayer.get_test_data(level=3)[0], True),
+
+    # Games with imperfect recall from files (game_input is a string)
+    # - imperfect recall without absent-mindedness
+    ("wichardt.efg", False),  # forgetting past action; Wichardt (GEB, 2008)
     ("noPR-action-selten-horse.efg", False),  # forgetting past action
     ("noPR-information-no-deflate.efg", False),  # forgetting past information
-    ("noPR-AM.efg", False),  # absent-mindedness
-    ("noPR-action-AM.efg", False),  # absent-mindedness + forgetting past action
+    ("gilboa_two_am_agents.efg", False),  # forgetting past information; Gilboa (GEB, 1997)
+    # - imperfect recall with absent-mindedness
+    ("noPR-AM-driver-one-player.efg", False),  # 1 players, one infoset unreached
+    ("noPR-AM-driver-two-players.efg", False),  # 2 players, one infoset unreached
+    ("noPR-action-AM.efg", False),  # 2 players + forgetting past action; P1 has one infoset
+    ("noPR-action-AM2.efg", False),  # 2 players + forgetting past action; P1 has >1 infoset
+    ("noPR-action-AM-two-hops.efg", False),  # 2 players, one AM-infoset each
+
+    # Games with imperfect recall from generated games (game_input is a gbt.Game object)
+    # - One-player binary tree games
+    (games.BinEfgOnePlayerIR.get_test_data(level=3)[0], False),
+    (games.BinEfgOnePlayerIR.get_test_data(level=4)[0], False),
 ])
-def test_is_perfect_recall(game_filename: str, expected_result: bool):
+def test_is_perfect_recall(game_input, expected_result: bool):
     """
     Verify the IsPerfectRecall implementation against a suite of games
-    with and without the perfect recall property.
+    with and without the perfect recall, from both files and generation.
     """
-    game = games.read_from_file(game_filename)
+    game = None
+    if isinstance(game_input, str):
+        game = games.read_from_file(game_input)
+    elif isinstance(game_input, gbt.Game):
+        game = game_input
+    else:
+        pytest.fail(f"Unknown type for game_input: {type(game_input)}")
+
     assert game.is_perfect_recall == expected_result
 
 

tests/test_games/gilboa_two_am_agents.efg

@@ -0,0 +1,14 @@
+EFG 2 R "Untitled Extensive Game" { "Player 1" "Player 2" }
+""
+
+c "" 1 "" { "1" 1/2 "2" 1/2 } 0
+p "" 1 1 "" { "1" "2" } 0
+t "" 1 "Outcome 1" { 1, -1 }
+p "" 1 2 "" { "1" "2" } 0
+t "" 2 "Outcome 2" { 2, -2 }
+t "" 3 "Outcome 3" { 3, -3 }
+p "" 1 2 "" { "1" "2" } 0
+p "" 1 1 "" { "1" "2" } 0
+t "" 4 "Outcome 4" { 4, -4 }
+t "" 5 "Outcome 5" { 5, -5 }
+t "" 6 "Outcome 6" { 6, -6 }

tests/test_games/noPR-AM-driver-one-player.efg

@@ -0,0 +1,12 @@
+EFG 2 R "Untitled Extensive Game" { "Player 1" "Player 2" }
+""
+
+p "" 1 1 "" { "1" "2" } 0
+p "" 1 2 "" { "1" "2" } 0
+p "" 1 1 "" { "1" "2" } 0
+t "" 1 "Outcome 1" { 1, -1 }
+p "" 1 3 "" { "1" "2" } 0
+t "" 2 "Outcome 2" { 2, -2 }
+t "" 5 "Outcome 5" { 5, -5 }
+t "" 3 "Outcome 3" { 3, -3 }
+t "" 4 "Outcome 4" { 4, -4 }

tests/test_games/noPR-AM.efg …est_games/noPR-AM-driver-two-players.efgtests/test_games/noPR-AM.efg renamed to tests/test_games/noPR-AM-driver-two-players.efg tests/test_games/noPR-AM.efg renamed to tests/test_games/noPR-AM-driver-two-players.efg

@@ -0,0 +1,19 @@
+EFG 2 R "Untitled Extensive Game" { "Player 1" "Player 2" }
+""
+
+p "" 1 1 "" { "1" "2" } 0
+p "" 2 1 "" { "1" "2" } 0
+p "" 1 1 "" { "1" "2" } 0
+p "" 2 1 "" { "1" "2" } 0
+p "" 1 2 "" { "1" "2" } 0
+t "" 1 "Outcome 1" { 1, 1 }
+p "" 1 1 "" { "1" "2" } 0
+t "" 10 "Outcome 10" { 10, -10 }
+t "" 11 "Outcome 11" { 11, -11 }
+t "" 12 "Outcome 12" { 12, -12 }
+p "" 2 2 "" { "1" "2" "3" } 0
+t "" 5 "Outcome 2" { 0, 2 }
+t "" 6 "Outcome 5" { 0, 5 }
+t "" 7 "Outcome 6" { 0, 6 }
+t "" 8 "Outcome 3" { 0, 3 }
+t "" 9 "Outcome 4" { 2, 0 }

tests/test_games/noPR-action-AM-two-hops.efg

@@ -0,0 +1,18 @@
+EFG 2 R "Untitled Extensive Game" { "Player 1" "Player 2" }
+""
+
+p "" 1 1 "" { "1" "2" } 0
+p "" 1 1 "" { "1" "2" } 0
+p "" 1 2 "" { "1" "2" } 0
+t "" 1 "Outcome 1" { 1, -1 }
+t "" 2 "Outcome 2" { 2, -2 }
+p "" 2 1 "" { "1" "2" } 0
+t "" 3 "Outcome 2" { 3, -3 }
+t "" 4 "Outcome 2" { 4, -4 }
+p "" 1 1 "" { "1" "2" } 0
+p "" 1 3 "" { "1" "2" } 0
+t "" 5 "Outcome 2" { 5, -5 }
+t "" 6 "Outcome 2" { 6, -6 }
+p "" 2 2 "" { "1" "2" } 0
+t "" 7 "Outcome 2" { 7, -7 }
+t "" 8 "Outcome 2" { 8, -8 }