passagemath-schemes 10.5.48__cp312-cp312-musllinux_1_2_aarch64.whl → 10.6.47__cp312-cp312-musllinux_1_2_aarch64.whl

sage/modular/modform_hecketriangle/abstract_ring.py

@@ -838,7 +838,7 @@ class FormsRing_abstract(Parent):
             - (self._group.n()-2) / (4*self._group.n()) * (Z**2+X**(self._group.n()-2)) * dZ
 
     @cached_method
-    def has_reduce_hom(self):
+    def has_reduce_hom(self) -> bool:
         r"""
         Return whether the method ``reduce`` should reduce
         homogeneous elements to the corresponding space of homogeneous elements.
@@ -862,10 +862,9 @@ class FormsRing_abstract(Parent):
             sage: ModularForms(k=6).graded_ring().has_reduce_hom()
             True
         """
-
         return self._red_hom
 
-    def is_homogeneous(self):
+    def is_homogeneous(self) -> bool:
         r"""
         Return whether ``self`` is homogeneous component.
 
@@ -879,10 +878,9 @@ class FormsRing_abstract(Parent):
             sage: ModularForms(k=6).is_homogeneous()
             True
         """
-
         return self._weight is not None
 
-    def is_modular(self):
+    def is_modular(self) -> bool:
         r"""
         Return whether ``self`` only contains modular elements.
 
@@ -900,10 +898,9 @@ class FormsRing_abstract(Parent):
             sage: CuspForms(n=7, k=12, base_ring=AA).is_modular()
             True
         """
-
         return not (self.AT("quasi") <= self._analytic_type)
 
-    def is_weakly_holomorphic(self):
+    def is_weakly_holomorphic(self) -> bool:
         r"""
         Return whether ``self`` only contains weakly
         holomorphic modular elements.
@@ -922,10 +919,9 @@ class FormsRing_abstract(Parent):
             sage: CuspForms(n=7, k=12, base_ring=AA).is_weakly_holomorphic()
             True
         """
-
         return (self.AT("weak", "quasi") >= self._analytic_type)
 
-    def is_holomorphic(self):
+    def is_holomorphic(self) -> bool:
         r"""
         Return whether ``self`` only contains holomorphic
         modular elements.
@@ -944,10 +940,9 @@ class FormsRing_abstract(Parent):
             sage: CuspForms(n=7, k=12, base_ring=AA).is_holomorphic()
             True
         """
-
         return (self.AT("holo", "quasi") >= self._analytic_type)
 
-    def is_cuspidal(self):
+    def is_cuspidal(self) -> bool:
         r"""
         Return whether ``self`` only contains cuspidal elements.
 
@@ -965,10 +960,9 @@ class FormsRing_abstract(Parent):
             sage: QuasiCuspForms(k=12).is_cuspidal()
             True
         """
-
         return (self.AT("cusp", "quasi") >= self._analytic_type)
 
-    def is_zerospace(self):
+    def is_zerospace(self) -> bool:
         r"""
         Return whether ``self`` is the (`0`-dimensional) zero space.
 
@@ -984,7 +978,6 @@ class FormsRing_abstract(Parent):
             sage: CuspForms(k=12).reduce_type([]).is_zerospace()
             True
         """
-
         return (self.AT(["quasi"]) >= self._analytic_type)
 
     def analytic_type(self):

sage/modular/modform_hecketriangle/abstract_space.py

@@ -363,7 +363,7 @@ class FormsSpace_abstract(FormsRing_abstract):
         """
         return self.extend_type("holo", ring=True)(1).reduce()
 
-    def is_ambient(self):
+    def is_ambient(self) -> bool:
         r"""
         Return whether ``self`` is an ambient space.
 
@@ -1353,7 +1353,7 @@ class FormsSpace_abstract(FormsRing_abstract):
 
         return (min_exp, order_1)
 
-    def quasi_part_gens(self, r=None, min_exp=0, max_exp=infinity, order_1=ZZ.zero()):
+    def quasi_part_gens(self, r=None, min_exp=0, max_exp=infinity, order_1=ZZ.zero()) -> tuple:
         r"""
         Return a basis in ``self`` of the subspace of (quasi) weakly
         holomorphic forms which satisfy the specified properties on
@@ -1392,17 +1392,20 @@ class FormsSpace_abstract(FormsRing_abstract):
             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), 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 + 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))
 
             sage: QF.quasi_part_gens(min_exp=-1, max_exp=-1)
-            [q^-1 + O(q), q^-1 - 9/(128*d) + O(q), q^-1 - 19/(64*d) + O(q), q^-1 + 1/(64*d) + O(q)]
+            (q^-1 + O(q), q^-1 - 9/(128*d) + O(q),
+             q^-1 - 19/(64*d) + O(q), q^-1 + 1/(64*d) + O(q))
             sage: QF.quasi_part_gens(min_exp=-2, r=1)
-            [q^-2 - 9/(128*d)*q^-1 - 261/(131072*d^2) + O(q), q^-1 - 9/(128*d) + O(q), 1 + O(q)]
+            (q^-2 - 9/(128*d)*q^-1 - 261/(131072*d^2) + O(q),
+             q^-1 - 9/(128*d) + O(q), 1 + O(q))
 
             sage: from sage.modular.modform_hecketriangle.space import ModularForms
             sage: MF = ModularForms(k=36)
             sage: MF.quasi_part_gens(min_exp=2)
-            [q^2 + 194184*q^4 + O(q^5), q^3 - 72*q^4 + O(q^5)]
+            (q^2 + 194184*q^4 + O(q^5), q^3 - 72*q^4 + O(q^5))
 
             sage: from sage.modular.modform_hecketriangle.space import QuasiModularForms
             sage: MF = QuasiModularForms(n=5, k=6, ep=-1)
@@ -1410,17 +1413,17 @@ class FormsSpace_abstract(FormsRing_abstract):
             sage: MF.dimension()
             3
             sage: MF.quasi_part_gens(r=0)
-            [1 - 37/(200*d)*q + O(q^2)]
+            (1 - 37/(200*d)*q + O(q^2),)
             sage: MF.quasi_part_gens(r=0)[0] == MF.E6()
             True
             sage: MF.quasi_part_gens(r=1)
-            [1 + 33/(200*d)*q + O(q^2)]
+            (1 + 33/(200*d)*q + O(q^2),)
             sage: MF.quasi_part_gens(r=1)[0] == MF.E2()*MF.E4()
             True
             sage: MF.quasi_part_gens(r=2)
-            []
+            ()
             sage: MF.quasi_part_gens(r=3)
-            [1 - 27/(200*d)*q + O(q^2)]
+            (1 - 27/(200*d)*q + O(q^2),)
             sage: MF.quasi_part_gens(r=3)[0] == MF.E2()^3
             True
 
@@ -1430,18 +1433,18 @@ class FormsSpace_abstract(FormsRing_abstract):
             sage: MF.dimension()
             8
             sage: MF.quasi_part_gens(r=0)
-            [q - 34743/(640000*d^2)*q^3 + O(q^4), q^2 - 69/(200*d)*q^3 + O(q^4)]
+            (q - 34743/(640000*d^2)*q^3 + O(q^4), q^2 - 69/(200*d)*q^3 + O(q^4))
             sage: MF.quasi_part_gens(r=1)
-            [q - 9/(200*d)*q^2 + 37633/(640000*d^2)*q^3 + O(q^4),
-             q^2 + 1/(200*d)*q^3 + O(q^4)]
+            (q - 9/(200*d)*q^2 + 37633/(640000*d^2)*q^3 + O(q^4),
+             q^2 + 1/(200*d)*q^3 + O(q^4))
             sage: MF.quasi_part_gens(r=2)
-            [q - 1/(4*d)*q^2 - 24903/(640000*d^2)*q^3 + O(q^4)]
+            (q - 1/(4*d)*q^2 - 24903/(640000*d^2)*q^3 + O(q^4),)
             sage: MF.quasi_part_gens(r=3)
-            [q + 1/(10*d)*q^2 - 7263/(640000*d^2)*q^3 + O(q^4)]
+            (q + 1/(10*d)*q^2 - 7263/(640000*d^2)*q^3 + O(q^4),)
             sage: MF.quasi_part_gens(r=4)
-            [q - 11/(20*d)*q^2 + 53577/(640000*d^2)*q^3 + O(q^4)]
+            (q - 11/(20*d)*q^2 + 53577/(640000*d^2)*q^3 + O(q^4),)
             sage: MF.quasi_part_gens(r=5)
-            [q - 1/(5*d)*q^2 + 4017/(640000*d^2)*q^3 + O(q^4)]
+            (q - 1/(5*d)*q^2 + 4017/(640000*d^2)*q^3 + O(q^4),)
 
             sage: MF.quasi_part_gens(r=1)[0] == MF.E2() * CuspForms(n=5, k=16, ep=1).gen(0)
             True
@@ -1454,9 +1457,9 @@ class FormsSpace_abstract(FormsRing_abstract):
             sage: MF.quasi_part_gens(r=1, min_exp=-2) == MF.quasi_part_gens(r=1, min_exp=1)
             True
             sage: MF.quasi_part_gens(r=1)
-            [q - 8*q^2 - 8*q^3 + 5952*q^4 + O(q^5),
+            (q - 8*q^2 - 8*q^3 + 5952*q^4 + O(q^5),
              q^2 - 8*q^3 + 208*q^4 + O(q^5),
-             q^3 - 16*q^4 + O(q^5)]
+             q^3 - 16*q^4 + O(q^5))
 
             sage: MF = QuasiWeakModularForms(n=infinity, k=4, ep=1)
             sage: MF.quasi_part_gens(r=2, min_exp=2, order_1=-2)[0] == MF.E2()^2 * MF.E4()^(-2) * MF.f_inf()^2
@@ -1464,23 +1467,22 @@ class FormsSpace_abstract(FormsRing_abstract):
             sage: [v.order_at(-1) for v in MF.quasi_part_gens(r=0, min_exp=2, order_1=-2)]
             [-2, -2]
         """
-
-        if (not self.is_weakly_holomorphic()):
+        if not self.is_weakly_holomorphic():
             from warnings import warn
             warn("This function only determines generators of (quasi) weakly modular forms!")
 
-        (min_exp, order_1) = self._canonical_min_exp(min_exp, order_1)
+        min_exp, order_1 = self._canonical_min_exp(min_exp, order_1)
 
         # For modular forms spaces the quasi parts are all zero except for r=0
-        if (self.is_modular()):
+        if self.is_modular():
             r = ZZ(r)
-            if (r != 0):
-                return []
+            if r:
+                return ()
 
         # The lower bounds on the powers of f_inf and E4 determine
         # how large powers of E2 we can fit in...
         n = self.hecke_n()
-        if (n == infinity):
+        if n == infinity:
             max_numerator_weight = self._weight - 4*min_exp - 4*order_1 + 4
         else:
             max_numerator_weight = self._weight - 4*n/(n-2)*min_exp + 4
@@ -1488,30 +1490,28 @@ class FormsSpace_abstract(FormsRing_abstract):
         # If r is not specified we gather all generators for all possible r's
         if r is None:
             gens = []
-            for rnew in range(QQ(max_numerator_weight/ZZ(2)).floor() + 1):
-                gens += self.quasi_part_gens(r=rnew, min_exp=min_exp, max_exp=max_exp, order_1=order_1)
-            return gens
+            for rnew in range(QQ(max_numerator_weight / ZZ(2)).floor() + 1):
+                gens.extend(self.quasi_part_gens(r=rnew, min_exp=min_exp, max_exp=max_exp, order_1=order_1))
+            return tuple(gens)
 
         r = ZZ(r)
         if r < 0 or 2*r > max_numerator_weight:
-            return []
+            return ()
 
         E2 = self.E2()
-        ambient_weak_space = self.graded_ring().reduce_type("weak", degree=(self._weight-QQ(2*r), self._ep*(-1)**r))
+        ambient_weak_space = self.graded_ring().reduce_type("weak",
+                                                            degree=(self._weight-QQ(2*r), self._ep*(-1)**r))
         order_inf = ambient_weak_space._l1 - order_1
 
-        if (max_exp == infinity):
+        if max_exp == infinity:
             max_exp = order_inf
-        elif (max_exp < min_exp):
-            return []
+        elif max_exp < min_exp:
+            return ()
         else:
             max_exp = min(ZZ(max_exp), order_inf)
 
-        gens = []
-        for m in range(min_exp, max_exp + 1):
-            gens += [ self(ambient_weak_space.F_basis(m, order_1=order_1)*E2**r) ]
-
-        return gens
+        return tuple(self(ambient_weak_space.F_basis(m, order_1=order_1) * E2**r)
+                     for m in range(min_exp, max_exp + 1))
 
     def quasi_part_dimension(self, r=None, min_exp=0, max_exp=infinity, order_1=ZZ.zero()):
         r"""
@@ -2097,7 +2097,7 @@ class FormsSpace_abstract(FormsRing_abstract):
             q^-1 + O(q^5)
 
             sage: MF = ModularForms(k=36)
-            sage: MF.q_basis() == MF.gens()
+            sage: MF.q_basis() == list(MF.gens())
             True
 
             sage: QF = QuasiModularForms(k=6)
@@ -2150,26 +2150,25 @@ class FormsSpace_abstract(FormsRing_abstract):
                     raise ValueError("Index out of range: m={} >= {}=dimension + min_exp".format(m, column_len + min_exp))
 
                 return q_basis[m - min_exp]
-            else:
-                row_len = self.required_laurent_prec(min_exp=min_exp, order_1=order_1) - min_exp
-                if (m >= row_len + min_exp):
-                    raise ValueError("Index out of range: m={} >= {}=required_precision + min_exp".format(m, row_len + min_exp))
-
-                A = self._quasi_form_matrix(min_exp=min_exp, order_1=order_1)
-                b = vector(self.coeff_ring(), row_len)
-                b[m - min_exp] = 1
-                try:
-                    coord_vector = A.solve_right(b)
-                except ValueError:
-                    raise ValueError("Unfortunately the q_basis vector (m={}, min_exp={}) doesn't exist in this case (this is rare/interesting, please report)".format(m, min_exp))
 
-                max_exp = order_inf + 1
-                basis = self.quasi_part_gens(min_exp=min_exp, max_exp=max_exp, order_1=order_1)
+            row_len = self.required_laurent_prec(min_exp=min_exp, order_1=order_1) - min_exp
+            if (m >= row_len + min_exp):
+                raise ValueError("Index out of range: m={} >= {}=required_precision + min_exp".format(m, row_len + min_exp))
 
-                column_len = A.dimensions()[1]
-                el = self(sum([coord_vector[l] * basis[l] for l in range(0, column_len)]))
+            A = self._quasi_form_matrix(min_exp=min_exp, order_1=order_1)
+            b = vector(self.coeff_ring(), row_len)
+            b[m - min_exp] = 1
+            try:
+                coord_vector = A.solve_right(b)
+            except ValueError:
+                raise ValueError("Unfortunately the q_basis vector (m={}, min_exp={}) doesn't exist in this case (this is rare/interesting, please report)".format(m, min_exp))
 
-                return el
+            max_exp = order_inf + 1
+            basis = self.quasi_part_gens(min_exp=min_exp, max_exp=max_exp, order_1=order_1)
+
+            column_len = A.dimensions()[1]
+            return self(sum([coord_vector[l] * basis[l]
+                             for l in range(column_len)]))
 
     def rationalize_series(self, laurent_series, coeff_bound=1e-10, denom_factor=ZZ(1)):
         r"""
@@ -2347,9 +2346,8 @@ class FormsSpace_abstract(FormsRing_abstract):
 
             return rational_coeff / d**m
 
-        laurent_series = sum([rationalize_coefficient(laurent_series[m], m) * q**m for m in range(first_exp, laurent_series.exponents()[-1] + 1)]).add_bigoh(series_prec)
-
-        return laurent_series
+        return sum([rationalize_coefficient(laurent_series[m], m) * q**m
+                    for m in range(first_exp, laurent_series.exponents()[-1] + 1)]).add_bigoh(series_prec)
 
     # DEFAULT METHODS (should be overwritten in concrete classes)
 
@@ -2491,11 +2489,11 @@ class FormsSpace_abstract(FormsRing_abstract):
 
         return self.module()(self.ambient_space().coordinate_vector(v))
 
-    def gens(self):
+    def gens(self) -> tuple:
         r"""
         This method should be overloaded by subclasses.
 
-        Return a basis of ``self``.
+        Return a basis of ``self`` as a tuple.
 
         Note that the coordinate vector of elements of ``self``
         are with respect to this basis.
@@ -2504,11 +2502,10 @@ class FormsSpace_abstract(FormsRing_abstract):
 
             sage: from sage.modular.modform_hecketriangle.space import ModularForms
             sage: ModularForms(k=12).gens() # defined in space.py
-            [1 + 196560*q^2 + 16773120*q^3 + 398034000*q^4 + O(q^5),
-             q - 24*q^2 + 252*q^3 - 1472*q^4 + O(q^5)]
+            (1 + 196560*q^2 + 16773120*q^3 + 398034000*q^4 + O(q^5),
+             q - 24*q^2 + 252*q^3 - 1472*q^4 + O(q^5))
         """
-
-        raise NotImplementedError("No generators are implemented yet for {}!".format(self))
+        raise NotImplementedError(f"No generators are implemented yet for {self}!")
 
     def gen(self, k=0):
         r"""

sage/modular/modform_hecketriangle/graded_ring_element.py

@@ -154,8 +154,6 @@ class FormsRingElement(CommutativeAlgebraElement, UniqueRepresentation,
             sage: MeromorphicModularFormsRing(n=3)(x) == MeromorphicModularFormsRing(n=4)(x)
             False
             sage: MeromorphicModularFormsRing()(-1/x) is MeromorphicModularFormsRing()(1/(-x))
-            False
-            sage: MeromorphicModularFormsRing()(-1/x) == MeromorphicModularFormsRing()(1/(-x))
             True
             sage: MeromorphicModularFormsRing(base_ring=CC)(-1/x) == MeromorphicModularFormsRing()(1/(-x))
             True
@@ -357,7 +355,7 @@ class FormsRingElement(CommutativeAlgebraElement, UniqueRepresentation,
         d = self.parent().get_d(fix_d=True)
         return self.parent()(self._rat.subs(d=d))
 
-    def is_homogeneous(self):
+    def is_homogeneous(self) -> bool:
         r"""
         Return whether ``self`` is homogeneous.
 
@@ -375,7 +373,6 @@ class FormsRingElement(CommutativeAlgebraElement, UniqueRepresentation,
             sage: QuasiModularFormsRing(n=infinity)(x*(x-y^2)+y^4).is_homogeneous()     # needs sage.symbolic
             True
         """
-
         return self._weight is not None
 
     def weight(self):
@@ -459,10 +456,11 @@ class FormsRingElement(CommutativeAlgebraElement, UniqueRepresentation,
         """
         return not (self.AT("quasi") <= self._analytic_type)
 
-    def is_weakly_holomorphic(self):
+    def is_weakly_holomorphic(self) -> bool:
         r"""
-        Return whether ``self`` is weakly holomorphic
-        in the sense that: ``self`` has at most a power of ``f_inf``
+        Return whether ``self`` is weakly holomorphic.
+
+        This means that ``self`` has at most a power of ``f_inf``
         in its denominator.
 
         EXAMPLES::
@@ -485,7 +483,7 @@ class FormsRingElement(CommutativeAlgebraElement, UniqueRepresentation,
 
         return self.AT("weak", "quasi") >= self._analytic_type
 
-    def is_holomorphic(self):
+    def is_holomorphic(self) -> bool:
         r"""
         Return whether ``self`` is holomorphic
         in the sense that the denominator of ``self``
@@ -510,10 +508,11 @@ class FormsRingElement(CommutativeAlgebraElement, UniqueRepresentation,
 
         return self.AT("holo", "quasi") >= self._analytic_type
 
-    def is_cuspidal(self):
+    def is_cuspidal(self) -> bool:
         r"""
-        Return whether ``self`` is cuspidal
-        in the sense that ``self`` is holomorphic and ``f_inf``
+        Return whether ``self`` is cuspidal.
+
+        This means that ``self`` is holomorphic and ``f_inf``
         divides the numerator.
 
         EXAMPLES::
@@ -536,7 +535,7 @@ class FormsRingElement(CommutativeAlgebraElement, UniqueRepresentation,
         """
         return self.AT("cusp", "quasi") >= self._analytic_type
 
-    def is_zero(self):
+    def is_zero(self) -> bool:
         r"""
         Return whether ``self`` is the zero function.