Change to only sorting information sets on demand.

The order in which information sets, and their members, was iterated was
previously enforced to be the order encountered in a depth-first
traversal of the tree.  This scales poorly when building large games
using many operations.

This introduces a new operation, `SortInfosets` in C++ and `sort_infosets` in Python,
which does this sorting, but only on demand when called.

Sorting is done automatically in the following circumstances:
* When reading an .efg file;
* When creating the reduced strategic form of a game (to ensure consistent strategy labels);
* After every operation in the GUI (where performance is not critical relative
  to the usefulness of having lists of information sets and
  members be independent of the editing order)

Closes #483.

Author: tturocy

ChangeLog

@@ -22,6 +22,10 @@
 
 ### Changed
 - Internally in C++ `std::shared_ptr` are now used to manage memory allocated for game objects.  (#518)
+- The iteration order of a player's information sets, and of the members of an information set, now may
+  depend on the order of operations to build a game tree.  The previous behaviour - ensuring sorting
+  by the order encountered in a depth-first traversal of the tree - can now be obtained by calling
+  `SortInfosets` (C++) or `sort_infosets` (Python) on the game.  (#483)
 
 ## [16.3.1] - unreleased
 

doc/pygambit.api.rst

@@ -69,8 +69,9 @@ Transforming game information structure
    Game.set_player
    Game.set_infoset
    Game.leave_infoset
-   Game.reveal
    Game.set_chance_probs
+   Game.reveal
+   Game.sort_infosets
 
 
 Transforming game components

src/games/file.cc

@@ -28,8 +28,6 @@
 #include <algorithm>
 
 #include "gambit.h"
-// for explicit access to turning off canonicalization
-#include "gametree.h"
 
 namespace {
 // This anonymous namespace encapsulates the file-parsing code
@@ -732,7 +730,6 @@ Game ReadEfgFile(std::istream &p_stream)
 
   TreeData treeData;
   Game game = NewTree();
-  dynamic_cast<GameTreeRep &>(*game).SetCanonicalization(false);
   game->SetTitle(parser.GetLastText());
   ReadPlayers(parser, game, treeData);
   if (parser.GetNextToken() == TOKEN_TEXT) {
@@ -741,7 +738,7 @@ Game ReadEfgFile(std::istream &p_stream)
     parser.GetNextToken();
   }
   ParseNode(parser, game, game->GetRoot(), treeData);
-  dynamic_cast<GameTreeRep &>(*game).SetCanonicalization(true);
+  game->SortInfosets();
   return game;
 }
 

src/games/game.h

@@ -862,6 +862,8 @@ class GameRep : public std::enable_shared_from_this<GameRep> {
   virtual GameInfoset GetInfoset(int iset) const { throw UndefinedException(); }
   /// Returns the set of information sets in the game
   virtual std::vector<GameInfoset> GetInfosets() const { throw UndefinedException(); }
+  /// Sort the information sets for each player in a canonical order
+  virtual void SortInfosets() {}
   //@}
 
   /// @name Outcomes

src/games/gametree.cc

@@ -145,7 +145,6 @@ void GameTreeRep::DeleteAction(GameAction p_action)
     member->m_children.erase(it);
   }
   ClearComputedValues();
-  Canonicalize();
 }
 
 GameInfoset GameActionRep::GetInfoset() const { return m_infoset->shared_from_this(); }
@@ -193,7 +192,6 @@ void GameTreeRep::SetPlayer(GameInfoset p_infoset, GamePlayer p_player)
   p_player->m_infosets.push_back(p_infoset);
 
   ClearComputedValues();
-  Canonicalize();
 }
 
 bool GameInfosetRep::Precedes(GameNode p_node) const
@@ -237,7 +235,6 @@ GameAction GameTreeRep::InsertAction(GameInfoset p_infoset, GameAction p_action
   m_numNodes += p_infoset->m_members.size();
   // m_numNonterminalNodes stays unchanged when an action is appended to an information set
   ClearComputedValues();
-  Canonicalize();
   return action;
 }
 
@@ -251,10 +248,7 @@ void GameTreeRep::RemoveMember(GameInfosetRep *p_infoset, GameNodeRep *p_node)
     p_infoset->Invalidate();
     p_infoset->m_player->m_infosets.erase(std::find(
         player->m_infosets.begin(), player->m_infosets.end(), p_infoset->shared_from_this()));
-    int iset = 1;
-    for (auto &infoset : player->m_infosets) {
-      infoset->m_number = iset++;
-    }
+    RenumberInfosets(player);
   }
 }
 
@@ -284,7 +278,6 @@ void GameTreeRep::Reveal(GameInfoset p_atInfoset, GamePlayer p_player)
   }
 
   ClearComputedValues();
-  Canonicalize();
 }
 
 //========================================================================
@@ -422,7 +415,6 @@ void GameTreeRep::DeleteParent(GameNode p_node)
 
   oldParent->Invalidate();
   ClearComputedValues();
-  Canonicalize();
 }
 
 void GameTreeRep::DeleteTree(GameNode p_node)
@@ -449,7 +441,6 @@ void GameTreeRep::DeleteTree(GameNode p_node)
   node->m_label = "";
 
   ClearComputedValues();
-  Canonicalize();
 }
 
 void GameTreeRep::CopySubtree(GameNodeRep *dest, GameNodeRep *src, GameNodeRep *stop)
@@ -491,7 +482,6 @@ void GameTreeRep::CopyTree(GameNode p_dest, GameNode p_src)
       CopySubtree(dest_child->get(), src_child->get(), dest);
     }
     ClearComputedValues();
-    Canonicalize();
   }
 }
 
@@ -515,7 +505,6 @@ void GameTreeRep::MoveTree(GameNode p_dest, GameNode p_src)
   dest->m_outcome = nullptr;
 
   ClearComputedValues();
-  Canonicalize();
 }
 
 Game GameTreeRep::CopySubgame(GameNode p_root) const
@@ -547,7 +536,6 @@ void GameTreeRep::SetInfoset(GameNode p_node, GameInfoset p_infoset)
   node->m_infoset = p_infoset.get();
 
   ClearComputedValues();
-  Canonicalize();
 }
 
 GameInfoset GameTreeRep::LeaveInfoset(GameNode p_node)
@@ -578,7 +566,6 @@ GameInfoset GameTreeRep::LeaveInfoset(GameNode p_node)
     (*new_act)->SetLabel((*old_act)->GetLabel());
   }
   ClearComputedValues();
-  Canonicalize();
   return node->m_infoset->shared_from_this();
 }
 
@@ -619,7 +606,6 @@ GameInfoset GameTreeRep::AppendMove(GameNode p_node, GameInfoset p_infoset)
                 });
   m_numNonterminalNodes++;
   ClearComputedValues();
-  Canonicalize();
   return node->m_infoset->shared_from_this();
 }
 
@@ -671,7 +657,6 @@ GameInfoset GameTreeRep::InsertMove(GameNode p_node, GameInfoset p_infoset)
   m_numNodes += newNode->m_infoset->m_actions.size();
   m_numNonterminalNodes++;
   ClearComputedValues();
-  Canonicalize();
   return p_infoset;
 }
 
@@ -769,64 +754,39 @@ bool GameTreeRep::IsPerfectRecall() const
 //               GameTreeRep: Managing the representation
 //------------------------------------------------------------------------
 
-void GameTreeRep::NumberNodes(GameNodeRep *n, int &index)
+void GameTreeRep::SortInfosets(GamePlayerRep *p_player)
 {
-  n->m_number = index++;
-  for (auto &child : n->m_children) {
-    NumberNodes(child.get(), index);
+  // Sort nodes within information sets according to ID.
+  for (auto &infoset : p_player->m_infosets) {
+    std::sort(infoset->m_members.begin(), infoset->m_members.end(),
+              [](const std::shared_ptr<GameNodeRep> &a, const std::shared_ptr<GameNodeRep> &b) {
+                return a->m_number < b->m_number;
+              });
   }
+  // Sort information sets by the smallest ID among their members
+  std::sort(
+      p_player->m_infosets.begin(), p_player->m_infosets.end(),
+      [](const std::shared_ptr<GameInfosetRep> &a, const std::shared_ptr<GameInfosetRep> &b) {
+        return a->m_members.front()->m_number < b->m_members.front()->m_number;
+      });
+  RenumberInfosets(p_player);
+}
+void GameTreeRep::RenumberInfosets(GamePlayerRep *p_player)
+{
+  std::for_each(
+      p_player->m_infosets.begin(), p_player->m_infosets.end(),
+      [iset = 1](const std::shared_ptr<GameInfosetRep> &s) mutable { s->m_number = iset++; });
 }
 
-void GameTreeRep::Canonicalize()
+void GameTreeRep::SortInfosets()
 {
-  if (!m_doCanon) {
-    return;
-  }
   int nodeindex = 1;
-  NumberNodes(m_root.get(), nodeindex);
-
-  for (size_t pl = 0; pl <= m_players.size(); pl++) {
-    auto player = (pl) ? m_players[pl - 1].get() : m_chance.get();
-
-    // Sort nodes within information sets according to ID.
-    // Coded using a bubble sort for simplicity; large games might
-    // find a quicksort worthwhile.
-    for (auto &infoset : player->m_infosets) {
-      for (size_t i = 1; i < infoset->m_members.size(); i++) {
-        for (size_t j = 1; j < infoset->m_members.size() - i; j++) {
-          if (infoset->m_members[j]->m_number < infoset->m_members[j - 1]->m_number) {
-            auto tmp = infoset->m_members[j - 1];
-            infoset->m_members[j - 1] = infoset->m_members[j];
-            infoset->m_members[j] = tmp;
-          }
-        }
-      }
-    }
-
-    // Sort information sets by the smallest ID among their members
-    // Coded using a bubble sort for simplicity; large games might
-    // find a quicksort worthwhile.
-    for (size_t i = 1; i < player->m_infosets.size(); i++) {
-      for (size_t j = 1; j < player->m_infosets.size() - i; j++) {
-        const int a = ((player->m_infosets[j]->m_members.size())
-                           ? player->m_infosets[j]->m_members[0]->m_number
-                           : 0);
-        const int b = ((player->m_infosets[j - 1]->m_members.size())
-                           ? player->m_infosets[j - 1]->m_members[0]->m_number
-                           : 0);
-
-        if (a < b || b == 0) {
-          auto tmp = player->m_infosets[j - 1];
-          player->m_infosets[j - 1] = player->m_infosets[j];
-          player->m_infosets[j] = tmp;
-        }
-      }
-    }
-
-    // Reassign information set IDs
-    std::for_each(
-        player->m_infosets.begin(), player->m_infosets.end(),
-        [iset = 1](const std::shared_ptr<GameInfosetRep> &s) mutable { s->m_number = iset++; });
+  for (const auto &node : GetNodes()) {
+    node->m_number = nodeindex++;
+  }
+  SortInfosets(m_chance.get());
+  for (auto player : m_players) {
+    SortInfosets(player.get());
   }
 }
 
@@ -848,7 +808,7 @@ void GameTreeRep::BuildComputedValues() const
   if (m_computedValues) {
     return;
   }
-  const_cast<GameTreeRep *>(this)->Canonicalize();
+  const_cast<GameTreeRep *>(this)->SortInfosets();
   for (const auto &player : m_players) {
     std::map<GameInfosetRep *, int> behav;
     std::map<GameNodeRep *, GameNodeRep *> ptr, whichbranch;

src/games/gametree.h

@@ -33,7 +33,7 @@ class GameTreeRep : public GameExplicitRep {
   friend class GameActionRep;
 
 protected:
-  mutable bool m_computedValues{false}, m_doCanon{true};
+  mutable bool m_computedValues{false};
   std::shared_ptr<GameNodeRep> m_root;
   std::shared_ptr<GamePlayerRep> m_chance;
   std::size_t m_numNodes = 1;
@@ -43,14 +43,14 @@ class GameTreeRep : public GameExplicitRep {
 
   /// @name Private auxiliary functions
   //@{
-  void NumberNodes(GameNodeRep *, int &);
+  void SortInfosets(GamePlayerRep *);
+  static void RenumberInfosets(GamePlayerRep *);
   /// Normalize the probability distribution of actions at a chance node
   Game NormalizeChanceProbs(GameInfosetRep *);
   //@}
 
   /// @name Managing the representation
   //@{
-  void Canonicalize();
   void BuildComputedValues() const override;
   void BuildConsistentPlays();
   void ClearComputedValues() const;
@@ -74,14 +74,6 @@ class GameTreeRep : public GameExplicitRep {
   bool IsTree() const override { return true; }
   bool IsConstSum() const override;
   bool IsPerfectRecall() const override;
-  /// Turn on or off automatic canonicalization of the game
-  void SetCanonicalization(bool p_doCanon) const
-  {
-    m_doCanon = p_doCanon;
-    if (m_doCanon) {
-      const_cast<GameTreeRep *>(this)->Canonicalize();
-    }
-  }
   //@}
 
   /// @name Players
@@ -122,6 +114,8 @@ class GameTreeRep : public GameExplicitRep {
   GameInfoset GetInfoset(int iset) const override;
   /// Returns the set of information sets in the game
   std::vector<GameInfoset> GetInfosets() const override;
+  /// Sort the information sets for each player in a canonical order
+  void SortInfosets() override;
   //@}
 
   /// @name Modification