stephen: add support for Presentation[str]

Author: james-d-mitchell

src/libsemigroups_pybind11/stephen.py

@@ -13,9 +13,13 @@
 from typing_extensions import Self as _Self
 
 from _libsemigroups_pybind11 import (
+    InversePresentationString as _InversePresentationString,
     InversePresentationWord as _InversePresentationWord,
+    PresentationString as _PresentationString,
     PresentationWord as _PresentationWord,
+    StephenInversePresentationString as _StephenInversePresentationString,
     StephenInversePresentationWord as _StephenInversePresentationWord,
+    StephenPresentationString as _StephenPresentationString,
     StephenPresentationWord as _StephenPresentationWord,
     stephen_accepts as _stephen_accepts,
     stephen_dot as _stephen_dot,
@@ -46,8 +50,10 @@ class Stephen(_CxxWrapper):
     __doc__ = _StephenPresentationWord.__doc__
 
     _py_template_params_to_cxx_type = {
-        (_PresentationWord,): _StephenPresentationWord,
+        (_InversePresentationString,): _StephenInversePresentationString,
         (_InversePresentationWord,): _StephenInversePresentationWord,
+        (_PresentationString,): _StephenPresentationString,
+        (_PresentationWord,): _StephenPresentationWord,
     }
 
     _cxx_type_to_py_template_params = dict(

src/stephen.cpp

@@ -34,7 +34,8 @@ namespace libsemigroups {
   namespace {
     template <typename PresentationType>
     void bind_stephen(py::module& m, std::string const& name) {
-      using Stephen_ = Stephen<PresentationType>;
+      using Stephen_         = Stephen<PresentationType>;
+      using native_word_type = typename Stephen_::native_word_type;
 
       py::class_<Stephen_, Runner> thing(m,
                                          name.c_str(),
@@ -217,7 +218,7 @@ Get the input presentation.
       // in libsemigroups itself
       thing.def(
           "set_word",
-          [](Stephen_& self, word_type const& word) -> Stephen_& {
+          [](Stephen_& self, native_word_type const& word) -> Stephen_& {
             return stephen::set_word(self, word);
           },
           py::arg("word"),
@@ -545,11 +546,12 @@ been triggered already).
 
   }  // namespace
   void init_stephen(py::module& m) {
-    // TODO(2): figure out how to handle std::string Stephens once that's
-    // supported
     bind_stephen<Presentation<word_type>>(m, "StephenPresentationWord");
     bind_stephen<InversePresentation<word_type>>(
         m, "StephenInversePresentationWord");
+    bind_stephen<Presentation<std::string>>(m, "StephenPresentationString");
+    bind_stephen<InversePresentation<std::string>>(
+        m, "StephenInversePresentationString");
   }
 
 }  // namespace libsemigroups

tests/test_stephen.py

@@ -39,7 +39,6 @@
 def check_000(s):
     s.set_word([0]).run()
     assert s.word_graph().number_of_nodes() == 2
-    # TODO(1): use UNDEFINED once that works
     assert s.word_graph() == WordGraph(2, [[1, UNDEFINED], [UNDEFINED, 1]])
     assert stephen.number_of_words_accepted(s) == POSITIVE_INFINITY
     assert list(islice(stephen.words_accepted(s), 10)) == [
@@ -323,8 +322,6 @@ def test_stephen_002():
     )
 
 
-# TODO(2): add a version of all test cases for std::string once this is
-# allowed by Stephen.
 @pytest.mark.quick
 def test_stephen_003():
     """from step_hen 002"""
@@ -354,6 +351,34 @@ def test_stephen_003():
     assert stephen.accepts(S, to_word("bbaba"))
 
 
+@pytest.mark.quick
+def test_stephen_003_str():
+    """from step_hen 002"""
+    ReportGuard(False)
+    p = Presentation("ab")
+    presentation.add_rule(p, "aaa", "a")
+    presentation.add_rule(p, "bbb", "b")
+    presentation.add_rule(p, "abab", "aa")
+
+    S = Stephen(p)
+    S.set_word("bbab")
+
+    assert stephen.accepts(S, "bbaaba")
+    assert not stephen.accepts(S, "")
+    assert not stephen.accepts(S, "aaaaaaaaaa")
+    assert not stephen.accepts(S, "bbb")
+
+    S.set_word("bba")
+    assert stephen.accepts(S, "bbabb")
+    assert stephen.accepts(S, "bba")
+    assert not stephen.accepts(S, "bbb")
+    assert not stephen.accepts(S, "a")
+    assert not stephen.accepts(S, "ab")
+
+    S.set_word("bbaab")
+    assert stephen.accepts(S, "bbaba")
+
+
 @pytest.mark.quick
 def test_stephen_004():
     """from step_hen 003"""
@@ -454,6 +479,40 @@ def test_stephen_005():
     ]
 
 
+@pytest.mark.quick
+def test_stephen_005_str():
+    """from step_hen 004"""
+    ReportGuard(False)
+    p = Presentation("abc")
+    presentation.add_rule(p, "ab", "ba")
+    presentation.add_rule(p, "ac", "cc")
+    presentation.add_rule(p, "ac", "a")
+    presentation.add_rule(p, "cc", "a")
+    presentation.add_rule(p, "bc", "cc")
+    presentation.add_rule(p, "bcc", "b")
+    presentation.add_rule(p, "bc", "b")
+    presentation.add_rule(p, "cc", "b")
+    presentation.add_rule(p, "a", "b")
+
+    S = Stephen(p)
+    S.set_word("abcc").run()
+    assert stephen.accepts(S, "baac")
+    assert S.word_graph().number_of_nodes() == 3
+    assert stephen.number_of_words_accepted(S) == POSITIVE_INFINITY
+    assert list(islice(stephen.words_accepted(S), 10)) == [
+        "a",
+        "b",
+        "aa",
+        "ab",
+        "ac",
+        "ba",
+        "bb",
+        "bc",
+        "ca",
+        "cb",
+    ]
+
+
 @pytest.mark.quick
 def test_stephen_006():
     """from step_hen 005"""
@@ -1236,9 +1295,6 @@ def test_stephen_044():
         assert stephen.accepts(T.set_word(ww), ww)
 
 
-# TODO(2): add test_case_45 once we fix it
-
-
 @pytest.mark.quick
 def test_stephen_046():
     """non-inverse presentation -- operator=="""
@@ -1541,28 +1597,27 @@ def test_stephen_049():
 def test_stephen_051():
     """Incomplete Munn tree products"""
     ReportGuard(False)
-    to_word = ToWord("abcABC")
 
-    p = InversePresentation(to_word("abcABC"))
-    p.inverses(to_word("ABCabc"))
+    p = InversePresentation("abcABC")
+    p.inverses("ABCabc")
 
     S = Stephen(p)
     Si = Stephen(p)
     T = Stephen(p)
     Ti = Stephen(p)
 
-    S.set_word(to_word("aBbcaABAabCc")).run()
-    T.set_word(to_word("aBbcaABAabCc")).run()
+    S.set_word("aBbcaABAabCc").run()
+    T.set_word("aBbcaABAabCc").run()
     S *= T
     S.run()
 
-    Si.set_word(to_word("aBbcaABAabCc"))
+    Si.set_word("aBbcaABAabCc")
     Si *= T
     Si.run()
     assert Si == S
 
-    Si.set_word(to_word("aBbcaABAabCc"))
-    Ti.set_word(to_word("aBbcaABAabCc"))
+    Si.set_word("aBbcaABAabCc")
+    Ti.set_word("aBbcaABAabCc")
     Si.run()
     Si *= Ti
     Si.run()
@@ -1572,14 +1627,13 @@ def test_stephen_051():
 @pytest.mark.quick
 def test_stephen_return_policy():
     ReportGuard(False)
-    to_word = ToWord("abcABC")
 
-    p = InversePresentation(to_word("abcABC"))
-    p.inverses(to_word("ABCabc"))
+    p = InversePresentation("abcABC")
+    p.inverses("ABCabc")
 
     S = Stephen(p)
 
     assert S.copy() is not S
     assert S.init(p) is S
-    assert S.set_word([0, 1]) is S
+    assert S.set_word("ab") is S
     assert S.word_graph() is S.word_graph()