Get alphabet from presentation

Joseph-Edwards · Nov 14, 2023 · d353aae · d353aae
1 parent 2cca72e
commit d353aae
Show file tree

Hide file tree

Showing 3 changed files with 68 additions and 20 deletions.
diff --git a/include/libsemigroups/knuth-bendix.hpp b/include/libsemigroups/knuth-bendix.hpp
@@ -376,23 +376,52 @@ namespace libsemigroups {
     };
 
     class Rewriter : public Rules {
-      mutable std::atomic<bool> _confluent;
-      mutable std::atomic<bool> _confluence_known;
-      std::stack<Rule*>         _stack;
+      std::unordered_set<internal_char_type> _alphabet;
+      mutable std::atomic<bool>              _confluent;
+      mutable std::atomic<bool>              _confluence_known;
+      std::atomic<bool>                      _requires_alphabet;
+      std::stack<Rule*>                      _stack;
+
+      using alphabet_citerator
+          = std::unordered_set<internal_char_type>::const_iterator;
 
      public:
       Rewriter() = default;
       Rewriter& init();
 
+      Rewriter(bool requires_alphabet) : Rewriter() {
+        _requires_alphabet = requires_alphabet;
+      }
+
       ~Rewriter();
 
       Rewriter& operator=(Rewriter const& that) {
         Rules::operator=(that);
-        _confluent        = that._confluent.load();
-        _confluence_known = that._confluence_known.load();
+        _confluent         = that._confluent.load();
+        _confluence_known  = that._confluence_known.load();
+        _requires_alphabet = that._requires_alphabet.load();
+        if (_requires_alphabet) {
+          _alphabet = that._alphabet;
+        }
         return *this;
       }
 
+      bool requires_alphabet() const {
+        return _requires_alphabet;
+      }
+
+      decltype(_alphabet) alphabet() const {
+        return _alphabet;
+      }
+
+      alphabet_citerator alphabet_cbegin() const {
+        return _alphabet.cbegin();
+      }
+
+      alphabet_citerator alphabet_cend() const {
+        return _alphabet.cend();
+      }
+
       // TODO remove?
       //  TODO to cpp if keeping it
       void confluent(tril val) const {
@@ -444,6 +473,10 @@ namespace libsemigroups {
         }
         return false;
       }
+
+      void add_to_alphabet(internal_char_type letter) {
+        _alphabet.emplace(letter);
+      }
     };
 
     class RewriteFromLeft : public Rewriter {
@@ -493,16 +526,15 @@ namespace libsemigroups {
     class RewriteTrie : public Rewriter {
       using index_type = AhoCorasick::index_type;
 
-      std::unordered_map<index_type, Rule*>  _rules;
-      std::unordered_set<internal_char_type> _alphabet;
-      AhoCorasick                            _trie;
+      std::unordered_map<index_type, Rule*> _rules;
+      AhoCorasick                           _trie;
 
      public:
       using Rewriter::confluent;
       using Rules::stats;
       using iterator = internal_string_type::iterator;
 
-      RewriteTrie() = default;
+      RewriteTrie() : Rewriter(true), _rules(), _trie() {}
 
       RewriteTrie(const RewriteTrie& that);
       RewriteTrie& operator=(RewriteTrie const& that) {
@@ -521,7 +553,6 @@ namespace libsemigroups {
         Rewriter::init();
         _trie.init();
         _rules.clear();
-        _alphabet.clear();
         return *this;
       }
 
@@ -669,7 +700,7 @@ namespace libsemigroups {
           return true;
         }
 
-        for (auto x = _alphabet.cbegin(); x != _alphabet.cend(); ++x) {
+        for (auto x = alphabet_cbegin(); x != alphabet_cend(); ++x) {
           if (!backtrack_confluence(
                   rule1,
                   _trie.traverse_from(current_node,
@@ -691,15 +722,15 @@ namespace libsemigroups {
       void add_rule_to_trie(Rule* rule) {
         index_type node = _trie.add_word_no_checks(rule->lhs()->cbegin(),
                                                    rule->lhs()->cend());
-        _rules[node]    = rule;
-        for (auto it = rule->lhs()->cbegin(); it != rule->lhs()->cend(); ++it) {
-#ifdef LIBSEMIGROUPS_DEBUG
-          _alphabet.emplace(*it);
-          LIBSEMIGROUPS_ASSERT(_alphabet.count(*it) == 1);
-#else
-          _alphabet.emplace(*it);
-#endif
-        }
+        _rules.emplace(node, rule);
+        //         for (auto it = rule->lhs()->cbegin(); it !=
+        //         rule->lhs()->cend(); ++it) {
+        // #ifdef LIBSEMIGROUPS_DEBUG _alphabet.emplace(*it);
+        //           LIBSEMIGROUPS_ASSERT(_alphabet.count(*it) == 1);
+        // #else
+        // _alphabet.emplace(*it);
+        // #endif
+        //         }
       }
 
       // TODO Make use of trie

diff --git a/src/knuth-bendix.cpp b/src/knuth-bendix.cpp
@@ -169,6 +169,9 @@ namespace libsemigroups {
 
   KnuthBendix::Rewriter& KnuthBendix::Rewriter::init() {
     Rules::init();
+    if (_requires_alphabet) {
+      _alphabet.clear();
+    }
     // Put all active rules and those rules in the stack into the
     // inactive_rules list
     while (!_stack.empty()) {
@@ -1157,6 +1160,19 @@ namespace libsemigroups {
         break;
       }
     }
+
+    if (_rewriter.requires_alphabet()) {
+      if (_internal_is_same_as_external) {
+        for (auto x = p.alphabet().begin(); x != p.alphabet().end(); ++x) {
+          _rewriter.add_to_alphabet(*x);
+        }
+      } else {
+        for (auto x = p.alphabet().begin(); x != p.alphabet().end(); ++x) {
+          _rewriter.add_to_alphabet(external_to_internal_char(*x));
+        }
+      }
+    }
+
     auto const first = p.rules.cbegin();
     auto const last  = p.rules.cend();
     for (auto it = first; it != last; it += 2) {

diff --git a/tests/test-rewriting.cpp b/tests/test-rewriting.cpp
@@ -30,6 +30,7 @@ namespace libsemigroups {
     REQUIRE(rt.number_of_active_rules() == 0);
     rt.add_rule("ba"s, "a"s);
     REQUIRE(rt.number_of_active_rules() == 1);
+    REQUIRE(rt.requires_alphabet());
   }
 
   LIBSEMIGROUPS_TEST_CASE("RewriteTrie", "001", "simple test", "[quick]") {