Only check for overlaps in pairs that we haven't already checked

include/libsemigroups/detail/aho-corasick-impl.hpp

@@ -65,6 +65,7 @@ namespace libsemigroups {
         // Private data
         ////////////////////////////////////////////////////////////////////////
        private:
+        mutable size_t                 _last_checked;
         uint32_t                       _height;
         index_type                     _link;
         index_type                     _parent;
@@ -97,6 +98,10 @@ namespace libsemigroups {
         // Getters - public
         ////////////////////////////////////////////////////////////////////////
 
+        [[nodiscard]] size_t last_checked() const noexcept {
+          return _last_checked;
+        }
+
         [[nodiscard]] size_t height() const noexcept {
           return _height;
         }
@@ -126,12 +131,22 @@ namespace libsemigroups {
           return _value;
         }
 
+        ////////////////////////////////////////////////////////////////////////
+        // Setters - public
+        ////////////////////////////////////////////////////////////////////////
+
+        Node const& last_checked(size_t val) const noexcept {
+          _last_checked = val;
+          return *this;
+        }
+
        private:
         ////////////////////////////////////////////////////////////////////////
         // Setters - private
         ////////////////////////////////////////////////////////////////////////
 
-        // All setters are private to avoid corrupting the objects.
+        // All setters of non-mutable members are private to avoid corrupting
+        // the objects.
 
         Node const& height(size_t val) noexcept {
           _height = val;
@@ -148,7 +163,6 @@ namespace libsemigroups {
           _value = value;
           return *this;
         }
-
       };  // class Node
 
       // TODO(1) if we store pointers here instead of Nodes, then inside the
@@ -162,6 +176,7 @@ namespace libsemigroups {
       std::vector<index_type>           _inactive_nodes_index;
       std::vector<index_type>           _node_indices_to_update;
       std::unordered_set<index_type>    _terminal_nodes_index;
+      mutable size_t                    _generation;
 
       // TODO(1): it seems likely that the positions of the active nodes in
       // _all_nodes will become scattered and disordered over time, and so it'd
@@ -187,6 +202,14 @@ namespace libsemigroups {
 
       ~AhoCorasickImpl();
 
+      void increment_generation() const noexcept {
+        ++_generation;
+      }
+
+      size_t generation() const noexcept {
+        return _generation;
+      }
+
       size_t alphabet_size() const noexcept {
         return _children.number_of_cols();
       }
@@ -407,7 +430,7 @@ namespace libsemigroups {
                                               Word const&            w);
 
     }  // namespace aho_corasick_impl
-  }  // namespace detail
+  }    // namespace detail
 }  // namespace libsemigroups
 
 #include "aho-corasick-impl.tpp"

include/libsemigroups/detail/aho-corasick-impl.tpp

@@ -29,6 +29,7 @@ namespace libsemigroups {
       LIBSEMIGROUPS_ASSERT(val != nullptr);
       index_type current = root;
       for (auto it = first; it != last; ++it) {
+        _all_nodes[current].last_checked(generation());
         index_type next = _children.get(current, *it);
         if (next == UNDEFINED) {
           // index of next node added
@@ -40,7 +41,7 @@ namespace libsemigroups {
       if (inserted) {
         _all_nodes[current].value(val);
       }
-
+      _all_nodes[current].last_checked(generation());
       return {current, inserted};
     }
 
@@ -309,5 +310,5 @@ namespace libsemigroups {
       }
 
     }  // namespace aho_corasick_impl
-  }  // namespace detail
+  }    // namespace detail
 }  // namespace libsemigroups

include/libsemigroups/detail/knuth-bendix-impl.hpp

@@ -831,7 +831,7 @@ namespace libsemigroups {
 
       bool finished_impl() const override;
     };  // class KnuthBendixImpl
-  }  // namespace detail
+  }     // namespace detail
 
 ////////////////////////////////////////////////////////////////////////
 // global functions - to_human_readable_repr

include/libsemigroups/detail/knuth-bendix-impl.tpp

@@ -565,6 +565,7 @@ namespace libsemigroups {
             _rewriter.add_rule(u.begin(), u.end(), v.begin(), v.end());
             ++start;
           }
+          _rewriter.trie().increment_generation();
         } else {
           // _rewriter.rules() calls process_pending_rules, so can't call it
           // inside the rule1 loop below.

include/libsemigroups/detail/knuth-bendix-nf.hpp

@@ -39,7 +39,7 @@ namespace libsemigroups {
     class KnuthBendixNormalFormRange : public Paths<uint32_t> {
       using Paths_ = Paths<uint32_t>;
 
-      mutable Word                                 _current;
+      mutable Word                                        _current;
       KnuthBendix<Word, RewritingSystem, ReductionOrder>* _kb;
 
      public:
@@ -113,14 +113,14 @@ namespace libsemigroups {
 
     template <typename Word, typename RewritingSystem, typename ReductionOrder>
     KnuthBendixNormalFormRange<Word, RewritingSystem, ReductionOrder>&
-    KnuthBendixNormalFormRange<Word, RewritingSystem, ReductionOrder>::operator=(
-        KnuthBendixNormalFormRange const&)
+    KnuthBendixNormalFormRange<Word, RewritingSystem, ReductionOrder>::
+    operator=(KnuthBendixNormalFormRange const&)
         = default;
 
     template <typename Word, typename RewritingSystem, typename ReductionOrder>
     KnuthBendixNormalFormRange<Word, RewritingSystem, ReductionOrder>&
-    KnuthBendixNormalFormRange<Word, RewritingSystem, ReductionOrder>::operator=(
-        KnuthBendixNormalFormRange&&)
+    KnuthBendixNormalFormRange<Word, RewritingSystem, ReductionOrder>::
+    operator=(KnuthBendixNormalFormRange&&)
         = default;
 
     template <typename Word, typename RewritingSystem, typename ReductionOrder>

include/libsemigroups/detail/overlap-iterators.hpp

@@ -87,10 +87,10 @@ namespace libsemigroups::detail {
           _suffix_descendent_index(),
           _overlap(),
           _trie(nullptr),
-          _index_stack() {};
+          _index_stack() {}
 
     // TODO: Use an init rather than setting default values?
-    OverlapIteratorTrie(Trie const& trie)
+    explicit OverlapIteratorTrie(Trie const& trie)
         : _current_word_iterator(trie.cbegin_terminal_nodes()),
           _last_word_iterator(trie.cend_terminal_nodes()),
           _word_index(Trie::root),
@@ -177,9 +177,11 @@ namespace libsemigroups::detail {
     // TODO better name
     bool traverse_to_root() {
       while (_suffix_index != Trie::root) {
-        _index_stack.emplace_back(_suffix_index);
-        if (find_next_descendent()) {
-          return true;
+        if (should_check_descendants(_suffix_index)) {
+          _index_stack.emplace_back(_suffix_index);
+          if (find_next_descendent()) {
+            return true;
+          }
         }
         _suffix_index = _trie->node_no_checks(_suffix_index).suffix_link();
       }
@@ -204,14 +206,23 @@ namespace libsemigroups::detail {
         for (letter_type x = 0; x < _trie->alphabet_size(); ++x) {
           index_type child_index
               = _trie->child_no_checks(_suffix_descendent_index, x);
-          if (child_index != UNDEFINED) {
+          if (child_index != UNDEFINED
+              && should_check_descendants(child_index)) {
             _index_stack.emplace_back(child_index);
           }
         }
       }
       return false;
     }
+
+    // The <generation> of a trie represents which iteration
+    bool should_check_descendants(size_t index) {
+      return _trie->node_no_checks(_word_index).last_checked()
+                 == _trie->generation()
+             || _trie->node_no_checks(index).last_checked()
+                    == _trie->generation();
+    }
   };  // class OverlapIteratorTrie
 }  // namespace libsemigroups::detail
 
-#endif
+#endif  // LIBSEMIGROUPS_DETAIL_OVERLAP_ITERATORS_HPP_

include/libsemigroups/detail/rewriters.hpp

@@ -172,7 +172,6 @@ namespace libsemigroups {
       virtual void report_reducing_rules(
           std::atomic_uint64_t const&,
           std::chrono::high_resolution_clock::time_point const&) const {}
-
     };  // class RewritingSystemBase
 
     ////////////////////////////////////////////////////////////////////////
@@ -386,6 +385,10 @@ namespace libsemigroups {
         return _rule_trie;
       }
 
+      [[nodiscard]] Trie& trie() noexcept {
+        return _rule_trie;
+      }
+
      private:
       ////////////////////////////////////////////////////////////////////////
       // Private member functions

include/libsemigroups/detail/rules.hpp

@@ -26,6 +26,7 @@
 #include <cstddef>  // for size_t
 #include <cstdint>  // for uint64_t
 #include <list>     // for list
+#include <string>   // for std::string
 #include <utility>  // for move
 #include <vector>   // for vector
 
@@ -273,4 +274,4 @@ namespace libsemigroups {
 
   }  // namespace detail
 }  // namespace libsemigroups
-#endif
+#endif  // LIBSEMIGROUPS_DETAIL_RULES_HPP_

include/libsemigroups/knuth-bendix-helpers.hpp

@@ -64,9 +64,9 @@ namespace libsemigroups {
     //! This function triggers a full enumeration of \p kb.
     //!
     //! \tparam Word the type of the words contained in the output range.
-    //! \tparam RewritingSystem the first template parameter for \ref_knuth_bendix.
-    //! \tparam ReductionOrder the second template parameter for
-    //! \ref_knuth_bendix.
+    //! \tparam RewritingSystem the first template parameter for
+    //! \ref_knuth_bendix. \tparam ReductionOrder the second template parameter
+    //! for \ref_knuth_bendix.
     //!
     //! \param kb the \ref_knuth_bendix instance.
     //!
@@ -79,8 +79,8 @@ namespace libsemigroups {
     template <typename Word, typename RewritingSystem, typename ReductionOrder>
     [[nodiscard]] auto
     normal_forms(KnuthBendix<Word, RewritingSystem, ReductionOrder>& kb) {
-      return detail::KnuthBendixNormalFormRange<Word, RewritingSystem, ReductionOrder>(
-          kb);
+      return detail::
+          KnuthBendixNormalFormRange<Word, RewritingSystem, ReductionOrder>(kb);
     }
 
     ////////////////////////////////////////////////////////////////////////
@@ -106,9 +106,9 @@ namespace libsemigroups {
     //!
     //! \tparam Word the type of the words contained in the output range
     //! (default: std::string).
-    //! \tparam RewritingSystem the first template parameter for \ref_knuth_bendix.
-    //! \tparam ReductionOrder the second template parameter for
-    //! \ref_knuth_bendix.
+    //! \tparam RewritingSystem the first template parameter for
+    //! \ref_knuth_bendix. \tparam ReductionOrder the second template parameter
+    //! for \ref_knuth_bendix.
     //!
     //! \param kb1 the first \ref_knuth_bendix instance.
     //! \param kb2 the second \ref_knuth_bendix instance.
@@ -128,9 +128,9 @@ namespace libsemigroups {
     //!
     //! \cong_common_warn_undecidable{Knuth-Bendix}.
     template <typename Word, typename RewritingSystem, typename ReductionOrder>
-    [[nodiscard]] std::vector<std::vector<Word>>
-    non_trivial_classes(KnuthBendix<Word, RewritingSystem, ReductionOrder>& kb1,
-                        KnuthBendix<Word, RewritingSystem, ReductionOrder>& kb2);
+    [[nodiscard]] std::vector<std::vector<Word>> non_trivial_classes(
+        KnuthBendix<Word, RewritingSystem, ReductionOrder>& kb1,
+        KnuthBendix<Word, RewritingSystem, ReductionOrder>& kb2);
 
   }  // namespace congruence_common
 
@@ -174,9 +174,9 @@ namespace libsemigroups {
     //!
     //! \tparam Word the type of the words in the
     //! \ref KnuthBendix::presentation.
-    //! \tparam RewritingSystem the first template parameter for \ref_knuth_bendix.
-    //! \tparam ReductionOrder the second template parameter for
-    //! \ref_knuth_bendix.
+    //! \tparam RewritingSystem the first template parameter for
+    //! \ref_knuth_bendix. \tparam ReductionOrder the second template parameter
+    //! for \ref_knuth_bendix.
     //!
     //! \param kb the \ref_knuth_bendix instance.
     //!
@@ -188,7 +188,8 @@ namespace libsemigroups {
     //!
     //! \sa KnuthBendix::run.
     template <typename Word, typename RewritingSystem, typename ReductionOrder>
-    void by_overlap_length(KnuthBendix<Word, RewritingSystem, ReductionOrder>& kb);
+    void
+    by_overlap_length(KnuthBendix<Word, RewritingSystem, ReductionOrder>& kb);
 
     //! \ingroup knuth_bendix_helpers_group
     //!
@@ -198,9 +199,9 @@ namespace libsemigroups {
     //!
     //! \tparam Word the type of the words in the
     //! \ref KnuthBendix::presentation.
-    //! \tparam RewritingSystem the first template parameter for \ref_knuth_bendix.
-    //! \tparam ReductionOrder the second template parameter for
-    //! \ref_knuth_bendix.
+    //! \tparam RewritingSystem the first template parameter for
+    //! \ref_knuth_bendix. \tparam ReductionOrder the second template parameter
+    //! for \ref_knuth_bendix.
     //!
     //! \param kb the \ref_knuth_bendix instance defining the rules that are to
     //! be checked for being reduced.

include/libsemigroups/obvinf.hpp

@@ -649,8 +649,8 @@ namespace libsemigroups {
   //! \note If this function returns \c false, it is still possible that the
   //! quotient defined by the \ref_knuth_bendix object \p kb is infinite.
   template <typename RewritingSystem, typename ReductionOrder>
-  bool
-  is_obviously_infinite(detail::KnuthBendixImpl<RewritingSystem, ReductionOrder>& kb) {
+  bool is_obviously_infinite(
+      detail::KnuthBendixImpl<RewritingSystem, ReductionOrder>& kb) {
     if (kb.finished()) {
       return !v4::word_graph::is_acyclic(kb.gilman_graph());
     }

include/libsemigroups/to-froidure-pin.hpp

@@ -167,8 +167,9 @@ namespace libsemigroups {
   //! \p kb.
   //!
   //! \tparam Thing used for SFINAE should be FroidurePin.
-  //! \tparam RewritingSystem the second template parameter for \ref_knuth_bendix.
-  //! \tparam ReductionOrder the third template parameter for \ref_knuth_bendix.
+  //! \tparam RewritingSystem the second template parameter for
+  //! \ref_knuth_bendix. \tparam ReductionOrder the third template parameter for
+  //! \ref_knuth_bendix.
   //!
   //! \param kb the \ref_knuth_bendix instance to convert.
   //!
@@ -180,9 +181,11 @@ namespace libsemigroups {
             typename Word,
             typename RewritingSystem,
             typename ReductionOrder>
-  auto to(KnuthBendix<Word, RewritingSystem, ReductionOrder>& kb) -> std::enable_if_t<
-      std::is_same_v<Thing<int>, FroidurePin<int>>,
-      FroidurePin<detail::KBE<KnuthBendix<Word, RewritingSystem, ReductionOrder>>>>;
+  auto to(KnuthBendix<Word, RewritingSystem, ReductionOrder>& kb)
+      -> std::enable_if_t<
+          std::is_same_v<Thing<int>, FroidurePin<int>>,
+          FroidurePin<
+              detail::KBE<KnuthBendix<Word, RewritingSystem, ReductionOrder>>>>;
 
   //! \ingroup to_froidure_pin_group
   //!

include/libsemigroups/to-froidure-pin.tpp

@@ -27,7 +27,8 @@ namespace libsemigroups {
 
   template <typename Word, typename RewritingSystem, typename ReductionOrder>
   FroidurePin(KnuthBendix<Word, RewritingSystem, ReductionOrder> const&)
-      -> FroidurePin<detail::KBE<KnuthBendix<Word, RewritingSystem, ReductionOrder>>>;
+      -> FroidurePin<
+          detail::KBE<KnuthBendix<Word, RewritingSystem, ReductionOrder>>>;
 
   FroidurePin(detail::ToddCoxeterImpl const&)->FroidurePin<detail::TCE>;
 
@@ -89,9 +90,11 @@ namespace libsemigroups {
             typename Word,
             typename RewritingSystem,
             typename ReductionOrder>
-  auto to(KnuthBendix<Word, RewritingSystem, ReductionOrder>& kb) -> std::enable_if_t<
-      std::is_same_v<Thing<int>, FroidurePin<int>>,
-      FroidurePin<detail::KBE<KnuthBendix<Word, RewritingSystem, ReductionOrder>>>> {
+  auto to(KnuthBendix<Word, RewritingSystem, ReductionOrder>& kb)
+      -> std::enable_if_t<
+          std::is_same_v<Thing<int>, FroidurePin<int>>,
+          FroidurePin<detail::KBE<
+              KnuthBendix<Word, RewritingSystem, ReductionOrder>>>> {
     size_t const n = kb.presentation().alphabet().size();
 
     if (n == 0) {

include/libsemigroups/to-presentation.hpp

@@ -130,8 +130,9 @@ namespace libsemigroups {
   //! `Presentation<WordOut>` for some type `WordOut`.
   //! \tparam WordIn the type of the rules in the presentation of the
   //! \ref_knuth_bendix object \p kb.
-  //! \tparam RewritingSystem the second template parameter for \ref_knuth_bendix.
-  //! \tparam ReductionOrder the third template parameter for \ref_knuth_bendix.
+  //! \tparam RewritingSystem the second template parameter for
+  //! \ref_knuth_bendix. \tparam ReductionOrder the third template parameter for
+  //! \ref_knuth_bendix.
   //!
   //! \param kb the \ref_knuth_bendix object from which to obtain the rules.
   //!