Return null/none for action value at unreached information set

Author: tturocy

src/games/behavmixed.cc

@@ -331,10 +331,13 @@ template <class T> T MixedBehaviorProfile<T>::GetActionProb(const GameAction &ac
   return m_probs[m_profileIndex.at(action)];
 }
 
-template <class T> const T &MixedBehaviorProfile<T>::GetPayoff(const GameAction &act) const
+template <class T> std::optional<T> MixedBehaviorProfile<T>::GetPayoff(const GameAction &act) const
 {
   CheckVersion();
   EnsureActionValues();
+  if (GetInfosetProb(act->GetInfoset()) == T{0}) {
+    return std::nullopt;
+  }
   return m_cache.m_actionValues[act];
 }
 

src/games/behavmixed.h

@@ -245,7 +245,7 @@ template <class T> class MixedBehaviorProfile {
   Vector<T> GetPayoff(const GameNode &node) const;
   const T &GetPayoff(const GamePlayer &player, const GameNode &node) const;
   const T &GetPayoff(const GameInfoset &p_infoset) const;
-  const T &GetPayoff(const GameAction &act) const;
+  std::optional<T> GetPayoff(const GameAction &act) const;
   T GetActionProb(const GameAction &act) const;
 
   /// @brief Computes the regret to playing \p p_action

src/gui/analysis.cc

@@ -367,10 +367,10 @@ std::string AnalysisProfileList<T>::GetActionValue(const GameNode &p_node, int p
   }
 
   try {
-    if (m_behavProfiles[index]->GetInfosetProb(p_node->GetInfoset()) > Rational(0)) {
-      return lexical_cast<std::string>(
-          m_behavProfiles[index]->GetPayoff(p_node->GetInfoset()->GetAction(p_act)),
-          m_doc->GetStyle().NumDecimals());
+    std::optional<T> actionValue =
+        m_behavProfiles[index]->GetPayoff(p_node->GetInfoset()->GetAction(p_act));
+    if (actionValue.has_value()) {
+      return lexical_cast<std::string>(actionValue.value(), m_doc->GetStyle().NumDecimals());
     }
     // In the absence of beliefs, this is not well-defined
     return "*";

src/pygambit/behavmixed.pxi

@@ -686,10 +686,13 @@ class MixedBehaviorProfile:
             raise ValueError("infoset_value() is not defined for the chance player")
         return self._infoset_value(resolved_infoset)
 
-    def action_value(self, action: ActionReference) -> ProfileDType:
+    def action_value(self, action: ActionReference) -> ProfileDType | None:
         """Returns the expected payoff to the player of playing an action conditional on reaching
         its information set, if all players play according to the profile.
 
+        If the information set is not reachable, the expected payoff is not well-defined.
+        In this case, the function returns `None`.
+
         Parameters
         ----------
         action : Action or str
@@ -704,6 +707,10 @@ class MixedBehaviorProfile:
             If `action` is a string and no action in the game has that label.
         ValueError
             If `action` resolves to an action that belongs to the chance player
+
+        See also
+        --------
+        MixedBehaviorProfile.infoset_prob
         """
         self._check_validity()
         resolved_action = self.game._resolve_action(action, "action_value")
@@ -959,8 +966,11 @@ class MixedBehaviorProfileDouble(MixedBehaviorProfile):
     def _node_value(self, player: Player, node: Node) -> float:
         return deref(self.profile).GetPayoff(player.player, node.node)
 
-    def _action_value(self, action: Action) -> float:
-        return deref(self.profile).GetPayoff(action.action)
+    def _action_value(self, action: Action) -> float | None:
+        cdef optional[float] value = deref(self.profile).GetPayoff(action.action)
+        if value.has_value():
+            return value.value()
+        return None
 
     def _action_regret(self, action: Action) -> float:
         return deref(self.profile).GetRegret(action.action)
@@ -1061,8 +1071,11 @@ class MixedBehaviorProfileRational(MixedBehaviorProfile):
     def _node_value(self, player: Player, node: Node) -> Rational:
         return rat_to_py(deref(self.profile).GetPayoff(player.player, node.node))
 
-    def _action_value(self, action: Action) -> Rational:
-        return rat_to_py(deref(self.profile).GetPayoff(action.action))
+    def _action_value(self, action: Action) -> Rational | None:
+        cdef optional[c_Rational] value = deref(self.profile).GetPayoff(action.action)
+        if value.has_value():
+            return rat_to_py(value.value())
+        return None
 
     def _action_regret(self, action: Action) -> Rational:
         return rat_to_py(deref(self.profile).GetRegret(action.action))

src/pygambit/gambit.pxd

@@ -4,6 +4,7 @@ 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
+from libcpp.optional cimport optional
 
 
 cdef extern from "gambit.h":
@@ -367,7 +368,7 @@ cdef extern from "games/behavmixed.h" namespace "Gambit":
         T GetInfosetProb(c_GameInfoset) except +
         T GetPayoff(c_GameInfoset) except +
         T GetPayoff(c_GamePlayer, c_GameNode) except +
-        T GetPayoff(c_GameAction) except +
+        optional[T] GetPayoff(c_GameAction) except +
         T GetRegret(c_GameAction) except +
         T GetRegret(c_GameInfoset) except +
         T GetAgentMaxRegret() except +

src/solvers/liap/efgliap.cc

@@ -76,7 +76,7 @@ AgentLyapunovFunction::PenalizedLiapValue(const MixedBehaviorProfile<double> &p_
   for (const auto &infoset : p_profile.GetGame()->GetInfosets()) {
     double infosetValue = p_profile.GetPayoff(infoset);
     value += sum_function(infoset->GetActions(), [&](const auto &action) -> double {
-      return sqr(std::max(m_scale * (p_profile.GetPayoff(action) - infosetValue), 0.0));
+      return sqr(std::max(m_scale * (p_profile.GetPayoff(action).value() - infosetValue), 0.0));
     });
   }
   // Penalty function for non-negativity constraint for each action

src/tools/util.h

@@ -229,7 +229,10 @@ void MixedBehaviorProfileDetailRenderer<T>::Render(const MixedBehaviorProfile<T>
         m_stream << lexical_cast<std::string>(p_profile[action], m_numDecimals);
         m_stream << "   ";
         m_stream << std::setw(11);
-        m_stream << lexical_cast<std::string>(p_profile.GetPayoff(action), m_numDecimals);
+        std::optional<T> actionValue = p_profile.GetPayoff(action);
+        if (actionValue.has_value()) {
+          m_stream << lexical_cast<std::string>(actionValue.value(), m_numDecimals);
+        }
         m_stream << std::endl;
       }
     }