passagemath-schemes 10.5.44__cp313-cp313-musllinux_1_2_aarch64.whl → 10.6.42__cp313-cp313-musllinux_1_2_aarch64.whl

sage/modular/modform_hecketriangle/hecke_triangle_group_element.py

@@ -275,7 +275,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             sage: (-G.I()).word_S_T()[1]
             [-1  0]
             [ 0 -1]
-            sage: (L, sgn) = (-G.V(2)).word_S_T()
+            sage: L, sgn = (-G.V(2)).word_S_T()
             sage: L
             (
             [  1 lam]  [ 0 -1]  [  1 lam]
@@ -285,7 +285,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             True
             sage: -G.V(2) == sgn * prod(L)
             True
-            sage: (L, sgn) = G.U().word_S_T()
+            sage: L, sgn = G.U().word_S_T()
             sage: L
             (
             [  1 lam]  [ 0 -1]
@@ -297,7 +297,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             True
 
             sage: G = HeckeTriangleGroup(n=infinity)
-            sage: (L, sgn) = (-G.V(2)*G.V(3)).word_S_T()
+            sage: L, sgn = (-G.V(2)*G.V(3)).word_S_T()
             sage: L
             (
             [1 2]  [ 0 -1]  [1 4]  [ 0 -1]  [1 2]  [ 0 -1]  [1 2]
@@ -308,7 +308,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
         """
         Tf = self.parent().T
         S = self.parent().S()
-        (L, sgn) = self._word_S_T_data()
+        L, sgn = self._word_S_T_data()
 
         M = [S if v[0] == 0 else Tf(v[1]) for v in L]
         if sgn > 0:
@@ -453,8 +453,8 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
         """
         if method == "default":
             return MatrixGroupElement_generic._repr_(self)
-        elif method == "basic":
-            (L, sgn) = self._word_S_T_data()
+        if method == "basic":
+            L, sgn = self._word_S_T_data()
 
             if not L:
                 return "-1" if sgn < 0 else "1"
@@ -475,12 +475,12 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
 
             return "-" + Lstr if sgn < 0 else Lstr
 
-        elif method == "block":
+        if method == "block":
             if self.parent().n() == infinity:
                 from warnings import warn
                 warn("The case n=infinity here is not verified at all and probably wrong!")
 
-            (L, R, sgn) = self._block_decomposition_data()
+            L, R, sgn = self._block_decomposition_data()
 
             repr_str = self.string_repr(method='conj')
             repr_str = repr_str[1:-1]
@@ -496,12 +496,12 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
 
             return repr_str
 
-        elif method == "conj":
+        if method == "conj":
             if self.parent().n() == infinity:
                 from warnings import warn
                 warn("The case n=infinity here is not verified at all and probably wrong!")
 
-            (L, R, sgn) = self._block_decomposition_data()
+            L, R, sgn = self._block_decomposition_data()
 
             if self.is_elliptic():
                 L = [L]
@@ -541,13 +541,11 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
                 repr_str += "1"
 
             if sgn < 0:
-                repr_str = "-{}".format(repr_str)
+                repr_str = f"-{repr_str}"
 
-            repr_str = "[{}]".format(repr_str)
+            return f"[{repr_str}]"
 
-            return repr_str
-        else:
-            raise NotImplementedError
+        raise NotImplementedError
 
     # We cache this method since the calculation is rather long and the
     # result is being reused:
@@ -722,58 +720,58 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             sage: G = HeckeTriangleGroup(n=7)
             sage: G.element_repr_method("basic")
 
-            sage: (L, R) = G.T()._primitive_block_decomposition_data()
+            sage: L, R = G.T()._primitive_block_decomposition_data()
             sage: L
             ((1, 1),)
             sage: R
             T^(-1)
-            sage: (L, R) = G.V(2).acton(G.T(-3))._primitive_block_decomposition_data()
+            sage: L, R = G.V(2).acton(G.T(-3))._primitive_block_decomposition_data()
             sage: L
             ((6, 1),)
             sage: R
             T
-            sage: (L, R) = (-G.V(2))._primitive_block_decomposition_data()
+            sage: L, R = (-G.V(2))._primitive_block_decomposition_data()
             sage: L
             ((2, 1),)
             sage: R
             T*S*T
-            sage: (L, R) = (-G.V(2)^3*G.V(6)^2*G.V(3))._primitive_block_decomposition_data()
+            sage: L, R = (-G.V(2)^3*G.V(6)^2*G.V(3))._primitive_block_decomposition_data()
             sage: L
             ((2, 3), (6, 2), (3, 1))
             sage: R
             1
-            sage: (L, R) = (G.U()^4*G.S()*G.V(2)).acton(-G.V(2)^3*G.V(6)^2*G.V(3))._primitive_block_decomposition_data()
+            sage: L, R = (G.U()^4*G.S()*G.V(2)).acton(-G.V(2)^3*G.V(6)^2*G.V(3))._primitive_block_decomposition_data()
             sage: L
             ((2, 3), (6, 2), (3, 1))
             sage: R
             T*S*T*S*T*S*T^2*S*T
-            sage: (L, R) = (G.V(1)^5*G.V(2)*G.V(3)^3)._primitive_block_decomposition_data()
+            sage: L, R = (G.V(1)^5*G.V(2)*G.V(3)^3)._primitive_block_decomposition_data()
             sage: L
             ((3, 3), (1, 5), (2, 1))
             sage: R
             T^6*S*T
 
             sage: G.element_repr_method("default")
-            sage: (L, R) = G.I()._primitive_block_decomposition_data()
+            sage: L, R = G.I()._primitive_block_decomposition_data()
             sage: L
             ((6, 0),)
             sage: R
             [1 0]
             [0 1]
 
-            sage: (L, R) = G.U()._primitive_block_decomposition_data()
+            sage: L, R = G.U()._primitive_block_decomposition_data()
             sage: L
             (1, 1)
             sage: R
             [1 0]
             [0 1]
-            sage: (L, R) = (-G.S())._primitive_block_decomposition_data()
+            sage: L, R = (-G.S())._primitive_block_decomposition_data()
             sage: L
             (0, 1)
             sage: R
             [-1  0]
             [ 0 -1]
-            sage: (L, R) = (G.V(2)*G.V(3)).acton(G.U()^6)._primitive_block_decomposition_data()
+            sage: L, R = (G.V(2)*G.V(3)).acton(G.U()^6)._primitive_block_decomposition_data()
             sage: L
             (1, 1)
             sage: R
@@ -800,7 +798,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             embp = emb(p)
             embp.simplify()
             embp.exactify()
-            (R, embw) = G.get_FD(embp)
+            R, embw = G.get_FD(embp)
             w = R.inverse().acton(p)
             # we should have: embw == emb(w)
             embw = emb(w)
@@ -827,7 +825,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
         # The parabolic case is much simpler but the same algorithm
         # as in the hyperbolic case still works
 
-        (preperiod, period) = self.continued_fraction()
+        preperiod, period = self.continued_fraction()
 
         number_of_ones = []
         list_larger = []
@@ -1047,7 +1045,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             if self.parent().n() == infinity:
                 raise NotImplementedError
 
-            (data, R) = self._primitive_block_decomposition_data()
+            data, R = self._primitive_block_decomposition_data()
             if data[0] == 0:
                 P = G.S()
             else:
@@ -1056,15 +1054,15 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             return (P, R)
 
         if method == "cf":
-            (preperiod, period) = self.continued_fraction()
+            preperiod, period = self.continued_fraction()
 
-            P = prod((G.T()**r*G.S() for r in period), G.I())
-            R = prod((G.T()**r*G.S() for r in preperiod), G.I())
+            P = prod((G.T()**r * G.S() for r in period), G.I())
+            R = prod((G.T()**r * G.S() for r in preperiod), G.I())
 
             return (P, R)
 
         elif method == "block":
-            (data_list, R) = self._primitive_block_decomposition_data()
+            data_list, R = self._primitive_block_decomposition_data()
             P = prod((G.V(v[0])**v[1] for v in data_list), G.I())
 
             return (P, R)
@@ -1160,9 +1158,9 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             from warnings import warn
             warn("The case n=infinity here is not verified at all and probably wrong!")
 
-        (P, R) = self.primitive_representative(method=method)
+        P, R = self.primitive_representative(method=method)
 
-        return R*P*R.inverse()
+        return R * P * R.inverse()
 
     def reduce(self, primitive=True):
         r"""
@@ -1218,7 +1216,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             from warnings import warn
             warn("The case n=infinity here is not verified at all and probably wrong!")
 
-        (P, R) = self.primitive_representative(method='cf')
+        P, R = self.primitive_representative(method='cf')
 
         if primitive:
             return P
@@ -1359,7 +1357,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             if self.parent().n() == infinity:
                 raise NotImplementedError
 
-            (data, R) = self._primitive_block_decomposition_data()
+            data, R = self._primitive_block_decomposition_data()
             if data[0] == 0:
                 return one
             else:
@@ -1373,7 +1371,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
                     if U_power == Uj:
                         # L = [one, ZZ(j)]
                         break
-                    elif U_power == -Uj:
+                    if U_power == -Uj:
                         # L = [one, ZZ(-j)]
                         break
                 else:
@@ -1568,64 +1566,64 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             sage: G = HeckeTriangleGroup(n=7)
             sage: G.element_repr_method("basic")
 
-            sage: (L, R, sgn) = G.T()._block_decomposition_data()
+            sage: L, R, sgn = G.T()._block_decomposition_data()
             sage: (L, sgn)
             (((1, 1),), 1)
             sage: R
             T^(-1)
-            sage: (L, R, sgn) = G.V(2).acton(G.T(-3))._block_decomposition_data()
+            sage: L, R, sgn = G.V(2).acton(G.T(-3))._block_decomposition_data()
             sage: (L, sgn)
             (((6, 3),), 1)
             sage: R
             T
-            sage: (L, R, sgn) = (-G.V(2)^2)._block_decomposition_data()
+            sage: L, R, sgn = (-G.V(2)^2)._block_decomposition_data()
             sage: (L, sgn)
             (((2, 2),), -1)
             sage: R
             T*S*T
             sage: el = (-G.V(2)*G.V(6)*G.V(3)*G.V(2)*G.V(6)*G.V(3))
-            sage: (L, R, sgn) = el._block_decomposition_data()
+            sage: L, R, sgn = el._block_decomposition_data()
             sage: (L, sgn)
             (((6, 1), (3, 1), (2, 1), (6, 1), (3, 1), (2, 1)), -1)
             sage: R
             T*S*T
-            sage: (L, R, sgn) = (G.U()^4*G.S()*G.V(2)).acton(el)._block_decomposition_data()
+            sage: L, R, sgn = (G.U()^4*G.S()*G.V(2)).acton(el)._block_decomposition_data()
             sage: (L, sgn)
             (((2, 1), (6, 1), (3, 1), (2, 1), (6, 1), (3, 1)), -1)
             sage: R
             T*S*T*S*T*S*T^2*S*T
-            sage: (L, R, sgn) = (G.V(1)^5*G.V(2)*G.V(3)^3)._block_decomposition_data()
+            sage: L, R, sgn = (G.V(1)^5*G.V(2)*G.V(3)^3)._block_decomposition_data()
             sage: (L, sgn)
             (((3, 3), (1, 5), (2, 1)), 1)
             sage: R
             T^6*S*T
 
             sage: G.element_repr_method("default")
-            sage: (L, R, sgn) = (-G.I())._block_decomposition_data()
+            sage: L, R, sgn = (-G.I())._block_decomposition_data()
             sage: (L, sgn)
             (((6, 0),), -1)
             sage: R
             [1 0]
             [0 1]
-            sage: (L, R, sgn) = G.U()._block_decomposition_data()
+            sage: L, R, sgn = G.U()._block_decomposition_data()
             sage: (L, sgn)
             ((1, 1), 1)
             sage: R
             [1 0]
             [0 1]
-            sage: (L, R, sgn) = (-G.S())._block_decomposition_data()
+            sage: L, R, sgn = (-G.S())._block_decomposition_data()
             sage: (L, sgn)
             ((0, 1), -1)
             sage: R
             [-1  0]
             [ 0 -1]
-            sage: (L, R, sgn) = (G.V(2)*G.V(3)).acton(G.U()^6)._block_decomposition_data()
+            sage: L, R, sgn = (G.V(2)*G.V(3)).acton(G.U()^6)._block_decomposition_data()
             sage: (L, sgn)
             ((1, -1), -1)
             sage: R
             [-2*lam^2 - 2*lam + 2 -2*lam^2 - 2*lam + 1]
             [        -2*lam^2 + 1   -2*lam^2 - lam + 2]
-            sage: (L, R, sgn) = (G.U()^(-6))._block_decomposition_data()
+            sage: L, R, sgn = (G.U()^(-6))._block_decomposition_data()
             sage: (L, sgn)
             ((1, 1), -1)
             sage: R
@@ -1633,13 +1631,13 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             [0 1]
 
             sage: G = HeckeTriangleGroup(n=8)
-            sage: (L, R, sgn) = (G.U()^4)._block_decomposition_data()
+            sage: L, R, sgn = (G.U()^4)._block_decomposition_data()
             sage: (L, sgn)
             ((1, 4), 1)
             sage: R
             [1 0]
             [0 1]
-            sage: (L, R, sgn) = (G.U()^(-4))._block_decomposition_data()
+            sage: L, R, sgn = (G.U()^(-4))._block_decomposition_data()
             sage: (L, sgn)
             ((1, 4), -1)
             sage: R
@@ -1650,7 +1648,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             from warnings import warn
             warn("The case n=infinity here is not verified at all and probably wrong!")
 
-        (L, R) = self._primitive_block_decomposition_data()
+        L, R = self._primitive_block_decomposition_data()
         if self.sign() == self.parent().I():
             sgn = ZZ(1)
         else:
@@ -1675,7 +1673,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             # abs(self.primitive_power()) == self.primitive_power(method="block")
             L2 = ((L[0][0], abs(self.primitive_power())),)
         else:
-            L2 = L*abs(self.primitive_power())
+            L2 = L * abs(self.primitive_power())
 
         return (L2, R, sgn)
 
@@ -1760,7 +1758,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             warn("The case n=infinity here is not verified at all and probably wrong!")
 
         G = self.parent()
-        (L, R, sgn) = self._block_decomposition_data()
+        L, R, sgn = self._block_decomposition_data()
         if sgn > 0:
             sgn = G.I()
         else:
@@ -1843,9 +1841,9 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
 
         if primitive:
             ignore_sign = True
-            (L, R) = self._primitive_block_decomposition_data()
+            L, R = self._primitive_block_decomposition_data()
         else:
-            (L, R, sgn) = self._block_decomposition_data()
+            L, R, sgn = self._block_decomposition_data()
 
         if not self.is_elliptic():
             L = tuple(cyclic_representative(L))
@@ -1911,9 +1909,8 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             cur_period = rotate(period, k)
             if cur_period in period_set:
                 continue
-            else:
-                period_set.add(cur_period)
-                L.append(prod((G.T()**r*G.S() for r in cur_period), G.I()))
+            period_set.add(cur_period)
+            L.append(prod((G.T()**r * G.S() for r in cur_period), G.I()))
 
         return L
 
@@ -2196,12 +2193,13 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             sage: AA(G.V(3).discriminant())
             16.19566935808922?
         """
-
         return self.trace()**2 - 4
 
-    def is_translation(self, exclude_one=False):
+    def is_translation(self, exclude_one=False) -> bool:
         r"""
-        Return whether ``self`` is a translation. If ``exclude_one = True``,
+        Return whether ``self`` is a translation.
+
+        If ``exclude_one = True``,
         then the identity map is not considered as a translation.
 
         EXAMPLES::
@@ -2218,12 +2216,9 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
 
         if not (c.is_zero() and a == d and (a.is_one() or (-a).is_one())):
             return False
-        elif exclude_one and b.is_zero():
-            return False
-        else:
-            return True
+        return not (exclude_one and b.is_zero())
 
-    def is_reflection(self):
+    def is_reflection(self) -> bool:
         r"""
         Return whether ``self`` is the usual reflection on the unit circle.
 
@@ -2237,7 +2232,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
         """
         return self == self.parent().S() or self == -self.parent().S()
 
-    def is_hyperbolic(self):
+    def is_hyperbolic(self) -> bool:
         r"""
         Return whether ``self`` is a hyperbolic matrix.
 
@@ -2252,7 +2247,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
         """
         return coerce_AA(self.discriminant()) > 0
 
-    def is_parabolic(self, exclude_one=False):
+    def is_parabolic(self, exclude_one=False) -> bool:
         r"""
         Return whether ``self`` is a parabolic matrix.
 
@@ -2277,7 +2272,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
 
         return self.discriminant() == 0
 
-    def is_identity(self):
+    def is_identity(self) -> bool:
         r"""
         Return whether ``self`` is the identity or minus the identity.
 
@@ -2295,7 +2290,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
         else:
             return False
 
-    def is_elliptic(self):
+    def is_elliptic(self) -> bool:
         r"""
         Return whether ``self`` is an elliptic matrix.
 
@@ -2310,7 +2305,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
         """
         return coerce_AA(self.discriminant()) < 0
 
-    def is_primitive(self):
+    def is_primitive(self) -> bool:
         r"""
         Return whether ``self`` is primitive. We call an element
         primitive if (up to a sign and taking inverses) it generates
@@ -2369,9 +2364,12 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
         else:
             return abs(pow) <= 1
 
-    def is_reduced(self, require_primitive=True, require_hyperbolic=True):
+    def is_reduced(self, require_primitive=True,
+                   require_hyperbolic=True) -> bool:
         r"""
-        Return whether ``self`` is reduced. We call an element
+        Return whether ``self`` is reduced.
+
+        We call an element
         reduced if the associated lambda-CF is purely periodic.
 
         I.e. (in the hyperbolic case) if the associated hyperbolic
@@ -2435,9 +2433,11 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
         else:
             return self.continued_fraction()[0] == ()
 
-    def is_simple(self):
+    def is_simple(self) -> bool:
         r"""
-        Return whether ``self`` is simple. We call an element
+        Return whether ``self`` is simple.
+
+        We call an element
         simple if it is hyperbolic, primitive, has positive sign
         and if the associated hyperbolic fixed points satisfy:
         ``alpha' < 0 < alpha`` where ``alpha`` is the attracting
@@ -2464,7 +2464,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             sage: R = el.simple_elements()
             sage: [v.is_simple() for v in R]
             [True]
-            sage: (fp1, fp2) = R[0].fixed_points(embedded=True)
+            sage: fp1, fp2 = R[0].fixed_points(embedded=True)
             sage: (fp1, fp2)
             (1.272019649514069?, -1.272019649514069?)
             sage: fp2 < 0 < fp1
@@ -2476,7 +2476,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             sage: R = el.simple_elements()
             sage: [v.is_simple() for v in R]
             [True, True]
-            sage: (fp1, fp2) = R[1].fixed_points(embedded=True)
+            sage: fp1, fp2 = R[1].fixed_points(embedded=True)
             sage: fp2 < 0 < fp1
             True
 
@@ -2488,7 +2488,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             True
             sage: [v.is_simple() for v in R]
             [True, True, True, True]
-            sage: (fp1, fp2) = R[2].fixed_points(embedded=True)
+            sage: fp1, fp2 = R[2].fixed_points(embedded=True)
             sage: fp2 < 0 < fp1
             True
         """
@@ -2499,7 +2499,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
         a, b, c, d = self._matrix.list()
         return (coerce_AA(a) > 0 and coerce_AA(b) > 0 and coerce_AA(c) > 0 and coerce_AA(d) > 0)
 
-    def is_hecke_symmetric(self):
+    def is_hecke_symmetric(self) -> bool:
         r"""
         Return whether the conjugacy class of the primitive part of
         ``self``, denoted by ``[gamma]`` is `Hecke-symmetric`:
@@ -2588,12 +2588,10 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
             sage: S = G.S()
             sage: U = G.U()
 
-            sage: def is_rpf(f, k=None):
+            sage: def is_rpf(f, k=None) -> bool:
             ....:     if not f + S.slash(f, k=k) == 0:
             ....:         return False
-            ....:     if not sum([(U^m).slash(f, k=k) for m in range(G.n())]) == 0:
-            ....:         return False
-            ....:     return True
+            ....:     return sum((U^m).slash(f, k=k) for m in range(G.n())) == 0
 
             sage: z = PolynomialRing(G.base_ring(), 'z').gen()
             sage: [is_rpf(1 - z^(-k), k=k) for k in range(-6, 6, 2)]  # long time
@@ -2835,7 +2833,7 @@ class HeckeTriangleGroupElement(MatrixGroupElement_generic):
         if self.is_identity():
             return ZZ.zero()
 
-        (L, R, sgn) = self._block_decomposition_data()
+        L, R, sgn = self._block_decomposition_data()
         n = self.parent().n()
 
         if self.is_elliptic():

sage/modular/modform_hecketriangle/hecke_triangle_groups.py

@@ -997,14 +997,14 @@ class HeckeTriangleGroup(FinitelyGeneratedMatrixGroup_generic,
         if max_block_length <= self._max_block_length:
             return
 
-        def is_cycle(seq):
+        def is_cycle(seq) -> bool:
             length = len(seq)
             for n in divisors(length):
                 if n < length and is_cycle_of_length(seq, n):
                     return True
             return False
 
-        def is_cycle_of_length(seq, n):
+        def is_cycle_of_length(seq, n) -> bool:
             for j in range(n, len(seq)):
                 if seq[j] != seq[j % n]:
                     return False

sage/modular/modform_hecketriangle/readme.py

@@ -404,12 +404,10 @@ Hecke triangle groups and elements:
       sage: S = G.S()
       sage: U = G.U()
 
-      sage: def is_rpf(f, k=None):
+      sage: def is_rpf(f, k=None) -> bool:
       ....:     if not f + S.slash(f, k=k) == 0:
       ....:         return False
-      ....:     if not sum([(U^m).slash(f, k=k) for m in range(G.n())]) == 0:
-      ....:         return False
-      ....:     return True
+      ....:     return sum((U^m).slash(f, k=k) for m in range(G.n())) == 0
 
       sage: z = PolynomialRing(G.base_ring(), 'z').gen()
       sage: [is_rpf(1 - z^(-k), k=k) for k in range(-6, 6, 2)]  # long time
@@ -1016,12 +1014,12 @@ Modular forms ring and spaces for Hecke triangle groups:
       sage: QF = QuasiWeakModularForms(n=8, k=10/3, ep=-1)
       sage: QF.default_prec(1)
       sage: QF.quasi_part_gens(min_exp=-1)
-      [q^-1 + O(q),
+      (q^-1 + O(q),
        1 + O(q),
        q^-1 - 9/(128*d) + O(q),
        1 + O(q),
        q^-1 - 19/(64*d) + O(q),
-       q^-1 + 1/(64*d) + O(q)]
+       q^-1 + 1/(64*d) + O(q))
       sage: QF.default_prec(QF.required_laurent_prec(min_exp=-1))
       sage: QF.q_basis(min_exp=-1)    # long time
       [q^-1 + O(q^5),
@@ -1043,9 +1041,9 @@ Modular forms ring and spaces for Hecke triangle groups:
       3
       sage: MF.default_prec(2)
       sage: MF.gens()
-      [1 - 37/(200*d)*q + O(q^2),
+      (1 - 37/(200*d)*q + O(q^2),
        1 + 33/(200*d)*q + O(q^2),
-       1 - 27/(200*d)*q + O(q^2)]
+       1 - 27/(200*d)*q + O(q^2))
 
 
 - **Coordinate vectors for (quasi) holomorphic modular forms and (quasi) cusp forms:**
@@ -1136,7 +1134,7 @@ Modular forms ring and spaces for Hecke triangle groups:
       sage: MF.dimension()
       2
       sage: MF.gens()
-      [1 + 240*q^2 + 2160*q^4 + O(q^5), q - 8*q^2 + 28*q^3 - 64*q^4 + O(q^5)]
+      (1 + 240*q^2 + 2160*q^4 + O(q^5), q - 8*q^2 + 28*q^3 - 64*q^4 + O(q^5))
       sage: E4(i)
       1.941017189...
       sage: E4.order_at(-1)
@@ -1144,8 +1142,8 @@ Modular forms ring and spaces for Hecke triangle groups:
 
       sage: MF = (E2/E4).reduced_parent()
       sage: MF.quasi_part_gens(order_1=-1)
-      [1 - 40*q + 552*q^2 - 4896*q^3 + 33320*q^4 + O(q^5),
-       1 - 24*q + 264*q^2 - 2016*q^3 + 12264*q^4 + O(q^5)]
+      (1 - 40*q + 552*q^2 - 4896*q^3 + 33320*q^4 + O(q^5),
+       1 - 24*q + 264*q^2 - 2016*q^3 + 12264*q^4 + O(q^5))
       sage: prec = MF.required_laurent_prec(order_1=-1)
       sage: qexp = (E2/E4).q_expansion(prec=prec)
       sage: qexp