Refactor implementation of GameTreeRep::IsPerfectRecall, extend tests

Added #include <optional>

Author: d-kad

src/games/game.h

@@ -561,15 +561,8 @@ class GameRep : public BaseGameRep {
   /// Returns the set of terminal nodes which are descendants of members of an action
   virtual std::vector<GameNode> GetPlays(GameAction action) const { throw UndefinedException(); }
 
-  /// Returns true if the game is perfect recall.  If not,
-  /// a pair of violating information sets is returned in the parameters.
-  virtual bool IsPerfectRecall(GameInfoset &, GameInfoset &) const = 0;
   /// Returns true if the game is perfect recall
-  bool IsPerfectRecall() const
-  {
-    GameInfoset s, t;
-    return IsPerfectRecall(s, t);
-  }
+  virtual bool IsPerfectRecall() const = 0;
   //@}
 
   /// @name Writing data files

src/games/gameagg.h

@@ -84,7 +84,7 @@ class GameAGGRep : public GameRep {
   //@{
   bool IsTree() const override { return false; }
   bool IsAgg() const override { return true; }
-  bool IsPerfectRecall(GameInfoset &, GameInfoset &) const override { return true; }
+  bool IsPerfectRecall() const override { return true; }
   bool IsConstSum() const override;
   /// Returns the smallest payoff to any player in any outcome of the game
   Rational GetMinPayoff() const override { return Rational(aggPtr->getMinPayoff()); }

src/games/gamebagg.h

@@ -91,7 +91,7 @@ class GameBAGGRep : public GameRep {
   //@{
   bool IsTree() const override { return false; }
   virtual bool IsBagg() const { return true; }
-  bool IsPerfectRecall(GameInfoset &, GameInfoset &) const override { return true; }
+  bool IsPerfectRecall() const override { return true; }
   bool IsConstSum() const override { throw UndefinedException(); }
   /// Returns the smallest payoff to any player in any outcome of the game
   Rational GetMinPayoff() const override { return Rational(baggPtr->getMinPayoff()); }

src/games/gametable.h

@@ -57,7 +57,7 @@ class GameTableRep : public GameExplicitRep {
   //@{
   bool IsTree() const override { return false; }
   bool IsConstSum() const override;
-  bool IsPerfectRecall(GameInfoset &, GameInfoset &) const override { return true; }
+  bool IsPerfectRecall() const override { return true; }
   //@}
 
   /// @name Dimensions of the game

src/games/gametree.cc

@@ -732,50 +732,63 @@ bool GameTreeRep::IsConstSum() const
   }
 }
 
-bool GameTreeRep::IsPerfectRecall(GameInfoset &s1, GameInfoset &s2) const
+bool GameTreeRep::IsPerfectRecall() const
 {
-  for (auto player : m_players) {
-    for (size_t i = 1; i <= player->m_infosets.size(); i++) {
-      auto *iset1 = player->m_infosets[i - 1];
-      for (size_t j = 1; j <= player->m_infosets.size(); j++) {
-        auto *iset2 = player->m_infosets[j - 1];
-
-        bool precedes = false;
-        GameAction action = nullptr;
-
-        for (size_t m = 1; m <= iset2->m_members.size(); m++) {
-          size_t n;
-          for (n = 1; n <= iset1->m_members.size(); n++) {
-            if (iset2->GetMember(m)->IsSuccessorOf(iset1->GetMember(n)) &&
-                iset1->GetMember(n) != iset2->GetMember(m)) {
-              precedes = true;
-              for (const auto &act : iset1->GetActions()) {
-                if (iset2->GetMember(m)->IsSuccessorOf(iset1->GetMember(n)->GetChild(act))) {
-                  if (action != nullptr && action != act) {
-                    s1 = iset1;
-                    s2 = iset2;
-                    return false;
-                  }
-                  action = act;
-                }
-              }
-              break;
-            }
-          }
+  using ChildIterator = GameNodeRep::Children::iterator;
+  using ActionIterator = GameInfosetRep::Actions::iterator;
 
-          if (i == j && precedes) {
-            s1 = iset1;
-            s2 = iset2;
-            return false;
-          }
+  std::map<GamePlayer, std::stack<GameAction>> prior_actions;
+  std::map<GameInfoset, std::vector<GameAction>> infoset_parents;
+  std::stack<std::tuple<GameNode, ChildIterator, ActionIterator>> position;
 
-          if (n > iset1->m_members.size() && precedes) {
-            s1 = iset1;
-            s2 = iset2;
-            return false;
-          }
-        }
+  for (auto player : GetPlayers()) {
+    prior_actions[player].emplace(nullptr);
+  }
+  prior_actions[GetChance()].emplace(nullptr);
+  prior_actions[GetRoot()->GetPlayer()].emplace(nullptr);
+
+  if (GetRoot()->IsTerminal()) {
+    return true;
+  }
+
+  position.emplace(GetRoot(), GetRoot()->GetChildren().begin(),
+                   GetRoot()->GetInfoset()->GetActions().begin());
+
+  infoset_parents[GetRoot()->GetInfoset()].emplace_back(nullptr);
+
+  while (!position.empty()) {
+    auto &[parent, child_it, action_it] = position.top();
+
+    if (child_it != parent->GetChildren().end()) {
+      const GameNode child = *child_it;
+      const GameAction action = *action_it;
+
+      prior_actions[parent->GetPlayer()].top() = action;
+
+      if (!child->IsTerminal()) {
+        infoset_parents[child->GetInfoset()].push_back(prior_actions[child->GetPlayer()].top());
+        position.emplace(child, child->GetChildren().begin(),
+                         child->GetInfoset()->GetActions().begin());
+        prior_actions[child->GetPlayer()].emplace(nullptr);
       }
+      ++child_it;
+      ++action_it;
+    }
+
+    else {
+      prior_actions[parent->GetPlayer()].pop();
+      position.pop();
+    }
+  }
+
+  for (const auto &[infoset, parent_action_options] : infoset_parents) {
+    if (parent_action_options.size() == 1) {
+      continue;
+    }
+    const std::set<std::optional<GameAction>> unique_parents(parent_action_options.begin(),
+                                                             parent_action_options.end());
+    if (unique_parents.size() > 1) {
+      return false;
     }
   }
 

src/games/gametree.h

@@ -72,8 +72,7 @@ class GameTreeRep : public GameExplicitRep {
   //@{
   bool IsTree() const override { return true; }
   bool IsConstSum() const override;
-  using GameRep::IsPerfectRecall;
-  bool IsPerfectRecall(GameInfoset &, GameInfoset &) const override;
+  bool IsPerfectRecall() const override;
   /// Turn on or off automatic canonicalization of the game
   void SetCanonicalization(bool p_doCanon) const
   {

tests/test_extensive.py

@@ -49,14 +49,28 @@ def test_game_add_players_nolabel():
     game.add_player()
 
 
-def test_game_is_perfect_recall():
-    game = games.read_from_file("perfect_recall.efg")
-    assert game.is_perfect_recall
+@pytest.mark.parametrize("game_filename,expected_result", [
+    # Games that have perfect recall
+    ("e01.efg", True),
+    ("e02.efg", True),
+    ("cent3.efg", True),
+    ("poker.efg", True),
+    ("basic_extensive_game.efg", True),
 
-
-def test_game_is_not_perfect_recall():
-    game = games.read_from_file("not_perfect_recall.efg")
-    assert not game.is_perfect_recall
+    # Games that do not have perfect recall
+    ("wichardt.efg", False),  # forgetting past action
+    ("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
+])
+def test_is_perfect_recall(game_filename: str, expected_result: bool):
+    """
+    Verify the IsPerfectRecall implementation against a suite of games
+    with and without the perfect recall property.
+    """
+    game = games.read_from_file(game_filename)
+    assert game.is_perfect_recall == expected_result
 
 
 def test_getting_payoff_by_label_string():
@@ -95,7 +109,7 @@ def test_outcome_index_exception_label():
     "game,strategy_labels,np_arrays_of_rsf",
     [
         ###############################################################################
-        # # 1 player; reduction; generic payoffs
+        # 1 player; reduction; generic payoffs
         (
             games.create_reduction_one_player_generic_payoffs_efg(),
             [["11", "12", "2*", "3*", "4*"]],

tests/test_games/noPR-AM.efg

@@ -0,0 +1,13 @@
+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
+t "" 1 "Outcome 1" { 1, 1 }
+p "" 2 2 "" { "1" "2" "3" } 0
+t "" 2 "Outcome 2" { 0, 2 }
+t "" 5 "Outcome 5" { 0, 5 }
+t "" 6 "Outcome 6" { 0, 6 }
+t "" 3 "Outcome 3" { 0, 3 }
+t "" 4 "Outcome 4" { 2, 0 }

tests/test_games/noPR-action-AM.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 "" 2 1 "" { "1" "2" } 0
+t "" 1 "Outcome 1" { 1, -1 }
+t "" 2 "Outcome 2" { 2, -2 }
+p "" 2 2 "" { "1" "2" } 0
+t "" 3 "Outcome 2" { 3, -3 }
+t "" 4 "Outcome 2" { 4, -4 }
+p "" 1 1 "" { "1" "2" } 0
+p "" 2 3 "" { "1" "2" } 0
+t "" 5 "Outcome 2" { 5, -5 }
+t "" 6 "Outcome 2" { 6, -6 }
+p "" 2 4 "" { "1" "2" } 0
+t "" 7 "Outcome 2" { 7, -7 }
+t "" 8 "Outcome 2" { 8, -8 }

tests/test_games/noPR-action-selten-horse.efg

@@ -0,0 +1,12 @@
+EFG 2 R "Selten's Horse': 2 players, imperfect recall" { "Player 1" "Player 2" }
+""
+
+p "" 1 1 "(1,1)" { "R" "L" } 0
+p "" 2 1 "(2,1)" { "R" "L" } 0
+t "" 1 "Outcome 1" { 1, 1 }
+p "" 1 2 "(1,2)" { "R" "L" } 0
+t "" 2 "Outcome 2" { 4, 4 }
+t "" 3 "Outcome 3" { 0, 0 }
+p "" 1 2 "(1,2)" { "R" "L" } 0
+t "" 4 "Outcome 4" { 3, 2 }
+t "" 5 "Outcome 5" { 0, 0 }