Replace len-lex -> lenlex

Author: james-d-mitchell

src/order.cpp

@@ -131,7 +131,7 @@ Letters are compared by their positions in *alphabet*.
           R"pbdoc(
 :sig=(x: str | list[int], y: str | list[int]) -> bool:
 :only-document-once:
-Compare two words using len-lex ordering.
+Compare two words using lenlex ordering.
 
 Words are first ordered by length and then lexicographically.
 
@@ -162,7 +162,7 @@ Words are first ordered by length and then lexicographically.
           R"pbdoc(
 :sig=(alphabet: Alphabet, x: str | list[int], y: str | list[int]) -> bool:
 :only-document-once:
-Compare two words using len-lex ordering and an alphabet.
+Compare two words using lenlex ordering and an alphabet.
 
 Words are first ordered by length and then lexicographically, with letters
 compared by their positions in *alphabet*.
@@ -255,7 +255,7 @@ from right to left before being compared.
           R"pbdoc(
 :sig=(x: str | list[int], y: str | list[int]) -> bool:
 :only-document-once:
-Compare two words using reversed len-lex ordering.
+Compare two words using reversed lenlex ordering.
 
 Words are first ordered by length and then lexicographically after being read
 from right to left.
@@ -285,7 +285,7 @@ from right to left.
           R"pbdoc(
 :sig=(alphabet: Alphabet, x: str | list[int], y: str | list[int]) -> bool:
 :only-document-once:
-Compare two words using alphabet-aware reversed len-lex ordering.
+Compare two words using alphabet-aware reversed lenlex ordering.
 
 Words are first ordered by length and then lexicographically after being read
 from right to left. Letters are compared by their positions in *alphabet*.
@@ -320,7 +320,7 @@ from right to left. Letters are compared by their positions in *alphabet*.
           R"pbdoc(
 :sig=(weights: list[int], x: str | list[int], y: str | list[int]) -> bool:
 :only-document-once:
-Compare two words using weighted len-lex ordering.
+Compare two words using weighted lenlex ordering.
 
 The *i*-th entry of *weights* is the weight assigned to generator *i*.
 Words are first ordered by their total weight, then by length, and finally
@@ -357,7 +357,7 @@ lexicographically.
           R"pbdoc(
 :sig=(alphabet: Alphabet, weights: list[int], x: str | list[int], y: str | list[int]) -> bool:
 :only-document-once:
-Compare two words using alphabet-aware weighted len-lex ordering.
+Compare two words using alphabet-aware weighted lenlex ordering.
 
 Letters are mapped to their positions in *alphabet*, and the *i*-th entry of
 *weights* is the weight assigned to the *i*-th letter of *alphabet*. Words are
@@ -621,7 +621,7 @@ Letters are mapped to their positions in *alphabet*, and the *i*-th entry of
           R"pbdoc(
 :sig=(weights: list[int], x: str | list[int], y: str | list[int]) -> bool:
 :only-document-once:
-Compare two words using reversed weighted len-lex ordering.
+Compare two words using reversed weighted lenlex ordering.
 
 Words are first ordered by total weight, then by length, and finally
 lexicographically after being read from right to left. The *i*-th entry of
@@ -660,7 +660,7 @@ lexicographically after being read from right to left. The *i*-th entry of
           R"pbdoc(
 :sig=(alphabet: Alphabet, weights: list[int], x: str | list[int], y: str | list[int]) -> bool:
 :only-document-once:
-Compare two words using alphabet-aware reversed weighted len-lex ordering.
+Compare two words using alphabet-aware reversed weighted lenlex ordering.
 
 Letters are mapped to their positions in *alphabet*, and the *i*-th entry of
 *weights* is the weight assigned to the *i*-th letter of *alphabet*. Words are
@@ -993,7 +993,7 @@ left, with letters compared by their positions in *alphabet*.
           R"pbdoc(
 :sig=(weights: list[int], x: str | list[int], y: str | list[int]) -> bool:
 :only-document-once:
-Compare two words using weighted len-lex ordering.
+Compare two words using weighted lenlex ordering.
 
 The *i*-th entry of *weights* is the weight assigned to generator *i*.
 Words are first ordered by their total weight, then by length, and finally
@@ -1030,7 +1030,7 @@ lexicographically.
           R"pbdoc(
 :sig=(alphabet: Alphabet, weights: list[int], x: str | list[int], y: str | list[int]) -> bool:
 :only-document-once:
-Compare two words using alphabet-aware weighted len-lex ordering.
+Compare two words using alphabet-aware weighted lenlex ordering.
 
 Letters are mapped to their positions in *alphabet*, and the *i*-th entry of
 *weights* is the weight assigned to the *i*-th letter of *alphabet*. Words are
@@ -1166,7 +1166,7 @@ Compare two words using wreath-product ordering.
 
 The *i*-th entry of *levels* is the level assigned to generator *i*.
 Differences at higher levels dominate differences at lower levels, and
-differences within one level are compared using len-lex ordering.
+differences within one level are compared using lenlex ordering.
 
 :param levels: the level assigned to each generator.
 :type levels: list[int]
@@ -1205,7 +1205,7 @@ Compare two words using alphabet-aware wreath-product ordering.
 Letters are mapped to their positions in *alphabet*, and the *i*-th entry of
 *levels* is the level assigned to the *i*-th letter of *alphabet*.
 Differences at higher levels dominate differences at lower levels, and
-differences within one level are compared using len-lex ordering.
+differences within one level are compared using lenlex ordering.
 
 :param alphabet: the ordered alphabet containing the letters of both words.
 :type alphabet: Alphabet
@@ -1255,7 +1255,7 @@ respectively, in new code.
 .. py:attribute:: Order.lenlex
   :value: <Order.right: 1>
 
-    The len-lex ordering. Words are first ordered by length, and then
+    The lenlex ordering. Words are first ordered by length, and then
     lexicographically.
 
 .. py:attribute:: Order.shortlex

src/present.cpp

@@ -946,10 +946,10 @@ Adds rules to *p* of the form :math:`uv = vu` for every letter :math:`u` in
           R"pbdoc(
 :sig=(p: Presentation) -> bool:
 :only-document-once:
-Check the rules are sorted relative to len-lex.
+Check the rules are sorted relative to lenlex.
 
 Check if the rules :math:`u_1 = v_1, \ldots, u_n = v_n` satisfy
-:math:`u_1v_1 < \cdots < u_nv_n` where :math:`<` is len-lex order.
+:math:`u_1v_1 < \cdots < u_nv_n` where :math:`<` is lenlex order.
 
 :param p: the presentation to check.
 :type p: Presentation
@@ -1496,9 +1496,9 @@ is defined to be the sum of the lengths of its left-hand and right-hand sides.
           R"pbdoc(
 :sig=(p: Presentation) -> bool:
 :only-document-once:
-Sort the left-hand and right-hand side of each rule by len-lex.
+Sort the left-hand and right-hand side of each rule by lenlex.
 
-Sort each rule :math:`u = v` so that the left-hand side is len-lex greater than
+Sort each rule :math:`u = v` so that the left-hand side is lenlex greater than
 the right-hand side, and return :any:`True` if any of the rules are changed.
 
 :param p: the presentation whose rules should be sorted.
@@ -1548,10 +1548,10 @@ rules are changed.
           R"pbdoc(
 :sig=(p: Presentation) -> None:
 :only-document-once:
-Sort all of the rules by len-lex.
+Sort all of the rules by lenlex.
 
 Sort the rules :math:`u_1 = v_1, \ldots, u_n = v_n` so that :math:`u_1v_1 <
-\cdots < u_nv_n` where :math:`<` is the len-lex order.
+\cdots < u_nv_n` where :math:`<` is the lenlex order.
 
 :param p: the presentation to sort.
 :type p: Presentation

src/todd-coxeter.cpp

@@ -533,7 +533,7 @@ This function performs a lookbehind using the function *collapser* to decide
 whether or not to collapse nodes. For example, it might be the case that
 *collapser* uses a :any:`KnuthBendix` instance to determine whether or
 not nodes in the graph represent the same class of the congruence. More
-specifically, the len-lex least path from the initial node to every node
+specifically, the lenlex least path from the initial node to every node
 ``n`` is rewritten using *collapser*, and if the rewritten word labels a
 path in the graph to a node ``m``, then it is assumed that ``m`` and ``n``
 represent the same class of the congruence, and they are marked for