passagemath-schemes 10.8.1a4__cp314-cp314t-macosx_13_0_arm64.whl

sage/modular/abvar/abvar_ambient_jacobian.py

@@ -0,0 +1,414 @@
+# sage_setup: distribution = sagemath-schemes
+"""
+Ambient Jacobian abelian variety
+
+TESTS::
+
+    sage: loads(dumps(J0(37))) == J0(37)
+    True
+    sage: loads(dumps(J1(13))) == J1(13)
+    True
+"""
+
+import weakref
+from sage.structure.sequence import Sequence
+
+from .abvar import (ModularAbelianVariety_modsym_abstract,
+                    simple_factorization_of_modsym_space, modsym_lattices,
+                    ModularAbelianVariety_modsym)
+from sage.rings.rational_field import QQ
+
+from sage.modular.modsym.modsym import ModularSymbols
+from sage.modular.modform.constructor import Newforms
+from sage.modular.arithgroup.congroup_gamma0 import Gamma0_class
+from sage.modular.arithgroup.congroup_gamma1 import Gamma1_class
+from sage.modular.abvar import morphism
+
+
+_cache = {}
+
+
+def ModAbVar_ambient_jacobian(group):
+    """
+    Return the ambient Jacobian attached to a given congruence
+    subgroup.
+
+    The result is cached using a weakref. This function is called
+    internally by modular abelian variety constructors.
+
+    INPUT:
+
+    - ``group`` -- a congruence subgroup
+
+    OUTPUT: a modular abelian variety attached
+
+    EXAMPLES::
+
+        sage: import sage.modular.abvar.abvar_ambient_jacobian as abvar_ambient_jacobian
+        sage: A = abvar_ambient_jacobian.ModAbVar_ambient_jacobian(Gamma0(11))
+        sage: A
+        Abelian variety J0(11) of dimension 1
+        sage: B = abvar_ambient_jacobian.ModAbVar_ambient_jacobian(Gamma0(11))
+        sage: A is B
+        True
+
+    You can get access to and/or clear the cache as follows::
+
+        sage: abvar_ambient_jacobian._cache = {}
+        sage: B = abvar_ambient_jacobian.ModAbVar_ambient_jacobian(Gamma0(11))
+        sage: A is B
+        False
+    """
+    try:
+        X = _cache[group]()
+        if X is not None:
+            return X
+    except KeyError:
+        pass
+    X = ModAbVar_ambient_jacobian_class(group)
+    _cache[group] = weakref.ref(X)
+    return X
+
+
+class ModAbVar_ambient_jacobian_class(ModularAbelianVariety_modsym_abstract):
+    """
+    An ambient Jacobian modular abelian variety attached to a
+    congruence subgroup.
+    """
+    def __init__(self, group):
+        """
+        Create an ambient Jacobian modular abelian variety.
+
+        EXAMPLES::
+
+            sage: A = J0(37); A
+            Abelian variety J0(37) of dimension 2
+            sage: type(A)
+            <class 'sage.modular.abvar.abvar_ambient_jacobian.ModAbVar_ambient_jacobian_class_with_category'>
+            sage: A.group()
+            Congruence Subgroup Gamma0(37)
+        """
+        ModularAbelianVariety_modsym_abstract.__init__(self, (group,), QQ)
+        self.__group = group
+        self._is_hecke_stable = True
+
+    def _modular_symbols(self):
+        """
+        Return the modular symbols space associated to this ambient
+        Jacobian.
+
+        OUTPUT: modular symbols space
+
+        EXAMPLES::
+
+            sage: M = J0(33)._modular_symbols(); M
+            Modular Symbols subspace of dimension 6 of Modular Symbols space of dimension 9 for Gamma_0(33) of weight 2 with sign 0 over Rational Field
+            sage: J0(33)._modular_symbols() is M
+            True
+        """
+        try:
+            return self.__modsym
+        except AttributeError:
+            self.__modsym = ModularSymbols(self.__group, weight=2).cuspidal_submodule()
+            return self.__modsym
+
+    def _repr_(self):
+        """
+        Return string representation of this Jacobian modular abelian
+        variety.
+
+        EXAMPLES::
+
+            sage: A = J0(11); A
+            Abelian variety J0(11) of dimension 1
+            sage: A._repr_()
+            'Abelian variety J0(11) of dimension 1'
+            sage: A.rename('J_0(11)')
+            sage: A
+            J_0(11)
+
+        We now clear the cache to get rid of our renamed
+        `J_0(11)`.
+
+        ::
+
+            sage: import sage.modular.abvar.abvar_ambient_jacobian as abvar_ambient_jacobian
+            sage: abvar_ambient_jacobian._cache = {}
+        """
+        return 'Abelian variety %s of dimension %s%s' % (self._ambient_repr(),
+                                                         self.dimension(),
+                                    '' if self.base_field() == QQ else ' over %s' % self.base_field())
+
+    def _latex_(self):
+        """
+        Return Latex representation of ``self``.
+
+        EXAMPLES::
+
+            sage: latex(J0(37))
+            J_0(37)
+            sage: J1(13)._latex_()
+            'J_1(13)'
+            sage: latex(JH(389,[16]))
+            J_H(389,[16])
+        """
+        return self._ambient_latex_repr()
+
+    def ambient_variety(self):
+        """
+        Return the ambient modular abelian variety that contains ``self``.
+        Since ``self`` is a Jacobian modular abelian variety, this is just
+        ``self``.
+
+        OUTPUT: abelian variety
+
+        EXAMPLES::
+
+            sage: A = J0(17)
+            sage: A.ambient_variety()
+            Abelian variety J0(17) of dimension 1
+            sage: A is A.ambient_variety()
+            True
+        """
+        return self
+
+    def group(self):
+        """
+        Return the group that this Jacobian modular abelian variety is
+        attached to.
+
+        EXAMPLES::
+
+            sage: J1(37).group()
+            Congruence Subgroup Gamma1(37)
+            sage: J0(5077).group()
+            Congruence Subgroup Gamma0(5077)
+            sage: J = GammaH(11,[3]).modular_abelian_variety(); J
+            Abelian variety JH(11,[3]) of dimension 1
+            sage: J.group()
+            Congruence Subgroup Gamma_H(11) with H generated by [3]
+        """
+        return self.__group
+
+    def groups(self):
+        """
+        Return the tuple of congruence subgroups attached to this ambient
+        Jacobian. This is always a tuple of length 1.
+
+        OUTPUT: tuple
+
+        EXAMPLES::
+
+            sage: J0(37).groups()
+            (Congruence Subgroup Gamma0(37),)
+        """
+        return (self.__group,)
+
+    def _calculate_endomorphism_generators(self):
+        """
+        Calculate generators for the endomorphism ring of ``self``.
+
+        EXAMPLES::
+
+            sage: J0(11)._calculate_endomorphism_generators()
+            [Abelian variety endomorphism of Abelian variety J0(11) of dimension 1]
+            sage: ls = J0(46)._calculate_endomorphism_generators() ; ls
+            [Abelian variety endomorphism of Abelian variety J0(46) of dimension 5,
+             Abelian variety endomorphism of Abelian variety J0(46) of dimension 5,
+             Abelian variety endomorphism of Abelian variety J0(46) of dimension 5,
+             Abelian variety endomorphism of Abelian variety J0(46) of dimension 5,
+             Abelian variety endomorphism of Abelian variety J0(46) of dimension 5]
+            sage: len(ls) == J0(46).dimension()
+            True
+        """
+        D = self.decomposition()
+        phi = self._isogeny_to_product_of_simples()
+        psi = phi.complementary_isogeny()
+
+        m1 = phi.matrix()
+        m2 = psi.matrix()
+
+        H = self.Hom(self)
+        M = H.matrix_space()
+
+        ls = []
+        ind = 0
+        for d in D:
+            to_newform = d._isogeny_to_newform_abelian_variety()
+            n1 = to_newform.matrix()
+            n2 = to_newform.complementary_isogeny().matrix()
+            f_gens = to_newform.codomain()._calculate_endomorphism_generators()
+            small_space = to_newform.parent().matrix_space()
+            f_gens = [small_space(x.list()) for x in f_gens]
+            for m in f_gens:
+                mat = H.matrix_space()(0)
+                mat.set_block(ind, ind, n1 * m * n2)
+                ls.append((m1 * mat * m2).list())
+            ind += 2 * d.dimension()
+
+        return [H(morphism.Morphism(H, M(x))) for x in ls]
+
+    def degeneracy_map(self, level, t=1, check=True):
+        """
+        Return the `t`-th degeneracy map from ``self`` to ``J(level)``. Here
+        `t` must be a divisor of either ``level/self.level()`` or
+        ``self.level()/level``.
+
+        INPUT:
+
+        - ``level`` -- integer (multiple or divisor of level of
+          ``self``)
+
+        - ``t`` -- divisor of quotient of level of ``self`` and
+          level
+
+        - ``check`` -- boolean (default: ``True``); if ``True`` do some
+          checks on the input
+
+        OUTPUT: a morphism
+
+        EXAMPLES::
+
+            sage: J0(11).degeneracy_map(33)
+            Degeneracy map from Abelian variety J0(11) of dimension 1 to Abelian variety J0(33) of dimension 3 defined by [1]
+            sage: J0(11).degeneracy_map(33).matrix()
+            [ 0 -3  2  1 -2  0]
+            [ 1 -2  0  1  0 -1]
+            sage: J0(11).degeneracy_map(33,3).matrix()
+            [-1  0  0  0  1 -2]
+            [-1 -1  1 -1  1  0]
+            sage: J0(33).degeneracy_map(11,1).matrix()
+            [ 0  1]
+            [ 0 -1]
+            [ 1 -1]
+            [ 0  1]
+            [-1  1]
+            [ 0  0]
+            sage: J0(11).degeneracy_map(33,1).matrix() * J0(33).degeneracy_map(11,1).matrix()
+            [4 0]
+            [0 4]
+        """
+        if check:
+            if (level % self.level()) and (self.level() % level):
+                raise ValueError("level must be divisible by level of self")
+            if (max(level, self.level()) // min(self.level(), level)) % t:
+                raise ValueError("t must divide the quotient of the two levels")
+
+        Mself = self.modular_symbols()
+        Jdest = (type(Mself.group()))(level).modular_abelian_variety()
+        Mdest = Jdest.modular_symbols()
+
+        symbol_map = Mself.degeneracy_map(level, t).restrict_codomain(Mdest)
+        H = self.Hom(Jdest)
+
+        return H(morphism.DegeneracyMap(H, symbol_map.matrix(), [t]))
+
+    def dimension(self):
+        """
+        Return the dimension of this modular abelian variety.
+
+        EXAMPLES::
+
+            sage: J0(2007).dimension()
+            221
+            sage: J1(13).dimension()
+            2
+            sage: J1(997).dimension()
+            40920
+            sage: J0(389).dimension()
+            32
+            sage: JH(389,[4]).dimension()
+            64
+            sage: J1(389).dimension()
+            6112
+        """
+        try:
+            return self._dimension
+        except AttributeError:
+            d = self.group().genus()
+            self._dimension = d
+            return d
+
+    def decomposition(self, simple=True, bound=None):
+        """
+        Decompose this ambient Jacobian as a product of abelian
+        subvarieties, up to isogeny.
+
+        EXAMPLES::
+
+            sage: J0(33).decomposition(simple=False)
+            [Abelian subvariety of dimension 2 of J0(33),
+             Abelian subvariety of dimension 1 of J0(33)]
+            sage: J0(33).decomposition(simple=False)[1].is_simple()
+            True
+            sage: J0(33).decomposition(simple=False)[0].is_simple()
+            False
+            sage: J0(33).decomposition(simple=False)
+            [Abelian subvariety of dimension 2 of J0(33),
+             Simple abelian subvariety 33a(None,33) of dimension 1 of J0(33)]
+            sage: J0(33).decomposition(simple=True)
+            [Simple abelian subvariety 11a(1,33) of dimension 1 of J0(33),
+             Simple abelian subvariety 11a(3,33) of dimension 1 of J0(33),
+             Simple abelian subvariety 33a(1,33) of dimension 1 of J0(33)]
+        """
+        try:
+            return self.__decomposition[simple]
+        except KeyError:
+            pass
+        except AttributeError:
+            self.__decomposition = {}
+
+        M = self.modular_symbols().ambient_module()
+        level = M.level()
+        group = M.group()
+        factors = simple_factorization_of_modsym_space(M, simple=simple)
+        factors = modsym_lattices(M, factors)
+
+        D = []
+        is_simple = True if simple else None
+        for newform_level, isogeny_number, number, modsym, lattice in factors:
+            A = ModularAbelianVariety_modsym(modsym, lattice=lattice,
+                               newform_level=(newform_level, group),
+                                             is_simple=is_simple,
+                                             isogeny_number=isogeny_number,
+                                             number=(number, level),
+                                             check=False)
+            D.append(A)
+
+            # This line below could be safely deleted.  It basically creates a circular
+            # reference so that say J0(389)[0] + J0(389)[1] doesn't do two separate
+            # decompositions.  Memory will be freed though, at least if you do
+            # import gc; gc.collect().
+            A._ambient = self
+
+        D.sort()
+        D = Sequence(D, immutable=True, cr=True, universe=self.category())
+        self.__decomposition[simple] = D
+        return D
+
+    def newform_decomposition(self, names=None):
+        """
+        Return the newforms of the simple subvarieties in the decomposition of
+        ``self`` as a product of simple subvarieties, up to isogeny.
+
+        OUTPUT: an array of newforms
+
+        EXAMPLES::
+
+            sage: J0(81).newform_decomposition('a')
+            [q - 2*q^4 + O(q^6), q - 2*q^4 + O(q^6), q + a0*q^2 + q^4 - a0*q^5 + O(q^6)]
+
+            sage: J1(19).newform_decomposition('a')
+            [q - 2*q^3 - 2*q^4 + 3*q^5 + O(q^6),
+             q + a1*q^2 + (-1/9*a1^5 - 1/3*a1^4 - 1/3*a1^3 + 1/3*a1^2 - a1 - 1)*q^3 + (4/9*a1^5 + 2*a1^4 + 14/3*a1^3 + 17/3*a1^2 + 6*a1 + 2)*q^4 + (-2/3*a1^5 - 11/3*a1^4 - 10*a1^3 - 14*a1^2 - 15*a1 - 9)*q^5 + O(q^6)]
+        """
+        if self.dimension() == 0:
+            return []
+        G = self.group()
+        if not isinstance(G, (Gamma0_class, Gamma1_class)):
+            return [S.newform(names=names) for S in self.decomposition()]
+        Gtype = G.parent()
+        N = G.level()
+        preans = [Newforms(Gtype(d), names=names) * len((N // d).divisors())
+                  for d in N.divisors()]
+        return [newform for l in preans for newform in l]

sage/modular/abvar/abvar_newform.py

@@ -0,0 +1,246 @@
+# sage_setup: distribution = sagemath-schemes
+# sage.doctest: needs sage.libs.pari
+"""
+Abelian varieties attached to newforms
+
+TESTS::
+
+    sage: A = AbelianVariety('23a')
+    sage: loads(dumps(A)) == A
+    True
+"""
+###########################################################################
+#       Copyright (C) 2008 William Stein <wstein@gmail.com>               #
+#  Distributed under the terms of the GNU General Public License (GPL)    #
+#                  https://www.gnu.org/licenses/                           #
+###########################################################################
+from sage.misc.lazy_import import lazy_import
+
+from sage.rings.integer_ring import ZZ
+from sage.rings.rational_field import QQ
+
+from sage.modular.modform.element import Newform
+from sage.modular.arithgroup.congroup_gamma0 import Gamma0_class
+from sage.modular.arithgroup.congroup_gamma1 import Gamma1_class
+from sage.modular.arithgroup.congroup_gammaH import GammaH_class
+
+from .abvar import ModularAbelianVariety_modsym_abstract
+from sage.modular.abvar import homspace
+lazy_import('sage.databases.cremona', 'cremona_letter_code')
+
+
+class ModularAbelianVariety_newform(ModularAbelianVariety_modsym_abstract):
+    """
+    A modular abelian variety attached to a specific newform.
+    """
+    def __init__(self, f, internal_name=False):
+        """
+        Create the modular abelian variety `A_f` attached to the
+        newform `f`.
+
+        INPUT:
+
+        - ``f`` -- a newform
+
+        EXAMPLES::
+
+            sage: f = CuspForms(37).newforms('a')[0]
+            sage: f.abelian_variety()
+            Newform abelian subvariety 37a of dimension 1 of J0(37)
+
+            sage: AbelianVariety(Newforms(1, 12)[0])
+            Traceback (most recent call last):
+            ...
+            TypeError: f must have weight 2
+        """
+        if not isinstance(f, Newform):
+            raise TypeError("f must be a newform")
+        if f.weight() != 2:
+            raise TypeError("f must have weight 2")
+        self.__f = f
+        self._is_hecke_stable = True
+        K = f.qexp().base_ring()
+        if K == QQ:
+            variable_name = None
+        else:
+            variable_name = K.variable_name()
+        self.__named_newforms = {variable_name: self.__f}
+        if not internal_name:
+            self.__named_newforms[None] = self.__f
+        ModularAbelianVariety_modsym_abstract.__init__(self, (f.group(),), QQ,
+            is_simple=True, newform_level=(f.level(), f.group()),
+            isogeny_number=f.number(), number=0)
+
+    def _modular_symbols(self, sign=0):
+        """
+        EXAMPLES::
+
+            sage: f = CuspForms(52).newforms('a')[0]
+            sage: A = f.abelian_variety()
+            sage: A._modular_symbols()
+            Modular Symbols subspace of dimension 2 of Modular Symbols space of dimension 15 for Gamma_0(52) of weight 2 with sign 0 over Rational Field
+            sage: A._modular_symbols(1)
+            Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 10 for Gamma_0(52) of weight 2 with sign 1 over Rational Field
+            sage: A._modular_symbols(-1)
+            Modular Symbols subspace of dimension 1 of Modular Symbols space of dimension 5 for Gamma_0(52) of weight 2 with sign -1 over Rational Field
+        """
+        return self.__f.modular_symbols(sign=sign)
+
+    def newform(self, names=None):
+        r"""
+        Return the newform that this modular abelian variety is attached to.
+
+        EXAMPLES::
+
+            sage: f = Newform('37a')
+            sage: A = f.abelian_variety()
+            sage: A.newform()
+            q - 2*q^2 - 3*q^3 + 2*q^4 - 2*q^5 + O(q^6)
+            sage: A.newform() is f
+            True
+
+        If the a variable name has not been specified, we must specify one::
+
+            sage: A = AbelianVariety('67b')
+            sage: A.newform()
+            Traceback (most recent call last):
+            ...
+            TypeError: You must specify the name of the generator.
+            sage: A.newform('alpha')
+            q + alpha*q^2 + (-alpha - 3)*q^3 + (-3*alpha - 3)*q^4 - 3*q^5 + O(q^6)
+
+        If the eigenform is actually over `\QQ` then we don't have to specify
+        the name::
+
+            sage: A = AbelianVariety('67a')
+            sage: A.newform()
+            q + 2*q^2 - 2*q^3 + 2*q^4 + 2*q^5 + O(q^6)
+        """
+        try:
+            return self.__named_newforms[names]
+        except KeyError:
+            self.__named_newforms[names] = Newform(self.__f.parent().change_ring(QQ), self.__f.modular_symbols(1), names=names, check=False)
+            return self.__named_newforms[names]
+
+    def label(self) -> str:
+        """
+        Return canonical label that defines this newform modular
+        abelian variety.
+
+        OUTPUT: string
+
+        EXAMPLES::
+
+            sage: A = AbelianVariety('43b')
+            sage: A.label()
+            '43b'
+        """
+        G = self.__f.group()
+        if isinstance(G, Gamma0_class):
+            group = ''
+        elif isinstance(G, Gamma1_class):
+            group = 'G1'
+        elif isinstance(G, GammaH_class):
+            group = 'GH[' + ','.join(str(z) for z in G._generators_for_H()) + ']'
+        return '%s%s%s' % (self.level(), cremona_letter_code(self.factor_number()), group)
+
+    def factor_number(self):
+        """
+        Return factor number.
+
+        OUTPUT: int
+
+        EXAMPLES::
+
+            sage: A = AbelianVariety('43b')
+            sage: A.factor_number()
+            1
+        """
+        try:
+            return self.__factor_number
+        except AttributeError:
+            self.__factor_number = self.__f.number()
+            return self.__factor_number
+
+    def _repr_(self) -> str:
+        """
+        String representation of this modular abelian variety.
+
+        EXAMPLES::
+
+            sage: AbelianVariety('37a')._repr_()
+            'Newform abelian subvariety 37a of dimension 1 of J0(37)'
+        """
+        return "Newform abelian subvariety %s of dimension %s of %s" % (
+            self.newform_label(), self.dimension(), self._ambient_repr())
+
+    def endomorphism_ring(self):
+        """
+        Return the endomorphism ring of this newform abelian variety.
+
+        EXAMPLES::
+
+            sage: A = AbelianVariety('23a')
+            sage: E = A.endomorphism_ring(); E
+            Endomorphism ring of Newform abelian subvariety 23a of dimension 2 of J0(23)
+
+        We display the matrices of these two basis matrices::
+
+            sage: E.0.matrix()
+            [1 0 0 0]
+            [0 1 0 0]
+            [0 0 1 0]
+            [0 0 0 1]
+            sage: E.1.matrix()
+            [ 0  1 -1  0]
+            [ 0  1 -1  1]
+            [-1  2 -2  1]
+            [-1  1  0 -1]
+
+        The result is cached::
+
+            sage: E is A.endomorphism_ring()
+            True
+        """
+        try:
+            return self.__endomorphism_ring
+        except AttributeError:
+            pass
+
+        E = homspace.EndomorphismSubring(self)
+        self.__endomorphism_ring = E
+        return self.__endomorphism_ring
+
+    def _calculate_endomorphism_generators(self):
+        """
+        EXAMPLES::
+
+            sage: A = AbelianVariety('43b')
+            sage: B = A.endomorphism_ring(); B   # indirect doctest
+            Endomorphism ring of Newform abelian subvariety 43b of dimension 2 of J0(43)
+            sage: [b.matrix() for b in B.gens()]
+            [
+            [1 0 0 0]  [ 0  1  0  0]
+            [0 1 0 0]  [ 1 -2  0  0]
+            [0 0 1 0]  [ 1  0 -2 -1]
+            [0 0 0 1], [ 0  1 -1  0]
+            ]
+        """
+        M = self.modular_symbols()
+        bound = M.sturm_bound()
+
+        d = self.dimension()
+        T1list = self.hecke_operator(1).matrix().list()
+        EndVecZ = ZZ**(len(T1list))
+        V = EndVecZ.submodule([T1list])
+        n = 2
+
+        while V.dimension() < d:
+            W = EndVecZ.submodule([((self.hecke_operator(n).matrix())**i).list()
+                                   for i in range(1, d + 1)])
+            V = V + W
+            n += 1
+            if n > bound:
+                raise ArithmeticError("Error computing endomorphism generators")
+
+        return V.saturation().basis()

sage/modular/abvar/all.py

@@ -0,0 +1,8 @@
+# sage_setup: distribution = sagemath-schemes
+###########################################################################
+#       Copyright (C) 2007 William Stein <wstein@gmail.com>               #
+#  Distributed under the terms of the GNU General Public License (GPL)    #
+#                  https://www.gnu.org/licenses/                           #
+###########################################################################
+
+from sage.modular.abvar.constructor import J0, J1, JH, AbelianVariety