passagemath-schemes 10.6.47__cp312-cp312-macosx_13_0_arm64.whl

sage/schemes/jacobians/abstract_jacobian.py

@@ -0,0 +1,277 @@
+# sage_setup: distribution = sagemath-schemes
+"""
+Jacobians of curves
+
+This module defines the base class of Jacobians as an abstract scheme.
+
+AUTHORS:
+
+- William Stein (2005)
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2005 William Stein <wstein@gmail.com>
+#
+# 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.categories.schemes import Jacobians
+from sage.categories.fields import Fields
+from sage.schemes.generic.scheme import Scheme
+from sage.structure.richcmp import richcmp_method, richcmp
+
+_Fields = Fields()
+
+
+def is_Jacobian(J):
+    """
+    Return ``True`` if `J` is of type ``Jacobian_generic``.
+
+    EXAMPLES::
+
+        sage: from sage.schemes.jacobians.abstract_jacobian import Jacobian, is_Jacobian
+        sage: P2.<x, y, z> = ProjectiveSpace(QQ, 2)
+        sage: C = Curve(x^3 + y^3 + z^3)
+        sage: J = Jacobian(C)
+        sage: is_Jacobian(J)
+        ...
+        DeprecationWarning: Use Jacobian_generic directly
+        See https://github.com/sagemath/sage/issues/35467 for details.
+        True
+
+    ::
+
+        sage: E = EllipticCurve('37a1')                                                 # needs database_cremona_mini_ellcurve
+        sage: is_Jacobian(E)                                                            # needs database_cremona_mini_ellcurve
+        False
+    """
+    from sage.misc.superseded import deprecation
+    deprecation(35467, "Use Jacobian_generic directly")
+    return isinstance(J, Jacobian_generic)
+
+
+def Jacobian(C):
+    """
+    EXAMPLES::
+
+        sage: from sage.schemes.jacobians.abstract_jacobian import Jacobian
+        sage: P2.<x, y, z> = ProjectiveSpace(QQ, 2)
+        sage: C = Curve(x^3 + y^3 + z^3)
+        sage: Jacobian(C)
+        Jacobian of Projective Plane Curve over Rational Field defined by x^3 + y^3 + z^3
+    """
+    try:
+        return C.jacobian()
+    except (AttributeError, TypeError):
+        return Jacobian_generic(C)
+
+
+@richcmp_method
+class Jacobian_generic(Scheme):
+    """
+    Base class for Jacobians of projective curves.
+
+    The input must be a projective curve over a field.
+
+    EXAMPLES::
+
+        sage: from sage.schemes.jacobians.abstract_jacobian import Jacobian
+        sage: P2.<x, y, z> = ProjectiveSpace(QQ, 2)
+        sage: C = Curve(x^3 + y^3 + z^3)
+        sage: J = Jacobian(C); J
+        Jacobian of Projective Plane Curve over Rational Field defined by x^3 + y^3 + z^3
+    """
+    def __init__(self, C, category=None):
+        """
+        Initialize.
+
+        TESTS::
+
+            sage: from sage.schemes.jacobians.abstract_jacobian import Jacobian_generic
+            sage: P2.<x, y, z> = ProjectiveSpace(QQ, 2)
+            sage: C = Curve(x^3 + y^3 + z^3)
+            sage: J = Jacobian_generic(C); J
+            Jacobian of Projective Plane Curve over Rational Field defined by x^3 + y^3 + z^3
+            sage: type(J)
+            <class 'sage.schemes.jacobians.abstract_jacobian.Jacobian_generic_with_category'>
+
+        Note: this is an abstract parent, so we skip element tests::
+
+            sage: TestSuite(J).run(skip =["_test_an_element", \
+            ....:                         "_test_zero", \
+            ....:                         "_test_elements", \
+            ....:                         "_test_elements_eq_reflexive", \
+            ....:                         "_test_elements_eq_symmetric", \
+            ....:                         "_test_elements_eq_transitive", \
+            ....:                         "_test_additive_associativity", \
+            ....:                         "_test_elements_neq", \
+            ....:                         "_test_some_elements"])
+
+        ::
+
+            sage: Jacobian_generic(ZZ)
+            Traceback (most recent call last):
+            ...
+            TypeError: Argument (=Integer Ring) must be a scheme.
+            sage: Jacobian_generic(P2)
+            Traceback (most recent call last):
+            ...
+            ValueError: C (=Projective Space of dimension 2 over Rational Field)
+            must have dimension 1.
+
+        ::
+
+            sage: P2.<x, y, z> = ProjectiveSpace(Zmod(6), 2)
+            sage: C = Curve(x + y + z, P2)
+            sage: Jacobian_generic(C)
+            Traceback (most recent call last):
+            ...
+            TypeError: C (=Projective Plane Curve over Ring of integers modulo 6
+            defined by x + y + z) must be defined over a field.
+        """
+        if not isinstance(C, Scheme):
+            raise TypeError("Argument (=%s) must be a scheme." % C)
+        if C.base_ring() not in _Fields:
+            raise TypeError("C (=%s) must be defined over a field." % C)
+        if C.dimension() != 1:
+            raise ValueError("C (=%s) must have dimension 1." % C)
+        self.__curve = C
+        Scheme.__init__(self, C.base_scheme(), category=Jacobians(C.base_ring()).or_subcategory(category))
+
+    def __richcmp__(self, J, op):
+        """
+        Compare the Jacobian ``self`` to `J`.  If `J` is a Jacobian, then
+        ``self`` and `J` are equal if and only if their curves are equal.
+
+        EXAMPLES::
+
+            sage: from sage.schemes.jacobians.abstract_jacobian import Jacobian
+            sage: P2.<x, y, z> = ProjectiveSpace(QQ, 2)
+            sage: J1 = Jacobian(Curve(x^3 + y^3 + z^3))
+            sage: J1 == J1
+            True
+            sage: J1 == P2
+            False
+            sage: J1 != P2
+            True
+            sage: J2 = Jacobian(Curve(x + y + z))
+            sage: J1 == J2
+            False
+            sage: J1 != J2
+            True
+        """
+        if not isinstance(J, Jacobian_generic):
+            return NotImplemented
+        return richcmp(self.curve(), J.curve(), op)
+
+    def _repr_(self):
+        """
+        Return a string representation of this Jacobian.
+
+        EXAMPLES::
+
+            sage: from sage.schemes.jacobians.abstract_jacobian import Jacobian
+            sage: P2.<x, y, z> = ProjectiveSpace(QQ, 2)
+            sage: J = Jacobian(Curve(x^3 + y^3 + z^3)); J
+            Jacobian of Projective Plane Curve over Rational Field defined by x^3 + y^3 + z^3
+            sage: J._repr_()
+            'Jacobian of Projective Plane Curve over Rational Field defined by x^3 + y^3 + z^3'
+        """
+        return "Jacobian of %s" % self.__curve
+
+    def _point(self):
+        """
+        Return the Hom-set from some affine scheme to ``self``.
+
+        OUTPUT:
+
+        This method always raises a :exc:`NotImplementedError`; it is
+        only abstract.
+
+        EXAMPLES::
+
+            sage: from sage.schemes.jacobians.abstract_jacobian import Jacobian
+            sage: P2.<x, y, z> = ProjectiveSpace(QQ, 2)
+            sage: J = Jacobian(Curve(x^3 + y^3 + z^3))
+            sage: J._point()
+            Traceback (most recent call last):
+            ...
+            NotImplementedError
+        """
+        raise NotImplementedError
+
+    def curve(self):
+        """
+        Return the curve of which ``self`` is the Jacobian.
+
+        EXAMPLES::
+
+            sage: from sage.schemes.jacobians.abstract_jacobian import Jacobian
+            sage: P2.<x, y, z> = ProjectiveSpace(QQ, 2)
+            sage: J = Jacobian(Curve(x^3 + y^3 + z^3))
+            sage: J.curve()
+            Projective Plane Curve over Rational Field defined by x^3 + y^3 + z^3
+        """
+        return self.__curve
+
+    base_curve = curve
+
+    def change_ring(self, R):
+        r"""
+        Return the Jacobian over the ring `R`.
+
+        INPUT:
+
+        - ``R`` -- a field; the new base ring
+
+        OUTPUT: the Jacobian over the ring `R`
+
+        EXAMPLES::
+
+            sage: R.<x> = QQ['x']
+            sage: H = HyperellipticCurve(x^3 - 10*x + 9)
+            sage: Jac = H.jacobian();   Jac
+            Jacobian of Hyperelliptic Curve over Rational Field
+             defined by y^2 = x^3 - 10*x + 9
+            sage: Jac.change_ring(RDF)
+            Jacobian of Hyperelliptic Curve over Real Double Field
+             defined by y^2 = x^3 - 10.0*x + 9.0
+        """
+        return self.curve().change_ring(R).jacobian()
+
+    def base_extend(self, R):
+        r"""
+        Return the natural extension of ``self`` over `R`.
+
+        INPUT:
+
+        - ``R`` -- a field; the new base field
+
+        OUTPUT: the Jacobian over the ring `R`
+
+        EXAMPLES::
+
+            sage: R.<x> = QQ['x']
+            sage: H = HyperellipticCurve(x^3 - 10*x + 9)
+            sage: Jac = H.jacobian();   Jac
+            Jacobian of Hyperelliptic Curve over Rational Field
+             defined by y^2 = x^3 - 10*x + 9
+
+            sage: # needs sage.rings.number_field
+            sage: F.<a> = QQ.extension(x^2 + 1)
+            sage: Jac.base_extend(F)
+            Jacobian of Hyperelliptic Curve over Number Field in a with defining
+             polynomial x^2 + 1 defined by y^2 = x^3 - 10*x + 9
+        """
+        if R not in _Fields:
+            raise ValueError('Not a field: ' + str(R))
+        if self.base_ring() is R:
+            return self
+        if not R.has_coerce_map_from(self.base_ring()):
+            raise ValueError('no natural map from the base ring (=%s) to R (=%s)!'
+                             % (self.base_ring(), R))
+        return self.change_ring(R)

sage/schemes/jacobians/all.py

@@ -0,0 +1,2 @@
+# sage_setup: distribution = sagemath-schemes
+# from abstract_jacobian import is_Jacobian, Jacobian

sage/schemes/overview.py

@@ -0,0 +1,161 @@
+# sage_setup: distribution = sagemath-schemes
+r"""
+Scheme implementation overview
+
+Various parts of schemes were implemented by different authors. This document
+aims to give an overview of the different classes of schemes working together
+coherently.
+
+Generic
+-------
+
+- **Scheme:**
+  A scheme whose datatype might not be defined in terms of algebraic equations:
+  e.g. the Jacobian of a curve may be represented by means of a Scheme.
+
+- **AlgebraicScheme:**
+  A scheme defined by means of polynomial equations, which may be reducible or
+  defined over a ring other than a field.  In particular, the defining ideal
+  need not be a radical ideal, and an algebraic scheme may be defined over
+  `\mathrm{Spec}(R)`.
+
+- **AmbientSpaces:**
+  Most effective models of algebraic scheme will be defined not by generic
+  gluings, but by embeddings in some fixed ambient space.
+
+Ambients
+--------
+
+- **AffineSpace:**
+  Affine spaces and their affine subschemes form the most important universal
+  objects from which algebraic schemes are built.  The affine spaces form
+  universal objects in the sense that a morphism is uniquely determined by the
+  images of its coordinate functions and any such images determine a
+  well-defined morphism.
+
+  By default affine spaces will embed in some ordinary projective space, unless
+  it is created as an affine patch of another object.
+
+- **ProjectiveSpace:**
+  Projective spaces are the most natural ambient spaces for most projective
+  objects.  They are locally universal objects.
+
+- **ProjectiveSpace_ordinary (not implemented):**
+  The ordinary projective spaces have the standard weights `[1,..,1]` on their
+  coefficients.
+
+- **ProjectiveSpace_weighted (not implemented):**
+  A special subtype for non-standard weights.
+
+- **ToricVariety:**
+  Toric varieties are (partial) compactifications of algebraic tori `(\CC^*)^n`
+  compatible with torus action. Affine and projective spaces are examples of
+  toric varieties, but it is not envisioned that these special cases should
+  inherit from :class:`~sage.schemes.toric.variety.ToricVariety`.
+
+Subschemes
+----------
+
+- **AlgebraicScheme_subscheme_affine:**
+  An algebraic scheme defined by means of an embedding in a
+  fixed ambient affine space.
+
+- **AlgebraicScheme_subscheme_projective:**
+  An algebraic scheme defined by means of an embedding in a fixed ambient
+  projective space.
+
+- **QuasiAffineScheme (not yet implemented):**
+  An open subset `U = X \setminus Z` of a closed subset `X` of affine space;
+  note that this is mathematically a quasi-projective scheme, but its
+  ambient space is an affine space and its points are represented by
+  affine rather than projective points.
+
+  .. NOTE::
+
+    AlgebraicScheme_quasi is implemented, as a base class for this.
+
+- **QuasiProjectiveScheme (not yet implemented):**
+  An open subset of a closed subset of projective space; this datatype
+  stores the defining polynomial, polynomials, or ideal defining the
+  projective closure `X` plus the closed subscheme `Z` of `X` whose complement
+  `U = X \setminus Z` is the quasi-projective scheme.
+
+  .. NOTE::
+
+    The quasi-affine and quasi-projective datatype lets one create schemes
+    like the multiplicative group scheme
+    `\mathbb{G}_m = \mathbb{A}^1\setminus \{(0)\}`
+    and the non-affine scheme `\mathbb{A}^2\setminus \{(0,0)\}`.  The latter
+    is not affine and is not of the form `\mathrm{Spec}(R)`.
+
+Point sets
+----------
+
+- **PointSets and points over a ring (to do):**
+  For algebraic schemes `X/S` and `T/S` over `S`, one can form the point set
+  `X(T)` of morphisms from `T\to X` over `S`.
+
+  A projective space object in the category of schemes is a locally free object
+  -- the images of the generator functions *locally* determine a point.  Over a
+  field, one can choose one of the standard affine patches by the condition
+  that a coordinate function `X_i \ne 0`.
+
+  ::
+
+        sage: PP.<X,Y,Z> = ProjectiveSpace(2, QQ)
+        sage: PP
+        Projective Space of dimension 2 over Rational Field
+        sage: PP(QQ)
+        Set of rational points of Projective Space
+        of dimension 2 over Rational Field
+        sage: PP(QQ)([-2, 3, 5])
+        (-2/5 : 3/5 : 1)
+
+  Over a ring, this is not true anymore. For example, even over an integral
+  domain which is not a PID, there may be no *single* affine patch which covers
+  a point.
+
+  ::
+
+        sage: R.<x> = ZZ[]
+        sage: S.<t> = R.quo(x^2 + 5)
+        sage: P.<X,Y,Z> = ProjectiveSpace(2, S)
+        sage: P(S)
+        Set of rational points of Projective Space of dimension 2 over
+        Univariate Quotient Polynomial Ring in t over Integer Ring with
+        modulus x^2 + 5
+
+  In order to represent the projective point `(2:1+t) = (1-t:3)` we note that
+  the first representative is not well-defined at the prime `p = (2,1+t)` and
+  the second element is not well-defined at the prime `q = (1-t,3)`, but that
+  `p + q = (1)`, so globally the pair of coordinate representatives is
+  well-defined.
+
+  ::
+
+        sage: P([2, 1 + t])
+        (2 : t + 1 : 1)
+
+  In fact, we need a test ``R.ideal([2, 1 + t]) == R.ideal([1])`` in order to make
+  this meaningful.
+
+Berkovich Analytic Spaces
+-------------------------
+
+- **Berkovich Analytic Space (not yet implemented)**
+  The construction of analytic spaces from schemes due to Berkovich. Any Berkovich
+  space should inherit from :class:`Berkovich`
+
+- **Berkovich Analytic Space over Cp**
+  A special case of the general Berkovich analytic space construction.
+  Affine Berkovich space over `\CC_p` is the set of seminorms on the polynomial
+  ring `\CC_p[x]`, while projective Berkovich space over `\CC_p` is the one-point compactification
+  of affine Berkovich space `\CC_p`. Points are represented using the classification (due
+  to Berkovich) of a corresponding decreasing sequence of disks in `\CC_p`.
+
+AUTHORS:
+
+- David Kohel, William Stein (2006-01-03): initial version
+
+- Andrey Novoseltsev (2010-09-24): updated due to addition of toric varieties
+"""

sage/schemes/plane_conics/all.py

@@ -0,0 +1,22 @@
+# sage_setup: distribution = sagemath-schemes
+"""
+Plane conics
+"""
+# ****************************************************************************
+#
+#   Sage: Open Source Mathematical Software
+#
+#       Copyright (C) 2005 William Stein <was@math.harvard.edu>
+#
+#  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.schemes.plane_conics.constructor import Conic