Remove "frozen" strategies in contingencies; handle in support profiles instead.

Author: tturocy

src/games/stratpure.h

@@ -122,39 +122,26 @@ class PureStrategyProfile {
 
 class StrategyContingencies {
   StrategySupportProfile m_support;
-  std::vector<GamePlayer> m_unfrozen;
-  std::vector<GameStrategy> m_frozen;
 
 public:
   class iterator {
     StrategyContingencies *m_cont;
     bool m_atEnd{false};
-
-    // One index per unfrozen player (odometer digits)
     std::vector<size_t> m_pos;
-
-    // Current pure-strategy profile
     PureStrategyProfile m_profile;
 
   public:
-    iterator(StrategyContingencies *cont, bool end)
-      : m_cont(cont), m_atEnd(end), m_profile(cont->m_support.GetGame()->NewPureStrategyProfile())
+    iterator(StrategyContingencies *cont, bool p_end)
+      : m_cont(cont), m_atEnd(p_end),
+        m_profile(cont->m_support.GetGame()->NewPureStrategyProfile())
     {
       if (m_atEnd) {
         return;
       }
-
-      // Apply frozen strategies
-      for (const auto &s : m_cont->m_frozen) {
-        m_profile->SetStrategy(s);
-      }
-
-      // Initialise odometer
-      const size_t n = m_cont->m_unfrozen.size();
+      const size_t n = m_cont->m_support.GetPlayers().size();
       m_pos.assign(n, 0);
-
       for (size_t i = 0; i < n; ++i) {
-        const GamePlayer player = m_cont->m_unfrozen[i];
+        const GamePlayer player = m_cont->m_support.GetGame()->GetPlayer(i + 1);
         auto support = m_cont->m_support.GetStrategies(player);
         m_profile->SetStrategy(support[0]);
       }
@@ -163,23 +150,18 @@ class StrategyContingencies {
     iterator &operator++()
     {
       const size_t n = m_pos.size();
-
       for (size_t i = 0; i < n; ++i) {
-        const GamePlayer player = m_cont->m_unfrozen[i];
+        const GamePlayer player = m_cont->m_support.GetGame()->GetPlayer(i + 1);
         auto support = m_cont->m_support.GetStrategies(player);
-
         ++m_pos[i];
         if (m_pos[i] < support.size()) {
           m_profile->SetStrategy(support[m_pos[i]]);
           return *this;
         }
-
-        // rollover this dimension
         m_pos[i] = 0;
         m_profile->SetStrategy(support[0]);
       }
 
-      // overflow in all dimensions → end
       m_atEnd = true;
       return *this;
     }
@@ -201,31 +183,8 @@ class StrategyContingencies {
     const PureStrategyProfile &operator*() const { return m_profile; }
   };
 
-  explicit StrategyContingencies(const Game &p_game) : m_support(StrategySupportProfile(p_game))
-  {
-    for (const auto &player : p_game->GetPlayers()) {
-      m_unfrozen.push_back(player);
-    }
-  }
-  explicit StrategyContingencies(const StrategySupportProfile &support,
-                                 const std::vector<GameStrategy> &frozen = {})
-    : m_support(support), m_frozen(frozen)
-  {
-    // Determine unfrozen players
-    auto players = m_support.GetPlayers();
-    for (auto player : players) {
-      bool is_frozen = false;
-      for (const auto &s : m_frozen) {
-        if (s->GetPlayer() == player) {
-          is_frozen = true;
-          break;
-        }
-      }
-      if (!is_frozen) {
-        m_unfrozen.push_back(player);
-      }
-    }
-  }
+  explicit StrategyContingencies(const Game &p_game) : m_support(StrategySupportProfile(p_game)) {}
+  explicit StrategyContingencies(const StrategySupportProfile &support) : m_support(support) {}
 
   iterator begin() { return {this, false}; }
   iterator end() { return {this, true}; }

src/games/stratspt.h

@@ -193,6 +193,19 @@ class StrategySupportProfile {
   /// player, it is not removed.  Returns true if the removal was
   /// executed, and false if not.
   bool RemoveStrategy(const GameStrategy &);
+
+  StrategySupportProfile RestrictTo(const GameStrategy &p_strategy) const
+  {
+    if (p_strategy->GetGame() != m_game) {
+      throw MismatchException();
+    }
+    const GamePlayer player = p_strategy->GetPlayer();
+    const size_t player_index = player->GetNumber() - 1;
+    const int digit = p_strategy->GetNumber() - 1;
+    StrategySupportProfile restricted(*this);
+    restricted.m_strategies.m_allowedDigits[player_index].assign(1, digit);
+    return restricted;
+  }
   //@}
 
   /// @name Identification of dominated strategies

src/games/writer.cc

@@ -31,8 +31,10 @@ std::string WriteHTMLFile(const Game &p_game, const GamePlayer &p_rowPlayer,
   std::string theHtml;
   theHtml += "<center><h1>" + p_game->GetTitle() + "</h1></center>\n";
 
-  for (const auto &iter : StrategyContingencies(
-           p_game, {p_rowPlayer->GetStrategies().front(), p_colPlayer->GetStrategies().front()})) {
+  auto support = StrategySupportProfile(p_game)
+                     .RestrictTo(p_rowPlayer->GetStrategies().front())
+                     .RestrictTo(p_colPlayer->GetStrategies().front());
+  for (const auto &iter : StrategyContingencies(support)) {
     if (p_game->NumPlayers() > 2) {
       theHtml += "<center><b>Subtable with strategies:</b></center>";
       for (auto player : p_game->GetPlayers()) {
@@ -99,8 +101,10 @@ std::string WriteLaTeXFile(const Game &p_game, const GamePlayer &p_rowPlayer,
 {
   std::string theHtml;
 
-  for (const auto &iter : StrategyContingencies(
-           p_game, {p_rowPlayer->GetStrategies().front(), p_colPlayer->GetStrategies().front()})) {
+  auto support = StrategySupportProfile(p_game)
+                     .RestrictTo(p_rowPlayer->GetStrategies().front())
+                     .RestrictTo(p_colPlayer->GetStrategies().front());
+  for (const auto &iter : StrategyContingencies(support)) {
     theHtml += "\\begin{game}{";
     theHtml += std::to_string(p_rowPlayer->GetStrategies().size());
     theHtml += "}{";

src/solvers/enumpoly/nfgpoly.cc

@@ -63,7 +63,7 @@ IndifferenceEquation(std::shared_ptr<VariableSpace> space, const StrategySupport
 {
   Polynomial<double> equation(space);
 
-  for (auto iter : StrategyContingencies(support, {s1})) {
+  for (const auto &iter : StrategyContingencies(support.RestrictTo(s1))) {
     Polynomial<double> term(space, 1);
     for (auto player : support.GetGame()->GetPlayers()) {
       if (player != s1->GetPlayer()) {