Develop concept of a Cartesian product space and apply to games in strategic form. (#740)

This creates an abstraction, CartesianProductSpace, which aims to separate out the computations
related to representing a Cartesian product.  This has always been implicit in the strategic form,
but the core ideas apply equally to other situations (sequence form, some applications of pure behavior profiles).
Underpinning this is that any element of a cartesian product space can be represented by an
integer computed using mixed radix arithmetic.

This then leads to simplifications in the internal representation of several objects:
* PureStrategyProfile, which is now be characterised simply by an integer index.
* StrategySupportProfile, which is characterised by the set of "digits" which are valid for each dimension.
* StrategyContingencies, which iterates over the valid digits for each dimension.

Author: tturocy

Makefile.am

@@ -299,7 +299,6 @@ game_SOURCES = \
 	src/games/behavmixed.h \
 	src/games/stratspt.cc \
 	src/games/stratspt.h \
-	src/games/stratpure.cc \
 	src/games/stratpure.h \
 	src/games/stratmixed.h \
 	src/games/file.cc \

src/games/behavmixed.cc

@@ -252,6 +252,7 @@ template <class T> MixedBehaviorProfile<T> MixedBehaviorProfile<T>::ToFullSuppor
 
 template <class T> T MixedBehaviorProfile<T>::GetLiapValue() const
 {
+  m_support.GetGame()->BuildComputedValues();
   return MixedStrategyProfile<T>(*this).GetLiapValue();
 }
 
@@ -356,6 +357,7 @@ template <class T> T MixedBehaviorProfile<T>::GetRegret(const GameInfoset &p_inf
 
 template <class T> T MixedBehaviorProfile<T>::GetMaxRegret() const
 {
+  m_support.GetGame()->BuildComputedValues();
   return MixedStrategyProfile<T>(*this).GetMaxRegret();
 }
 
@@ -553,6 +555,7 @@ template <class T> bool MixedBehaviorProfile<T>::IsDefinedAt(GameInfoset p_infos
 template <class T> MixedStrategyProfile<T> MixedBehaviorProfile<T>::ToMixedProfile() const
 {
   CheckVersion();
+  m_support.GetGame()->BuildComputedValues();
   return MixedStrategyProfile<T>(*this);
 }
 

src/games/file.cc

@@ -411,23 +411,21 @@ void ReadOutcomeList(GameFileLexer &p_parser, Game &p_nfg)
 void ParseOutcomeBody(GameFileLexer &p_parser, Game &p_nfg)
 {
   ReadOutcomeList(p_parser, p_nfg);
-  const StrategySupportProfile profile(p_nfg);
-  for (auto iter : StrategyContingencies(profile)) {
+  for (const auto &profile : StrategyContingencies(p_nfg)) {
     p_parser.ExpectCurrentToken(TOKEN_NUMBER, "outcome index");
     if (const int outcomeId = std::stoi(p_parser.GetLastText())) {
-      iter->SetOutcome(p_nfg->GetOutcome(outcomeId));
+      profile->SetOutcome(p_nfg->GetOutcome(outcomeId));
     }
     p_parser.GetNextToken();
   }
 }
 
 void ParsePayoffBody(GameFileLexer &p_parser, Game &p_nfg)
 {
-  const StrategySupportProfile profile(p_nfg);
-  for (auto iter : StrategyContingencies(profile)) {
+  for (const auto &profile : StrategyContingencies(p_nfg)) {
     for (const auto &player : p_nfg->GetPlayers()) {
       p_parser.ExpectCurrentToken(TOKEN_NUMBER, "numerical payoff");
-      iter->GetOutcome()->SetPayoff(player, Number(p_parser.GetLastText()));
+      profile->GetOutcome()->SetPayoff(player, Number(p_parser.GetLastText()));
       p_parser.GetNextToken();
     }
   }

src/games/game.cc

@@ -182,6 +182,24 @@ GameRep::~GameRep()
   }
 }
 
+void GameRep::IndexStrategies() const
+{
+  const size_t n = m_players.size();
+  m_pureStrategies.m_radices.resize(n);
+  m_pureStrategies.m_strides.resize(n);
+
+  long stride = 1L;
+  for (size_t i = 0; i < n; ++i) {
+    const auto &player = m_players[i];
+    m_pureStrategies.m_strides[i] = stride;
+    m_pureStrategies.m_radices[i] = player->m_strategies.size();
+    for (auto [st, strategy] : enumerate(player->m_strategies)) {
+      strategy->m_number = st + 1;
+    }
+    stride *= m_pureStrategies.m_radices[i];
+  }
+}
+
 //------------------------------------------------------------------------
 //                     GameRep: Writing data files
 //------------------------------------------------------------------------
@@ -405,6 +423,16 @@ template <class T> T MixedStrategyProfile<T>::GetMaxRegret() const
                            [this](const auto &player) -> T { return this->GetRegret(player); });
 }
 
+MixedStrategyProfile<Rational> PureStrategyProfileRep::ToMixedStrategyProfile() const
+{
+  auto temp = m_game->NewMixedStrategyProfile(Rational(0));
+  temp = Rational(0);
+  for (const auto &player : m_game->GetPlayers()) {
+    temp[GetStrategy(player)] = Rational(1);
+  }
+  return temp;
+}
+
 template class MixedStrategyProfileRep<double>;
 template class MixedStrategyProfileRep<Rational>;
 

src/games/game.h

@@ -267,6 +267,7 @@ class GameInfosetRep : public std::enable_shared_from_this<GameInfosetRep> {
 /// relatively efficient.
 class GameStrategyRep : public std::enable_shared_from_this<GameStrategyRep> {
   friend class GameExplicitRep;
+  friend class GameRep;
   friend class GameTreeRep;
   friend class GameTableRep;
   friend class GameAGGRep;
@@ -283,7 +284,6 @@ class GameStrategyRep : public std::enable_shared_from_this<GameStrategyRep> {
   bool m_valid{true};
   GamePlayerRep *m_player;
   int m_number;
-  long m_offset{-1L};
   std::string m_label;
   std::map<GameInfosetRep *, int> m_behav;
 
@@ -360,6 +360,7 @@ class GamePlayerRep : public std::enable_shared_from_this<GamePlayerRep> {
   friend class GameInfosetRep;
   friend class GameNodeRep;
   friend class StrategySupportProfile;
+  friend class PureStrategyProfileRep;
   template <class T> friend class MixedBehaviorProfile;
   template <class T> friend class MixedStrategyProfile;
 
@@ -594,6 +595,24 @@ inline GameNode GameNodeRep::Actions::iterator::GetOwner() const { return m_chil
 
 enum class TraversalOrder { Preorder, Postorder };
 
+class CartesianProductSpace {
+public:
+  std::vector<int> m_radices;
+  std::vector<long> m_strides;
+};
+
+class CartesianSubset {
+public:
+  const CartesianProductSpace *m_space{nullptr};
+  std::vector<std::vector<int>> m_allowedDigits;
+};
+
+template <class T> class CartesianTensor {
+public:
+  const CartesianProductSpace *m_space{nullptr};
+  std::vector<T> m_data;
+};
+
 /// This is the class for representing an arbitrary finite game.
 class GameRep : public std::enable_shared_from_this<GameRep> {
   friend class GameOutcomeRep;
@@ -602,13 +621,15 @@ class GameRep : public std::enable_shared_from_this<GameRep> {
   friend class GamePlayerRep;
   friend class PureStrategyProfileRep;
   friend class TablePureStrategyProfileRep;
+  friend class StrategySupportProfile;
   template <class T> friend class MixedBehaviorProfile;
   template <class T> friend class MixedStrategyProfile;
   template <class T> friend class TableMixedStrategyProfileRep;
 
 protected:
   std::vector<std::shared_ptr<GamePlayerRep>> m_players;
   std::vector<std::shared_ptr<GameOutcomeRep>> m_outcomes;
+  mutable CartesianProductSpace m_pureStrategies;
   std::string m_title, m_comment;
   unsigned int m_version{0};
 
@@ -618,6 +639,7 @@ class GameRep : public std::enable_shared_from_this<GameRep> {
   //@{
   /// Mark that the content of the game has changed
   void IncrementVersion() { m_version++; }
+  void IndexStrategies() const;
   //@}
 
   /// Hooks for derived classes to update lazily-computed orderings if required

src/games/gameagg.cc

@@ -51,21 +51,21 @@ class AGGPureStrategyProfileRep : public PureStrategyProfileRep {
 
 Rational AGGPureStrategyProfileRep::GetPayoff(const GamePlayer &p_player) const
 {
-  const std::shared_ptr<agg::AGG> aggPtr = dynamic_cast<GameAGGRep &>(*m_nfg).aggPtr;
+  const std::shared_ptr<agg::AGG> aggPtr = dynamic_cast<GameAGGRep &>(*m_game).aggPtr;
   std::vector<int> s(aggPtr->getNumPlayers());
   for (int i = 1; i <= aggPtr->getNumPlayers(); i++) {
-    s[i - 1] = m_profile.at(m_nfg->GetPlayer(i))->GetNumber() - 1;
+    s[i - 1] = GetStrategy(m_game->GetPlayer(i))->GetNumber() - 1;
   }
   return Rational(aggPtr->getPurePayoff(p_player->GetNumber() - 1, s));
 }
 
 Rational AGGPureStrategyProfileRep::GetStrategyValue(const GameStrategy &p_strategy) const
 {
   const int player = p_strategy->GetPlayer()->GetNumber();
-  const std::shared_ptr<agg::AGG> aggPtr = dynamic_cast<GameAGGRep &>(*m_nfg).aggPtr;
+  const std::shared_ptr<agg::AGG> aggPtr = dynamic_cast<GameAGGRep &>(*m_game).aggPtr;
   std::vector<int> s(aggPtr->getNumPlayers());
   for (int i = 1; i <= aggPtr->getNumPlayers(); i++) {
-    s[i - 1] = m_profile.at(m_nfg->GetPlayer(i))->GetNumber() - 1;
+    s[i - 1] = GetStrategy(m_game->GetPlayer(i))->GetNumber() - 1;
   }
   s[player - 1] = p_strategy->GetNumber() - 1;
   return Rational(aggPtr->getPurePayoff(player - 1, s));
@@ -236,23 +236,14 @@ GameAGGRep::NewMixedStrategyProfile(const Rational &, const StrategySupportProfi
 
 bool GameAGGRep::IsConstSum() const
 {
-  auto profile = NewPureStrategyProfile();
-  Rational sum(0);
-  for (const auto &player : m_players) {
-    sum += profile->GetPayoff(player);
-  }
-
-  for (auto iter : StrategyContingencies(std::const_pointer_cast<GameRep>(shared_from_this()))) {
-    Rational newsum(0);
-    for (const auto &player : m_players) {
-      newsum += iter->GetPayoff(player);
-    }
-    if (newsum != sum) {
-      return false;
-    }
-  }
-
-  return true;
+  auto payoff_sum = [&](const PureStrategyProfile &p) {
+    return sum_function(m_players, [&](const auto &player) { return p->GetPayoff(player); });
+  };
+  const Rational sum = payoff_sum(NewPureStrategyProfile());
+
+  auto contingencies = StrategyContingencies(std::const_pointer_cast<GameRep>(shared_from_this()));
+  return std::all_of(contingencies.begin(), contingencies.end(),
+                     [&](const PureStrategyProfile &p) { return payoff_sum(p) == sum; });
 }
 
 //------------------------------------------------------------------------

src/games/gamebagg.cc

@@ -50,26 +50,26 @@ class BAGGPureStrategyProfileRep : public PureStrategyProfileRep {
 
 Rational BAGGPureStrategyProfileRep::GetPayoff(const GamePlayer &p_player) const
 {
-  const std::shared_ptr<agg::BAGG> baggPtr = dynamic_cast<GameBAGGRep &>(*m_nfg).baggPtr;
-  std::vector<int> s(m_nfg->NumPlayers());
-  for (size_t i = 1; i <= m_nfg->NumPlayers(); i++) {
-    s[i - 1] = m_profile.at(m_nfg->GetPlayer(i))->GetNumber() - 1;
+  const std::shared_ptr<agg::BAGG> baggPtr = dynamic_cast<GameBAGGRep &>(*m_game).baggPtr;
+  std::vector<int> s(m_game->NumPlayers());
+  for (size_t i = 1; i <= m_game->NumPlayers(); i++) {
+    s[i - 1] = GetStrategy(m_game->GetPlayer(i))->GetNumber() - 1;
   }
-  const int bp = dynamic_cast<GameBAGGRep &>(*m_nfg).agent2baggPlayer[p_player->GetNumber()];
+  const int bp = dynamic_cast<GameBAGGRep &>(*m_game).agent2baggPlayer[p_player->GetNumber()];
   const int tp = p_player->GetNumber() - 1 - baggPtr->typeOffset[bp - 1];
   return Rational(baggPtr->getPurePayoff(bp - 1, tp, s));
 }
 
 Rational BAGGPureStrategyProfileRep::GetStrategyValue(const GameStrategy &p_strategy) const
 {
   const int player = p_strategy->GetPlayer()->GetNumber();
-  const std::shared_ptr<agg::BAGG> baggPtr = dynamic_cast<GameBAGGRep &>(*m_nfg).baggPtr;
-  std::vector<int> s(m_nfg->NumPlayers());
-  for (size_t i = 1; i <= m_nfg->NumPlayers(); i++) {
-    s[i - 1] = m_profile.at(m_nfg->GetPlayer(i))->GetNumber() - 1;
+  const std::shared_ptr<agg::BAGG> baggPtr = dynamic_cast<GameBAGGRep &>(*m_game).baggPtr;
+  std::vector<int> s(m_game->NumPlayers());
+  for (size_t i = 1; i <= m_game->NumPlayers(); i++) {
+    s[i - 1] = GetStrategy(m_game->GetPlayer(i))->GetNumber() - 1;
   }
   s[player - 1] = p_strategy->GetNumber() - 1;
-  const int bp = dynamic_cast<GameBAGGRep &>(*m_nfg).agent2baggPlayer[player];
+  const int bp = dynamic_cast<GameBAGGRep &>(*m_game).agent2baggPlayer[player];
   const int tp = player - 1 - baggPtr->typeOffset[bp - 1];
   return Rational(baggPtr->getPurePayoff(bp - 1, tp, s));
 }