present: add make for converting string presentations to words

Author: james-d-mitchell

docs/source/presentations/present-helpers.rst

@@ -61,40 +61,45 @@ Contents
      - Reverse every rule.
 
    * - :py:func:`normalize_alphabet`
-     - Modify the presentation so that the alphabet is :math:`\{0, \ldots, n - 1\}` (or equivalent), and rewrites the rules to use this alphabet.
+     - Modify the presentation so that the alphabet is :math:`\{0, \ldots, n -
+       1\}` (or equivalent), and rewrites the rules to use this alphabet.
+
+   * - :py:func:`make`
+     - Make a presentation from another type of presentation or a
+       ``FroidurePin`` instance.
 
 Full API
 --------
 
 .. py:function:: redundant_rule(p: Presentation, t: datetime.timedelta) -> int
 
    Return the index of the the left hand side of a redundant rule.
- 
+
    Starting with the last rule in the presentation, this function attempts to
    run the Knuth-Bendix algorithm on the rules of the presentation except for
    the given omitted rule. For every such omitted rule, Knuth-Bendix is run for
    the length of time indicated by the second parameter ``t`` and then it is
    checked if the omitted rule can be shown to be redundant (rewriting both
    sides of the omitted rule using the other rules using the output of the, not
    necessarily finished, Knuth-Bendix algorithm).
- 
+
    If the omitted rule can be shown to be redundant in this way, then the index
    of its left hand side is returned.
- 
+
    If no rule can be shown to be redundant in this way, then ``len(p.rules)``
    is returned.
- 
+
    :warning:
      The progress of the Knuth-Bendix algorithm may differ between different
      calls to this function even if the parameters are identical. As such this
      is non-deterministic, and may produce different results with the same
      input.
- 
+
    :param p: the presentation.
    :type p: Presentation
    :param t: time to run KnuthBendix for every omitted rule
    :type t: datetime.timedelta
- 
+
    :return: The index of a redundant rule (if any).
 
    **Example**::
@@ -111,19 +116,19 @@ Full API
 .. py:function:: add_rule(p: Presentation, lhop: Union[str, List[int]], rhop: Union[str, List[int]]) -> None
 
    Add a rule to the presentation.
-   
+
    Adds the rule with left hand side ``lhop`` and right hand side ``rhop``
    to the rules.
-   
+
    :param p: the presentation
    :type p: Presentation
    :param lhop: the left hand side of the rule
    :type lhop: str or List[int]
    :param rhop: the right hand side of the rule
    :type rhop: str or List[int]
-   
+
    :returns: None
-   
+
    :warning:
      No checks that the arguments describe words over the alphabet of the
      presentation are performed.
@@ -205,7 +210,7 @@ Full API
       p.rules  # ['ac', 'a', 'ca', 'a', 'bc', 'b', 'cb', 'b', 'cc', 'c']
 
 .. py:function:: add_inverse_rules(p: Presentation, vals: Union[str, List[int], e: Union[str, int]) -> None
-   
+
    Add rules for inverses.
 
    The letter ``a`` with index ``i`` in ``vals`` is the inverse of the letter in the alphabet
@@ -362,4 +367,25 @@ Full API
    :param p: the presentation
    :type p: Presentation
 
-   :returns: None   
+   :returns: None
+
+.. py:function:: make(p: Presentation) -> Presentation
+
+   Converts a presentation over strings to one over lists of integers or vice
+   versa.
+
+   :param p: the presentation
+   :type p: Presentation
+
+   :returns: A ``Presentation``.
+
+.. py:function:: make(S: FroidurePin) -> Presentation
+   :noindex:
+
+   Returns a presentation defining a semigroup isomorphic to that represented
+   by a ``FroidurePin`` instance.
+
+   :param S: the ``FroidurePin`` instance.
+   :type S: FroidurePin
+
+   :returns: A ``Presentation``.

libsemigroups_pybind11/presentation.py

@@ -33,7 +33,7 @@
     redundant_rule_strings,
     redundant_rule_words,
     FroidurePinBase,
-    make_from_froidure_pin,
+    make,
 )
 
 
@@ -51,11 +51,10 @@ def Presentation(arg):
     elif isinstance(arg, list) and all(isinstance(x, int) for x in arg):
         result = PresentationWords()
         result.alphabet(arg)
-    elif isinstance(arg, FroidurePinBase):
-        result = make_from_froidure_pin(arg)
     else:
-        # TODO update this string
-        raise TypeError("expected string or list of ints argument")
+        raise TypeError(
+            "expected the argument to be a Presentation, string, or list of ints"
+        )
     return result
 
 

src/present.cpp

@@ -46,7 +46,7 @@ namespace libsemigroups {
   namespace {
 
     template <typename T>
-    std::string presentation_repr(Presentation<T> &p) {
+    std::string presentation_repr(Presentation<T>& p) {
       // FIXME presentation::length does not take const refs but refs and so we
       // must do the same.
       std::ostringstream out;
@@ -59,18 +59,18 @@ namespace libsemigroups {
     }
 
     template <typename T>
-    void bind_present(py::module &m, std::string const &name) {
+    void bind_present(py::module& m, std::string const& name) {
       using size_type = typename Presentation<T>::size_type;
 
       py::class_<Presentation<T>>(m, name.c_str())
           .def(py::init<>())
-          .def(py::init<Presentation<T> const &>())
+          .def(py::init<Presentation<T> const&>())
           .def("alphabet",
                py::overload_cast<>(&Presentation<T>::alphabet, py::const_))
           .def("alphabet",
                py::overload_cast<size_type>(&Presentation<T>::alphabet))
           .def("alphabet",
-               py::overload_cast<T const &>(&Presentation<T>::alphabet))
+               py::overload_cast<T const&>(&Presentation<T>::alphabet))
           .def("alphabet_from_rules", &Presentation<T>::alphabet_from_rules)
           .def("letter", &Presentation<T>::letter)
           .def("index", &Presentation<T>::index)
@@ -89,10 +89,10 @@ namespace libsemigroups {
           .def("__repr__", &presentation_repr<T>);
 
       m.def("add_rule",
-            py::overload_cast<Presentation<T> &, T const &, T const &>(
+            py::overload_cast<Presentation<T>&, T const&, T const&>(
                 &presentation::add_rule<T>));
       m.def("add_rule_and_check",
-            py::overload_cast<Presentation<T> &, T const &, T const &>(
+            py::overload_cast<Presentation<T>&, T const&, T const&>(
                 &presentation::add_rule_and_check<T>));
       m.def("add_rules", &presentation::add_rules<T>);
       m.def("add_identity_rules", &presentation::add_identity_rules<T>);
@@ -103,21 +103,35 @@ namespace libsemigroups {
       m.def("sort_rules", &presentation::sort_rules<T>);
       m.def("longest_common_subword", &presentation::longest_common_subword<T>);
       m.def("replace_subword",
-            py::overload_cast<Presentation<T> &, T const &>(
+            py::overload_cast<Presentation<T>&, T const&>(
                 &presentation::replace_subword<T>));
       m.def("length", &presentation::length<T>);
       m.def("reverse", &presentation::reverse<T>);
       m.def("normalize_alphabet", &presentation::normalize_alphabet<T>);
 
       m.def(
-          "make_from_froidure_pin",
-          py::overload_cast<FroidurePinBase &>(&make<Presentation<word_type>>));
-
-      // TODO add make
+          "make",
+          py::overload_cast<FroidurePinBase&>(&make<Presentation<word_type>>));
+
+      m.def("make",
+            [](Presentation<std::string> const& p) -> Presentation<word_type> {
+              return make<Presentation<word_type>>(p);
+            });
+
+      m.def("make",
+            [](Presentation<word_type> const& p) -> Presentation<std::string> {
+              return make<Presentation<std::string>>(p);
+            });
+
+      m.def("make",
+            [](Presentation<word_type> const& p,
+               std::string const&             s) -> Presentation<std::string> {
+              return make<Presentation<word_type>>(p, s);
+            });
     }
   }  // namespace
 
-  void init_present(py::module &m) {
+  void init_present(py::module& m) {
     bind_present<word_type>(m, "PresentationWords");
     bind_present<std::string>(m, "PresentationStrings");
   }

tests/test_present.py

@@ -647,3 +647,40 @@ def test_helpers_longest_common_subword_019():
 def test_redundant_rule_020():
     check_redundant_rule(to_word)
     check_redundant_rule(to_string)
+
+
+def test_make_021():
+    p = Presentation([])
+    presentation.add_rule(p, [0, 1, 2, 1], [1, 2, 1])
+    presentation.add_rule(p, [1, 2, 1], [1, 1, 2, 1])
+    presentation.add_rule(p, [1, 1, 2, 1], [1, 1])
+    presentation.add_rule(p, [1, 1], [1, 2, 1])
+    presentation.add_rule(p, [1, 2, 1], [0])
+    p.alphabet_from_rules()
+    p = presentation.make(p, "abc")
+    assert p.rules == [
+        "abcb",
+        "bcb",
+        "bcb",
+        "bbcb",
+        "bbcb",
+        "bb",
+        "bb",
+        "bcb",
+        "bcb",
+        "a",
+    ]
+
+    p = presentation.make(p)
+    assert p.rules == [
+        [0, 1, 2, 1],
+        [1, 2, 1],
+        [1, 2, 1],
+        [1, 1, 2, 1],
+        [1, 1, 2, 1],
+        [1, 1],
+        [1, 1],
+        [1, 2, 1],
+        [1, 2, 1],
+        [0],
+    ]

tests/test_sims1.py

@@ -185,7 +185,7 @@ def test_case_sims1_006():
     assert S.number_of_generators() == 3
     assert S.number_of_rules() == 16
     C = Sims1(congruence_kind.right)
-    C.short_rules(Presentation(S))
+    C.short_rules(presentation.make(S))
     assert C.number_of_congruences(27) == 287
 
 
@@ -196,7 +196,7 @@ def test_case_sims1_007():
     assert S.number_of_generators() == 3
     assert S.number_of_rules() == 16
     C = Sims1(congruence_kind.left)
-    C.short_rules(Presentation(S))
+    C.short_rules(presentation.make(S))
     assert C.number_of_congruences(27) == 120