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

@@ -231,11 +231,9 @@ class MFSeriesConstructor(SageObject, UniqueRepresentation):
         # the current implementation of power series reversion is slow
         # J_inv_ZZ = ZZ(1) / ((q*Phi.exp()).reverse())
 
-        temp_f = (q*Phi.exp()).polynomial()
-        new_f = temp_f.revert_series(temp_f.degree()+1)
-        J_inv_ZZ = ZZ.one() / (new_f + O(q**(temp_f.degree()+1)))
-
-        return J_inv_ZZ
+        temp_f = (q * Phi.exp()).polynomial()
+        new_f = temp_f.revert_series(temp_f.degree() + 1)
+        return ZZ.one() / (new_f + O(q**(temp_f.degree() + 1)))
 
     @cached_method
     def f_rho_ZZ(self):
@@ -364,15 +362,15 @@ class MFSeriesConstructor(SageObject, UniqueRepresentation):
             q^-1 - 1/8 - 59/1024*q + O(q^2)
         """
         n = self.hecke_n()
-        # Note that G_inv is not a weakly holomorphic form (because of the behavior at -1)
+        # Note that G_inv is not a weakly holomorphic form (because of
+        # the behavior at -1)
         if n == infinity:
             q = self._series_ring.gen()
             temp_expr = (self.J_inv_ZZ()/self.f_inf_ZZ()*q**2).power_series()
             return 1/q*self.f_i_ZZ()*(temp_expr.log()/2).exp()
-        elif (ZZ(2).divides(n)):
+        if (ZZ(2).divides(n)):
             return self.f_i_ZZ()*(self.f_rho_ZZ()**(ZZ(n/ZZ(2))))/self.f_inf_ZZ()
-        else:
-            raise ValueError("G_inv doesn't exist for n={}.".format(self.hecke_n()))
+        raise ValueError("G_inv doesn't exist for n={}.".format(self.hecke_n()))
 
     @cached_method
     def E4_ZZ(self):
@@ -398,10 +396,8 @@ class MFSeriesConstructor(SageObject, UniqueRepresentation):
             sage: MFSeriesConstructor(group=infinity, prec=3).E4_ZZ()
             1 + 1/4*q + 7/256*q^2 + O(q^3)
         """
-
         q = self._series_ring.gen()
-        E4_ZZ = ((-q*self.J_inv_ZZ().derivative())**2/(self.J_inv_ZZ()*(self.J_inv_ZZ()-1))).power_series()
-        return E4_ZZ
+        return ((-q*self.J_inv_ZZ().derivative())**2 / (self.J_inv_ZZ()*(self.J_inv_ZZ()-1))).power_series()
 
     @cached_method
     def E6_ZZ(self):
@@ -427,10 +423,8 @@ class MFSeriesConstructor(SageObject, UniqueRepresentation):
             sage: MFSeriesConstructor(group=infinity, prec=3).E6_ZZ()
             1 - 1/8*q - 31/512*q^2 + O(q^3)
         """
-
         q = self._series_ring.gen()
-        E6_ZZ = ((-q*self.J_inv_ZZ().derivative())**3/(self.J_inv_ZZ()**2*(self.J_inv_ZZ()-1))).power_series()
-        return E6_ZZ
+        return ((-q*self.J_inv_ZZ().derivative())**3 / (self.J_inv_ZZ()**2*(self.J_inv_ZZ()-1))).power_series()
 
     @cached_method
     def Delta_ZZ(self):
@@ -483,10 +477,8 @@ class MFSeriesConstructor(SageObject, UniqueRepresentation):
             sage: MFSeriesConstructor(group=infinity, prec=3).E2_ZZ()
             1 - 1/8*q - 1/512*q^2 + O(q^3)
         """
-
         q = self._series_ring.gen()
-        E2_ZZ = (q*self.f_inf_ZZ().derivative())/self.f_inf_ZZ()
-        return E2_ZZ
+        return (q * self.f_inf_ZZ().derivative()) / self.f_inf_ZZ()
 
     @cached_method
     def EisensteinSeries_ZZ(self, k):

sage/modular/modform_hecketriangle/space.py

@@ -220,9 +220,9 @@ class QuasiModularForms(FormsSpace_abstract, Module, UniqueRepresentation):
         self._module = FreeModule(self.coeff_ring(), self.dimension())
 
     @cached_method
-    def gens(self):
+    def gens(self) -> tuple:
         r"""
-        Return a basis of ``self`` as a list of basis elements.
+        Return a basis of ``self`` as a tuple of basis elements.
 
         EXAMPLES::
 
@@ -230,16 +230,15 @@ class QuasiModularForms(FormsSpace_abstract, Module, UniqueRepresentation):
             sage: MF = QuasiModularForms(n=5, k=6, ep=-1)
             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))
 
             sage: MF = QuasiModularForms(n=infinity, k=2, ep=-1)
             sage: MF.default_prec(2)
             sage: MF.gens()
-            [1 - 24*q + O(q^2), 1 - 8*q + O(q^2)]
+            (1 - 24*q + O(q^2), 1 - 8*q + O(q^2))
         """
-
         return self.quasi_part_gens()
 
     @cached_method
@@ -256,7 +255,6 @@ class QuasiModularForms(FormsSpace_abstract, Module, UniqueRepresentation):
             sage: len(MF.gens()) == MF.dimension()
             True
         """
-
         return self.quasi_part_dimension()
 
     @cached_method
@@ -385,9 +383,9 @@ class QuasiCuspForms(FormsSpace_abstract, Module, UniqueRepresentation):
         self._module = FreeModule(self.coeff_ring(), self.dimension())
 
     @cached_method
-    def gens(self):
+    def gens(self) -> tuple:
         r"""
-        Return a basis of ``self`` as a list of basis elements.
+        Return a basis of ``self`` as a tuple of basis elements.
 
         EXAMPLES::
 
@@ -397,19 +395,18 @@ class QuasiCuspForms(FormsSpace_abstract, Module, UniqueRepresentation):
             sage: MF.dimension()
             7
             sage: MF.gens()
-            [q - 17535/(262144*d^2)*q^3 + O(q^4),
+            (q - 17535/(262144*d^2)*q^3 + O(q^4),
              q^2 - 47/(128*d)*q^3 + O(q^4),
              q - 9/(128*d)*q^2 + 15633/(262144*d^2)*q^3 + O(q^4),
              q^2 - 7/(128*d)*q^3 + O(q^4),
              q - 23/(64*d)*q^2 - 3103/(262144*d^2)*q^3 + O(q^4),
              q - 3/(64*d)*q^2 - 4863/(262144*d^2)*q^3 + O(q^4),
-             q - 27/(64*d)*q^2 + 17217/(262144*d^2)*q^3 + O(q^4)]
+             q - 27/(64*d)*q^2 + 17217/(262144*d^2)*q^3 + O(q^4))
 
             sage: MF = QuasiCuspForms(n=infinity, k=10, ep=-1)
             sage: MF.gens()
-            [q - 16*q^2 - 156*q^3 - 256*q^4 + O(q^5), q - 60*q^3 - 256*q^4 + O(q^5)]
+            (q - 16*q^2 - 156*q^3 - 256*q^4 + O(q^5), q - 60*q^3 - 256*q^4 + O(q^5))
         """
-
         return self.quasi_part_gens()
 
     @cached_method
@@ -661,9 +658,9 @@ class ModularForms(FormsSpace_abstract, Module, UniqueRepresentation):
         self._module = FreeModule(self.coeff_ring(), self.dimension())
 
     @cached_method
-    def gens(self):
+    def gens(self) -> tuple:
         r"""
-        Return a basis of ``self`` as a list of basis elements.
+        Return a basis of ``self`` as a tuple of basis elements.
 
         EXAMPLES::
 
@@ -672,15 +669,16 @@ class ModularForms(FormsSpace_abstract, Module, UniqueRepresentation):
             sage: MF.dimension()
             4
             sage: MF.gens()
-            [1 + 360360*q^4 + O(q^5),
+            (1 + 360360*q^4 + O(q^5),
              q + 21742*q^4 + O(q^5),
              q^2 + 702*q^4 + O(q^5),
-             q^3 - 6*q^4 + O(q^5)]
+             q^3 - 6*q^4 + O(q^5))
 
             sage: ModularForms(n=infinity, k=4).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))
         """
-        return [self.F_basis(m) for m in range(self.dimension())]
+        return tuple(self.F_basis(m) for m in range(self.dimension()))
 
     @cached_method
     def dimension(self):
@@ -801,9 +799,9 @@ class CuspForms(FormsSpace_abstract, Module, UniqueRepresentation):
         self._module = FreeModule(self.coeff_ring(), self.dimension())
 
     @cached_method
-    def gens(self):
+    def gens(self) -> tuple:
         r"""
-        Return a basis of ``self`` as a list of basis elements.
+        Return a basis of ``self`` as a tuple of basis elements.
 
         EXAMPLES::
 
@@ -814,16 +812,16 @@ class CuspForms(FormsSpace_abstract, Module, UniqueRepresentation):
             sage: MF.dimension()
             3
             sage: MF.gens()
-            [q + 296888795/(10319560704*d^3)*q^4 + O(q^5),
+            (q + 296888795/(10319560704*d^3)*q^4 + O(q^5),
              q^2 + 6629/(221184*d^2)*q^4 + O(q^5),
-             q^3 - 25/(96*d)*q^4 + O(q^5)]
+             q^3 - 25/(96*d)*q^4 + O(q^5))
 
             sage: MF = CuspForms(n=infinity, k=8, ep=1)
             sage: MF.gen(0) == MF.E4()*MF.f_inf()
             True
         """
-        return [self.F_basis(m, order_1=ZZ.one())
-                for m in range(1, self.dimension() + 1)]
+        return tuple(self.F_basis(m, order_1=ZZ.one())
+                     for m in range(1, self.dimension() + 1))
 
     @cached_method
     def dimension(self):
@@ -979,18 +977,19 @@ class ZeroForm(FormsSpace_abstract, Module, UniqueRepresentation):
                         k=k, ep=ep)
 
     @cached_method
-    def gens(self):
+    def gens(self) -> tuple:
         r"""
-        Return a basis of ``self`` as a list of basis elements.
-        Since this is the zero module an empty list is returned.
+        Return a basis of ``self`` as a tuple of basis elements.
+
+        Since this is the zero module an empty tuple is returned.
 
         EXAMPLES::
 
             sage: from sage.modular.modform_hecketriangle.space import ZeroForm
             sage: ZeroForm(6, CC, 3, -1).gens()
-            []
+            ()
         """
-        return []
+        return ()
 
     @cached_method
     def dimension(self):

sage/modular/modform_hecketriangle/subspace.py

@@ -74,7 +74,8 @@ def ModularFormsSubSpace(*args, **kwargs):
         sage: subspace.ambient_space()
         ModularForms(n=3, k=12, ep=1) over Integer Ring
         sage: subspace.gens()
-        [1 + 720*q + 179280*q^2 + 16954560*q^3 + 396974160*q^4 + O(q^5), 1 - 1007*q + 220728*q^2 + 16519356*q^3 + 399516304*q^4 + O(q^5)]
+        (1 + 720*q + 179280*q^2 + 16954560*q^3 + 396974160*q^4 + O(q^5),
+         1 - 1007*q + 220728*q^2 + 16519356*q^3 + 399516304*q^4 + O(q^5))
         sage: ModularFormsSubSpace(MF.E4()^3-MF.E6()^2, reduce=True).ambient_space()
         CuspForms(n=3, k=12, ep=1) over Integer Ring
         sage: ModularFormsSubSpace(MF.E4()^3-MF.E6()^2, MF.J_inv()*MF.E4()^3, reduce=True)
@@ -187,7 +188,8 @@ class SubSpaceForms(FormsSpace_abstract, Module, UniqueRepresentation):
             sage: subspace.basis()[0].parent() == MF
             True
             sage: subspace.gens()
-            [q + 78*q^2 + 2781*q^3 + 59812*q^4 + O(q^5), 1 + 360360*q^4 + O(q^5)]
+            (q + 78*q^2 + 2781*q^3 + 59812*q^4 + O(q^5),
+             1 + 360360*q^4 + O(q^5))
             sage: subspace.gens()[0].parent() == subspace
             True
             sage: subspace.is_ambient()
@@ -201,7 +203,7 @@ class SubSpaceForms(FormsSpace_abstract, Module, UniqueRepresentation):
             sage: subspace
             Subspace of dimension 3 of QuasiCuspForms(n=+Infinity, k=12, ep=1) over Integer Ring
             sage: subspace.gens()
-            [q + 24*q^2 + O(q^3), q - 24*q^2 + O(q^3), q - 8*q^2 + O(q^3)]
+            (q + 24*q^2 + O(q^3), q - 24*q^2 + O(q^3), q - 8*q^2 + O(q^3))
         """
         FormsSpace_abstract.__init__(self, group=ambient_space.group(), base_ring=ambient_space.base_ring(), k=ambient_space.weight(), ep=ambient_space.ep(), n=ambient_space.hecke_n())
         Module.__init__(self, base=ambient_space.base_ring())
@@ -209,7 +211,7 @@ class SubSpaceForms(FormsSpace_abstract, Module, UniqueRepresentation):
         self._ambient_space = ambient_space
         self._basis = list(basis)
         # self(v) instead would somehow mess up the coercion model
-        self._gens = [self._element_constructor_(v) for v in basis]
+        self._gens = tuple(self._element_constructor_(v) for v in basis)
         self._module = ambient_space._module.submodule([ambient_space.coordinate_vector(v) for v in basis])
         # TODO: get the analytic type from the basis
         # self._analytic_type=self.AT(["quasi", "mero"])
@@ -307,7 +309,7 @@ class SubSpaceForms(FormsSpace_abstract, Module, UniqueRepresentation):
         return self._basis
 
     @cached_method
-    def gens(self):
+    def gens(self) -> tuple:
         r"""
         Return the basis of ``self``.
 
@@ -317,11 +319,11 @@ class SubSpaceForms(FormsSpace_abstract, Module, UniqueRepresentation):
             sage: MF = ModularForms(n=6, k=20, ep=1)
             sage: subspace = MF.subspace([(MF.Delta()*MF.E4()^2).as_ring_element(), MF.gen(0)])
             sage: subspace.gens()
-            [q + 78*q^2 + 2781*q^3 + 59812*q^4 + O(q^5), 1 + 360360*q^4 + O(q^5)]
+            (q + 78*q^2 + 2781*q^3 + 59812*q^4 + O(q^5),
+             1 + 360360*q^4 + O(q^5))
             sage: subspace.gens()[0].parent() == subspace
             True
         """
-
         return self._gens
 
     @cached_method

sage/modular/modsym/ambient.py

@@ -1051,8 +1051,7 @@ class ModularSymbolsAmbient(ModularSymbolsSpace, AmbientHeckeModule):
         hom = self.Hom(M)
         if self.dimension() == 0 or M.dimension() == 0:
             A = MS(0)
-            phi = hom(A, "Heilbronn operator(%s,%s)" % (H, t))
-            return phi
+            return hom(A, "Heilbronn operator(%s,%s)" % (H, t))
 
         rows = []
         B = self.manin_basis()
@@ -1776,7 +1775,7 @@ class ModularSymbolsAmbient(ModularSymbolsSpace, AmbientHeckeModule):
 
     factor = factorization
 
-    def is_cuspidal(self):
+    def is_cuspidal(self) -> bool:
         r"""
         Return ``True`` if this space is cuspidal, else ``False``.
 
@@ -1799,7 +1798,8 @@ class ModularSymbolsAmbient(ModularSymbolsSpace, AmbientHeckeModule):
             self.__is_cuspidal = (S.dimension() == self.dimension())
         return self.__is_cuspidal
 
-    def is_eisenstein(self):
+    @cached_method
+    def is_eisenstein(self) -> bool:
         r"""
         Return ``True`` if this space is Eisenstein, else ``False``.
 
@@ -1815,12 +1815,8 @@ class ModularSymbolsAmbient(ModularSymbolsSpace, AmbientHeckeModule):
             sage: S.is_eisenstein()
             False
         """
-        try:
-            return self.__is_eisenstein
-        except AttributeError:
-            S = self.ambient_hecke_module().eisenstein_submodule()
-            self.__is_eisenstein = self.dimension() == S.dimension()
-        return self.__is_eisenstein
+        S = self.ambient_hecke_module().eisenstein_submodule()
+        return self.dimension() == S.dimension()
 
     def manin_symbols_basis(self):
         """
@@ -2672,8 +2668,7 @@ class ModularSymbolsAmbient_wtk_g0(ModularSymbolsAmbient):
                 z += M((i, hg[1, 0], hg[1, 1]))
             rows.append(z.element())
 
-        A = MS(rows)
-        return A
+        return MS(rows)
 
     def _cuspidal_new_submodule_dimension_formula(self):
         r"""
@@ -3262,8 +3257,7 @@ class ModularSymbolsAmbient_wtk_g1(ModularSymbolsAmbient):
                 z += M((i, hg[1, 0], hg[1, 1]))
             rows.append(z.element())
 
-        A = MS(rows)
-        return A
+        return MS(rows)
 
     def boundary_space(self):
         r"""
@@ -3340,7 +3334,7 @@ class ModularSymbolsAmbient_wtk_gamma_h(ModularSymbolsAmbient):
             9
             sage: M._dimension_formula()
         """
-        return None
+        return
 
     def _repr_(self):
         r"""
@@ -3364,7 +3358,7 @@ class ModularSymbolsAmbient_wtk_gamma_h(ModularSymbolsAmbient):
             sage: ModularSymbols(GammaH(15,[4]),2)._cuspidal_submodule_dimension_formula() is None
             True
         """
-        return None
+        return
 
     def _cuspidal_new_submodule_dimension_formula(self):
         r"""
@@ -3375,7 +3369,7 @@ class ModularSymbolsAmbient_wtk_gamma_h(ModularSymbolsAmbient):
             sage: ModularSymbols(GammaH(15,[4]),2)._cuspidal_new_submodule_dimension_formula() is None
             True
         """
-        return None
+        return
 
     def _compute_hecke_matrix_prime_power(self, p, r):
         r"""
@@ -3669,8 +3663,7 @@ class ModularSymbolsAmbient_wtk_eps(ModularSymbolsAmbient):
                 hg = h * g
                 z += eps(h[0, 0]) * M((i, hg[1, 0], hg[1, 1]))
             rows.append(z.element())
-        A = MS(rows)
-        return A
+        return MS(rows)
 
     def _dimension_formula(self):
         r"""
@@ -3684,7 +3677,7 @@ class ModularSymbolsAmbient_wtk_eps(ModularSymbolsAmbient):
             0
             sage: M._dimension_formula()
         """
-        return None
+        return
 
     def boundary_space(self):
         r"""

sage/modular/modsym/boundary.py

@@ -341,7 +341,7 @@ class BoundarySpace(hecke.HeckeModule_generic):
                        (other.group(), other.weight(), other.character()),
                        op)
 
-    def _known_cusps(self):
+    def _known_cusps(self) -> list:
         """
         Return the list of non-vanishing cusps found so far.
 
@@ -356,7 +356,7 @@ class BoundarySpace(hecke.HeckeModule_generic):
         """
         return list(self._known_gens)
 
-    def is_ambient(self):
+    def is_ambient(self) -> bool:
         """
         Return ``True`` if ``self`` is a space of boundary symbols
         associated to an ambient space of modular symbols.

sage/modular/modsym/manin_symbol_list.py

@@ -38,6 +38,7 @@ import sage.modular.modsym.ghlist as ghlist
 from sage.rings.integer import Integer
 from sage.structure.parent import Parent
 from sage.misc.persist import register_unpickle_override
+from sage.misc.cachefunc import cached_method
 from sage.structure.richcmp import richcmp_method, richcmp
 from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
 
@@ -284,6 +285,7 @@ class ManinSymbolList(Parent):
         except KeyError:
             return -1
 
+    @cached_method
     def manin_symbol_list(self):
         """
         Return all the Manin symbols in ``self`` as a list.
@@ -313,13 +315,7 @@ class ManinSymbolList(Parent):
             [X^2,(3,1)],
             [X^2,(3,2)]]
         """
-        import copy
-        try:
-            return copy.copy(self.__manin_symbol_list)
-        except AttributeError:
-            self.__manin_symbol_list = [self.manin_symbol(i)
-                                        for i in range(len(self))]
-        return copy.copy(self.__manin_symbol_list)
+        return [self.manin_symbol(i) for i in range(len(self))]
 
     list = manin_symbol_list
 

sage/modular/modsym/space.py

@@ -407,7 +407,7 @@ class ModularSymbolsSpace(HeckeModule_free_module):
         """
         return self.__group
 
-    def is_ambient(self):
+    def is_ambient(self) -> bool:
         """
         Return ``True`` if ``self`` is an ambient space of modular symbols.
 
@@ -421,7 +421,7 @@ class ModularSymbolsSpace(HeckeModule_free_module):
         from sage.modular.modsym.ambient import ModularSymbolsAmbient
         return isinstance(self, ModularSymbolsAmbient)
 
-    def is_cuspidal(self):
+    def is_cuspidal(self) -> bool:
         """
         Return ``True`` if ``self`` is a cuspidal space of modular symbols.
 
@@ -440,7 +440,7 @@ class ModularSymbolsSpace(HeckeModule_free_module):
         """
         raise NotImplementedError("computation of cuspidal subspace not yet implemented for this class")
 
-    def is_simple(self):
+    def is_simple(self) -> bool:
         r"""
         Return whether this modular symbols space is simple as a module
         over the anemic Hecke algebra adjoin \*.
@@ -1260,11 +1260,9 @@ class ModularSymbolsSpace(HeckeModule_free_module):
             # should we perhaps check at this point if self is new?
             f = self.q_eigenform(prec, names)
             R = PowerSeriesRing(self.base_ring(), 'q')
-            B = [R([f[i][j] for i in range(prec)], prec)
-                 for j in range(self.rank())]
-            return B
-        else:
-            raise NotImplementedError
+            return [R([f[i][j] for i in range(prec)], prec)
+                    for j in range(self.rank())]
+        raise NotImplementedError
 
     #########################################################################
     #
@@ -2127,6 +2125,7 @@ class ModularSymbolsSpace(HeckeModule_free_module):
     # Cuspidal torsion groups
     #########################################################
 
+    @cached_method
     def abvarquo_cuspidal_subgroup(self):
         """
         Compute the rational subgroup of the cuspidal subgroup (as an
@@ -2151,10 +2150,6 @@ class ModularSymbolsSpace(HeckeModule_free_module):
             sage: [A.abvarquo_cuspidal_subgroup().invariants() for A in D]
             [(), (), ()]
         """
-        try:
-            return self.__abvarquo_cuspidal_subgroup
-        except AttributeError:
-            pass
         if self.base_ring() != QQ:
             raise ValueError("base ring must be QQ")
         if self.weight() != 2:
@@ -2163,7 +2158,7 @@ class ModularSymbolsSpace(HeckeModule_free_module):
         phi = self.integral_period_mapping()
 
         # Make a list of all the finite cusps.
-        P = [c for c in M.cusps() if not c.is_infinity()]
+        P = (c for c in M.cusps() if not c.is_infinity())
 
         # Compute the images of the cusp classes (c)-(oo) in the
         # rational homology of the quotient modular abelian variety.
@@ -2174,11 +2169,9 @@ class ModularSymbolsSpace(HeckeModule_free_module):
 
         # The cuspidal subgroup is then the quotient of that module +
         # H_1(A) by H_1(A)
-        C = (A.ambient_module() + A) / A.ambient_module()
-
-        self.__abvarquo_cuspidal_subgroup = C
-        return C
+        return (A.ambient_module() + A) / A.ambient_module()
 
+    @cached_method
     def abvarquo_rational_cuspidal_subgroup(self):
         r"""
         Compute the rational subgroup of the cuspidal subgroup (as an
@@ -2242,10 +2235,6 @@ class ModularSymbolsSpace(HeckeModule_free_module):
             sage: [A.abelian_variety().rational_torsion_subgroup().multiple_of_order() for A in D]
             [1, 5, 5]
         """
-        try:
-            return self.__abvarquo_rational_cuspidal_subgroup
-        except AttributeError:
-            pass
         if self.base_ring() != QQ:
             raise ValueError("base ring must be QQ")
         if self.weight() != 2:
@@ -2297,7 +2286,6 @@ class ModularSymbolsSpace(HeckeModule_free_module):
             if CQ.cardinality() == 1:
                 break  # done -- no point in wasting more time shrinking CQ
 
-        self.__abvarquo_rational_cuspidal_subgroup = CQ
         return CQ
 
     def _matrix_of_galois_action(self, t, P):

sage/modular/modsym/subspace.py

@@ -23,6 +23,7 @@ Subspace of ambient spaces of modular symbols
 import sage.modular.hecke.all as hecke
 import sage.structure.factorization
 import sage.modular.modsym.space
+from sage.misc.cachefunc import cached_method
 
 
 class ModularSymbolsSubspace(sage.modular.modsym.space.ModularSymbolsSpace, hecke.HeckeSubmodule):
@@ -354,7 +355,8 @@ class ModularSymbolsSubspace(sage.modular.modsym.space.ModularSymbolsSpace, heck
         """
         self.__is_cuspidal = t
 
-    def is_eisenstein(self):
+    @cached_method
+    def is_eisenstein(self) -> bool:
         """
         Return ``True`` if ``self`` is an Eisenstein subspace.
 
@@ -365,12 +367,8 @@ class ModularSymbolsSubspace(sage.modular.modsym.space.ModularSymbolsSpace, heck
             sage: ModularSymbols(22,6).eisenstein_submodule().is_eisenstein()
             True
         """
-        try:
-            return self.__is_eisenstien
-        except AttributeError:
-            C = self.ambient_hecke_module().eisenstein_subspace()
-            self.__is_eisenstein = self.is_submodule(C)
-            return self.__is_eisenstein
+        C = self.ambient_hecke_module().eisenstein_subspace()
+        return self.is_submodule(C)
 
     def _compute_sign_subspace(self, sign, compute_dual=True):
         """