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/element.py

@@ -58,12 +58,12 @@ from sage.rings.real_mpfr import RealField
 from sage.structure.element import coercion_model, ModuleElement, Element
 from sage.structure.richcmp import richcmp, op_NE, op_EQ
 
-lazy_import('sage.combinat.integer_vector_weighted', 'WeightedIntegerVectors')
-lazy_import('sage.rings.number_field.number_field_morphisms', 'NumberFieldEmbedding')
-
 import sage.modular.hecke.element as element
 from . import defaults
 
+lazy_import('sage.combinat.integer_vector_weighted', 'WeightedIntegerVectors')
+lazy_import('sage.rings.number_field.number_field_morphisms', 'NumberFieldEmbedding')
+
 
 def is_ModularFormElement(x):
     """
@@ -338,7 +338,6 @@ class ModularForm_abstract(ModuleElement):
             sage: f(ComplexField(128)(1+2*I)/3 + x - x)  # rel tol 1e-36
             429.19994832206294278688085399056359632 - 786.15736284188243351153830824852974995*I
         """
-        from sage.rings.integer import Integer
         from sage.misc.functional import log
         from sage.structure.element import parent
         from sage.rings.complex_mpfr import ComplexNumber
@@ -358,7 +357,7 @@ class ModularForm_abstract(ModuleElement):
             if not isinstance(x, (RealNumber, ComplexNumber)):
                 x = CC(x)  # might lose precision if this is done unconditionally (TODO what about interval and ball types?)
         if isinstance(x, (RealNumber, ComplexNumber)):
-            return self.eval_at_tau(log(x)/(2*parent(x)(pi)*I))  # cast to parent(x) to force numerical evaluation of pi
+            return self.eval_at_tau(log(x) / (2 * parent(x)(pi) * I))  # cast to parent(x) to force numerical evaluation of pi
         return self.q_expansion(prec)(x)
 
     def eval_at_tau(self, tau):
@@ -394,7 +393,6 @@ class ModularForm_abstract(ModuleElement):
             sage: f.eval_at_tau(ComplexField(128)(1+2*I)/3 + x - x)  # rel tol 1e-36
             -1.0451570582202060056197878314286036966 + 2.7225112098519803098203933583286590274*I
         """
-        from sage.libs.pari.convert_sage import gen_to_sage
         from sage.libs.pari import pari
         from sage.rings.cc import CC
         from sage.rings.complex_mpfr import ComplexNumber, ComplexField
@@ -583,9 +581,9 @@ class ModularForm_abstract(ModuleElement):
             if n.stop is None:
                 return self.q_expansion().list()[n]
             else:
-                return self.q_expansion(n.stop+1).list()[n]
+                return self.q_expansion(n.stop + 1).list()[n]
         else:
-            return self.q_expansion(n+1)[int(n)]
+            return self.q_expansion(n + 1)[int(n)]
 
     def coefficient(self, n):
         r"""
@@ -611,7 +609,7 @@ class ModularForm_abstract(ModuleElement):
             -1472
         """
         n = ZZ(n)
-        return self.q_expansion(n+1)[n]
+        return self.q_expansion(n + 1)[n]
 
     def padded_list(self, n):
         """
@@ -999,11 +997,11 @@ class ModularForm_abstract(ModuleElement):
 
         M = self.group()(M)
         # coefficients of the matrix M
-        (b, c, d) = (M.b(), M.c() / N, M.d())
+        b, c, d = (M.b(), M.c() / N, M.d())
         if d == 0:
             return R.zero()
         if d < 0:
-            (b, c, d) = (-b, -c, -d)
+            b, c, d = (-b, -c, -d)
 
         twopi = 2 * R.pi()
         I = R.complex_field().gen()
@@ -1196,13 +1194,13 @@ class ModularForm_abstract(ModuleElement):
         # Find out how many coefficients of the Dirichlet series are needed
         # in order to compute to the required precision
         num_coeffs = L.num_coeffs()
-        coeffs = self.q_expansion(num_coeffs+1).padded_list()[1:]
+        coeffs = self.q_expansion(num_coeffs + 1).padded_list()[1:]
 
         # renormalize so that coefficient of q is 1
         b = coeffs[0]
         if b != 1:
-            invb = 1/b
-            coeffs = (invb*c for c in coeffs)
+            invb = 1 / b
+            coeffs = (invb * c for c in coeffs)
 
         v = [emb(c) for c in coeffs]
         w = [c.conjugate() for c in v]
@@ -1313,7 +1311,7 @@ class ModularForm_abstract(ModuleElement):
 
         # utility function for Dirichlet convolution of series
         def dirichlet_convolution(A, B):
-            return [sum(A[d-1] * B[n/d - 1] for d in divisors(n))
+            return [sum(A[d - 1] * B[n // d - 1] for d in divisors(n))
                     for n in range(1, 1 + min(len(A), len(B)))]
 
         # The Dirichlet series for \zeta(2 s - 2 k + 2)
@@ -1392,7 +1390,7 @@ class ModularForm_abstract(ModuleElement):
         pi = RealField(prec).pi()
         L = self.symsquare_lseries(prec=prec, embedding=embedding)
         k = self.weight()
-        return (ZZ(k - 1).factorial() / 2**(2*k - 1) / pi**(k+1)) * L(k).real_part()
+        return (ZZ(k - 1).factorial() / 2**(2 * k - 1) / pi**(k + 1)) * L(k).real_part()
 
     def _q_expansion_bound(self, eps):
         r"""
@@ -1440,11 +1438,11 @@ class ModularForm_abstract(ModuleElement):
                  chi.conductor() * eps.conductor()])
         y = QQ(self.weight()) / QQ(12) * M
         for p in M.prime_divisors():
-            y *= (1 + 1/QQ(p))
+            y *= (1 + 1 / QQ(p))
         return y.ceil()
 
     @cached_method
-    def has_cm(self):
+    def has_cm(self) -> bool:
         r"""
         Return whether the modular form ``self`` has complex multiplication.
 
@@ -1806,9 +1804,11 @@ class Newform(ModularForm_abstract):
         S = self.parent()
         return S(self.q_expansion(S.sturm_bound()))
 
-    def is_cuspidal(self):
+    def is_cuspidal(self) -> bool:
         """
-        Return True. For compatibility with elements of modular forms spaces.
+        Return ``True``.
+
+        For compatibility with elements of modular forms spaces.
 
         EXAMPLES::
 
@@ -1979,12 +1979,12 @@ class Newform(ModularForm_abstract):
             a2
         """
         if Q == 1:
-            return ZZ(1)
+            return ZZ.one()
         a_Q = self[Q]
         if not a_Q:
             raise ValueError("a_Q must be nonzero")
 
-        l = ZZ(1)
+        l = ZZ.one()
         M = self.character().conductor()
         for p, e in Q.factor():
             if p.divides(M):  # principal series at p
@@ -2019,7 +2019,7 @@ class Newform(ModularForm_abstract):
             True
         """
         if Q == 1:
-            return ZZ(1)
+            return ZZ.one()
 
         S = self._defining_modular_symbols()
         A = S.ambient()
@@ -2037,16 +2037,16 @@ class Newform(ModularForm_abstract):
                     continue
                 aa = crt(a, 1, Q, N.prime_to_m_part(Q))
                 diam = matrix(ZZ, 2, lift_to_sl2z(0, aa, N))
-                L.append((W * diam * matrix(QQ, 2, [1, a/Q0, 0, 1])).change_ring(ZZ))
+                L.append((W * diam * matrix(QQ, 2, [1, a / Q0, 0, 1])).change_ring(ZZ))
 
         W = A._matrix_of_operator_on_modular_symbols(A, [x.list() for x in L])
         e = S.dual_eigenvector(names=self._name())
         i = e.nonzero_positions()[0]
-        w = (W*e)[i]/e[i]
+        w = (W * e)[i] / e[i]
         if W * e != w * e:
             raise ArithmeticError("Bug in Atkin--Lehner computation: eigenspace not invariant")
         sign = prod([eps(-1) for eps in self.character().decomposition() if eps.conductor().divides(Q)])
-        return w / Q0 / sign * self.character()(crt(1, Q//Q0, Q, N//Q))
+        return w / Q0 / sign * self.character()(crt(1, Q // Q0, Q, N // Q))
 
     def atkin_lehner_action(self, d=None, normalization='analytic', embedding=None):
         r"""
@@ -2309,7 +2309,7 @@ class Newform(ModularForm_abstract):
         w3a = self._atkin_lehner_eigenvalue_from_modsym(d3)
         w3b = self._atkin_lehner_eigenvalue_from_qexp(d3)
         assert w3a == w3b
-        w = w1*w2*w3a
+        w = w1 * w2 * w3a
 
         if embedding is None:
             R = self.hecke_eigenvalue_field()
@@ -2334,9 +2334,9 @@ class Newform(ModularForm_abstract):
                     raise ValueError("Unable to compute Gauss sum. Try specifying an embedding into a larger ring")
             else:
                 G = R(1)
-            if not R(d**(self.weight()-2)).is_square():
+            if not R(d**(self.weight() - 2)).is_square():
                 raise ValueError("Unable to compute square root. Try specifying an embedding into a larger ring")
-            ratio = R(d**(self.weight()-2)).sqrt() * embedding(self.character()(crt(1, d//d0, d, N//d))) / G
+            ratio = R(d**(self.weight() - 2)).sqrt() * embedding(self.character()(crt(1, d // d0, d, N // d))) / G
             return embedding(w) / ratio
 
     def twist(self, chi, level=None, check=True):
@@ -2447,8 +2447,8 @@ class Newform(ModularForm_abstract):
                 alpha = N_epsilon.valuation(q)
                 beta = N_chi.valuation(q)
                 gamma = N.valuation(q)
-                delta = max(alpha + beta, 2*beta, gamma)
-                if delta == gamma and max(alpha + beta, 2*beta) < gamma:
+                delta = max(alpha + beta, 2 * beta, gamma)
+                if delta == gamma and max(alpha + beta, 2 * beta) < gamma:
                     continue
                 if delta > gamma and N_epsilon_chi.valuation(q) == max(alpha, beta):
                     continue
@@ -2468,7 +2468,7 @@ class Newform(ModularForm_abstract):
         for p in prime_range(500):
             if p.divides(chi.level()):
                 continue
-            D = (D.hecke_operator(p) - self[p]*chi(p)).kernel()
+            D = (D.hecke_operator(p) - self[p] * chi(p)).kernel()
             if D.rank() == 1:
                 break
             if D.is_zero():
@@ -2508,11 +2508,11 @@ class Newform(ModularForm_abstract):
         if p is None:
             # test local minimality at all primes
             for p in self.level().prime_divisors():
-                (g, chi) = self.minimal_twist(p)
+                g, chi = self.minimal_twist(p)
                 if g.level() < self.level():
                     h, tau = g.minimal_twist(p=None)
                     M = chi.modulus().lcm(tau.modulus())
-                    return (h, chi.extend(M)*tau.extend(M))
+                    return (h, chi.extend(M) * tau.extend(M))
             # f locally minimal at all p, hence globally minimal
             return (self, DirichletGroup(1, self.base_ring())(1))
 
@@ -2526,27 +2526,27 @@ class Newform(ModularForm_abstract):
         if (r == c) or (r == 1 and c == 0):
             # easy cases
             return (self, DirichletGroup(1, self.base_ring())(1))
-        elif r < 2*c:
+        elif r < 2 * c:
             # In this case we know that there is a unique chi of conductor p^u
             # such that self x chi has level N/p^u, where u = r-c, and this
             # twist is minimal.
             candidates = []
-            for chi in DirichletGroup(p**(r-c), self.base_ring()):
+            for chi in DirichletGroup(p**(r - c), self.base_ring()):
                 if not chi.is_primitive():
                     continue
                 try:
-                    g = self.twist(chi, level=N//p**(r-c))
+                    g = self.twist(chi, level=N // p**(r - c))
                     candidates.append((g, chi))
                 except ValueError:
                     continue
 
-            l = ZZ(1)
+            l = ZZ.one()
             while len(candidates) > 1:
                 l = l.next_prime()
                 if l == p:
                     continue
-                candidates = [(h, chi) for (h, chi) in candidates if h[l] == chi(l)*self[l]]
-                if l > 10000 or len(candidates) == 0:
+                candidates = [(h, chi) for (h, chi) in candidates if h[l] == chi(l) * self[l]]
+                if l > 10000 or not candidates:
                     raise RuntimeError("bug finding minimal twist")
             return candidates[0]
         else:
@@ -2558,27 +2558,27 @@ class Newform(ModularForm_abstract):
             T = TypeSpace(self, p)
             if T.is_minimal():
                 return (self, DirichletGroup(1, self.base_ring())(1))
+
+            g = T.minimal_twist()
+            epsg = g.character().extend(N)
+            chisq = (epsg / self.character()).restrict(p**(r // 2))
+            K = coercion_model.common_parent(self.base_ring(), g.base_ring())
+            chis = [chi for chi in DirichletGroup(p**(r // 2), K) if chi**2 == chisq]
+
+            if g.has_cm() and g.cm_discriminant().prime_divisors() == [p]:
+                # Quicker to test g than self, because g has smaller level.
+                t = 2
             else:
-                g = T.minimal_twist()
-                epsg = g.character().extend(N)
-                chisq = (epsg / self.character()).restrict(p**(r//2))
-                K = coercion_model.common_parent(self.base_ring(), g.base_ring())
-                chis = [chi for chi in DirichletGroup(p**(r//2), K) if chi**2 == chisq]
-
-                if g.has_cm() and g.cm_discriminant().prime_divisors() == [p]:
-                    # Quicker to test g than self, because g has smaller level.
-                    t = 2
-                else:
-                    t = 1
-                l = ZZ(1)
-                while len(chis) > t:
-                    l = l.next_prime()
-                    if l == p:
-                        continue
-                    chis = [chi for chi in chis if g[l] == chi(l) * self[l] ]
-                    if l > 10000 or len(chis) == 0:
-                        raise RuntimeError("bug finding minimal twist")
-                return (g, chis[0])
+                t = 1
+            l = ZZ.one()
+            while len(chis) > t:
+                l = l.next_prime()
+                if l == p:
+                    continue
+                chis = [chi for chi in chis if g[l] == chi(l) * self[l]]
+                if l > 10000 or not chis:
+                    raise RuntimeError("bug finding minimal twist")
+            return (g, chis[0])
 
     def local_component(self, p, twist_factor=None):
         """
@@ -3462,11 +3462,11 @@ class GradedModularFormElement(ModuleElement):
             sage: M([E4, ModularForms(3, 6).0])
             Traceback (most recent call last):
             ...
-            ValueError: the group and/or the base ring of at least one modular form (q - 6*q^2 + 9*q^3 + 4*q^4 + 6*q^5 + O(q^6)) is not consistant with the base space
+            ValueError: the group and/or the base ring of at least one modular form (q - 6*q^2 + 9*q^3 + 4*q^4 + 6*q^5 + O(q^6)) is not consistent with the base space
             sage: M({4:E4, 6:ModularForms(3, 6).0})
             Traceback (most recent call last):
             ...
-            ValueError: the group and/or the base ring of at least one modular form (q - 6*q^2 + 9*q^3 + 4*q^4 + 6*q^5 + O(q^6)) is not consistant with the base space
+            ValueError: the group and/or the base ring of at least one modular form (q - 6*q^2 + 9*q^3 + 4*q^4 + 6*q^5 + O(q^6)) is not consistent with the base space
             sage: M = ModularFormsRing(Gamma0(2))
             sage: E4 = ModularForms(1, 4).0
             sage: M(E4)[4].parent()
@@ -3489,7 +3489,7 @@ class GradedModularFormElement(ModuleElement):
                                 M = parent.modular_forms_of_weight(f.weight()).change_ring(parent.base_ring())
                                 forms_dictionary[k] = M(f)
                             else:
-                                raise ValueError('the group and/or the base ring of at least one modular form (%s) is not consistant with the base space' % (f))
+                                raise ValueError('the group and/or the base ring of at least one modular form (%s) is not consistent with the base space' % (f))
                         else:
                             raise ValueError('at least one key (%s) of the defining dictionary does not correspond to the weight of its value (%s). Real weight: %s' % (k, f, f.weight()))
                     else:
@@ -3506,15 +3506,15 @@ class GradedModularFormElement(ModuleElement):
                         M = parent.modular_forms_of_weight(f.weight()).change_ring(parent.base_ring())
                         forms_dictionary[f.weight()] = M(forms_dictionary.get(f.weight(), 0) + f)
                     else:
-                        raise ValueError('the group and/or the base ring of at least one modular form (%s) is not consistant with the base space' % (f))
+                        raise ValueError('the group and/or the base ring of at least one modular form (%s) is not consistent with the base space' % (f))
                 else:
-                    forms_dictionary[ZZ(0)] = parent.base_ring().coerce(f)
+                    forms_dictionary[ZZ.zero()] = parent.base_ring().coerce(f)
         else:
             raise TypeError('the defining data structure should be a list or a dictionary')
         self._forms_dictionary = {k: f for k, f in forms_dictionary.items() if not f.is_zero()}  # remove the zero values
         Element.__init__(self, parent)
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         r"""
         Return "True" if ``self`` is nonzero and "False" otherwise.
 
@@ -3530,7 +3530,7 @@ class GradedModularFormElement(ModuleElement):
         """
         return bool(self._forms_dictionary)
 
-    def is_zero(self):
+    def is_zero(self) -> bool:
         r"""
         Return "True" if the graded form is 0 and "False" otherwise.
 
@@ -3547,7 +3547,7 @@ class GradedModularFormElement(ModuleElement):
         """
         return not self
 
-    def is_one(self):
+    def is_one(self) -> bool:
         r"""
         Return "True" if the graded form is 1 and "False" otherwise.
 
@@ -3850,7 +3850,7 @@ class GradedModularFormElement(ModuleElement):
         """
         GM = self.__class__
         f_self = self._forms_dictionary
-        f_mul = {k: c*f for k, f in f_self.items()}
+        f_mul = {k: c * f for k, f in f_self.items()}
         return GM(self.parent(), f_mul)
 
     def _richcmp_(self, other, op):
@@ -3908,7 +3908,7 @@ class GradedModularFormElement(ModuleElement):
         """
         if self.is_homogeneous():
             if self.is_zero():
-                return ZZ(0)
+                return ZZ.zero()
             return next(iter(self._forms_dictionary))
         else:
             raise ValueError("the given graded form is not homogeneous (not a modular form)")
@@ -3930,10 +3930,10 @@ class GradedModularFormElement(ModuleElement):
             [0]
         """
         if self.is_zero():
-            return [ZZ(0)]
+            return [ZZ.zero()]
         return sorted(self._forms_dictionary)
 
-    def is_homogeneous(self):
+    def is_homogeneous(self) -> bool:
         r"""
         Return ``True`` if the graded modular form is homogeneous, i.e. if it
         is a modular forms of a certain weight.

sage/modular/modform/half_integral.py

@@ -101,7 +101,7 @@ def half_integral_weight_modform_basis(chi, k, prec):
 
     ALGORITHM: Basmaji (page 55 of his Essen thesis, "Ein Algorithmus
     zur Berechnung von Hecke-Operatoren und Anwendungen auf modulare
-    Kurven", http://wstein.org/scans/papers/basmaji/).
+    Kurven", https://web.archive.org/web/20160905111513/http://wstein.org/scans/papers/basmaji/thesis_of_basmaji.dvi).
 
     Let `S = S_{k+1}(\epsilon)` be the space of cusp forms of
     even integer weight `k+1` and character

sage/modular/modform/l_series_gross_zagier.py

@@ -1,5 +1,8 @@
 # sage_setup: distribution = sagemath-schemes
 # sage.doctest: needs database_cremona_mini_ellcurve
+r"""
+Gross-Zagier L-series
+"""
 from sage.rings.integer import Integer
 from sage.structure.sage_object import SageObject
 from sage.lfunctions.dokchitser import Dokchitser

sage/modular/modform/l_series_gross_zagier_coeffs.pyx

@@ -1,4 +1,7 @@
 # sage_setup: distribution = sagemath-schemes
+r"""
+Utilities for Gross-Zagier L-series
+"""
 from cysignals.memory cimport check_allocarray, check_calloc, sig_free
 from cysignals.signals cimport sig_check, sig_on, sig_off
 
@@ -15,7 +18,7 @@ from libc.string cimport memcpy
 
 cpdef to_series(L, var):
     """
-    Create a power series element out of a list ``L`` in the variable`` var``.
+    Create a power series element out of a list ``L`` in the variable ``var``.
 
     EXAMPLES::
 
@@ -43,7 +46,7 @@ def bqf_theta_series(Q, long bound, var=None):
 
     .. MATH::
 
-        \sum_{(x,y) \in \Z^2} q^{f(x,y)} = \sum_{n=-\infty}^{\infty} r(n)q^n
+        \sum_{(x,y) \in \ZZ^2} q^{f(x,y)} = \sum_{n=-\infty}^{\infty} r(n)q^n
 
     where `r(n)` give the number of way `n` is represented by `f`.
 

sage/modular/modform/ring.py

@@ -385,7 +385,7 @@ class ModularFormsRing(Parent):
         return PolynomialRing(self.base_ring(), len(gens), names,
                               order=TermOrder('wdeglex', degs))
 
-    def _generators_variables_dictionnary(self, poly_parent, gens):
+    def _generators_variables_dictionary(self, poly_parent, gens):
         r"""
         Return a dictionary giving an association between polynomial
         ring generators and generators of modular forms ring.
@@ -399,7 +399,7 @@ class ModularFormsRing(Parent):
 
             sage: M = ModularFormsRing(Gamma0(6))
             sage: P = QQ['x, y, z']
-            sage: M._generators_variables_dictionnary(P, M.gen_forms())
+            sage: M._generators_variables_dictionary(P, M.gen_forms())
             {z: q^2 - 2*q^3 + 3*q^4 + O(q^6),
              y: q + 5*q^3 - 2*q^4 + 6*q^5 + O(q^6),
              x: 1 + 24*q^3 + O(q^6)}
@@ -480,7 +480,7 @@ class ModularFormsRing(Parent):
             raise TypeError('`polynomial` must be a multivariate polynomial')
         if gens is None:
             gens = self.gen_forms()
-        dict = self._generators_variables_dictionnary(polynomial.parent(), gens)
+        dict = self._generators_variables_dictionary(polynomial.parent(), gens)
         if polynomial.is_constant():
             return self(polynomial.constant_coefficient())
         return polynomial.substitute(dict)
@@ -514,12 +514,12 @@ class ModularFormsRing(Parent):
             sage: M(f)
             Traceback (most recent call last):
             ...
-            ValueError: the group (Congruence Subgroup Gamma0(3)) and/or the base ring (Rational Field) of the given modular form is not consistant with the base space: Ring of Modular Forms for Modular Group SL(2,Z) over Rational Field
+            ValueError: the group (Congruence Subgroup Gamma0(3)) and/or the base ring (Rational Field) of the given modular form is not consistent with the base space: Ring of Modular Forms for Modular Group SL(2,Z) over Rational Field
             sage: M = ModularFormsRing(1, base_ring=ZZ)
             sage: M(ModularForms(1,4).0)
             Traceback (most recent call last):
             ...
-            ValueError: the group (Modular Group SL(2,Z)) and/or the base ring (Rational Field) of the given modular form is not consistant with the base space: Ring of Modular Forms for Modular Group SL(2,Z) over Integer Ring
+            ValueError: the group (Modular Group SL(2,Z)) and/or the base ring (Rational Field) of the given modular form is not consistent with the base space: Ring of Modular Forms for Modular Group SL(2,Z) over Integer Ring
             sage: M('x')
             Traceback (most recent call last):
             ...
@@ -539,7 +539,7 @@ class ModularFormsRing(Parent):
             if self.group().is_subgroup(forms_datum.group()) and self.base_ring().has_coerce_map_from(forms_datum.base_ring()):
                 forms_dictionary = {forms_datum.weight(): forms_datum}
             else:
-                raise ValueError('the group (%s) and/or the base ring (%s) of the given modular form is not consistant with the base space: %s' % (forms_datum.group(), forms_datum.base_ring(), self))
+                raise ValueError('the group (%s) and/or the base ring (%s) of the given modular form is not consistent with the base space: %s' % (forms_datum.group(), forms_datum.base_ring(), self))
         elif forms_datum in self.base_ring():
             forms_dictionary = {0: forms_datum}
         elif isinstance(forms_datum, MPolynomial):
@@ -1061,9 +1061,8 @@ class ModularFormsRing(Parent):
             V = _span_of_forms_in_weight(G, weight, prec=working_prec, use_random=use_random, stop_dim=d)
             if V.rank() == d and (self.base_ring().is_field() or V.index_in_saturation() == 1):
                 break
-            else:
-                gen_weight += 1
-                verbose("Need more generators: trying again with generators of weight up to %s" % gen_weight)
+            gen_weight += 1
+            verbose("Need more generators: trying again with generators of weight up to %s" % gen_weight)
 
         R = G[0][1].parent()
         return [R(list(x), prec=prec) for x in V.gens()]
@@ -1207,9 +1206,8 @@ class ModularFormsRing(Parent):
             W = A.span([A(f.padded_list(working_prec)) for f in flist])
             if W.rank() == d and (self.base_ring().is_field() or W.index_in_saturation() == 1):
                 break
-            else:
-                gen_weight += 1
-                verbose("Need more generators: trying again with generators of weight up to %s" % gen_weight)
+            gen_weight += 1
+            verbose("Need more generators: trying again with generators of weight up to %s" % gen_weight)
 
         R = G[0][1].parent()
         return [R(list(x), prec=prec) for x in W.gens()]

sage/modular/modform/space.py

@@ -328,7 +328,7 @@ class ModularFormsSpace(hecke.HeckeModule_generic):
         """
         return self.__character
 
-    def has_character(self):
+    def has_character(self) -> bool:
         r"""
         Return ``True`` if this space of modular forms has a specific
         character.
@@ -356,7 +356,7 @@ class ModularFormsSpace(hecke.HeckeModule_generic):
         """
         return self.character() is not None
 
-    def is_ambient(self):
+    def is_ambient(self) -> bool:
         """
         Return ``True`` if this an ambient space of modular forms.
 
@@ -664,9 +664,8 @@ class ModularFormsSpace(hecke.HeckeModule_generic):
             B = [f for f in self._compute_q_expansion_basis(current_prec) if f != 0]
             if len(B) == d:
                 break
-            else:
-                tries += 1
-                current_prec += d
+            tries += 1
+            current_prec += d
             if tries > 5:
                 print("WARNING: possible bug in q_expansion_basis for modular forms space %s" % self)
         if prec == -1:
@@ -1359,7 +1358,7 @@ class ModularFormsSpace(hecke.HeckeModule_generic):
         except IndexError:
             raise ValueError("Generator %s not defined" % n)
 
-    def gens(self):
+    def gens(self) -> tuple:
         """
         Return a complete set of generators for ``self``.
 
@@ -1367,13 +1366,13 @@ class ModularFormsSpace(hecke.HeckeModule_generic):
 
             sage: N = ModularForms(6,4)
             sage: N.gens()
-            [q - 2*q^2 - 3*q^3 + 4*q^4 + 6*q^5 + O(q^6),
+            (q - 2*q^2 - 3*q^3 + 4*q^4 + 6*q^5 + O(q^6),
              1 + O(q^6),
              q - 8*q^4 + 126*q^5 + O(q^6),
              q^2 + 9*q^4 + O(q^6),
-             q^3 + O(q^6)]
+             q^3 + O(q^6))
         """
-        return self.basis()
+        return tuple(self.basis())
 
     def sturm_bound(self, M=None):
         r"""
@@ -1484,7 +1483,7 @@ class ModularFormsSpace(hecke.HeckeModule_generic):
         else:
             assert S.dimension() == self.dimension()
             self.__is_cuspidal = True
-        S.__is_eisenstein = (S.dimension() == 0)
+        S.is_eisenstein.set_cache(S.dimension() == 0)
         S.__is_cuspidal = True
         return S
 
@@ -1511,7 +1510,7 @@ class ModularFormsSpace(hecke.HeckeModule_generic):
         """
         return self.cuspidal_submodule()
 
-    def is_cuspidal(self):
+    def is_cuspidal(self) -> bool:
         r"""
         Return ``True`` if this space is cuspidal.
 
@@ -1525,7 +1524,8 @@ class ModularFormsSpace(hecke.HeckeModule_generic):
         """
         return (self.cuspidal_submodule() == self)
 
-    def is_eisenstein(self):
+    @cached_method
+    def is_eisenstein(self) -> bool:
         r"""
         Return ``True`` if this space is Eisenstein.
 
@@ -1659,28 +1659,25 @@ class ModularFormsSpace(hecke.HeckeModule_generic):
             sage: W.eisenstein_submodule()
             Modular Forms subspace of dimension 0 of Modular Forms space of dimension 11 for Congruence Subgroup Gamma0(6) of weight 10 over Rational Field
         """
-        try:
-            if self.__is_eisenstein:
-                return self
-        except AttributeError:
-            pass
+        if self.is_eisenstein.cache is True:
+            return self
 
         if self.is_ambient():
             raise NotImplementedError("ambient modular forms spaces must override eisenstein_submodule")
         A = self.ambient_module().eisenstein_submodule()
         E = self.intersection(A)
         if E.dimension() < self.dimension():
-            self.__is_eisenstein = False
+            self.is_eisenstein.set_cache(False)
         else:
             assert E.dimension() == self.dimension()
-            self.__is_eisenstein = True
+            self.is_eisenstein.set_cache(True)
         E.__is_cuspidal = (E.dimension() == 0)
-        E.__is_eisenstein = True
+        E.is_eisenstein.set_cache(True)
         return E
 
     def eisenstein_subspace(self):
         """
-        Synonym for eisenstein_submodule.
+        Synonym for :meth:`eisenstein_submodule`.
 
         EXAMPLES::
 

sage/modular/modform/weight1.py

@@ -187,8 +187,7 @@ def hecke_stable_subspace(chi, aux_prime=ZZ(2)):
     if D.dimension() != 0:
         raise ArithmeticError("Got non-cuspidal form!")
     verbose("Done", t=t, level=1)
-    qexps = Sequence(A(x.list()).add_bigoh(R) for x in J.gens())
-    return qexps
+    return Sequence(A(x.list()).add_bigoh(R) for x in J.gens())
 
 
 @cached_function