passagemath-schemes 10.6.40__cp314-cp314-macosx_13_0_arm64.whl

sage/schemes/elliptic_curves/jacobian.py

@@ -0,0 +1,237 @@
+# sage_setup: distribution = sagemath-schemes
+"""
+Construct elliptic curves as Jacobians
+
+An elliptic curve is a genus one curve with a designated point. The
+Jacobian of a genus-one curve can be defined as the set of line
+bundles on the curve, and is isomorphic to the original genus-one
+curve. It is also an elliptic curve with the trivial line bundle as
+designated point. The utility of this construction is that we can
+construct elliptic curves without having to specify which point we
+take as the origin.
+
+EXAMPLES::
+
+    sage: R.<u,v,w> = QQ[]
+    sage: Jacobian(u^3 + v^3 + w^3)
+    Elliptic Curve defined by y^2 = x^3 - 27/4 over Rational Field
+    sage: Jacobian(u^4 + v^4 + w^2)
+    Elliptic Curve defined by y^2 = x^3 - 4*x over Rational Field
+
+    sage: C = Curve(u^3 + v^3 + w^3)
+    sage: Jacobian(C)
+    Elliptic Curve defined by y^2 = x^3 - 27/4 over Rational Field
+
+    sage: P2.<u,v,w> = ProjectiveSpace(2, QQ)
+    sage: C = P2.subscheme(u^3 + v^3 + w^3)
+    sage: Jacobian(C)
+    Elliptic Curve defined by y^2 = x^3 - 27/4 over Rational Field
+
+One can also define Jacobians of varieties that are not genus-one
+curves. These are not implemented in this module, but we call the
+relevant functionality::
+
+    sage: R.<x> = PolynomialRing(QQ)
+    sage: f = x**5 + 1184*x**3 + 1846*x**2 + 956*x + 560
+    sage: C = HyperellipticCurve(f)
+    sage: Jacobian(C)
+    Jacobian of Hyperelliptic Curve over Rational Field defined
+     by y^2 = x^5 + 1184*x^3 + 1846*x^2 + 956*x + 560
+
+REFERENCES:
+
+- :wikipedia:`Jacobian_variety`
+"""
+
+##############################################################################
+#       Copyright (C) 2013 Volker Braun <vbraun.name@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#  The full text of the GPL is available at:
+#
+#                  http://www.gnu.org/licenses/
+##############################################################################
+
+from sage.schemes.elliptic_curves.constructor import EllipticCurve
+
+
+def Jacobian(X, **kwds):
+    """
+    Return the Jacobian.
+
+    INPUT:
+
+    - ``X`` -- polynomial, algebraic variety, or anything else that
+      has a Jacobian elliptic curve
+
+    - ``kwds`` -- optional keyword arguments
+
+    The input ``X`` can be one of the following:
+
+    * A polynomial, see :func:`Jacobian_of_equation` for details.
+
+    * A curve, see :func:`Jacobian_of_curve` for details.
+
+    EXAMPLES::
+
+        sage: R.<u,v,w> = QQ[]
+        sage: Jacobian(u^3 + v^3 + w^3)
+        Elliptic Curve defined by y^2 = x^3 - 27/4 over Rational Field
+
+        sage: C = Curve(u^3 + v^3 + w^3)
+        sage: Jacobian(C)
+        Elliptic Curve defined by y^2 = x^3 - 27/4 over Rational Field
+
+        sage: P2.<u,v,w> = ProjectiveSpace(2, QQ)
+        sage: C = P2.subscheme(u^3 + v^3 + w^3)
+        sage: Jacobian(C)
+        Elliptic Curve defined by y^2 = x^3 - 27/4 over Rational Field
+
+        sage: Jacobian(C, morphism=True)
+        Scheme morphism:
+          From: Closed subscheme of Projective Space of dimension 2 over Rational Field defined by:
+          u^3 + v^3 + w^3
+          To:   Elliptic Curve defined by y^2 = x^3 - 27/4 over Rational Field
+          Defn: Defined on coordinates by sending (u : v : w) to
+                (-u^4*v^4*w - u^4*v*w^4 - u*v^4*w^4 :
+                 1/2*u^6*v^3 - 1/2*u^3*v^6 - 1/2*u^6*w^3 + 1/2*v^6*w^3 + 1/2*u^3*w^6 - 1/2*v^3*w^6 :
+                 u^3*v^3*w^3)
+    """
+    try:
+        return X.jacobian(**kwds)
+    except (AttributeError, TypeError):
+        pass
+
+    morphism = kwds.pop('morphism', False)
+    from sage.rings.polynomial.multi_polynomial import MPolynomial
+    if isinstance(X, MPolynomial):
+        if morphism:
+            from sage.schemes.curves.constructor import Curve
+            return Jacobian_of_equation(X, curve=Curve(X), **kwds)
+        else:
+            return Jacobian_of_equation(X, **kwds)
+
+    from sage.schemes.generic.scheme import Scheme
+    if isinstance(X, Scheme) and X.dimension() == 1:
+        return Jacobian_of_curve(X, morphism=morphism, **kwds)
+
+
+def Jacobian_of_curve(curve, morphism=False):
+    """
+    Return the Jacobian of a genus-one curve.
+
+    INPUT:
+
+    - ``curve`` -- a one-dimensional algebraic variety of genus one
+
+    OUTPUT: its Jacobian elliptic curve
+
+    EXAMPLES::
+
+        sage: R.<u,v,w> = QQ[]
+        sage: C = Curve(u^3 + v^3 + w^3)
+        sage: Jacobian(C)
+        Elliptic Curve defined by y^2 = x^3 - 27/4 over Rational Field
+    """
+    eqn = None
+    try:
+        eqn = curve.defining_polynomial()
+    except AttributeError:
+        pass
+    if len(curve.defining_polynomials()) == 1:
+        eqn = curve.defining_polynomials()[0]
+    if eqn is not None:
+        if morphism:
+            return Jacobian_of_equation(eqn, curve=curve)
+        else:
+            return Jacobian_of_equation(eqn)
+    raise NotImplementedError('Jacobian for this curve is not implemented')
+
+
+def Jacobian_of_equation(polynomial, variables=None, curve=None):
+    r"""
+    Construct the Jacobian of a genus-one curve given by a polynomial.
+
+    INPUT:
+
+    - ``F`` -- a polynomial defining a plane curve of genus one. May
+      be homogeneous or inhomogeneous
+
+    - ``variables`` -- list of two or three variables or ``None``
+      (default). The inhomogeneous or homogeneous coordinates. By
+      default, all variables in the polynomial are used.
+
+    - ``curve`` -- the genus-one curve defined by ``polynomial`` or #
+      ``None`` (default). If specified, suitable morphism from the
+      jacobian elliptic curve to the curve is returned.
+
+    OUTPUT:
+
+    An elliptic curve in short Weierstrass form isomorphic to the
+    curve ``polynomial=0``. If the optional argument ``curve`` is
+    specified, a rational multicover from the Jacobian elliptic curve
+    to the genus-one curve is returned.
+
+    EXAMPLES::
+
+        sage: R.<a,b,c> = QQ[]
+        sage: f = a^3 + b^3 + 60*c^3
+        sage: Jacobian(f)
+        Elliptic Curve defined by y^2 = x^3 - 24300 over Rational Field
+        sage: Jacobian(f.subs(c=1))
+        Elliptic Curve defined by y^2 = x^3 - 24300 over Rational Field
+
+    If we specify the domain curve, the birational covering is returned::
+
+        sage: h = Jacobian(f, curve=Curve(f));  h
+        Scheme morphism:
+          From: Projective Plane Curve over Rational Field defined by a^3 + b^3 + 60*c^3
+          To:   Elliptic Curve defined by y^2 = x^3 - 24300 over Rational Field
+          Defn: Defined on coordinates by sending (a : b : c) to
+                (-216000*a^4*b^4*c - 12960000*a^4*b*c^4 - 12960000*a*b^4*c^4
+                 : 108000*a^6*b^3 - 108000*a^3*b^6 - 6480000*a^6*c^3 + 6480000*b^6*c^3
+                   + 388800000*a^3*c^6 - 388800000*b^3*c^6
+                 : 216000*a^3*b^3*c^3)
+
+        sage: h([1,-1,0])
+        (0 : 1 : 0)
+
+    Plugging in the polynomials defining `h` allows us to verify that
+    it is indeed a rational morphism to the elliptic curve::
+
+        sage: E = h.codomain()
+        sage: E.defining_polynomial()(h.defining_polynomials()).factor()
+        (2519424000000000) * c^3 * b^3 * a^3 * (a^3 + b^3 + 60*c^3)
+        * (a^9*b^6 + a^6*b^9 - 120*a^9*b^3*c^3 + 900*a^6*b^6*c^3 - 120*a^3*b^9*c^3
+           + 3600*a^9*c^6 + 54000*a^6*b^3*c^6 + 54000*a^3*b^6*c^6 + 3600*b^9*c^6
+           + 216000*a^6*c^9 - 432000*a^3*b^3*c^9 + 216000*b^6*c^9)
+
+    By specifying the variables, we can also construct an elliptic
+    curve over a polynomial ring::
+
+        sage: R.<u,v,t> = QQ[]
+        sage: Jacobian(u^3 + v^3 + t, variables=[u,v])
+        Elliptic Curve defined by y^2 = x^3 + (-27/4*t^2) over
+         Multivariate Polynomial Ring in u, v, t over Rational Field
+
+    TESTS::
+
+        sage: from sage.schemes.elliptic_curves.jacobian import Jacobian_of_equation
+        sage: Jacobian_of_equation(f, variables=[a,b,c])
+        Elliptic Curve defined by y^2 = x^3 - 24300 over Rational Field
+    """
+    from sage.schemes.toric.weierstrass import WeierstrassForm
+    f, g = WeierstrassForm(polynomial, variables=variables)
+    try:
+        K = polynomial.base_ring()
+        f = K(f)
+        g = K(g)
+    except (TypeError, ValueError):
+        pass
+    E = EllipticCurve([f, g])
+    if curve is None:
+        return E
+    X, Y, Z = WeierstrassForm(polynomial, variables=variables, transformation=True)
+    from sage.schemes.elliptic_curves.weierstrass_transform import WeierstrassTransformation
+    return WeierstrassTransformation(curve, E, [X*Z, Y, Z**3], 1)

sage/schemes/elliptic_curves/kodaira_symbol.py

@@ -0,0 +1,344 @@
+# sage_setup: distribution = sagemath-schemes
+r"""
+Kodaira symbols
+
+Kodaira symbols encode the type of reduction of an elliptic curve at a
+(finite) place.
+
+The standard notation for Kodaira Symbols is as a string which is one
+of `\rm{I}_m`, `\rm{II}`, `\rm{III}`, `\rm{IV}`, `\rm{I}^*_m`,
+`\rm{II}^*`, `\rm{III}^*`, `\rm{IV}^*`, where `m` denotes a
+nonnegative integer.  These have been encoded by single integers by
+different people.  For convenience we give here the conversion table
+between strings, the eclib coding and the PARI encoding.
+
++----------------------+----------------+--------------------+
+| Kodaira Symbol       |  Eclib coding  |  PARI Coding       |
++======================+================+====================+
+| `\rm{I}_0`           |      `0`       |   `1`              |
++----------------------+----------------+--------------------+
+| `\rm{I}^*_0`         |      `1`       |   `-1`             |
++----------------------+----------------+--------------------+
+| `\rm{I}_m`  `(m>0)`  |      `10m`     |   `m+4`            |
++----------------------+----------------+--------------------+
+| `\rm{I}^*_m` `(m>0)` |      `10m+1`   |   `-(m+4)`         |
++----------------------+----------------+--------------------+
+| `\rm{II}`            | `2`            |   `2`              |
++----------------------+----------------+--------------------+
+| `\rm{III}`           | `3`            |   `3`              |
++----------------------+----------------+--------------------+
+| `\rm{IV}`            | `4`            |   `4`              |
++----------------------+----------------+--------------------+
+| `\rm{II}^*`          | `7`            |   `-2`             |
++----------------------+----------------+--------------------+
+| `\rm{III}^*`         | `6`            |   `-3`             |
++----------------------+----------------+--------------------+
+| `\rm{IV}^*`          | `5`            |   `-4`             |
++----------------------+----------------+--------------------+
+
+
+AUTHORS:
+
+- David Roe       <roed@math.harvard.edu>
+
+- John Cremona
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2007 David Roe       <roed@math.harvard.edu>
+#                          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.sage_object import SageObject
+from sage.structure.richcmp import richcmp_method, richcmp
+from sage.rings.integer import Integer
+import weakref
+
+
+@richcmp_method
+class KodairaSymbol_class(SageObject):
+    r"""
+    Class to hold a Kodaira symbol of an elliptic curve over a
+    `p`-adic local field.
+
+    Users should use the ``KodairaSymbol()`` function to construct
+    Kodaira Symbols rather than use the class constructor directly.
+    """
+    def __init__(self, symbol):
+        r"""
+        Constructor for Kodaira Symbol class.
+
+        INPUT:
+
+        - ``symbol`` -- string or integer; the string should be a
+          standard string representation (e.g. III*) of a Kodaira
+          symbol, which will be parsed.  Alternatively, use the PARI
+          encoding of Kodaira symbols as integers.
+
+        EXAMPLES::
+
+            sage: from sage.schemes.elliptic_curves.kodaira_symbol import KodairaSymbol_class
+            sage: KodairaSymbol_class(14)
+            I10
+            sage: KodairaSymbol_class('III*')
+            III*
+            sage: latex(KodairaSymbol_class('In'))
+            I_n
+            sage: KodairaSymbol_class('In')
+            In
+
+        Check that :issue:`31147` is fixed::
+
+            sage: latex(KodairaSymbol_class(-14))
+            I_{10}^{*}
+        """
+        if not isinstance(symbol, str):
+            n = Integer(symbol)
+            self._n = None
+            if n == 0:
+                raise ValueError("Kodaira Symbol code number must be nonzero.")
+            if n == 1:
+                self._n = 0
+                self._roman = 1
+                self._str = 'I0'
+                self._latex = 'I_0'
+            elif n == 2:
+                self._roman = 2
+                self._str = 'II'
+                self._latex = 'II'
+            elif n == 3:
+                self._roman = 3
+                self._str = 'III'
+                self._latex = 'III'
+            elif n == 4:
+                self._roman = 4
+                self._str = 'IV'
+                self._latex = 'IV'
+            elif n > 4:
+                nu = n - 4
+                self._n = nu
+                self._roman = 1
+                self._str = 'I%s' % nu
+                self._latex = 'I_{%s}' % nu
+            elif n == -1:
+                self._roman = 1
+                self._n = 0
+                self._str = 'I0*'
+                self._latex = 'I_0^{*}'
+            elif n == -2:
+                self._roman = 2
+                self._str = 'II*'
+                self._latex = 'II^{*}'
+            elif n == -3:
+                self._roman = 3
+                self._str = 'III*'
+                self._latex = 'III^{*}'
+            elif n == -4:
+                self._roman = 4
+                self._str = 'IV*'
+                self._latex = 'IV^{*}'
+            elif n < -4:
+                nu = -n - 4
+                self._roman = 1
+                self._n = nu
+                self._str = 'I%s*' % nu
+                self._latex = 'I_{%s}^{*}' % nu
+            self._starred = (n < 0)
+            self._pari = n
+            return
+        elif not symbol:
+            raise TypeError("symbol must be a nonempty string")
+        if symbol[0] == "I":
+            symbol = symbol[1:]
+        starred = False
+        if symbol[-1] == "*":
+            starred = True
+            symbol = symbol[:-1]
+        self._starred = starred
+        if symbol in ["I", "II", "V"]:    # NB we have already stripped off the leading 'I'
+            self._roman = ["I", "II", "V"].index(symbol) + 2   # =2, 3 or 4
+            self._n = None
+            if starred:
+                sign = -1
+                self._str = "I" + symbol + "*"
+                self._latex = "I" + symbol + "^*"
+            else:
+                sign = 1
+                self._str = "I" + symbol
+                self._latex = "" + self._str + ""
+            if symbol == "I":
+                self._pari = 2 * sign
+            elif symbol == "II":
+                self._pari = 3 * sign
+            elif symbol == "V":
+                self._pari = 4 * sign
+        elif symbol == "n":
+            self._roman = 1
+            self._pari = None
+            self._n = "generic"
+            if starred:
+                self._str = "In*"
+                self._latex = "I_n^*"
+            else:
+                self._str = "In"
+                self._latex = "I_n"
+        elif symbol.isdigit():
+            self._roman = 1
+            self._n = Integer(symbol)
+            if starred:
+                if self._n == 0:
+                    self._pari = -1
+                else:
+                    self._pari = -self._n - 4
+                self._str = "I" + symbol + "*"
+                self._latex = "I_{%s}^*" % (symbol)
+            else:
+                if self._n == 0:
+                    self._pari = 1
+                else:
+                    self._pari = self._n + 4
+                self._str = "I" + symbol
+                self._latex = "I_{%s}" % (symbol)
+        else:
+            raise ValueError("input is not a Kodaira symbol")
+
+    def __repr__(self):
+        r"""
+        Return the string representation of this Kodaira Symbol.
+
+        EXAMPLES::
+
+            sage: from sage.schemes.elliptic_curves.kodaira_symbol import KodairaSymbol_class
+            sage: KS = KodairaSymbol_class(15)
+            sage: str(KS) # indirect doctest
+            'I11'
+        """
+        return self._str
+
+    def _latex_(self):
+        r"""
+        Return the string representation of this Kodaira Symbol.
+
+        EXAMPLES::
+
+            sage: from sage.schemes.elliptic_curves.kodaira_symbol import KodairaSymbol_class
+            sage: KS = KodairaSymbol_class(15)
+            sage: latex(KS)
+            I_{11}
+        """
+        return self._latex
+
+    def __richcmp__(self, other, op):
+        r"""
+        Standard comparison function for Kodaira Symbols.
+
+        EXAMPLES::
+
+            sage: from sage.schemes.elliptic_curves.kodaira_symbol import KodairaSymbol_class
+            sage: KS1 = KodairaSymbol_class(15); KS1
+            I11
+            sage: KS2 = KodairaSymbol_class(-34); KS2
+            I30*
+            sage: KS1 < KS2
+            True
+            sage: KS2 < KS1
+            False
+
+        ::
+
+            sage: Klist = [KodairaSymbol_class(i) for i in [-10..10] if i!=0]
+            sage: Klist.sort()
+            sage: Klist
+            [I0,
+            I0*,
+            I1,
+            I1*,
+            I2,
+            I2*,
+            I3,
+            I3*,
+            I4,
+            I4*,
+            I5,
+            I5*,
+            I6,
+            I6*,
+            II,
+            II*,
+            III,
+            III*,
+            IV,
+            IV*]
+        """
+        if isinstance(other, KodairaSymbol_class):
+            if (self._n == "generic" and other._n is not None) or (other._n == "generic" and self._n is not None):
+                return richcmp(self._starred, other._starred, op)
+            return richcmp(self._str, other._str, op)
+        else:
+            return NotImplemented
+
+    def _pari_code(self):
+        """
+        Return the PARI encoding of this Kodaira Symbol.
+
+        EXAMPLES::
+
+            sage: KodairaSymbol('I0')._pari_code()
+            1
+            sage: KodairaSymbol('I10')._pari_code()
+            14
+            sage: KodairaSymbol('I10*')._pari_code()
+            -14
+            sage: [KodairaSymbol(s)._pari_code() for s in ['II','III','IV']]
+            [2, 3, 4]
+            sage: [KodairaSymbol(s)._pari_code() for s in ['II*','III*','IV*']]
+            [-2, -3, -4]
+        """
+        return self._pari
+
+
+_ks_cache = {}
+
+
+def KodairaSymbol(symbol):
+    r"""
+    Return the specified Kodaira symbol.
+
+    INPUT:
+
+    - ``symbol`` -- string or integer; either a string of the form
+      "I0", "I1", ..., "In", "II", "III", "IV", "I0*", "I1*", ..., "In*", "II*", "III*", or "IV*",
+      or an integer encoding a Kodaira symbol using PARI's conventions
+
+    OUTPUT:
+
+    (KodairaSymbol)  The corresponding Kodaira symbol.
+
+    EXAMPLES::
+
+        sage: KS = KodairaSymbol
+        sage: [KS(n) for n in range(1,10)]
+        [I0, II, III, IV, I1, I2, I3, I4, I5]
+        sage: [KS(-n) for n in range(1,10)]
+        [I0*, II*, III*, IV*, I1*, I2*, I3*, I4*, I5*]
+        sage: all(KS(str(KS(n))) == KS(n) for n in range(-10,10) if n != 0)
+        True
+    """
+    if symbol in _ks_cache:
+        ks = _ks_cache[symbol]()
+        if ks is not None:
+            return ks
+    ks = KodairaSymbol_class(symbol)
+    _ks_cache[symbol] = weakref.ref(ks)
+    return ks