passagemath-schemes 10.6.47__cp312-cp312-macosx_13_0_arm64.whl

sage/modular/modsym/element.py

@@ -0,0 +1,336 @@
+# sage_setup: distribution = sagemath-schemes
+# sage.doctest: needs sage.libs.flint
+"""
+A single element of an ambient space of modular symbols
+"""
+# ****************************************************************************
+#       Sage: Open Source Mathematical Software
+#
+#       Copyright (C) 2005 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+import sage.modules.free_module_element
+from sage.misc.repr import repr_lincomb
+import sage.structure.formal_sum as formal_sum
+import sage.modular.hecke.all as hecke
+import sage.misc.latex as latex
+
+
+_print_mode = "manin"
+
+
+def is_ModularSymbolsElement(x) -> bool:
+    r"""
+    Return ``True`` if x is an element of a modular symbols space.
+
+    EXAMPLES::
+
+        sage: sage.modular.modsym.element.is_ModularSymbolsElement(ModularSymbols(11, 2).0)
+        doctest:warning...
+        DeprecationWarning: The function is_ModularSymbolsElement is deprecated;
+        use 'isinstance(..., ModularSymbolsElement)' instead.
+        See https://github.com/sagemath/sage/issues/38184 for details.
+        True
+        sage: sage.modular.modsym.element.is_ModularSymbolsElement(13)
+        False
+    """
+    from sage.misc.superseded import deprecation
+    deprecation(38184,
+                "The function is_ModularSymbolsElement is deprecated; "
+                "use 'isinstance(..., ModularSymbolsElement)' instead.")
+    return isinstance(x, ModularSymbolsElement)
+
+
+def set_modsym_print_mode(mode='manin'):
+    r"""
+    Set the mode for printing of elements of modular symbols spaces.
+
+    INPUT:
+
+    - ``mode`` -- string; the possibilities are as follows:
+
+      - ``'manin'`` -- (the default) formal sums of Manin
+        symbols [P(X,Y),(u,v)]
+
+      - ``'modular'`` -- formal sums of Modular symbols
+        P(X,Y)\*alpha,beta, where alpha and beta are cusps
+
+      - ``'vector'`` -- as vectors on the basis for the
+        ambient space
+
+    OUTPUT: none
+
+    EXAMPLES::
+
+        sage: M = ModularSymbols(13, 8)
+        sage: x = M.0 + M.1 + M.14
+        sage: set_modsym_print_mode('manin'); x
+        [X^5*Y,(1,11)] + [X^5*Y,(1,12)] + [X^6,(1,11)]
+        sage: set_modsym_print_mode('modular'); x
+        1610510*X^6*{-1/11, 0} + 893101*X^5*Y*{-1/11, 0} + 206305*X^4*Y^2*{-1/11, 0} + 25410*X^3*Y^3*{-1/11, 0} + 1760*X^2*Y^4*{-1/11, 0} + 65*X*Y^5*{-1/11, 0} - 248832*X^6*{-1/12, 0} - 103680*X^5*Y*{-1/12, 0} - 17280*X^4*Y^2*{-1/12, 0} - 1440*X^3*Y^3*{-1/12, 0} - 60*X^2*Y^4*{-1/12, 0} - X*Y^5*{-1/12, 0} + Y^6*{-1/11, 0}
+        sage: set_modsym_print_mode('vector'); x
+        (1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0)
+        sage: set_modsym_print_mode()
+    """
+    mode = str(mode).lower()
+    if mode not in ['manin', 'modular', 'vector']:
+        raise ValueError("mode must be one of 'manin', 'modular', or 'vector'")
+    global _print_mode
+    _print_mode = mode
+
+
+class ModularSymbolsElement(hecke.HeckeModuleElement):
+    """
+    An element of a space of modular symbols.
+
+    TESTS::
+
+        sage: x = ModularSymbols(3, 12).cuspidal_submodule().gen(0)
+        sage: x == loads(dumps(x))
+        True
+    """
+    def __init__(self, parent, x, check=True):
+        """
+        INPUT:
+
+        - ``parent`` -- a space of modular symbols
+
+        - ``x`` -- a free module element that represents the modular
+          symbol in terms of a basis for the ambient space (not in
+          terms of a basis for parent!)
+
+        EXAMPLES::
+
+            sage: S = ModularSymbols(11, sign=1).cuspidal_submodule()
+            sage: S(vector([0,1])) == S.basis()[0]
+            True
+            sage: S(vector([1,0]))
+            Traceback (most recent call last):
+            ...
+            TypeError: x does not coerce to an element of this Hecke module
+        """
+        if check:
+            from .space import ModularSymbolsSpace
+            if not isinstance(parent, ModularSymbolsSpace):
+                raise TypeError("parent (= %s) must be a space of modular symbols" % parent)
+            if not isinstance(x, sage.modules.free_module_element.FreeModuleElement):
+                raise TypeError("x must be a free module element.")
+            if x.degree() != parent.degree():
+                raise TypeError("x (of degree %s) must be of degree the same as the degree of the parent (of degree %s)." % (x.degree(), parent.degree()))
+        hecke.HeckeModuleElement.__init__(self, parent, x)
+
+    def _repr_(self):
+        r"""
+        String representation of ``self``. The output will depend on the global
+        modular symbols print mode setting controlled by the function
+        ``set_modsym_print_mode``.
+
+        EXAMPLES::
+
+            sage: M = ModularSymbols(13, 4)
+            sage: set_modsym_print_mode('manin'); M.0._repr_()
+            '[X^2,(0,1)]'
+            sage: set_modsym_print_mode('modular'); M.0._repr_()
+            'X^2*{0, Infinity}'
+            sage: set_modsym_print_mode('vector'); M.0._repr_()
+            '(1, 0, 0, 0, 0, 0, 0, 0)'
+            sage: set_modsym_print_mode()
+        """
+        if _print_mode == "vector":
+            return str(self.element())
+        elif _print_mode == "manin":
+            m = self.manin_symbol_rep()
+        elif _print_mode == "modular":
+            m = self.modular_symbol_rep()
+        return repr_lincomb([(t, c) for c, t in m])
+
+    def _latex_(self):
+        r"""
+        LaTeX representation of ``self``. The output will be determined by the
+        print mode setting set using ``set_modsym_print_mode``.
+
+        EXAMPLES::
+
+            sage: M = ModularSymbols(11, 2)
+            sage: x = M.0 + M.2; x
+            (1,0) + (1,9)
+            sage: set_modsym_print_mode('manin'); latex(x) # indirect doctest
+            (1,0) + (1,9)
+            sage: set_modsym_print_mode('modular'); latex(x) # indirect doctest
+            \left\{\infty, 0\right\} + \left\{\frac{-1}{9}, 0\right\}
+            sage: set_modsym_print_mode('vector'); latex(x) # indirect doctest
+            \left(1,\,0,\,1\right)
+            sage: set_modsym_print_mode()
+        """
+
+        if _print_mode == "vector":
+            return self.element()._latex_()
+        elif _print_mode == "manin":
+            m = self.manin_symbol_rep()
+        elif _print_mode == "modular":
+            m = self.modular_symbol_rep()
+        c = [x[0] for x in m]
+        v = [x[1] for x in m]
+        # TODO: use repr_lincomb with is_latex=True
+        return latex.repr_lincomb(v, c)
+
+    def _add_(self, right):
+        r"""
+        Sum of ``self`` and ``other``.
+
+        EXAMPLES::
+
+            sage: M = ModularSymbols(3, 12)
+            sage: x = M.0; y = M.1; z = x + y; z # indirect doctest
+            [X^8*Y^2,(1,2)] + [X^9*Y,(1,0)]
+            sage: z.parent() is M
+            True
+        """
+        return ModularSymbolsElement(self.parent(), self.element() + right.element(), check=False)
+
+    def _rmul_(self, other):
+        r"""
+        Right-multiply ``self`` by ``other``.
+
+        EXAMPLES::
+
+            sage: M = ModularSymbols(3, 12)
+            sage: x = M.0; z = x*3; z # indirect doctest
+            3*[X^8*Y^2,(1,2)]
+            sage: z.parent() is M
+            True
+            sage: z*Mod(1, 17)
+            Traceback (most recent call last):
+            ...
+            TypeError: unsupported operand parent(s) for *: 'Modular Symbols space of dimension 8 for Gamma_0(3) of weight 12 with sign 0 over Rational Field' and 'Ring of integers modulo 17'
+        """
+        return ModularSymbolsElement(self.parent(), self.element() * other,
+                                     check=False)
+
+    def _lmul_(self, left):
+        r"""
+        Left-multiply ``self`` by ``other``.
+
+        EXAMPLES::
+
+            sage: M = ModularSymbols(3, 12)
+            sage: x = M.0; z = 3*x; z # indirect doctest
+            3*[X^8*Y^2,(1,2)]
+            sage: z.parent() is M
+            True
+            sage: Mod(1, 17)*z
+            Traceback (most recent call last):
+            ...
+            TypeError: unsupported operand parent(s) for *: 'Ring of integers modulo 17' and 'Modular Symbols space of dimension 8 for Gamma_0(3) of weight 12 with sign 0 over Rational Field'
+        """
+        return ModularSymbolsElement(self.parent(), left * self.element(),
+                                     check=False)
+
+    def _neg_(self):
+        r"""
+        Multiply by -1.
+
+        EXAMPLES::
+
+            sage: M = ModularSymbols(3, 12)
+            sage: x = M.0; z = -x; z # indirect doctest
+            -[X^8*Y^2,(1,2)]
+            sage: z.parent() is M
+            True
+        """
+        return ModularSymbolsElement(self.parent(), -self.element(), check=False)
+
+    def _sub_(self, other):
+        r"""
+        Subtract ``other`` from ``self``.
+
+        EXAMPLES::
+
+            sage: M = ModularSymbols(3, 12)
+            sage: x = M.0; y = M.1; z = y-x; z # indirect doctest
+            -[X^8*Y^2,(1,2)] + [X^9*Y,(1,0)]
+            sage: z.parent() is M
+            True
+        """
+        return ModularSymbolsElement(self.parent(), self.element() - other.element(), check=False)
+
+#   this clearly hasn't worked for some time -- the method embedded_vector_space doesn't exist -- DL 2009-05-18
+#    def coordinate_vector(self):
+#        if self.parent().is_ambient():
+#            return self.element()
+#        return self.parent().embedded_vector_space().coordinate_vector(self.element())
+
+    def list(self):
+        r"""
+        Return a list of the coordinates of ``self`` in terms of a basis for
+        the ambient space.
+
+        EXAMPLES::
+
+            sage: ModularSymbols(37, 2).0.list()
+            [1, 0, 0, 0, 0]
+        """
+        return self.element().list()
+
+    def manin_symbol_rep(self):
+        """
+        Return a representation of ``self`` as a formal sum of Manin symbols.
+
+        EXAMPLES::
+
+            sage: x = ModularSymbols(37, 4).0
+            sage: x.manin_symbol_rep()
+            [X^2,(0,1)]
+
+        The result is cached::
+
+            sage: x.manin_symbol_rep() is x.manin_symbol_rep()
+            True
+        """
+        try:
+            return self.__manin_symbols
+        except AttributeError:
+            A = self.parent()
+            v = self.element()
+            manin_symbols = A.ambient_hecke_module().manin_symbols_basis()
+            F = formal_sum.FormalSums(A.base_ring())
+            ms = F([(v[i], manin_symbols[i]) for i in range(v.degree())
+                    if v[i] != 0], check=False, reduce=False)
+            self.__manin_symbols = ms
+        return self.__manin_symbols
+
+    def modular_symbol_rep(self):
+        """
+        Return a representation of ``self`` as a formal sum of modular symbols.
+
+        EXAMPLES::
+
+            sage: x = ModularSymbols(37, 4).0
+            sage: x.modular_symbol_rep()
+            X^2*{0, Infinity}
+
+        The result is cached::
+
+            sage: x.modular_symbol_rep() is x.modular_symbol_rep()
+            True
+        """
+        try:
+            return self.__modular_symbols
+        except AttributeError:
+            v = self.manin_symbol_rep()
+            if v == 0:
+                return v
+            w = [c * x.modular_symbol_rep() for c, x in v]
+            self.__modular_symbols = sum(w)
+            return self.__modular_symbols

sage/modular/modsym/g1list.py

@@ -0,0 +1,178 @@
+# sage_setup: distribution = sagemath-schemes
+r"""
+List of coset representatives for `\Gamma_1(N)` in `\SL_2(\ZZ)`
+"""
+
+# ****************************************************************************
+#       Sage: Open Source Mathematical Software
+#
+#       Copyright (C) 2005 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.arith.misc import GCD
+from sage.structure.richcmp import richcmp_method, richcmp
+from sage.structure.sage_object import SageObject
+from sage.misc.persist import register_unpickle_override
+
+
+@richcmp_method
+class G1list(SageObject):
+    r"""
+    A class representing a list of coset representatives for `\Gamma_1(N)` in
+    `\SL_2(\ZZ)`. What we actually calculate is a list of elements of
+    `(\ZZ/N\ZZ)^2` of exact order `N`.
+
+    TESTS::
+
+        sage: L = sage.modular.modsym.g1list.G1list(18)
+        sage: loads(dumps(L)) == L
+        True
+    """
+    def __init__(self, N):
+        """
+        EXAMPLES::
+
+            sage: L = sage.modular.modsym.g1list.G1list(6); L # indirect doctest
+            List of coset representatives for Gamma_1(6) in SL_2(Z)
+        """
+        self.__N = N
+        self.__list = [(u, v) for u in range(N) for v in range(N)
+                       if GCD(GCD(u, v), N) == 1]
+
+    def __richcmp__(self, other, op):
+        r"""
+        Compare ``self`` to ``other``.
+
+        EXAMPLES::
+
+            sage: L1 = sage.modular.modsym.g1list.G1list(6)
+            sage: L2 = sage.modular.modsym.g1list.G1list(7)
+            sage: L1 < L2
+            True
+            sage: L1 == QQ
+            False
+        """
+        if not isinstance(other, G1list):
+            return NotImplemented
+        else:
+            return richcmp(self.__N, other.__N, op)
+
+    def __getitem__(self, i):
+        """
+        EXAMPLES::
+
+            sage: L = sage.modular.modsym.g1list.G1list(19); L[100] # indirect doctest
+            (5, 6)
+        """
+        return self.__list[i]
+
+    def __len__(self):
+        """
+        Return the length of the underlying list.
+
+        EXAMPLES::
+
+            sage: L = sage.modular.modsym.g1list.G1list(24); len(L) # indirect doctest
+            384
+        """
+        return len(self.__list)
+
+    def __repr__(self):
+        """
+        String representation of ``self``.
+
+        EXAMPLES::
+
+            sage: L = sage.modular.modsym.g1list.G1list(3); L.__repr__()
+            'List of coset representatives for Gamma_1(3) in SL_2(Z)'
+        """
+        return f"List of coset representatives for Gamma_1({self.__N}) in SL_2(Z)"
+
+    def list(self):
+        r"""
+        Return a list of vectors representing the cosets.
+
+        Do not change the returned list!
+
+        EXAMPLES::
+
+            sage: L = sage.modular.modsym.g1list.G1list(4); L.list()
+            [(0, 1), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 1), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3)]
+        """
+        return self.__list
+
+    def normalize(self, u, v):
+        r"""
+        Given a pair `(u,v)` of integers, return the unique pair `(u', v')`
+        such that the pair `(u', v')` appears in ``self.list()`` and `(u, v)`
+        is equivalent to `(u', v')`. This is rather trivial, but is here for
+        consistency with the ``P1List`` class which is the equivalent for
+        `\Gamma_0` (where the problem is rather harder).
+
+        This will only make sense if `{\rm gcd}(u, v, N) = 1`; otherwise the
+        output will not be an element of ``self``.
+
+        EXAMPLES::
+
+            sage: L = sage.modular.modsym.g1list.G1list(4); L.normalize(6, 1)
+            (2, 1)
+            sage: L = sage.modular.modsym.g1list.G1list(4); L.normalize(6, 2) # nonsense!
+            (2, 2)
+        """
+        return u % self.__N, v % self.__N
+
+
+class _G1list_old_pickle(G1list):
+    """
+    This class exists only for dealing with old pickles.
+
+    This needs to handle both old-style class pickles, where there is
+    no input to the class on the initial ``__init__`` call, and the
+    new class pickles, we need to have ``__setstate__`` handle it.
+    """
+    def __init__(self):
+        """
+        For unpickling old pickles.
+
+        TESTS::
+
+            sage: from sage.modular.modsym.g1list import _G1list_old_pickle
+            sage: L = _G1list_old_pickle()
+            sage: type(L) == G1list
+            True
+        """
+        self.__class__ = G1list
+
+    def __setstate__(self, state):
+        """
+        For unpickling new pickles.
+
+        TESTS::
+
+            sage: from sage.modular.modsym.g1list import G1list
+            sage: L = G1list(6)
+            sage: Lp = loads(dumps(L))
+            sage: L == Lp
+            True
+            sage: type(Lp) == G1list
+            True
+        """
+        # We don't really want this class, but we want to handle new
+        #   pickles without creating a new class
+        self.__class__ = G1list
+        self.__dict__ = state  # Default pickling is ``state = self.__dict__``
+
+
+register_unpickle_override('sage.modular.modsym.g1list', 'G1list',
+                           _G1list_old_pickle)

sage/modular/modsym/ghlist.py

@@ -0,0 +1,182 @@
+# sage_setup: distribution = sagemath-schemes
+# sage.doctest: needs sage.libs.pari
+r"""
+List of coset representatives for `\Gamma_H(N)` in `\SL_2(\ZZ)`
+"""
+###########################################################################
+#       Sage: Open Source Mathematical Software
+#
+#       Copyright (C) 2005 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+###########################################################################
+from sage.structure.richcmp import richcmp_method, richcmp
+from sage.structure.sage_object import SageObject
+from sage.misc.persist import register_unpickle_override
+
+from . import p1list
+
+
+@richcmp_method
+class GHlist(SageObject):
+    r"""
+    A class representing a list of coset representatives for `\Gamma_H(N)` in
+    `\SL_2(\ZZ)`.
+
+    TESTS::
+
+        sage: L = sage.modular.modsym.ghlist.GHlist(GammaH(18,[13]))
+        sage: loads(dumps(L)) == L
+        True
+    """
+    def __init__(self, group):
+        """
+        EXAMPLES::
+
+            sage: L = sage.modular.modsym.ghlist.GHlist(GammaH(8,[7])); L # indirect doctest
+            List of coset representatives for Congruence Subgroup Gamma_H(8) with H generated by [7]
+        """
+        self.__group = group
+        N = group.level()
+        v = group._coset_reduction_data()[0]
+        N = group.level()
+        coset_reps = {a for a, b, _ in v if b == 1}
+        w = [group._reduce_coset(x*u, x*v) for x in coset_reps for u,v in p1list.P1List(N).list()]
+        w = sorted(set(w))
+        self.__list = w
+
+    def __getitem__(self, i):
+        """
+        EXAMPLES::
+
+            sage: L = sage.modular.modsym.ghlist.GHlist(GammaH(8, [5])); L[5] # indirect doctest
+            (1, 3)
+        """
+        return self.__list[i]
+
+    def __richcmp__(self, other, op):
+        r"""
+        Compare ``self`` to ``other``.
+
+        EXAMPLES::
+
+            sage: L1 = sage.modular.modsym.ghlist.GHlist(GammaH(18, [11]))
+            sage: L2 = sage.modular.modsym.ghlist.GHlist(GammaH(18, [13]))
+            sage: L1 > L2
+            True
+            sage: L1 == QQ
+            False
+        """
+        if not isinstance(other, GHlist):
+            return NotImplemented
+        else:
+            return richcmp(self.__group, other.__group, op)
+
+    def __len__(self):
+        """
+        Return the length of the underlying list (the index of the group).
+
+        EXAMPLES::
+
+            sage: L = sage.modular.modsym.ghlist.GHlist(GammaH(24, [5])); len(L) # indirect doctest
+            192
+        """
+        return len(self.__list)
+
+    def __repr__(self):
+        """
+        String representation of ``self``.
+
+        EXAMPLES::
+
+            sage: L = sage.modular.modsym.ghlist.GHlist(GammaH(11, [3]))
+            sage: L.__repr__()
+            'List of coset representatives for Congruence Subgroup Gamma_H(11) with H generated by [3]'
+        """
+        return "List of coset representatives for %s" % self.__group
+
+    def list(self):
+        r"""
+        Return a list of vectors representing the cosets. Do not change the
+        returned list!
+
+        EXAMPLES::
+
+            sage: L = sage.modular.modsym.ghlist.GHlist(GammaH(4,[])); L.list()
+            [(0, 1), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 1), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3)]
+        """
+        return self.__list
+
+    def normalize(self, u, v):
+        r"""
+        Given a pair `(u,v)` of integers, return the unique pair `(u', v')`
+        such that the pair `(u', v')` appears in ``self.list()`` and `(u, v)`
+        is equivalent to `(u', v')`.
+
+        This will only make sense if `{\rm gcd}(u, v, N) = 1`; otherwise the
+        output will not be an element of ``self``.
+
+        EXAMPLES::
+
+            sage: sage.modular.modsym.ghlist.GHlist(GammaH(24, [17, 19])).normalize(17, 6)
+            (1, 6)
+            sage: sage.modular.modsym.ghlist.GHlist(GammaH(24, [7, 13])).normalize(17, 6)
+            (5, 6)
+            sage: sage.modular.modsym.ghlist.GHlist(GammaH(24, [5, 23])).normalize(17, 6)
+            (7, 18)
+        """
+        return self.__group._reduce_coset(u,v)
+
+
+class _GHlist_old_pickle(GHlist):
+    """
+    This class exists only for dealing with old pickles.
+
+    This needs to handle both old-style class pickles, where there is
+    no input to the class on the initial ``__init__`` call, and the
+    new class pickles, we need to have ``__setstate__`` handle it.
+    """
+    def __init__(self):
+        """
+        For unpickling old pickles.
+
+        TESTS::
+
+            sage: from sage.modular.modsym.ghlist import _GHlist_old_pickle
+            sage: L = _GHlist_old_pickle()
+            sage: type(L) == GHlist
+            True
+        """
+        self.__class__ = GHlist
+
+    def __setstate__(self, state):
+        """
+        For unpickling new pickles.
+
+        TESTS::
+
+            sage: from sage.modular.modsym.ghlist import GHlist
+            sage: L = GHlist(GammaH(4,[]))
+            sage: Lp = loads(dumps(L))
+            sage: L == Lp
+            True
+            sage: type(Lp) == GHlist
+            True
+        """
+        # We don't really want this class, but we want to handle new
+        #   pickles without creating a new class
+        self.__class__ = GHlist
+        self.__dict__ = state  # Default pickling is ``state = self.__dict__``
+
+
+register_unpickle_override('sage.modular.modsym.ghlist', 'GHlist',
+                           _GHlist_old_pickle)