diff --git a/docs/pictures/to-table.svg b/docs/pictures/to-table.svg
index b41772cd..6b8300fc 100644
--- a/docs/pictures/to-table.svg
+++ b/docs/pictures/to-table.svg
@@ -1,10 +1,10 @@
diff --git a/docs/pictures/to-table.tex b/docs/pictures/to-table.tex
index b4e2aa03..2df37a67 100644
--- a/docs/pictures/to-table.tex
+++ b/docs/pictures/to-table.tex
@@ -35,8 +35,8 @@
\xmark & \xmark & \xmark & \xmark & \xmark & \xmark & \xmark & \cmark \\\hline
\texttt{to(*args, rtype=Konieczny)} & \xmark & \xmark &
\xmark & \xmark & \xmark & \xmark & \xmark & \xmark & \xmark & \xmark \\\hline
- \texttt{to(*args, rtype=Presentation)} & \xmark & \cmark &
- \xmark & \xmark & \cmark & \xmark & \cmark & \xmark & \xmark & \xmark \\\hline
+ \texttt{to(*args, rtype=Presentation)} & \cmark & \cmark &
+ \xmark & \cmark & \cmark & \xmark & \cmark & \xmark & \cmark & \cmark \\\hline
\texttt{to(*args, rtype=SchreierSims)} & \xmark & \xmark &
\xmark & \xmark & \xmark & \xmark & \xmark & \xmark & \xmark & \xmark \\\hline
\texttt{to(*args, rtype=Stephen)} & \xmark & \xmark &
diff --git a/docs/source/data-structures/presentations/to-present.rst b/docs/source/data-structures/presentations/to-present.rst
index f47f1c00..f9b93ed8 100644
--- a/docs/source/data-structures/presentations/to-present.rst
+++ b/docs/source/data-structures/presentations/to-present.rst
@@ -29,8 +29,12 @@ possible:
- :ref:`presentation-to-presentation`;
- :ref:`presentation-and-function-to-presentation`;
- - :ref:`knuth-bendix-to-presentation`; and
- - :ref:`froidure-pin-to-presentation`.
+ - :ref:`knuth-bendix-to-presentation`;
+ - :ref:`froidure-pin-to-presentation`;
+ - :ref:`kambites-to-presentation`;
+ - :ref:`todd-coxeter-to-presentation`;
+ - :ref:`congruence-to-presentation`; and
+ - :ref:`stephen-to-presentation`.
.. _presentation-to-presentation:
@@ -266,3 +270,245 @@ to calling this function.
>>> p = to(S, rtype=(Presentation, str))
>>> len(p.alphabet()) == 4
True
+
+.. _kambites-to-presentation:
+
+Converting a :any:`Kambites` to a :any:`Presentation`
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To construct a :any:`Presentation` from a :any:`Kambites`, specify the
+following values for *args*:
+
+ - **k** (:any:`Kambites`) -- the :any:`Kambites` from which to obtain
+ the presentation.
+
+Additionally, specify one of the following for *Return*:
+
+ - ``(Presentation,)`` for constructing a :any:`Presentation` over words of
+ the same type as that in *k*.
+ - ``(Presentation, str)`` for constructing a :any:`Presentation` over words
+ of type ``str``.
+ - ``(Presentation, list[int])`` for constructing a :any:`Presentation` over
+ words of type ``list[int]``.
+
+This function constructs and returns a :any:`Presentation` object that is
+equivalent to the presentation used to construct the :any:`Kambites` object.
+When the word type matches, this function returns a reference to ``k.presentation()``.
+When the word types differ, a converted copy is returned.
+
+No computation is performed by this function; it simply retrieves the
+presentation that was used to define the :any:`Kambites` object.
+
+.. seealso::
+
+ - :any:`Kambites.presentation`.
+
+.. doctest:: Python
+
+ >>> from libsemigroups_pybind11 import (
+ ... congruence_kind,
+ ... Kambites,
+ ... Presentation,
+ ... presentation,
+ ... to,
+ ... )
+
+ >>> p = Presentation([5, 6, 7, 8, 9])
+ >>> presentation.add_rule(p, [5, 6], [7])
+ >>> presentation.add_rule(p, [6, 7], [8])
+ >>> presentation.add_rule(p, [7, 8], [9])
+ >>> presentation.add_rule(p, [8, 9], [5])
+ >>> presentation.add_rule(p, [9, 5], [6])
+
+ >>> k = Kambites(congruence_kind.twosided, p)
+ >>> result = to(k, rtype=(Presentation, list[int]))
+ >>> result == p
+ True
+
+ >>> result_str = to(k, rtype=(Presentation, str))
+ >>> result_str.alphabet()
+ 'abcde'
+ >>> result_str.rules
+ ['ab', 'c', 'bc', 'd', 'cd', 'e', 'de', 'a', 'ea', 'b']
+
+.. _todd-coxeter-to-presentation:
+
+Converting a :any:`ToddCoxeter` to a :any:`Presentation`
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To construct a :any:`Presentation` from a :any:`ToddCoxeter`, specify the
+following values for *args*:
+
+ - **tc** (:any:`ToddCoxeter`) -- the :any:`ToddCoxeter` from which to obtain
+ the presentation.
+
+Additionally, specify one of the following for *Return*:
+
+ - ``(Presentation,)`` for constructing a :any:`Presentation` over words of
+ the same type as that in *tc*.
+ - ``(Presentation, str)`` for constructing a :any:`Presentation` over words
+ of type ``str``.
+ - ``(Presentation, list[int])`` for constructing a :any:`Presentation` over
+ words of type ``list[int]``.
+
+This function constructs and returns a :any:`Presentation` object that is
+equivalent to the presentation used to construct the :any:`ToddCoxeter` object.
+When the word type matches, this function returns a reference to ``tc.presentation()``.
+When the word types differ, a converted copy is returned.
+
+No computation is performed by this function; it simply retrieves the
+presentation that was used to define the :any:`ToddCoxeter` object.
+
+.. seealso::
+
+ - :any:`ToddCoxeter.presentation`.
+
+.. doctest:: Python
+
+ >>> from libsemigroups_pybind11 import (
+ ... congruence_kind,
+ ... ToddCoxeter,
+ ... Presentation,
+ ... presentation,
+ ... to,
+ ... )
+
+ >>> p = Presentation([5, 6, 7, 8, 9])
+ >>> presentation.add_rule(p, [5, 6], [7])
+ >>> presentation.add_rule(p, [6, 7], [8])
+ >>> presentation.add_rule(p, [7, 8], [9])
+ >>> presentation.add_rule(p, [8, 9], [5])
+ >>> presentation.add_rule(p, [9, 5], [6])
+
+ >>> tc = ToddCoxeter(congruence_kind.twosided, p)
+ >>> result = to(tc, rtype=(Presentation, list[int]))
+ >>> result == p
+ True
+
+ >>> result_str = to(tc, rtype=(Presentation, str))
+ >>> result_str.alphabet()
+ 'abcde'
+ >>> result_str.rules
+ ['ab', 'c', 'bc', 'd', 'cd', 'e', 'de', 'a', 'ea', 'b']
+
+.. _congruence-to-presentation:
+
+Converting a :any:`Congruence` to a :any:`Presentation`
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To construct a :any:`Presentation` from a :any:`Congruence`, specify the
+following values for *args*:
+
+ - **c** (:any:`Congruence`) -- the :any:`Congruence` from which to obtain
+ the presentation.
+
+Additionally, specify one of the following for *Return*:
+
+ - ``(Presentation,)`` for constructing a :any:`Presentation` over words of
+ the same type as that in *c*.
+ - ``(Presentation, str)`` for constructing a :any:`Presentation` over words
+ of type ``str``.
+ - ``(Presentation, list[int])`` for constructing a :any:`Presentation` over
+ words of type ``list[int]``.
+
+This function constructs and returns a :any:`Presentation` object that is
+equivalent to the presentation used to construct the :any:`Congruence` object.
+When the word type matches, this function returns a reference to ``c.presentation()``.
+When the word types differ, a converted copy is returned.
+
+No computation is performed by this function; it simply retrieves the
+presentation that was used to define the :any:`Congruence` object. Note that
+any generating pairs added via :any:`Congruence.add_generating_pair`
+are not included in the returned presentation.
+
+.. seealso::
+
+ - :any:`Congruence.presentation`; and
+ - :any:`Congruence.add_generating_pair`.
+
+.. doctest:: Python
+
+ >>> from libsemigroups_pybind11 import (
+ ... congruence_kind,
+ ... Congruence,
+ ... Presentation,
+ ... presentation,
+ ... to,
+ ... )
+
+ >>> p = Presentation("abc")
+ >>> presentation.add_rule(p, "aa", "b")
+ >>> presentation.add_rule(p, "bb", "c")
+ >>> presentation.add_rule(p, "cc", "a")
+
+ >>> c = Congruence(congruence_kind.twosided, p)
+ >>> result = to(c, rtype=(Presentation, str))
+ >>> result == p
+ True
+
+ >>> result_word = to(c, rtype=(Presentation, list[int]))
+ >>> result_word.alphabet()
+ [0, 1, 2]
+ >>> result_word.rules
+ [[0, 0], [1], [1, 1], [2], [2, 2], [0]]
+
+.. _stephen-to-presentation:
+
+Converting a :any:`Stephen` to a :any:`Presentation`
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+To construct a :any:`Presentation` from a :any:`Stephen`, specify the
+following values for *args*:
+
+ - **s** (:any:`Stephen`) -- the :any:`Stephen` from which to obtain
+ the presentation.
+
+Additionally, specify one of the following for *Return*:
+
+ - ``(Presentation,)`` for constructing a :any:`Presentation` over words of
+ the same type as that in *s*.
+ - ``(Presentation, str)`` for constructing a :any:`Presentation` over words
+ of type ``str``.
+ - ``(Presentation, list[int])`` for constructing a :any:`Presentation` over
+ words of type ``list[int]``.
+
+This function constructs and returns a :any:`Presentation` object that is
+equivalent to the presentation used to construct the :any:`Stephen` object.
+A converted copy is always returned (even when word types match).
+
+No computation is performed by this function; it simply retrieves the
+presentation that was used to define the :any:`Stephen` object. Note that
+:any:`Stephen` can be constructed from either a :any:`Presentation` or an
+:any:`InversePresentation`; in both cases, this function returns a
+:any:`Presentation`.
+
+.. seealso::
+
+ - :any:`Stephen.presentation`.
+
+.. doctest:: Python
+
+ >>> from libsemigroups_pybind11 import (
+ ... Stephen,
+ ... Presentation,
+ ... presentation,
+ ... to,
+ ... )
+
+ >>> p = Presentation([5, 6, 7, 8, 9])
+ >>> presentation.add_rule(p, [5, 6], [7])
+ >>> presentation.add_rule(p, [6, 7], [8])
+ >>> presentation.add_rule(p, [7, 8], [9])
+ >>> presentation.add_rule(p, [8, 9], [5])
+ >>> presentation.add_rule(p, [9, 5], [6])
+
+ >>> s = Stephen(p)
+ >>> result = to(s, rtype=(Presentation, list[int]))
+ >>> result == p
+ True
+
+ >>> result_str = to(s, rtype=(Presentation, str))
+ >>> result_str.alphabet()
+ 'abcde'
+ >>> result_str.rules
+ ['ab', 'c', 'bc', 'd', 'cd', 'e', 'de', 'a', 'ea', 'b']
diff --git a/src/to-presentation.cpp b/src/to-presentation.cpp
index e4c6aa05..894ce75c 100644
--- a/src/to-presentation.cpp
+++ b/src/to-presentation.cpp
@@ -18,18 +18,25 @@
// C++ std headers
#include // for function
-#include // for string, basic_string, oper...
+#include
+#include // for string, basic_string, oper...
+#include // for Congruence
+#include // for MultiView
#include // for FroidurePinBase
+#include // for Kambites
#include // for KnuthBendix
#include // for Presentation
+#include // for Stephen
#include // for to
+#include // for ToddCoxeter
#include // for word_type
#include
#include // for class_, init, module
#include "main.hpp" // for init_present
+#include "todd-coxeter-class.hpp"
namespace libsemigroups {
namespace py = pybind11;
@@ -75,6 +82,84 @@ namespace libsemigroups {
[](FroidurePinBase& fp) { return to>(fp); });
}
+ template
+ void bind_stephen_to_pres(py::module& m, std::string const& name) {
+ std::string fn_name = std::string("to_presentation_") + name;
+ m.def(fn_name.c_str(),
+ [](Stephen& s) { return to>(s); });
+ }
+
+ ////////////////////////////////////////////////////////////////////////////
+ // For when WordIn == WordOut (return reference)
+ ////////////////////////////////////////////////////////////////////////////
+
+ template
+ void bind_kambites_to_pres_same_word(py::module& m,
+ std::string const& name) {
+ std::string fn_name = std::string("to_presentation_") + name;
+ m.def(
+ fn_name.c_str(),
+ [](Kambites& k) -> Presentation const& {
+ return to>(k);
+ },
+ py::return_value_policy::reference_internal);
+ }
+
+ template
+ void bind_congruence_to_pres_same_word(py::module& m,
+ std::string const& name) {
+ std::string fn_name = std::string("to_presentation_") + name;
+ m.def(
+ fn_name.c_str(),
+ [](Congruence& c) -> Presentation const& {
+ return to>(c);
+ },
+ py::return_value_policy::reference_internal);
+ }
+
+ template
+ void bind_todd_coxeter_to_pres_same_word(py::module& m,
+ std::string const& name) {
+ std::string fn_name = std::string("to_presentation_") + name;
+ m.def(fn_name.c_str(),
+ [](ToddCoxeter& tc) -> Presentation const& {
+ return to>(tc);
+ });
+ }
+
+ ////////////////////////////////////////////////////////////////////////////
+ // For when WordIn != WordOut (return value)
+ ////////////////////////////////////////////////////////////////////////////
+
+ template
+ void bind_kambites_to_pres_diff_word(py::module& m,
+ std::string const& name) {
+ std::string fn_name = std::string("to_presentation_") + name;
+ m.def(fn_name.c_str(),
+ [](Kambites& k) { return to>(k); });
+ }
+
+ template
+ void bind_congruence_to_pres_diff_word(py::module& m,
+ std::string const& name) {
+ std::string fn_name = std::string("to_presentation_") + name;
+ m.def(fn_name.c_str(),
+ [](Congruence& c) { return to>(c); });
+ }
+
+ template
+ void bind_todd_coxeter_to_pres_diff_word(py::module& m,
+ std::string const& name) {
+ std::string fn_name = std::string("to_presentation_") + name;
+ m.def(fn_name.c_str(), [](ToddCoxeter& tc) {
+ return to>(tc);
+ });
+ }
+
+ ////////////////////////////////////////////////////////////////////////////
+ // For InversePresentation
+ ////////////////////////////////////////////////////////////////////////////
+
template
void bind_pres_to_inv_pres(py::module& m) {
m.def("to_inverse_presentation", [](Presentation const& p) {
@@ -101,6 +186,7 @@ namespace libsemigroups {
typename InversePresentation::letter_type)>&&
f) { return to>(ip, f); });
}
+
} // namespace
void init_to_present(py::module& m) {
@@ -148,6 +234,35 @@ namespace libsemigroups {
bind_fp_to_pres(m, "string");
bind_fp_to_pres(m, "word");
+ // From Kambites
+ bind_kambites_to_pres_same_word(m, "string");
+ bind_kambites_to_pres_same_word(m, "word");
+ bind_kambites_to_pres_diff_word(m, "word");
+ bind_kambites_to_pres_diff_word(m, "string");
+ bind_kambites_to_pres_diff_word, word_type>(
+ m, "word");
+ bind_kambites_to_pres_diff_word,
+ std::string>(m, "string");
+
+ // From Congruence
+ bind_congruence_to_pres_same_word(m, "string");
+ bind_congruence_to_pres_same_word(m, "word");
+ bind_congruence_to_pres_diff_word(m, "string");
+ bind_congruence_to_pres_diff_word(m, "word");
+
+ // From Stephen
+ bind_stephen_to_pres, word_type>(m, "word");
+ bind_stephen_to_pres, std::string>(m, "string");
+ bind_stephen_to_pres, word_type>(m, "word");
+ bind_stephen_to_pres, std::string>(m,
+ "string");
+
+ // From ToddCoxeter
+ bind_todd_coxeter_to_pres_same_word(m, "string");
+ bind_todd_coxeter_to_pres_same_word(m, "word");
+ bind_todd_coxeter_to_pres_diff_word(m, "string");
+ bind_todd_coxeter_to_pres_diff_word(m, "word");
+
////////////////////////////////////////////////////////////////////////////
// to
////////////////////////////////////////////////////////////////////////////
diff --git a/tests/test_to.py b/tests/test_to.py
index ddf3ecc2..b2dc3c0d 100644
--- a/tests/test_to.py
+++ b/tests/test_to.py
@@ -33,6 +33,7 @@
KnuthBendix,
Presentation,
ReportGuard,
+ Stephen,
ToddCoxeter,
Transf,
WordGraph,
@@ -81,11 +82,33 @@ def sample_froidure_pin():
return S
+def sample_kambites_from_pres(Word):
+ p = sample_pres(Word)
+ S = Kambites(congruence_kind.twosided, p)
+ return S
+
+
def cong_from_sample_pres(ReturnType, Word, **kwargs):
p = sample_pres(Word)
return ReturnType(congruence_kind.twosided, p, **kwargs)
+def stephen_from_sample_pres(PresType, Word):
+ p = sample_pres(Word)
+ if PresType is InversePresentation:
+ p = InversePresentation(p)
+ if Word is str:
+ p.inverses("ba")
+ else:
+ p.inverses([1, 0])
+ s = Stephen(p)
+ if Word is str:
+ s.set_word("ab").run()
+ else:
+ s.set_word([0, 1]).run()
+ return s
+
+
def check_cong_to_froidure_pin(Type, Word, **kwargs):
thing = cong_from_sample_pres(Type, Word, **kwargs)
fp = to(thing, rtype=(FroidurePin,))
@@ -137,6 +160,39 @@ def check_froidure_pin_to_pres(Word):
assert isinstance(p, Presentation)
+def check_kambites_to_pres(WordIn, WordOut):
+ S = sample_kambites_from_pres(WordIn)
+
+ p = to(S, rtype=(Presentation, WordOut))
+ assert len(p.alphabet()) == len(S.presentation().alphabet())
+ assert len(p.rules) == len(S.presentation().rules)
+
+ # Kambites uses MultiViewString which returns value
+ if WordIn is not str and WordIn == WordOut:
+ assert id(to_cxx(p)) == id(to_cxx(S.presentation()))
+
+
+def check_cong_to_pres(Type, WordIn, WordOut):
+ S = cong_from_sample_pres(Type, WordIn)
+ s_pres = S.presentation()
+
+ p = to(S, rtype=(Presentation, WordOut))
+ assert len(p.alphabet()) == len(s_pres.alphabet())
+ assert len(p.rules) == len(s_pres.rules)
+
+ if WordIn == WordOut:
+ assert id(to_cxx(p)) == id(to_cxx(s_pres))
+
+
+def check_stephen_to_pres(PresType, WordIn, WordOut):
+ s = stephen_from_sample_pres(PresType, WordIn)
+ s_pres = s.presentation()
+
+ p = to(s, rtype=(Presentation, WordOut))
+ assert len(p.alphabet()) == len(s_pres.alphabet())
+ assert len(p.rules) == len(s_pres.rules)
+
+
def check_froidure_pin_to_knuth_bendix(Word, Rewriter):
S = sample_froidure_pin()
kb = to(congruence_kind.twosided, S, rtype=(KnuthBendix, Word, Rewriter))
@@ -615,6 +671,82 @@ def test_to_Presentation_029():
check_froidure_pin_to_pres(list[int])
+# From Kambites
+
+
+def test_to_Presentation_030():
+ check_kambites_to_pres(str, str)
+
+
+def test_to_Presentation_031():
+ check_kambites_to_pres(list[int], list[int])
+
+
+def test_to_Presentation_032():
+ check_kambites_to_pres(str, list[int])
+
+
+def test_to_Presentation_033():
+ check_kambites_to_pres(list[int], str)
+
+
+# From Congruence
+
+
+def test_to_Presentation_034():
+ check_cong_to_pres(Congruence, str, str)
+
+
+def test_to_Presentation_035():
+ check_cong_to_pres(Congruence, list[int], list[int])
+
+
+def test_to_Presentation_036():
+ check_cong_to_pres(Congruence, str, list[int])
+
+
+def test_to_Presentation_037():
+ check_cong_to_pres(Congruence, list[int], str)
+
+
+# From ToddCoxeter
+
+
+def test_to_Presentation_038():
+ check_cong_to_pres(ToddCoxeter, str, str)
+
+
+def test_to_Presentation_039():
+ check_cong_to_pres(ToddCoxeter, list[int], list[int])
+
+
+def test_to_Presentation_040():
+ check_cong_to_pres(ToddCoxeter, str, list[int])
+
+
+def test_to_Presentation_041():
+ check_cong_to_pres(ToddCoxeter, list[int], str)
+
+
+# From Stephen
+
+
+def test_to_Presentation_042():
+ check_stephen_to_pres(Presentation, list[int], list[int])
+
+
+def test_to_Presentation_043():
+ check_stephen_to_pres(Presentation, list[int], str)
+
+
+def test_to_Presentation_044():
+ check_stephen_to_pres(InversePresentation, list[int], list[int])
+
+
+def test_to_Presentation_045():
+ check_stephen_to_pres(InversePresentation, list[int], str)
+
+
###############################################################################
# InversePresentation
###############################################################################
@@ -622,7 +754,7 @@ def test_to_Presentation_029():
# From InversePresentation
-def test_to_InversePresentation_030():
+def test_to_InversePresentation_046():
ip = InversePresentation("abc")
ip.inverses("cba")
presentation.add_rule(ip, "aaa", "b")
@@ -644,7 +776,7 @@ def test_to_InversePresentation_030():
# From function + InversePresentation
-def test_to_InversePresentation_031():
+def test_to_InversePresentation_047():
ip = InversePresentation("abc")
ip.inverses("cba")
presentation.add_rule(ip, "aaa", "b")
@@ -674,7 +806,7 @@ def test_to_InversePresentation_031():
# From Presentation
-def test_to_InversePresentation_032():
+def test_to_InversePresentation_048():
p = Presentation("abc")
presentation.add_rule(p, "aaa", "b")
presentation.add_rule(p, "bac", "cab")
@@ -705,23 +837,23 @@ def test_to_InversePresentation_032():
# From FroidurePin
-def test_to_KnuthBendix_033():
+def test_to_KnuthBendix_049():
kb = check_froidure_pin_to_knuth_bendix(str, "RewriteFromLeft")
assert isinstance(kb, KnuthBendix)
assert kb.py_template_params == (str, "RewriteFromLeft")
-def test_to_KnuthBendix_034():
+def test_to_KnuthBendix_050():
kb = check_froidure_pin_to_knuth_bendix(str, "RewriteTrie")
assert isinstance(kb, KnuthBendix)
-def test_to_KnuthBendix_035():
+def test_to_KnuthBendix_051():
kb = check_froidure_pin_to_knuth_bendix(list[int], "RewriteFromLeft")
assert isinstance(kb, KnuthBendix)
-def test_to_KnuthBendix_036():
+def test_to_KnuthBendix_052():
kb = check_froidure_pin_to_knuth_bendix(list[int], "RewriteTrie")
assert isinstance(kb, KnuthBendix)
@@ -729,22 +861,22 @@ def test_to_KnuthBendix_036():
# From ToddCoxeter + Rewriter
-def test_to_KnuthBendix_037():
+def test_to_KnuthBendix_053():
kb = check_todd_coxeter_to_knuth_bendix(str, "RewriteFromLeft")
assert isinstance(kb, KnuthBendix)
-def test_to_KnuthBendix_038():
+def test_to_KnuthBendix_054():
kb = check_todd_coxeter_to_knuth_bendix(str, "RewriteTrie")
assert isinstance(kb, KnuthBendix)
-def test_to_KnuthBendix_039():
+def test_to_KnuthBendix_055():
kb = check_todd_coxeter_to_knuth_bendix(list[int], "RewriteFromLeft")
assert isinstance(kb, KnuthBendix)
-def test_to_KnuthBendix_040():
+def test_to_KnuthBendix_056():
kb = check_todd_coxeter_to_knuth_bendix(list[int], "RewriteTrie")
assert isinstance(kb, KnuthBendix)
@@ -752,13 +884,13 @@ def test_to_KnuthBendix_040():
# From ToddCoxeter
-def test_to_KnuthBendix_041():
+def test_to_KnuthBendix_057():
kb = check_todd_coxeter_to_knuth_bendix_default(str)
# RewriteTrie is the default rewriter
assert isinstance(kb, KnuthBendix)
-def test_to_KnuthBendix_042():
+def test_to_KnuthBendix_058():
kb = check_todd_coxeter_to_knuth_bendix_default(list[int])
# RewriteTrie is the default rewriter
assert isinstance(kb, KnuthBendix)
@@ -771,13 +903,13 @@ def test_to_KnuthBendix_042():
# From FroidurePin
-def test_to_Congruence_043():
+def test_to_Congruence_059():
c = check_froidure_pin_to_congruence(str)
assert isinstance(c, Congruence)
assert c.py_template_params == (str,)
-def test_to_Congruence_044():
+def test_to_Congruence_060():
c = check_froidure_pin_to_congruence(list[int])
assert isinstance(c, Congruence)
assert c.py_template_params == (list[int],)