Replace Tuple -> tuple

Author: james-d-mitchell

src/froidure-pin-base.cpp

@@ -648,7 +648,7 @@ complete set of rules, then use :any:`normal_forms` instead.
                                      fp.cend_current_rules());
           },
           R"pbdoc(
-:sig=(fp: FroidurePin) -> Iterator[Tuple[list[int],list[int]]]:
+:sig=(fp: FroidurePin) -> Iterator[tuple[list[int],list[int]]]:
 
 Returns an iterator yielding the so-far enumerated rules.
 
@@ -664,7 +664,7 @@ to obtain the complete set of rules, then use :any:`rules` instead.
 
 :returns:
     An iterator.
-:rtype: Iterator[Tuple[list[int], list[int]]]
+:rtype: Iterator[tuple[list[int], list[int]]]
 
 :complexity: Constant
 
@@ -740,7 +740,7 @@ then use :any:`current_normal_forms` instead.
             return py::make_iterator(fp.cbegin_rules(), fp.cend_rules());
           },
           R"pbdoc(
-:sig=(fp: FroidurePin) -> Iterator[Tuple[list[int],list[int]]]:
+:sig=(fp: FroidurePin) -> Iterator[tuple[list[int],list[int]]]:
 
 Returns an iterator yielding the rules.
 
@@ -758,7 +758,7 @@ use :any:`current_rules` instead.
 :returns:
     An iterator yielding rules.
 :rtype:
-    Iterator[Tuple[list[int],list[int]]]:
+    Iterator[tuple[list[int],list[int]]]:
 )pbdoc");
     }
   }  // init_froidure_pin_base

src/knuth-bendix-impl.cpp

@@ -376,7 +376,7 @@ to the re-initialisation of rules where possible.
             return py::make_iterator(rx::begin(rules), rx::end(rules));
           },
           R"pbdoc(
-:sig=(self: KnuthBendix) -> Iterator[Tuple[str, str]]:
+:sig=(self: KnuthBendix) -> Iterator[tuple[str, str]]:
 
 Return a copy of the active rules.
 
@@ -388,7 +388,7 @@ according to the reduction ordering used by the rewriting system, on the first
 entry.
 
 :return: An iterator yielding the currently active rules.
-:rtype: Iterator[Tuple[str, str]]
+:rtype: Iterator[tuple[str, str]]
 )pbdoc");
 
       //////////////////////////////////////////////////////////////////////////

src/knuth-bendix.cpp

@@ -287,7 +287,7 @@ Check if the all rules are reduced with respect to each other.
             return {};
           },
           R"pbdoc(
-:sig=(p: Presentation, t: datetime.timedelta) -> Tuple[list[int], list[int]] | Tuple[str, str] | None:
+:sig=(p: Presentation, t: datetime.timedelta) -> tuple[list[int], list[int]] | tuple[str, str] | None:
 :only-document-once:
 
 Return a redundant rule or ``None``.
@@ -308,7 +308,7 @@ redundant in this way, then ``None`` is returned.
 :type t: datetime.timedelta
 
 :returns: A redundant rule or ``None``.
-:rtype: Tuple[list[int], list[int]] | Tuple[str, str] | None
+:rtype: tuple[list[int], list[int]] | tuple[str, str] | None
 
 .. warning::
   The progress of the Knuth-Bendix algorithm may differ between
@@ -342,7 +342,7 @@ redundant in this way, then ``None`` is returned.
             return {};
           },
           R"pbdoc(
-:sig=(p: Presentation, t: datetime.timedelta) -> Tuple[list[int], list[int]] | Tuple[str, str] | None:
+:sig=(p: Presentation, t: datetime.timedelta) -> tuple[list[int], list[int]] | tuple[str, str] | None:
 :only-document-once:
 TODO where's the doc?
 )pbdoc");

src/todd-coxeter.cpp

@@ -406,7 +406,7 @@ enumeration of ``tc``.)pbdoc",
           py::arg("p"),
           py::arg("t"),
           R"pbdoc(
-:sig=(p: Presentation, t: timedelta) -> Tuple[list[int], list[int]] | Tuple[str, str] | None:
+:sig=(p: Presentation, t: timedelta) -> tuple[list[int], list[int]] | tuple[str, str] | None:
 :only-document-once:
 
 Return a redundant rule or ``None``.
@@ -426,7 +426,7 @@ be shown to be redundant in this way, then ``None`` is returned.
 :type t: timedelta
 
 :returns: A redundant rule or ``None``.
-:rtype: Tuple[list[int], list[int]] | Tuple[str, str] | None
+:rtype: tuple[list[int], list[int]] | tuple[str, str] | None
 )pbdoc");
 
       m.def(
@@ -440,7 +440,7 @@ be shown to be redundant in this way, then ``None`` is returned.
             return {};
           },
           R"pbdoc(
-:sig=(p: Presentation, t: timedelta) -> Tuple[list[int], list[int]] | Tuple[str, str] | None:
+:sig=(p: Presentation, t: timedelta) -> tuple[list[int], list[int]] | tuple[str, str] | None:
 :only-document-once:
 )pbdoc");
 

src/ukkonen.cpp

@@ -455,7 +455,7 @@ overlapping) of the words in the suffix tree *u*.
         py::arg("u"),
         py::arg("w"),
         R"pbdoc(
-:sig=(u: Ukkonen, w: str | list[int]) -> Tuple[Ukkonen.State, str | list[int]]:
+:sig=(u: Ukkonen, w: str | list[int]) -> tuple[Ukkonen.State, str | list[int]]:
 :only-document-once:
 Traverse the suffix tree from the root.
 
@@ -471,7 +471,7 @@ traversal is returned.
 :type w: str | list[int]
 
 :returns: A tuple containing the :any:`State` reached, and the word consumed.
-:rtype: Tuple[Ukkonen.State, str | list[int]]
+:rtype: tuple[Ukkonen.State, str | list[int]]
 
 :raises LibsemigroupsError:  if ``u.throw_if_contains_unique_letter(w)`` throws.
 

src/word-graph.cpp

@@ -370,7 +370,7 @@ equal to *a* that is incident to the node *s*. If ``target(s, b)`` equals
 :returns:
   Returns a pair where the first entry is the next label after *a* and the
   second is the next target of *s* that is not :any:`UNDEFINED`.
-:rtype: Tuple[int | Undefined, int | Undefined]
+:rtype: tuple[int | Undefined, int | Undefined]
 
 :complexity: At worst :math:`O(n)` where :math:`n` equals :any:`out_degree()`.
 
@@ -1128,7 +1128,7 @@ position in the word reached.
 :returns:
   A pair consisting of the last node reached and the index of
   the last letter in the word labelling an edge.
-:rtype: Tuple[int, int]
+:rtype: tuple[int, int]
 
 :complexity: At worst the length of *w*.)pbdoc");
 
@@ -1327,7 +1327,7 @@ spanning tree corresponds to the order *val*.
   this function (i.e. it was not standardized already), and ``False``
   otherwise. The second entry is a :any:`Forest` object containing a spanning
   tree for *wg*.
-:rtype: Tuple[bool, Forest]
+:rtype: tuple[bool, Forest]
 )pbdoc");
 
     m.def(