passagemath-eclib 10.6.40__cp314-cp314t-macosx_13_0_x86_64.whl

sage/libs/eclib/__init__.pxd

@@ -0,0 +1,158 @@
+# sage_setup: distribution = sagemath-eclib
+# distutils: language = c++
+# distutils: libraries = ec NTL_LIBRARIES pari gmp M_LIBRARIES
+# distutils: extra_compile_args = NTL_CFLAGS
+# distutils: include_dirs = NTL_INCDIR
+# distutils: library_dirs = NTL_LIBDIR
+# distutils: extra_link_args = NTL_LIBEXTRA
+
+
+from libcpp.map cimport map
+from libcpp.vector cimport vector
+from libcpp.pair cimport pair
+from sage.libs.ntl.types cimport ZZ_c
+
+
+# NOTE: eclib used to have specific dependencies, so that they had to
+# be included in a specific order. Although this is no longer the
+# case, we start by listing all relevant include files in the correct
+# order.
+
+cdef extern from "eclib/vector.h": pass
+cdef extern from "eclib/xmod.h": pass
+cdef extern from "eclib/svector.h": pass
+cdef extern from "eclib/matrix.h": pass
+cdef extern from "eclib/smatrix.h": pass
+cdef extern from "eclib/interface.h": pass
+cdef extern from "eclib/rat.h": pass
+cdef extern from "eclib/bigrat.h": pass
+cdef extern from "eclib/isogs.h": pass
+cdef extern from "eclib/curve.h": pass
+cdef extern from "eclib/descent.h": pass
+cdef extern from "eclib/egr.h": pass
+cdef extern from "eclib/htconst.h": pass
+cdef extern from "eclib/moddata.h": pass
+cdef extern from "eclib/symb.h": pass
+cdef extern from "eclib/homspace.h": pass
+cdef extern from "eclib/oldforms.h": pass
+cdef extern from "eclib/newforms.h": pass
+
+
+# Now the actual declarations, where the order no longer matters
+cdef extern from "eclib/vector.h":
+    ctypedef int scalar
+
+    cdef cppclass vec:
+        scalar operator[](long)
+
+cdef extern from "eclib/svector.h":
+    cdef cppclass svec:
+        vec as_vec()
+        scalar elem(int) const
+        map[int,scalar].iterator begin()
+        map[int,scalar].iterator end()
+
+cdef extern from "eclib/matrix.h":
+    cdef cppclass mat:
+        mat()
+        mat(mat m)
+        scalar sub(long, long)
+        long nrows()
+        long ncols()
+        long rank()
+
+    mat addscalar(mat M, scalar)
+
+cdef extern from "eclib/smatrix.h":
+    cdef cppclass smat:
+        smat()
+        smat(smat m)
+        scalar sub(long, long)
+        long nrows()
+        long ncols()
+        long rank()
+        scalar elem(int, int) const
+        svec row(int) const
+
+cdef extern from "eclib/interface.h":
+    ctypedef ZZ_c bigint
+    int I2int(bigint)
+
+cdef extern from "eclib/rat.h":
+    cdef cppclass rational:
+        rational()
+        rational(long num, long den)
+    cdef long rational_num "num"(rational q)
+    cdef long rational_den "den"(rational q)
+
+cdef extern from "eclib/bigrat.h":
+    cdef cppclass bigrational:
+        pass
+    cdef bigint bigrational_num "num"(bigrational q)
+    cdef bigint bigrational_den "den"(bigrational q)
+
+cdef extern from "eclib/curve.h":
+    cdef cppclass Curve:
+        Curve()
+        Curve(bigint aa1, bigint aa2, bigint aa3, bigint aa4, bigint aa6)
+        void getai(bigint a1, bigint a2, bigint a3, bigint a4, bigint a6)
+
+    cdef cppclass Curvedata:
+        Curvedata()
+        Curvedata(Curve C, int m)
+        Curvedata(bigint a1, bigint a2, bigint a3, bigint a4, bigint a6,
+                int min_on_init)
+        void getai(bigint a1, bigint a2, bigint a3, bigint a4, bigint a6)
+
+    cdef cppclass CurveRed:
+        CurveRed()
+        CurveRed(Curvedata CD)
+
+    bigint getconductor(CurveRed CR)
+
+cdef extern from "eclib/descent.h":
+    cdef cppclass two_descent:
+        two_descent(Curvedata* curve,
+                    int verb, int sel,
+                    long firstlim, long secondlim,
+                    long n_aux, int second_descent)
+
+    cdef cppclass mw:
+        mw(Curvedata* curve, int verb, int pp, int maxr)
+
+cdef extern from "eclib/homspace.h":
+    cdef cppclass homspace:
+        long modulus
+        int plusflag # sign
+        int cuspidal
+
+        homspace(long n, int hp, int hcusp, int verbose)
+
+        int h1dim()
+        int h1cuspdim()
+        mat heckeop(long p, int dual, int display)
+        vec heckeop_col(long p, int j, int display)
+        smat s_heckeop(long p, int dual, int display)
+        long h1ncusps()
+
+cdef extern from "eclib/newforms.h":
+    cdef cppclass newforms:
+        vector[newform] nflist
+        int verbose
+        int basisflag
+        long maxdepth
+        long cuspidal
+        long sign
+
+        newforms(long n, int disp)
+
+        void createfromcurve(int sign, CurveRed CR, int nap)
+        void display()
+        # Here i is the index of the relevant newform in the space,
+        # which for us will always be 0:
+        rational plus_modular_symbol(rational r, int i, int base_at_infinity)
+        rational minus_modular_symbol(rational r, int i, int base_at_infinity)
+        pair[rational,rational] full_modular_symbol(rational r, int i, int base_at_infinity)
+
+    cdef cppclass newform:
+        newforms* nf

sage/libs/eclib/__init__.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-eclib

sage/libs/eclib/all.py

@@ -0,0 +1,5 @@
+# sage_setup: distribution = sagemath-eclib
+from sage.libs.eclib.constructor import CremonaModularSymbols
+from sage.libs.eclib.interface import mwrank_EllipticCurve, mwrank_MordellWeil
+from sage.libs.eclib.mwrank import get_precision, set_precision
+from sage.libs.eclib.mwrank import initprimes as mwrank_initprimes

sage/libs/eclib/constructor.py

@@ -0,0 +1,75 @@
+# sage_setup: distribution = sagemath-eclib
+"Cremona modular symbols"
+
+
+def CremonaModularSymbols(level, sign=0, cuspidal=False, verbose=0):
+    """
+    Return the space of Cremona modular symbols with given level, sign, etc.
+
+    INPUT:
+
+    - ``level`` -- integer; at least 2, not just positive!
+    - ``sign`` -- integer (default: 0); either 0 or 1 or -1
+    - ``cuspidal`` -- boolean (default: ``False``); if ``True``, compute only
+      the cuspidal subspace
+    - ``verbose`` -- boolean (default: ``False``); if ``True``, print verbose
+      information while creating space
+
+    EXAMPLES::
+
+        sage: M = CremonaModularSymbols(43); M
+        Cremona Modular Symbols space of dimension 7 for Gamma_0(43) of weight 2 with sign 0
+        sage: M = CremonaModularSymbols(43, sign=1); M
+        Cremona Modular Symbols space of dimension 4 for Gamma_0(43) of weight 2 with sign 1
+        sage: M = CremonaModularSymbols(43, cuspidal=True); M
+        Cremona Cuspidal Modular Symbols space of dimension 6 for Gamma_0(43) of weight 2 with sign 0
+        sage: M = CremonaModularSymbols(43, cuspidal=True, sign=1); M
+        Cremona Cuspidal Modular Symbols space of dimension 3 for Gamma_0(43) of weight 2 with sign 1
+
+    When run interactively, the following command will display verbose output::
+
+        sage: M = CremonaModularSymbols(43, verbose=1)
+        After 2-term relations, ngens = 22
+        ngens     = 22
+        maxnumrel = 32
+        relation matrix has = 704 entries...
+        Finished 3-term relations: numrel = 16 ( maxnumrel = 32)
+        relmat has 42 nonzero entries (density = 0.0596591)
+        Computing kernel...
+        time to compute kernel =  (... seconds)
+        rk = 7
+        Number of cusps is 2
+        ncusps = 2
+        About to compute matrix of delta
+        delta matrix done: size 2x7.
+        About to compute kernel of delta
+        done
+        Finished constructing homspace.
+        sage: M
+        Cremona Modular Symbols space of dimension 7 for Gamma_0(43) of weight 2 with sign 0
+
+    The input must be valid or a :exc:`ValueError` is raised::
+
+        sage: M = CremonaModularSymbols(-1)
+        Traceback (most recent call last):
+        ...
+        ValueError: the level (= -1) must be at least 2
+        sage: M = CremonaModularSymbols(0)
+        Traceback (most recent call last):
+        ...
+        ValueError: the level (= 0) must be at least 2
+
+    The sign can only be 0 or 1 or -1::
+
+        sage: M = CremonaModularSymbols(10, sign = -2)
+        Traceback (most recent call last):
+        ...
+        ValueError: sign (= -2) is not supported; use 0, +1 or -1
+
+    We do allow -1 as a sign (see :issue:`9476`)::
+
+        sage: CremonaModularSymbols(10, sign = -1)
+        Cremona Modular Symbols space of dimension 0 for Gamma_0(10) of weight 2 with sign -1
+    """
+    from .homspace import ModularSymbols
+    return ModularSymbols(level=level, sign=sign, cuspidal=cuspidal, verbose=verbose)

sage/libs/eclib/homspace.pxd

@@ -0,0 +1,5 @@
+# sage_setup: distribution = sagemath-eclib
+from sage.libs.eclib cimport homspace
+
+cdef class ModularSymbols:
+    cdef homspace* H

sage/libs/eclib/homspace.pyx

@@ -0,0 +1,285 @@
+# sage_setup: distribution = sagemath-eclib
+"Cremona modular symbols"
+
+from cysignals.signals cimport sig_on, sig_off
+from cython.operator cimport dereference as deref
+from cython.operator cimport preincrement as inc
+
+from sage.libs.eclib cimport svec, mat, smat
+from sage.libs.eclib.mat cimport MatrixFactory
+
+from sage.matrix.matrix_space import MatrixSpace
+from sage.rings.integer_ring import ZZ
+
+cdef MatrixFactory MF = MatrixFactory()
+
+
+cdef class ModularSymbols:
+    """
+    Class of Cremona Modular Symbols of given level and sign (and weight 2).
+
+    EXAMPLES::
+
+        sage: M = CremonaModularSymbols(225)
+        sage: type(M)
+        <class 'sage.libs.eclib.homspace.ModularSymbols'>
+    """
+    def __init__(self, long level, int sign=0, bint cuspidal=False, int verbose=0):
+        """
+        Called when creating a space of Cremona modular symbols.
+
+        INPUT:
+
+        - ``level`` -- integer; the level: at least 2
+        - ``sign`` -- integer (default: 0); the sign: 0, +1 or -1
+        - ``cuspidal`` -- boolean (default: ``False``); ``True`` for cuspidal homology
+        - ``verbose`` -- integer (default: 0); verbosity level
+
+        EXAMPLES::
+
+            sage: CremonaModularSymbols(123, sign=1, cuspidal=True)
+            Cremona Cuspidal Modular Symbols space of dimension 13 for Gamma_0(123) of weight 2 with sign 1
+            sage: CremonaModularSymbols(123, sign=-1, cuspidal=True)
+            Cremona Cuspidal Modular Symbols space of dimension 13 for Gamma_0(123) of weight 2 with sign -1
+            sage: CremonaModularSymbols(123, sign=0, cuspidal=True)
+            Cremona Cuspidal Modular Symbols space of dimension 26 for Gamma_0(123) of weight 2 with sign 0
+            sage: CremonaModularSymbols(123, sign=0, cuspidal=False)
+            Cremona Modular Symbols space of dimension 29 for Gamma_0(123) of weight 2 with sign 0
+        """
+        if not (sign == 0 or sign == 1 or sign == -1):
+            raise ValueError("sign (= %s) is not supported; use 0, +1 or -1" % sign)
+        if level <= 1:
+            raise ValueError("the level (= %s) must be at least 2" % level)
+        sig_on()
+        self.H = new homspace(level, sign, cuspidal, verbose)
+        sig_off()
+
+    def __dealloc__(self):
+        del self.H
+
+    def __repr__(self):
+        """
+        String representation of space of Cremona modular symbols.
+
+        EXAMPLES:
+
+        We test various types of spaces that impact printing::
+
+            sage: M = CremonaModularSymbols(37, sign=1)
+            sage: M.__repr__()
+            'Cremona Modular Symbols space of dimension 3 for Gamma_0(37) of weight 2 with sign 1'
+
+            sage: CremonaModularSymbols(37, cuspidal=True).__repr__()
+            'Cremona Cuspidal Modular Symbols space of dimension 4 for Gamma_0(37) of weight 2 with sign 0'
+        """
+        return "Cremona %sModular Symbols space of dimension %s for Gamma_0(%s) of weight 2 with sign %s" % (
+            'Cuspidal ' if self.is_cuspidal() else '',
+            self.dimension(), self.level(), self.sign())
+
+    #cpdef long level(self):
+    def level(self):
+        """
+        Return the level of this modular symbols space.
+
+        EXAMPLES::
+
+            sage: M = CremonaModularSymbols(1234, sign=1)
+            sage: M.level()
+            1234
+        """
+        return self.H.modulus
+
+    #cpdef int dimension(self):
+    def dimension(self):
+        """
+        Return the dimension of this modular symbols space.
+
+        EXAMPLES::
+
+            sage: M = CremonaModularSymbols(1234, sign=1)
+            sage: M.dimension()
+            156
+        """
+        if self.is_cuspidal():
+            return self.H.h1cuspdim()
+        else:
+            return self.H.h1dim()
+
+    def number_of_cusps(self):
+        r"""
+        Return the number of cusps for `\Gamma_0(N)`, where `N` is the
+        level.
+
+        EXAMPLES::
+
+            sage: M = CremonaModularSymbols(225)
+            sage: M.number_of_cusps()
+            24
+        """
+        return self.H.h1ncusps()
+
+    #cpdef int sign(self):
+    def sign(self):
+        """
+        Return the sign of this Cremona modular symbols space.  The sign is either 0, +1 or -1.
+
+        EXAMPLES::
+
+            sage: M = CremonaModularSymbols(1122, sign=1); M
+            Cremona Modular Symbols space of dimension 224 for Gamma_0(1122) of weight 2 with sign 1
+            sage: M.sign()
+            1
+            sage: M = CremonaModularSymbols(1122); M
+            Cremona Modular Symbols space of dimension 433 for Gamma_0(1122) of weight 2 with sign 0
+            sage: M.sign()
+            0
+            sage: M = CremonaModularSymbols(1122, sign=-1); M
+            Cremona Modular Symbols space of dimension 209 for Gamma_0(1122) of weight 2 with sign -1
+            sage: M.sign()
+            -1
+        """
+        return self.H.plusflag
+
+    #cpdef bint is_cuspidal(self):
+    def is_cuspidal(self):
+        """
+        Return whether or not this space is cuspidal.
+
+        EXAMPLES::
+
+            sage: M = CremonaModularSymbols(1122); M.is_cuspidal()
+            0
+            sage: M = CremonaModularSymbols(1122, cuspidal=True); M.is_cuspidal()
+            1
+        """
+        return self.H.cuspidal
+
+    def hecke_matrix(self, long p, dual=False, verbose=False):
+        """
+        Return the matrix of the ``p``-th Hecke operator acting on
+        this space of modular symbols.
+
+        The result of this command is not cached.
+
+        INPUT:
+
+        - ``p`` -- a prime number
+
+        - ``dual`` -- boolean (default: ``False``); whether to compute the
+          Hecke operator acting on the dual space, i.e., the transpose of the
+          Hecke operator
+
+        - ``verbose`` -- boolean (default: ``False``); print verbose output
+
+        OUTPUT:
+
+        (matrix) If ``p`` divides the level, the matrix of the
+        Atkin-Lehner involution `W_p` at ``p``; otherwise the matrix of the
+        Hecke operator `T_p`,
+
+        EXAMPLES::
+
+            sage: M = CremonaModularSymbols(37)
+            sage: t = M.hecke_matrix(2); t
+            5 x 5 Cremona matrix over Rational Field
+            sage: print(t.str())
+            [ 3  0  0  0  0]
+            [-1 -1  1  1  0]
+            [ 0  0 -1  0  1]
+            [-1  1  0 -1 -1]
+            [ 0  0  1  0 -1]
+            sage: t.charpoly().factor()
+            (x - 3) * x^2 * (x + 2)^2
+            sage: print(M.hecke_matrix(2, dual=True).str())
+            [ 3 -1  0 -1  0]
+            [ 0 -1  0  1  0]
+            [ 0  1 -1  0  1]
+            [ 0  1  0 -1  0]
+            [ 0  0  1 -1 -1]
+            sage: w = M.hecke_matrix(37); w
+            5 x 5 Cremona matrix over Rational Field
+            sage: w.charpoly().factor()
+            (x - 1)^2 * (x + 1)^3
+            sage: sw = w.sage_matrix_over_ZZ()
+            sage: st = t.sage_matrix_over_ZZ()
+            sage: sw^2 == sw.parent()(1)
+            True
+            sage: st*sw == sw*st
+            True
+        """
+        sig_on()
+        cdef mat M = self.H.heckeop(p, dual, verbose)
+        sig_off()
+        return MF.new_matrix(M)
+
+    def sparse_hecke_matrix(self, long p, dual=False, verbose=False, base_ring=ZZ):
+        """
+        Return the matrix of the ``p``-th Hecke operator acting on
+        this space of modular symbols as a sparse Sage matrix over
+        ``base_ring``. This is more memory-efficient than creating a
+        Cremona matrix and then applying sage_matrix_over_ZZ with sparse=True.
+
+        The result of this command is not cached.
+
+        INPUT:
+
+        - ``p`` -- a prime number
+
+        - ``dual`` -- boolean (default: ``False``); whether to compute the
+          Hecke operator acting on the dual space, i.e., the transpose of the Hecke
+          operator
+
+        - ``verbose`` -- boolean (default: ``False``); print verbose output
+
+        OUTPUT:
+
+        (matrix) If ``p`` divides the level, the matrix of the
+        Atkin-Lehner involution `W_p` at ``p``; otherwise the matrix of the
+        Hecke operator `T_p`,
+
+        EXAMPLES::
+
+            sage: M = CremonaModularSymbols(37)
+            sage: t = M.sparse_hecke_matrix(2); type(t)
+            <class 'sage.matrix.matrix_integer_sparse.Matrix_integer_sparse'>
+            sage: print(t)
+            [ 3  0  0  0  0]
+            [-1 -1  1  1  0]
+            [ 0  0 -1  0  1]
+            [-1  1  0 -1 -1]
+            [ 0  0  1  0 -1]
+            sage: M = CremonaModularSymbols(5001)
+            sage: T = M.sparse_hecke_matrix(2)
+            sage: U = M.hecke_matrix(2).sage_matrix_over_ZZ(sparse=True)
+            sage: print(T == U)
+            True
+            sage: T = M.sparse_hecke_matrix(2, dual=True)
+            sage: print(T == U.transpose())
+            True
+            sage: T = M.sparse_hecke_matrix(2, base_ring=GF(7))
+            sage: print(T == U.change_ring(GF(7)))
+            True
+
+        This concerns an issue reported on :issue:`21303`::
+
+            sage: C = CremonaModularSymbols(45, cuspidal=True,sign=-1)
+            sage: T2a = C.hecke_matrix(2).sage_matrix_over_ZZ()
+            sage: T2b = C.sparse_hecke_matrix(2)
+            sage: print(T2a == T2b)
+            True
+        """
+        cdef long i, n = self.dimension()
+        cdef svec sv
+        d = {}
+        sig_on()
+        cdef smat M = self.H.s_heckeop(p, dual, verbose)
+        sig_off()
+        for i in range(n):
+            sv = M.row(i+1)
+            iter = sv.begin()
+            while iter != sv.end():
+                d[(i,deref(iter).first-1)] = deref(iter).second
+                inc(iter)
+        MS = MatrixSpace(base_ring, n, sparse=True)
+        # The next step is the bottleneck.
+        return MS(d)