Implement own prior actions (#653)

Adds functions to return "own prior action" for nodes and "own prior actions" for information sets (where the latter is the set of own prior actions of its member nodes).

Closes #582.

Author: d-kad

ChangeLog

@@ -12,6 +12,9 @@
 
 ### Added
 - Tests for EFG Nash solvers -- `enumpoly_solve`, `lp_solve`, `lcp_solve` -- in behavior stratgegies
+- In `pygambit`, `Node` objects now have a read-only property `own_prior_action` and `Infoset` objects
+  have a read-only property `own_prior_actions` to retrieve the last action or the set of last actions
+  taken by the player before reaching the node or information set, respectively. (#582)
 - In `pygambit`, `Node` objects now have a read-only property `is_strategy_reachable` to determine
   if the node is reachable by at least one pure strategy profile. This proves useful for identifying
   unreachable parts of the game tree in games with absent-mindedness. (#629)

doc/pygambit.api.rst

@@ -149,6 +149,7 @@ Information about the game
    Node.player
    Node.is_successor_of
    Node.plays
+   Node.own_prior_action
 
 .. autosummary::
 
@@ -162,6 +163,7 @@ Information about the game
    Infoset.members
    Infoset.precedes
    Infoset.plays
+   Infoset.own_prior_actions
 
 .. autosummary::
 

src/games/game.h

@@ -247,6 +247,8 @@ class GameInfosetRep : public std::enable_shared_from_this<GameInfosetRep> {
 
   bool Precedes(GameNode) const;
 
+  std::set<GameAction> GetOwnPriorActions() const;
+
   const Number &GetActionProb(const GameAction &p_action) const
   {
     if (p_action->GetInfoset().get() != this) {
@@ -492,6 +494,7 @@ class GameNodeRep : public std::enable_shared_from_this<GameNodeRep> {
   bool IsTerminal() const { return m_children.empty(); }
   GamePlayer GetPlayer() const { return (m_infoset) ? m_infoset->GetPlayer() : nullptr; }
   GameAction GetPriorAction() const; // returns null if root node
+  GameAction GetOwnPriorAction() const;
   GameNode GetParent() const { return (m_parent) ? m_parent->shared_from_this() : nullptr; }
   GameNode GetNextSibling() const;
   GameNode GetPriorSibling() const;
@@ -899,6 +902,11 @@ class GameRep : public std::enable_shared_from_this<GameRep> {
   virtual std::vector<GameInfoset> GetInfosets() const { throw UndefinedException(); }
   /// Sort the information sets for each player in a canonical order
   virtual void SortInfosets() {}
+  /// Returns the set of actions taken by the infoset's owner before reaching this infoset
+  virtual std::set<GameAction> GetOwnPriorActions(const GameInfoset &p_infoset) const
+  {
+    throw UndefinedException();
+  }
   //@}
 
   /// @name Outcomes
@@ -926,6 +934,11 @@ class GameRep : public std::enable_shared_from_this<GameRep> {
   virtual size_t NumNodes() const = 0;
   /// Returns the number of non-terminal nodes in the game
   virtual size_t NumNonterminalNodes() const = 0;
+  /// Returns the last action taken by the node's owner before reaching this node
+  virtual GameAction GetOwnPriorAction(const GameNode &p_node) const
+  {
+    throw UndefinedException();
+  }
   //@}
 
   /// @name Modification

src/games/gametree.cc

@@ -324,6 +324,16 @@ GameAction GameNodeRep::GetPriorAction() const
   return nullptr;
 }
 
+GameAction GameNodeRep::GetOwnPriorAction() const
+{
+  return m_game->GetOwnPriorAction(std::const_pointer_cast<GameNodeRep>(shared_from_this()));
+}
+
+std::set<GameAction> GameInfosetRep::GetOwnPriorActions() const
+{
+  return m_game->GetOwnPriorActions(std::const_pointer_cast<GameInfosetRep>(shared_from_this()));
+}
+
 void GameNodeRep::DeleteOutcome(GameOutcomeRep *outc)
 {
   m_game->IncrementVersion();
@@ -394,7 +404,7 @@ bool GameNodeRep::IsStrategyReachable() const
   auto tree_game = static_cast<GameTreeRep *>(m_game);
 
   if (!tree_game->m_unreachableNodes) {
-    tree_game->BuildInfosetParents();
+    tree_game->BuildUnreachableNodes();
   }
 
   // A node is reachable if it is NOT in the set of unreachable nodes.
@@ -786,15 +796,16 @@ Rational GameTreeRep::GetPlayerMaxPayoff(const GamePlayer &p_player) const
 
 bool GameTreeRep::IsPerfectRecall() const
 {
-  if (m_infosetParents.empty() && !m_root->IsTerminal()) {
-    const_cast<GameTreeRep *>(this)->BuildInfosetParents();
+  if (!m_ownPriorActionInfo && !m_root->IsTerminal()) {
+    BuildOwnPriorActions();
   }
 
   if (GetRoot()->IsTerminal()) {
     return true;
   }
 
-  return std::all_of(m_infosetParents.cbegin(), m_infosetParents.cend(),
+  return std::all_of(m_ownPriorActionInfo->infoset_map.cbegin(),
+                     m_ownPriorActionInfo->infoset_map.cend(),
                      [](const auto &pair) { return pair.second.size() <= 1; });
 }
 
@@ -847,7 +858,7 @@ void GameTreeRep::ClearComputedValues() const
     player->m_strategies.clear();
   }
   const_cast<GameTreeRep *>(this)->m_nodePlays.clear();
-  const_cast<GameTreeRep *>(this)->m_infosetParents.clear();
+  m_ownPriorActionInfo = nullptr;
   const_cast<GameTreeRep *>(this)->m_unreachableNodes = nullptr;
   m_computedValues = false;
 }
@@ -889,34 +900,119 @@ std::vector<GameNodeRep *> GameTreeRep::BuildConsistentPlaysRecursiveImpl(GameNo
   return consistent_plays;
 }
 
-void GameTreeRep::BuildInfosetParents()
+void GameTreeRep::BuildOwnPriorActions() const
 {
-  m_infosetParents.clear();
-  m_unreachableNodes = std::make_unique<std::set<GameNodeRep *>>();
+  auto info = std::make_shared<OwnPriorActionInfo>();
 
   if (m_root->IsTerminal()) {
-    m_infosetParents[m_root->m_infoset].insert(nullptr);
+    m_ownPriorActionInfo = info;
     return;
   }
 
-  using AbsentMindedEdge = std::pair<GameAction, GameNode>;
-  using ActiveEdge = std::variant<GameNodeRep::Actions::iterator, AbsentMindedEdge>;
-  std::stack<ActiveEdge> position;
+  info->node_map[m_root.get()] = nullptr;
+  if (m_root->m_infoset) {
+    info->infoset_map[m_root->m_infoset].insert(nullptr);
+  }
 
+  using ActiveEdge = GameNodeRep::Actions::iterator;
+
+  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[GamePlayer(m_chance)].emplace(nullptr);
 
   position.emplace(m_root->GetActions().begin());
-  prior_actions[m_root->m_infoset->m_player->shared_from_this()].emplace(nullptr);
   if (m_root->m_infoset) {
-    m_infosetParents[m_root->m_infoset].insert(nullptr);
+    prior_actions[m_root->m_infoset->m_player->shared_from_this()].emplace(nullptr);
+  }
+
+  while (!position.empty()) {
+    ActiveEdge &current_edge = position.top();
+    auto node = current_edge.GetOwner();
+
+    if (current_edge == node->GetActions().end()) {
+      if (node->m_infoset) {
+        prior_actions.at(node->m_infoset->m_player->shared_from_this()).pop();
+      }
+      position.pop();
+      continue;
+    }
+
+    auto [action, child] = *current_edge;
+    ++current_edge;
+
+    if (node->m_infoset) {
+      prior_actions.at(node->m_infoset->m_player->shared_from_this()).top() = action;
+    }
+
+    if (!child->IsTerminal()) {
+      if (child->m_infoset) {
+        auto child_player = child->m_infoset->m_player->shared_from_this();
+        auto prior_action = prior_actions.at(child_player).top();
+        GameActionRep *raw_prior = prior_action ? prior_action.get() : nullptr;
+
+        info->node_map[child.get()] = raw_prior;
+        info->infoset_map[child->m_infoset].insert(raw_prior);
+
+        position.emplace(child->GetActions().begin());
+        prior_actions.at(child_player).emplace(nullptr);
+      }
+      else {
+        position.emplace(child->GetActions().begin());
+      }
+    }
+  }
+  m_ownPriorActionInfo = info;
+}
+
+GameAction GameTreeRep::GetOwnPriorAction(const GameNode &p_node) const
+{
+  if (!m_ownPriorActionInfo) {
+    BuildOwnPriorActions();
+  }
+
+  auto it = m_ownPriorActionInfo->node_map.find(p_node.get());
+  if (it != m_ownPriorActionInfo->node_map.end() && it->second) {
+    return it->second->shared_from_this();
+  }
+  return nullptr;
+}
+
+std::set<GameAction> GameTreeRep::GetOwnPriorActions(const GameInfoset &p_infoset) const
+{
+  if (!m_ownPriorActionInfo) {
+    BuildOwnPriorActions();
+  }
+
+  std::set<GameAction> result;
+  auto it = m_ownPriorActionInfo->infoset_map.find(p_infoset.get());
+
+  if (it != m_ownPriorActionInfo->infoset_map.end()) {
+    for (auto *ptr : it->second) {
+      result.insert(ptr ? ptr->shared_from_this() : nullptr);
+    }
+  }
+  return result;
+}
+
+void GameTreeRep::BuildUnreachableNodes()
+{
+  m_unreachableNodes = std::make_unique<std::set<GameNodeRep *>>();
+
+  if (m_root->IsTerminal()) {
+    return;
   }
 
+  using AbsentMindedEdge = std::pair<GameAction, GameNode>;
+  using ActiveEdge = std::variant<GameNodeRep::Actions::iterator, AbsentMindedEdge>;
+
+  std::stack<ActiveEdge> position;
+  std::map<GameInfoset, GameAction> path_choices;
+  position.emplace(m_root->GetActions().begin());
+
   while (!position.empty()) {
     ActiveEdge &current_edge = position.top();
     GameNode child, node;
@@ -927,7 +1023,6 @@ void GameTreeRep::BuildInfosetParents()
       node = current_it.GetOwner();
 
       if (current_it == node->GetActions().end()) {
-        prior_actions.at(node->m_infoset->m_player->shared_from_this()).pop();
         position.pop();
         path_choices.erase(node->m_infoset->shared_from_this());
         continue;
@@ -944,40 +1039,31 @@ void GameTreeRep::BuildInfosetParents()
       child = node->GetChild(action);
     }
 
-    prior_actions.at(node->m_infoset->m_player->shared_from_this()).top() = action;
     if (!child->IsTerminal()) {
-      auto child_player = child->m_infoset->m_player->shared_from_this();
-      auto prior_action = prior_actions.at(child_player).top();
-      m_infosetParents[child->m_infoset].insert(prior_action ? prior_action.get() : nullptr);
-
+      // Check for Absent-Minded Re-entry of the infoset
       if (path_choices.find(child->m_infoset->shared_from_this()) != path_choices.end()) {
         const GameAction replay_action = path_choices.at(child->m_infoset->shared_from_this());
         position.emplace(AbsentMindedEdge{replay_action, child});
 
-        // Start of the traversal of unreachable subtrees
+        // Mark siblings and the nodes in their subtrees as unreachable
         for (const auto &[current_action, subtree_root] : child->GetActions()) {
           if (current_action != replay_action) {
-
             std::stack<GameNodeRep *> nodes_to_visit;
             nodes_to_visit.push(subtree_root.get());
-
             while (!nodes_to_visit.empty()) {
               GameNodeRep *current_unreachable_node = nodes_to_visit.top();
               nodes_to_visit.pop();
               m_unreachableNodes->insert(current_unreachable_node);
-
               for (const auto &unreachable_child : current_unreachable_node->GetChildren()) {
                 nodes_to_visit.push(unreachable_child.get());
               }
             }
           }
         }
-        // End of the traversal of unreachable subtrees
       }
       else {
         position.emplace(child->GetActions().begin());
       }
-      prior_actions.at(child_player).emplace(nullptr);
     }
   }
 }

src/games/gametree.h

@@ -32,14 +32,20 @@ class GameTreeRep : public GameExplicitRep {
   friend class GameInfosetRep;
   friend class GameActionRep;
 
+private:
+  struct OwnPriorActionInfo {
+    std::map<GameNodeRep *, GameActionRep *> node_map;
+    std::map<GameInfosetRep *, std::set<GameActionRep *>> infoset_map;
+  };
+
 protected:
   mutable bool m_computedValues{false};
   std::shared_ptr<GameNodeRep> m_root;
   std::shared_ptr<GamePlayerRep> m_chance;
   std::size_t m_numNodes = 1;
   std::size_t m_numNonterminalNodes = 0;
   std::map<GameNodeRep *, std::vector<GameNodeRep *>> m_nodePlays;
-  std::map<GameInfosetRep *, std::set<GameActionRep *>> m_infosetParents;
+  mutable std::shared_ptr<OwnPriorActionInfo> m_ownPriorActionInfo;
   mutable std::unique_ptr<std::set<GameNodeRep *>> m_unreachableNodes;
 
   /// @name Private auxiliary functions
@@ -98,6 +104,8 @@ class GameTreeRep : public GameExplicitRep {
   size_t NumNodes() const override { return m_numNodes; }
   /// Returns the number of non-terminal nodes in the game
   size_t NumNonterminalNodes() const override { return m_numNonterminalNodes; }
+  /// Returns the last action taken by the node's owner before reaching this node
+  GameAction GetOwnPriorAction(const GameNode &p_node) const override;
   //@}
 
   void DeleteOutcome(const GameOutcome &) override;
@@ -122,6 +130,8 @@ class GameTreeRep : public GameExplicitRep {
   std::vector<GameInfoset> GetInfosets() const override;
   /// Sort the information sets for each player in a canonical order
   void SortInfosets() override;
+  /// Returns the set of actions taken by the infoset's owner before reaching this infoset
+  std::set<GameAction> GetOwnPriorActions(const GameInfoset &p_infoset) const override;
   //@}
 
   /// @name Modification
@@ -160,7 +170,8 @@ class GameTreeRep : public GameExplicitRep {
 
 private:
   std::vector<GameNodeRep *> BuildConsistentPlaysRecursiveImpl(GameNodeRep *node);
-  void BuildInfosetParents();
+  void BuildOwnPriorActions() const;
+  void BuildUnreachableNodes();
 };
 
 template <class T> class TreeMixedStrategyProfileRep : public MixedStrategyProfileRep<T> {

src/pygambit/gambit.pxd

@@ -3,6 +3,7 @@ from libcpp.string cimport string
 from libcpp.memory cimport shared_ptr, unique_ptr
 from libcpp.list cimport list as stdlist
 from libcpp.vector cimport vector as stdvector
+from libcpp.set cimport set as stdset
 
 
 cdef extern from "gambit.h":
@@ -145,6 +146,7 @@ cdef extern from "games/game.h":
 
         bint IsChanceInfoset() except +
         bint Precedes(c_GameNode) except +
+        stdset[c_GameAction] GetOwnPriorActions() except +
 
     cdef cppclass c_GamePlayerRep "GamePlayerRep":
         cppclass Infosets:
@@ -220,6 +222,7 @@ cdef extern from "games/game.h":
         bint IsSubgameRoot() except +
         bint IsStrategyReachable() except +
         c_GameAction GetPriorAction() except +
+        c_GameAction GetOwnPriorAction() except +
 
     cdef cppclass c_GameRep "GameRep":
         cppclass Players: