passagemath-schemes 10.6.40__cp314-cp314-macosx_13_0_arm64.whl

sage/modular/modform/ambient_R.py

@@ -0,0 +1,177 @@
+# sage_setup: distribution = sagemath-schemes
+# sage.doctest: needs sage.libs.pari
+"""
+Modular forms over a non-minimal base ring
+"""
+
+#########################################################################
+#       Copyright (C) 2006 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#                  http://www.gnu.org/licenses/
+#########################################################################
+
+from . import ambient
+from .cuspidal_submodule import CuspidalSubmodule_R
+from sage.rings.integer_ring import ZZ
+from sage.misc.cachefunc import cached_method
+
+
+class ModularFormsAmbient_R(ambient.ModularFormsAmbient):
+    def __init__(self, M, base_ring):
+        """
+        Ambient space of modular forms over a ring other than QQ.
+
+        EXAMPLES::
+
+            sage: M = ModularForms(23, 2, base_ring=GF(7)) # indirect doctest
+            sage: M
+            Modular Forms space of dimension 3 for Congruence Subgroup Gamma0(23)
+             of weight 2 over Finite Field of size 7
+            sage: M == loads(dumps(M))
+            True
+        """
+        self.__M = M
+        if M.character() is not None:
+            self.__R_character = M.character().change_ring(base_ring)
+        else:
+            self.__R_character = None
+        ambient.ModularFormsAmbient.__init__(self, M.group(), M.weight(), base_ring, M.character(), M._eis_only)
+
+    @cached_method(key=lambda self,sign: ZZ(sign)) # convert sign to an Integer before looking this up in the cache
+    def modular_symbols(self, sign=0):
+        r"""
+        Return the space of modular symbols attached to this space, with the given sign (default 0).
+
+        TESTS::
+
+            sage: # needs sage.rings.number_field
+            sage: K.<i> = QuadraticField(-1)
+            sage: chi = DirichletGroup(5, base_ring=K).0
+            sage: x = polygen(ZZ, 'x')
+            sage: L.<c> = K.extension(x^2 - 402*i)
+            sage: M = ModularForms(chi, 7, base_ring=L)
+            sage: symbs = M.modular_symbols()
+            sage: symbs.character() == chi
+            True
+            sage: symbs.base_ring() == L
+            True
+        """
+        sign = ZZ(sign)
+        return self.__M.modular_symbols(sign).change_ring(self.base_ring())
+
+    def _repr_(self):
+        """
+        String representation for ``self``.
+
+        EXAMPLES::
+
+            sage: M = ModularForms(23,2,base_ring=GF(7)) # indirect doctest
+            sage: M._repr_()
+            'Modular Forms space of dimension 3 for Congruence Subgroup Gamma0(23) of weight 2 over Finite Field of size 7'
+
+            sage: # needs sage.rings.number_field
+            sage: chi = DirichletGroup(109).0 ** 36
+            sage: ModularForms(chi, 2, base_ring = chi.base_ring())
+            Modular Forms space of dimension 9, character [zeta3] and weight 2 over Cyclotomic Field of order 108 and degree 36
+        """
+        s = str(self.__M)
+        i = s.find('over')
+        if i != -1:
+            s = s[:i]
+        return s + 'over %s' % self.base_ring()
+
+    def _compute_q_expansion_basis(self, prec=None):
+        """
+        Compute `q`-expansions for a basis of ``self`` to precision ``prec``.
+
+        EXAMPLES::
+
+            sage: M = ModularForms(23,2,base_ring=GF(7))
+            sage: M._compute_q_expansion_basis(10)
+            [q + 6*q^3 + 6*q^4 + 5*q^6 + 2*q^7 + 6*q^8 + 2*q^9 + O(q^10),
+             q^2 + 5*q^3 + 6*q^4 + 2*q^5 + q^6 + 2*q^7 + 5*q^8 + O(q^10),
+             1 + 5*q^3 + 5*q^4 + 5*q^6 + 3*q^8 + 5*q^9 + O(q^10)]
+
+        TESTS:
+
+        This checks that :issue:`13445` is fixed::
+
+            sage: M = ModularForms(Gamma0(11), base_ring=GF(11))
+            sage: S = M.cuspidal_subspace()
+            sage: 0 in [f.valuation() for f in S.basis()]
+            False
+            sage: from sage.modular.dims import dimension_cusp_forms
+            sage: len(S.basis()) == dimension_cusp_forms(Gamma0(11), 2)
+            True
+        """
+        if prec is None:
+            prec = self.prec()
+        R = self._q_expansion_ring()
+        c = self.base_ring().characteristic()
+        if c == 0:
+            B = self.__M.q_expansion_basis(prec)
+            return [R(f) for f in B]
+        elif c.is_prime_power():
+            K = self.base_ring()
+            p = K.characteristic().prime_factors()[0]
+            from sage.rings.finite_rings.finite_field_constructor import GF
+            Kp = GF(p)
+            newB = [f.change_ring(K) for f in list(self.__M.cuspidal_subspace().q_integral_basis(prec))]
+            A = Kp**prec
+            gens = [f.padded_list(prec) for f in newB]
+            V = A.span(gens)
+            B = [f.change_ring(K) for f in self.__M.q_integral_basis(prec)]
+            for f in B:
+                fc = f.padded_list(prec)
+                gens.append(fc)
+                if not A.span(gens) == V:
+                    newB.append(f)
+                    V = A.span(gens)
+            if len(newB) != self.dimension():
+                raise RuntimeError("The dimension of the space is %s but the basis we computed has %s elements" % (self.dimension(), len(newB)))
+            lst = [R(f) for f in newB]
+            return [f/f[f.valuation()] for f in lst]
+        else:
+            # this returns a basis of q-expansions, without guaranteeing that
+            # the first vectors form a basis of the cuspidal subspace
+            # TODO: bring this in line with the other cases
+            # simply using the above code fails because free modules over
+            # general rings do not have a .span() method
+            B = self.__M.q_integral_basis(prec)
+            return [R(f) for f in B]
+
+    def cuspidal_submodule(self):
+        r"""
+        Return the cuspidal subspace of this space.
+
+        EXAMPLES::
+
+            sage: # needs sage.rings.number_field
+            sage: C = CuspForms(7, 4, base_ring=CyclotomicField(5))  # indirect doctest
+            sage: type(C)
+            <class 'sage.modular.modform.cuspidal_submodule.CuspidalSubmodule_R_with_category'>
+        """
+        return CuspidalSubmodule_R(self)
+
+    def change_ring(self, R):
+        r"""
+        Return this modular forms space with the base ring changed to the ring R.
+
+        EXAMPLES::
+
+            sage: # needs sage.rings.number_field
+            sage: chi = DirichletGroup(109, CyclotomicField(3)).0
+            sage: M9 = ModularForms(chi, 2, base_ring = CyclotomicField(9))
+            sage: M9.change_ring(CyclotomicField(15))
+            Modular Forms space of dimension 10, character [zeta3 + 1] and weight 2
+             over Cyclotomic Field of order 15 and degree 8
+            sage: M9.change_ring(QQ)
+            Traceback (most recent call last):
+            ...
+            ValueError: Space cannot be defined over Rational Field
+        """
+        if not R.has_coerce_map_from(self.__M.base_ring()):
+            raise ValueError("Space cannot be defined over %s" % R)
+        return ModularFormsAmbient_R(self.__M, R)

sage/modular/modform/ambient_eps.py

@@ -0,0 +1,306 @@
+# sage_setup: distribution = sagemath-schemes
+# sage.doctest: needs sage.libs.pari sage.rings.number_field
+r"""
+Modular forms with character
+
+EXAMPLES::
+
+    sage: eps = DirichletGroup(13).0
+    sage: M = ModularForms(eps^2, 2); M
+    Modular Forms space of dimension 3, character [zeta6] and weight 2 over
+     Cyclotomic Field of order 6 and degree 2
+
+    sage: S = M.cuspidal_submodule(); S
+    Cuspidal subspace of dimension 1 of Modular Forms space of dimension 3,
+     character [zeta6] and weight 2 over Cyclotomic Field of order 6 and degree 2
+    sage: S.modular_symbols()
+    Modular Symbols subspace of dimension 2 of
+     Modular Symbols space of dimension 4 and level 13, weight 2, character [zeta6],
+      sign 0, over Cyclotomic Field of order 6 and degree 2
+
+We create a spaces associated to Dirichlet characters of modulus 225::
+
+    sage: e = DirichletGroup(225).0
+    sage: e.order()
+    6
+    sage: e.base_ring()
+    Cyclotomic Field of order 60 and degree 16
+    sage: M = ModularForms(e,3)
+
+Notice that the base ring is "minimized"::
+
+    sage: M
+    Modular Forms space of dimension 66, character [zeta6, 1] and weight 3
+    over Cyclotomic Field of order 6 and degree 2
+
+If we don't want the base ring to change, we can explicitly specify it::
+
+    sage: ModularForms(e, 3, e.base_ring())
+    Modular Forms space of dimension 66, character [zeta6, 1] and weight 3
+    over Cyclotomic Field of order 60 and degree 16
+
+Next we create a space associated to a Dirichlet character of order 20::
+
+    sage: e = DirichletGroup(225).1
+    sage: e.order()
+    20
+    sage: e.base_ring()
+    Cyclotomic Field of order 60 and degree 16
+    sage: M = ModularForms(e,17); M
+    Modular Forms space of dimension 484, character [1, zeta20] and
+    weight 17 over Cyclotomic Field of order 20 and degree 8
+
+We compute the Eisenstein subspace, which is fast even though
+the dimension of the space is large (since an explicit basis
+of `q`-expansions has not been computed yet).
+
+::
+
+    sage: M.eisenstein_submodule()
+    Eisenstein subspace of dimension 8 of Modular Forms space of
+    dimension 484, character [1, zeta20] and weight 17 over
+    Cyclotomic Field of order 20 and degree 8
+
+    sage: M.cuspidal_submodule()
+    Cuspidal subspace of dimension 476 of Modular Forms space of dimension 484,
+    character [1, zeta20] and weight 17 over Cyclotomic Field of order 20 and degree 8
+
+TESTS::
+
+    sage: m = ModularForms(DirichletGroup(20).1,5)
+    sage: m == loads(dumps(m))
+    True
+    sage: type(m)
+    <class 'sage.modular.modform.ambient_eps.ModularFormsAmbient_eps_with_category'>
+"""
+
+#########################################################################
+#       Copyright (C) 2006 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#                  http://www.gnu.org/licenses/
+#########################################################################
+
+from sage.rings.integer import Integer
+
+import sage.modular.arithgroup.all as arithgroup
+import sage.modular.dirichlet as dirichlet
+import sage.modular.modsym.modsym as modsym
+from sage.misc.cachefunc import cached_method
+
+from .ambient import ModularFormsAmbient
+
+from . import ambient_R
+from . import cuspidal_submodule
+from . import eisenstein_submodule
+
+
+class ModularFormsAmbient_eps(ModularFormsAmbient):
+    """
+    A space of modular forms with character.
+    """
+    def __init__(self, character, weight=2, base_ring=None, eis_only=False):
+        """
+        Create an ambient modular forms space with character.
+
+        .. NOTE::
+
+           The base ring must be of characteristic 0.  The ambient_R
+           Python module is used for computing in characteristic p,
+           which we view as the reduction of characteristic 0.
+
+        INPUT:
+
+        - ``weight`` -- integer
+
+        - ``character`` -- dirichlet.DirichletCharacter
+
+        - ``base_ring`` -- base field
+
+        EXAMPLES::
+
+            sage: m = ModularForms(DirichletGroup(11).0,3); m
+            Modular Forms space of dimension 3, character [zeta10] and weight 3 over
+             Cyclotomic Field of order 10 and degree 4
+            sage: type(m)
+            <class 'sage.modular.modform.ambient_eps.ModularFormsAmbient_eps_with_category'>
+        """
+        if not isinstance(character, dirichlet.DirichletCharacter):
+            raise TypeError("character (=%s) must be a Dirichlet character" % character)
+        if base_ring is None:
+            base_ring = character.base_ring()
+        if character.base_ring() != base_ring:
+            character = character.change_ring(base_ring)
+        if base_ring.characteristic() != 0:
+            raise ValueError("the base ring must have characteristic 0.")
+        group = arithgroup.Gamma1(character.modulus())
+        base_ring = character.base_ring()
+        ModularFormsAmbient.__init__(self, group, weight, base_ring, character, eis_only)
+
+    def _repr_(self):
+        """
+        String representation of this space with character.
+
+        EXAMPLES::
+
+            sage: m = ModularForms(DirichletGroup(8).1,2)
+            sage: m._repr_()
+            'Modular Forms space of dimension 2, character [1, -1] and weight 2 over Rational Field'
+
+            sage: m = ModularForms(DirichletGroup(31, QQ).0, 1, eis_only=True)
+            sage: m._repr_()
+            'Modular Forms space of character [-1] and weight 1 over Rational Field'
+
+        You can rename the space with the rename command.
+
+        ::
+
+            sage: m.rename('Modforms of level 8')
+            sage: m
+            Modforms of level 8
+        """
+        if self._eis_only:
+            return "Modular Forms space of character %s and weight %s over %s" % (
+                        self.character()._repr_short_(), self.weight(), self.base_ring())
+        else:
+            return "Modular Forms space of dimension %s, character %s and weight %s over %s" % (
+            self.dimension(), self.character()._repr_short_(), self.weight(), self.base_ring())
+
+    @cached_method
+    def cuspidal_submodule(self):
+        """
+        Return the cuspidal submodule of this ambient space of modular forms.
+
+        EXAMPLES::
+
+            sage: eps = DirichletGroup(4).0
+            sage: M = ModularForms(eps, 5); M
+            Modular Forms space of dimension 3, character [-1] and weight 5
+             over Rational Field
+            sage: M.cuspidal_submodule()
+            Cuspidal subspace of dimension 1 of Modular Forms space of dimension 3,
+             character [-1] and weight 5 over Rational Field
+        """
+        if self.weight() > 1:
+            return cuspidal_submodule.CuspidalSubmodule_eps(self)
+        else:
+            return cuspidal_submodule.CuspidalSubmodule_wt1_eps(self)
+
+    def change_ring(self, base_ring):
+        """
+        Return space with same defining parameters as this ambient
+        space of modular symbols, but defined over a different base
+        ring.
+
+        EXAMPLES::
+
+            sage: m = ModularForms(DirichletGroup(13).0^2,2); m
+            Modular Forms space of dimension 3, character [zeta6] and weight 2 over
+             Cyclotomic Field of order 6 and degree 2
+            sage: m.change_ring(CyclotomicField(12))
+            Modular Forms space of dimension 3, character [zeta6] and weight 2 over
+             Cyclotomic Field of order 12 and degree 4
+
+        It must be possible to change the ring of the underlying Dirichlet character::
+
+            sage: m.change_ring(QQ)
+            Traceback (most recent call last):
+            ...
+            TypeError: Unable to coerce zeta6 to a rational
+        """
+        if self.base_ring() == base_ring:
+            return self
+        return ambient_R.ModularFormsAmbient_R(self, base_ring=base_ring)
+
+    @cached_method(key=lambda self, sign: Integer(sign)) # convert sign to an Integer before looking this up in the cache
+    def modular_symbols(self, sign=0):
+        """
+        Return corresponding space of modular symbols with given sign.
+
+        EXAMPLES::
+
+            sage: eps = DirichletGroup(13).0
+            sage: M = ModularForms(eps^2, 2)
+            sage: M.modular_symbols()
+            Modular Symbols space of dimension 4 and level 13, weight 2,
+             character [zeta6], sign 0, over Cyclotomic Field of order 6 and degree 2
+            sage: M.modular_symbols(1)
+            Modular Symbols space of dimension 3 and level 13, weight 2,
+             character [zeta6], sign 1, over Cyclotomic Field of order 6 and degree 2
+            sage: M.modular_symbols(-1)
+            Modular Symbols space of dimension 1 and level 13, weight 2,
+             character [zeta6], sign -1, over Cyclotomic Field of order 6 and degree 2
+            sage: M.modular_symbols(2)
+            Traceback (most recent call last):
+            ...
+            ValueError: sign must be -1, 0, or 1
+        """
+        sign = Integer(sign)
+        return modsym.ModularSymbols(self.character(),
+                                     weight=self.weight(),
+                                     sign=sign,
+                                     base_ring=self.base_ring())
+
+    @cached_method
+    def eisenstein_submodule(self):
+        """
+        Return the submodule of this ambient module with character that is
+        spanned by Eisenstein series.  This is the Hecke stable complement
+        of the cuspidal submodule.
+
+        EXAMPLES::
+
+            sage: m = ModularForms(DirichletGroup(13).0^2,2); m
+            Modular Forms space of dimension 3, character [zeta6] and weight 2 over
+             Cyclotomic Field of order 6 and degree 2
+            sage: m.eisenstein_submodule()
+            Eisenstein subspace of dimension 2 of Modular Forms space of dimension 3,
+             character [zeta6] and weight 2 over Cyclotomic Field of order 6 and degree 2
+        """
+        return eisenstein_submodule.EisensteinSubmodule_eps(self)
+
+    def hecke_module_of_level(self, N):
+        r"""
+        Return the Hecke module of level N corresponding to ``self``, which is the
+        domain or codomain of a degeneracy map from ``self``. Here N must be either
+        a divisor or a multiple of the level of ``self``, and a multiple of the
+        conductor of the character of ``self``.
+
+        EXAMPLES::
+
+            sage: M = ModularForms(DirichletGroup(15).0, 3); M.character().conductor()
+            3
+            sage: M.hecke_module_of_level(3)
+            Modular Forms space of dimension 2, character [-1] and weight 3
+             over Rational Field
+            sage: M.hecke_module_of_level(5)
+            Traceback (most recent call last):
+            ...
+            ValueError: conductor(=3) must divide M(=5)
+            sage: M.hecke_module_of_level(30)
+            Modular Forms space of dimension 16, character [-1, 1] and weight 3
+             over Rational Field
+        """
+        from . import constructor
+        if N % self.level() == 0:
+            return constructor.ModularForms(self.character().extend(N), self.weight(), self.base_ring(), prec=self.prec())
+        elif self.level() % N == 0:
+            return constructor.ModularForms(self.character().restrict(N), self.weight(), self.base_ring(), prec=self.prec())
+        else:
+            raise ValueError("N (=%s) must be a divisor or a multiple of the level of self (=%s)" % (N, self.level()))
+
+    def _pari_init_(self):
+        """
+        Conversion to Pari.
+
+        EXAMPLES::
+
+            sage: m = ModularForms(DirichletGroup(17).0^2, 2)
+            sage: pari.mfdim(m)
+            3
+            sage: pari.mfparams(m)
+            [17, 2, Mod(9, 17), 4, t^4 + 1]
+        """
+        from sage.libs.pari import pari
+        return pari.mfinit([self.level(), self.weight(), self.character()], 4)

sage/modular/modform/ambient_g0.py

@@ -0,0 +1,124 @@
+# sage_setup: distribution = sagemath-schemes
+# sage.doctest: needs sage.libs.pari
+r"""
+Modular forms for `\Gamma_0(N)` over `\QQ`
+
+TESTS::
+
+    sage: m = ModularForms(Gamma0(389),6)
+    sage: loads(dumps(m)) == m
+    True
+"""
+
+#########################################################################
+#       Copyright (C) 2006 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#                  http://www.gnu.org/licenses/
+#########################################################################
+
+from sage.rings.rational_field import Q as QQ
+
+import sage.modular.arithgroup.all as arithgroup
+
+from . import ambient
+from . import cuspidal_submodule
+from . import eisenstein_submodule
+
+from sage.misc.cachefunc import cached_method
+
+
+class ModularFormsAmbient_g0_Q(ambient.ModularFormsAmbient):
+    r"""
+    A space of modular forms for `\Gamma_0(N)` over `\QQ`.
+    """
+    def __init__(self, level, weight):
+        r"""
+        Create a space of modular symbols for `\Gamma_0(N)` of given
+        weight defined over `\QQ`.
+
+        EXAMPLES::
+
+            sage: m = ModularForms(Gamma0(11),4); m
+            Modular Forms space of dimension 4 for Congruence Subgroup Gamma0(11)
+             of weight 4 over Rational Field
+            sage: type(m)
+            <class 'sage.modular.modform.ambient_g0.ModularFormsAmbient_g0_Q_with_category'>
+        """
+        ambient.ModularFormsAmbient.__init__(self, arithgroup.Gamma0(level), weight, QQ)
+
+    def _pari_init_(self):
+        """
+        Conversion to Pari.
+
+        EXAMPLES::
+
+            sage: m = ModularForms(Gamma0(11),4)
+            sage: pari.mfdim(m)
+            4
+            sage: pari.mfparams(m)
+            [11, 4, 1, 4, t - 1]
+        """
+        from sage.libs.pari import pari
+        return pari.mfinit([self.level(), self.weight()], 4)
+
+    ####################################################################
+    # Computation of Special Submodules
+    ####################################################################
+    @cached_method
+    def cuspidal_submodule(self):
+        r"""
+        Return the cuspidal submodule of this space of modular forms for
+        `\Gamma_0(N)`.
+
+        EXAMPLES::
+
+            sage: m = ModularForms(Gamma0(33),4)
+            sage: s = m.cuspidal_submodule(); s
+            Cuspidal subspace of dimension 10 of Modular Forms space of dimension 14
+             for Congruence Subgroup Gamma0(33) of weight 4 over Rational Field
+            sage: type(s)
+            <class 'sage.modular.modform.cuspidal_submodule.CuspidalSubmodule_g0_Q_with_category'>
+        """
+        if self.level() == 1:
+            return cuspidal_submodule.CuspidalSubmodule_level1_Q(self)
+        else:
+            return cuspidal_submodule.CuspidalSubmodule_g0_Q(self)
+
+    @cached_method
+    def eisenstein_submodule(self):
+        r"""
+        Return the Eisenstein submodule of this space of modular forms for
+        `\Gamma_0(N)`.
+
+        EXAMPLES::
+
+            sage: m = ModularForms(Gamma0(389),6)
+            sage: m.eisenstein_submodule()
+            Eisenstein subspace of dimension 2 of Modular Forms space of dimension 163
+             for Congruence Subgroup Gamma0(389) of weight 6 over Rational Field
+        """
+        return eisenstein_submodule.EisensteinSubmodule_g0_Q(self)
+
+    def _compute_atkin_lehner_matrix(self, d):
+        r"""
+        Compute the matrix of the Atkin-Lehner operator W_d acting on self,
+        where d is a divisor of the level.  This is only implemented in the
+        (trivial) level 1 case.
+
+        EXAMPLES::
+
+            sage: ModularForms(1, 30).atkin_lehner_operator()
+            Hecke module morphism Atkin-Lehner operator W_1 defined by the matrix
+            [1 0 0]
+            [0 1 0]
+            [0 0 1]
+            Domain: Modular Forms space of dimension 3 for Modular Group SL(2,Z) ...
+            Codomain: Modular Forms space of dimension 3 for Modular Group SL(2,Z) ...
+        """
+        if self.level() == 1:
+            from sage.matrix.matrix_space import MatrixSpace
+            return MatrixSpace(self.base_ring(), self.rank())(1)
+        else:
+            raise NotImplementedError