passagemath-schemes 10.6.47__cp312-cp312-macosx_13_0_arm64.whl

sage/schemes/elliptic_curves/mod5family.py

@@ -0,0 +1,105 @@
+# sage_setup: distribution = sagemath-schemes
+"""
+Elliptic curves with congruent mod-5 representation
+
+AUTHORS:
+
+- Alice Silverberg and Karl Rubin -- original PARI/GP version
+
+- William Stein -- Sage version
+"""
+# ****************************************************************************
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
+from sage.rings.rational_field import QQ
+from .constructor import EllipticCurve
+
+
+def mod5family(a, b):
+    """
+    Formulas for computing the family of elliptic curves with
+    congruent mod-5 representation.
+
+    EXAMPLES::
+
+        sage: from sage.schemes.elliptic_curves.mod5family import mod5family
+        sage: mod5family(0,1)
+        Elliptic Curve defined by y^2 = x^3 + (t^30+30*t^29+435*t^28+4060*t^27+27405*t^26+142506*t^25+593775*t^24+2035800*t^23+5852925*t^22+14307150*t^21+30045015*t^20+54627300*t^19+86493225*t^18+119759850*t^17+145422675*t^16+155117520*t^15+145422675*t^14+119759850*t^13+86493225*t^12+54627300*t^11+30045015*t^10+14307150*t^9+5852925*t^8+2035800*t^7+593775*t^6+142506*t^5+27405*t^4+4060*t^3+435*t^2+30*t+1) over Fraction Field of Univariate Polynomial Ring in t over Rational Field
+    """
+    J = 4*a**3 / (4*a**3+27*b**2)
+
+    alpha = [0 for _ in range(21)]
+    alpha[0] = 1
+    alpha[1] = 0
+    alpha[2] = 190*(J - 1)
+    alpha[3] = -2280*(J - 1)**2
+    alpha[4] = 855*(J - 1)**2*(-17 + 16*J)
+    alpha[5] = 3648*(J - 1)**3*(17 - 9*J)
+    alpha[6] = 11400*(J - 1)**3*(17 - 8*J)
+    alpha[7] = -27360*(J - 1)**4*(17 + 26*J)
+    alpha[8] = 7410*(J - 1)**4*(-119 - 448*J + 432*J**2)
+    alpha[9] = 79040*(J - 1)**5*(17 + 145*J - 108*J**2)
+    alpha[10] = 8892*(J - 1)**5*(187 + 2640*J - 5104*J**2 + 1152*J**3)
+    alpha[11] = 98800*(J - 1)**6*(-17 - 388*J + 864*J**2)
+    alpha[12] = 7410*(J - 1)**6*(-187 - 6160*J + 24464*J**2 - 24192*J**3)
+    alpha[13] = 54720*(J - 1)**7*(17 + 795*J - 3944*J**2 + 9072*J**3)
+    alpha[14] = 2280*(J - 1)**7*(221 + 13832*J - 103792*J**2 + 554112*J**3 - 373248*J**4)
+    alpha[15] = 1824*(J - 1)**8*(-119 - 9842*J + 92608*J**2 - 911520*J**3 + 373248*J**4)
+    alpha[16] = 4275*(J - 1)**8*(-17 - 1792*J + 23264*J**2 - 378368*J**3 + 338688*J**4)
+    alpha[17] = 18240*(J - 1)**9*(1 + 133*J - 2132*J**2 + 54000*J**3 - 15552*J**4)
+    alpha[18] = 190*(J - 1)**9*(17 + 2784*J - 58080*J**2 + 2116864*J**3 - 946944*J**4 + 2985984*J**5)
+    alpha[19] = 360*(J - 1)**10*(-1 + 28*J - 1152*J**2)*(1 + 228*J + 176*J**2 + 1728*J**3)
+    alpha[20] = (J - 1)**10*(-19 - 4560*J + 144096*J**2 - 9859328*J**3 - 8798976*J**4 - 226934784*J**5 + 429981696*J**6)
+
+    beta = [0 for _ in range(31)]
+    beta[0] = 1
+    beta[1] = 30
+    beta[2] = -435*(J - 1)
+    beta[3] = 580*(J - 1)*(-7 + 9*J)
+    beta[4] = 3915*(J - 1)**2*(7 - 8*J)
+    beta[5] = 1566*(J - 1)**2*(91 - 78*J + 48*J**2)
+    beta[6] = -84825*(J - 1)**3*(7 + 16*J)
+    beta[7] = 156600*(J - 1)**3*(-13 - 91*J + 92*J**2)
+    beta[8] = 450225*(J - 1)**4*(13 + 208*J - 144*J**2)
+    beta[9] = 100050*(J - 1)**4*(143 + 4004*J - 5632*J**2 + 1728*J**3)
+    beta[10] = 30015*(J - 1)**5*(-1001 - 45760*J + 44880*J**2 - 6912*J**3)
+    beta[11] = 600300*(J - 1)**5*(-91 - 6175*J + 9272*J**2 - 2736*J**3)
+    beta[12] = 950475*(J - 1)**6*(91 + 8840*J - 7824*J**2)
+    beta[13] = 17108550*(J - 1)**6*(7 + 926*J - 1072*J**2 + 544*J**3)
+    beta[14] = 145422675*(J - 1)**7*(-1 - 176*J + 48*J**2 - 384*J**3)
+    beta[15] = 155117520*(J - 1)**8*(1 + 228*J + 176*J**2 + 1728*J**3)
+    beta[16] = 145422675*(J - 1)**8*(1 + 288*J + 288*J**2 + 5120*J**3 - 6912*J**4)
+    beta[17] = 17108550*(J - 1)**8*(7 + 2504*J + 3584*J**2 + 93184*J**3 - 283392*J**4 + 165888*J**5)
+    beta[18] = 950475*(J - 1)**9*(-91 - 39936*J - 122976*J**2 - 2960384*J**3 + 11577600*J**4 - 5971968*J**5)
+    beta[19] = 600300*(J - 1)**9*(-91 - 48243*J - 191568*J**2 - 6310304*J**3 + 40515072*J**4 - 46455552*J**5 + 11943936*J**6)
+    beta[20] = 30015*(J - 1)**10*(1001 + 634920*J + 3880800*J**2 + 142879744*J**3 - 1168475904*J**4 + 1188919296*J**5 - 143327232*J**6)
+    beta[21] = 100050*(J - 1)**10*(143 + 107250*J + 808368*J**2 + 38518336*J**3 - 451953408*J**4 + 757651968*J**5 - 367276032*J**6)
+    beta[22] = 450225*(J - 1)**11*(-13 - 11440*J - 117216*J**2 - 6444800*J**3 + 94192384*J**4 - 142000128*J**5 + 95551488*J**6)
+    beta[23] = 156600*(J - 1)**11*(-13 - 13299*J - 163284*J**2 - 11171552*J**3 + 217203840*J**4 - 474406656*J**5 + 747740160*J**6 - 429981696*J**7)
+    beta[24] = 6525*(J - 1)**12*(91 + 107536*J + 1680624*J**2 + 132912128*J**3 -
+          3147511552*J**4 + 6260502528*J**5 - 21054173184*J**6 + 10319560704*J**7)
+    beta[25] = 1566*(J - 1)**12*(91 + 123292*J + 2261248*J**2 + 216211904*J**3 -
+          6487793920*J**4 + 17369596928*J**5 - 97854234624*J**6 + 96136740864*J**7 - 20639121408*J**8)
+    beta[26] = 3915*(J - 1)**13*(-7 - 10816*J - 242352*J**2 - 26620160*J**3 + 953885440*J**4 -
+          2350596096*J**5 + 26796552192*J**6 - 13329432576*J**7)
+    beta[27] = 580*(J - 1)**13*(-7 - 12259*J - 317176*J**2 - 41205008*J**3 +
+          1808220160*J**4 - 5714806016*J**5 + 93590857728*J**6 - 70131806208*J**7 - 36118462464*J**8)
+    beta[28] = 435*(J - 1)**14*(1 + 1976*J + 60720*J**2 + 8987648*J**3 - 463120640*J**4 + 1359157248*J**5 -
+          40644882432*J**6 - 5016453120*J**7 + 61917364224*J**8)
+    beta[29] = 30*(J - 1)**14*(1 + 2218*J + 77680*J**2 + 13365152*J**3 -
+          822366976*J**4 + 2990693888*J**5 - 118286217216*J**6 - 24514928640*J**7 + 509958291456*J**8 - 743008370688*J**9)
+    beta[30] = (J - 1)**15*(-1 - 2480*J - 101040*J**2 - 19642496*J**3 + 1399023872*J**4 -
+          4759216128*J**5 + 315623485440*J**6 + 471904911360*J**7 - 2600529297408*J**8 + 8916100448256*J**9)
+
+    R = PolynomialRing(QQ, 't')
+    c2 = a * R(alpha)
+    c3 = b * R(beta)
+    d = c2.denominator().lcm(c3.denominator())
+    F = R.fraction_field()
+    return EllipticCurve(F, [c2 * d**4, c3 * d**6])

sage/schemes/elliptic_curves/mod_poly.py

@@ -0,0 +1,197 @@
+# sage_setup: distribution = sagemath-schemes
+r"""
+Modular polynomials for elliptic curves
+
+For a positive integer `\ell`, the classical modular polynomial
+`\Phi_\ell \in \ZZ[X,Y]` is characterized by the property that its
+zero set is exactly the set of pairs of `j`-invariants connected
+by a cyclic `\ell`-isogeny.
+
+AUTHORS:
+
+- Lorenz Panny (2023)
+"""
+
+from sage.structure.element import parent
+
+from sage.rings.integer_ring import ZZ
+
+from sage.libs.pari import pari
+from cypari2.handle_error import PariError
+
+_db = None
+
+_cache_bound = 100
+_cache = {}
+
+
+def classical_modular_polynomial(l, j=None):
+    r"""
+    Return the classical modular polynomial `\Phi_\ell`, either as a
+    "generic" bivariate polynomial over `\ZZ`, or as an "instantiated"
+    modular polynomial where one variable has been replaced by the
+    given `j`-invariant.
+
+    Generic polynomials are cached up to a certain size of `\ell`,
+    which significantly accelerates subsequent invocations with the
+    same `\ell`. The default bound is `\ell \leq 100`, which can be
+    adjusted using ``classical_modular_polynomial.set_cache_bound()``
+    with a different value. Beware that modular polynomials are very
+    big objects and the amount of memory consumed by the cache will
+    grow rapidly when the bound is set to a large value.
+
+    INPUT:
+
+    - ``l`` -- positive integer
+    - ``j`` -- either ``None`` or a ring element:
+
+      * if ``None`` is given, the original modular polynomial
+        is returned as an element of `\ZZ[X,Y]`
+      * if a ring element `j \in R` is given, the evaluation
+        `\Phi_\ell(j,Y)` is returned as an element of the
+        univariate polynomial ring `R[Y]`
+
+    ALGORITHMS:
+
+    - The Kohel database
+      :class:`~sage.databases.db_modular_polynomials.ClassicalModularPolynomialDatabase`
+    - :pari:`polmodular`
+
+    EXAMPLES::
+
+        sage: classical_modular_polynomial(2)
+        -X^2*Y^2 + X^3 + 1488*X^2*Y + 1488*X*Y^2 + Y^3 - 162000*X^2 + 40773375*X*Y - 162000*Y^2 + 8748000000*X + 8748000000*Y - 157464000000000
+        sage: j = Mod(1728, 419)
+        sage: classical_modular_polynomial(3, j)
+        Y^4 + 230*Y^3 + 84*Y^2 + 118*Y + 329
+
+    Increasing the cache size can be useful for repeated invocations::
+
+        sage: %timeit classical_modular_polynomial(101)                              # not tested
+        6.11 s ± 1.21 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+        sage: %timeit classical_modular_polynomial(101, GF(65537).random_element())  # not tested
+        5.43 s ± 2.71 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+
+        sage: classical_modular_polynomial.set_cache_bound(150)                      # not tested
+        sage: %timeit classical_modular_polynomial(101)                              # not tested
+        The slowest run took 10.35 times longer than the fastest. This could mean that an intermediate result is being cached.
+        1.84 µs ± 1.84 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)
+        sage: %timeit classical_modular_polynomial(101, GF(65537).random_element())  # not tested
+        59.8 ms ± 29.4 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
+
+    TESTS::
+
+        sage: q = random_prime(50)^randrange(1,4)
+        sage: j = GF(q).random_element()
+        sage: l = random_prime(50)
+        sage: Y = polygen(parent(j), 'Y')
+        sage: classical_modular_polynomial(l, j) == classical_modular_polynomial(l)(j, Y)
+        True
+        sage: p = 2^216 * 3^137 - 1
+        sage: F.<i> = GF((p,2), modulus=[1,0,1])
+        sage: l = random_prime(50)
+        sage: j = F.random_element()
+        sage: Y = polygen(parent(j), 'Y')
+        sage: classical_modular_polynomial(l, j) == classical_modular_polynomial(l)(j, Y)
+        True
+        sage: E = EllipticCurve(F, [0, 6, 0, 1, 0])
+        sage: j = E.j_invariant()
+        sage: l = random_prime(50)
+        sage: classical_modular_polynomial(l, j) == classical_modular_polynomial(l)(j, Y)
+        True
+        sage: R.<Y> = QQ['Y']
+        sage: j = QQ(1/2)
+        sage: l = random_prime(50)
+        sage: classical_modular_polynomial(l, j) == classical_modular_polynomial(l)(j, Y)
+        True
+    """
+    global _db
+    l = ZZ(l)
+
+    if j is None:
+        # We are supposed to return the generic modular polynomial. First
+        # check if it is already in the cache, then check the database,
+        # finally compute it using PARI.
+        try:
+            return _cache[l]
+        except KeyError:
+            pass
+
+        try:
+            if _db is None:
+                from sage.databases.db_modular_polynomials import ClassicalModularPolynomialDatabase
+                _db = ClassicalModularPolynomialDatabase()
+            Phi = ZZ['X,Y'](_db[l])
+        except (FileNotFoundError, ImportError, ValueError):
+            try:
+                pari_Phi = pari.polmodular(l)
+            except PariError:
+                raise NotImplementedError('modular polynomial is not in database and computing it on the fly is not yet implemented')
+            d = {(i, j): c for i, f in enumerate(pari_Phi)
+                 for j, c in enumerate(f)}
+            Phi = ZZ['X,Y'](d)
+
+        if l <= _cache_bound:
+            _cache[l] = Phi
+
+        return Phi
+
+    R = parent(j)['Y']
+    Y = R.gen()
+
+    # If the generic polynomial is in the cache or the database, evaluating
+    # it directly should always be faster than recomputing it from scratch.
+    if l in _cache:
+        return _cache[l](j, Y)
+    try:
+        if _db is None:
+            from sage.databases.db_modular_polynomials import ClassicalModularPolynomialDatabase
+            _db = ClassicalModularPolynomialDatabase()
+        Phi = _db[l]
+    except (ValueError, ImportError, FileNotFoundError):
+        pass
+    else:
+        if l <= _cache_bound:
+            _cache[l] = ZZ['X,Y'](Phi)
+        return Phi(j, Y)
+
+    # Now try to get the instantiated modular polynomial directly from PARI.
+    # This should be slightly more efficient (in particular regarding memory
+    # usage) than computing and evaluating the generic modular polynomial.
+    # This currently only works if we are over Z/nZ.
+    try:
+        pari_Phi = pari.polmodular(l, 0, j)
+        return R(pari_Phi)
+    except PariError:
+        pass
+    except TypeError:
+        return R(ZZ['Y'](pari_Phi))
+
+    # Nothing worked. Fall back to computing the generic modular polynomial
+    # and simply evaluating it.
+    return classical_modular_polynomial(l)(j, Y)
+
+
+def _set_cache_bound(bnd):
+    r"""
+    Internal helper function to allow setting the caching cutoff for
+    :func:`classical_modular_polynomial`.
+
+    Exposed as ``classical_modular_polynomial.set_cache_bound()``.
+
+    EXAMPLES::
+
+        sage: import sage.schemes.elliptic_curves.mod_poly as m
+        sage: m._cache_bound
+        100
+        sage: m._set_cache_bound(123)
+        sage: m._cache_bound
+        123
+        sage: classical_modular_polynomial.set_cache_bound is m._set_cache_bound
+        True
+    """
+    global _cache_bound
+    _cache_bound = bnd
+
+
+classical_modular_polynomial.set_cache_bound = _set_cache_bound