passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/schemes/generic/divisor.py

@@ -0,0 +1,465 @@
+# sage_setup: distribution = sagemath-categories
+# sage.doctest: needs sage.schemes
+"""
+Divisors on schemes
+
+AUTHORS:
+
+- William Stein
+
+- David Kohel
+
+- David Joyner
+
+- Volker Braun (2010-07-16): Documentation, doctests, coercion fixes, bugfixes.
+
+EXAMPLES::
+
+    sage: x,y,z = ProjectiveSpace(2, GF(5), names='x,y,z').gens()
+    sage: C = Curve(y^2*z^7 - x^9 - x*z^8)
+    sage: pts = C.rational_points(); pts
+    [(0 : 0 : 1), (0 : 1 : 0), (2 : 2 : 1), (2 : 3 : 1), (3 : 1 : 1), (3 : 4 : 1)]
+    sage: D1 = C.divisor(pts[0])*3
+    sage: D2 = C.divisor(pts[1])
+    sage: D3 = 10*C.divisor(pts[5])
+    sage: D1.parent() is D2.parent()
+    True
+    sage: D = D1 - D2 + D3; D
+    3*(x, y) - (x, z) + 10*(x + 2*z, y + z)
+    sage: D[1][0]
+    -1
+    sage: D[1][1]
+    Ideal (x, z) of Multivariate Polynomial Ring in x, y, z over Finite Field of size 5
+    sage: C.divisor([(3, pts[0]), (-1, pts[1]), (10, pts[5])])
+    3*(x, y) - (x, z) + 10*(x + 2*z, y + z)
+"""
+#*******************************************************************************
+#  Copyright (C) 2010 Volker Braun <vbraun.name@gmail.com>
+#  Copyright (C) 2005 David Kohel <kohel@maths.usyd.edu.au>
+#  Copyright (C) 2005 William Stein
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#*******************************************************************************
+
+from sage.misc.latex import latex
+from sage.misc.lazy_import import lazy_import
+from sage.misc.repr import repr_lincomb
+from sage.misc.search import search
+from sage.rings.integer_ring import ZZ
+from sage.schemes.affine.affine_space import AffineSpace_generic
+from sage.schemes.projective.projective_space import ProjectiveSpace_ring
+from sage.structure.formal_sum import FormalSum
+
+lazy_import('sage.schemes.generic.morphism', 'SchemeMorphism')
+
+
+def CurvePointToIdeal(C, P):
+    r"""
+    Return the vanishing ideal of a point on a curve.
+
+    EXAMPLES::
+
+        sage: x,y = AffineSpace(2, QQ, names='xy').gens()
+        sage: C = Curve(y^2 - x^9 - x)
+        sage: from sage.schemes.generic.divisor import CurvePointToIdeal
+        sage: CurvePointToIdeal(C, (0,0))
+        Ideal (x, y) of Multivariate Polynomial Ring in x, y over Rational Field
+    """
+    A = C.ambient_space()
+    R = A.coordinate_ring()
+    n = A.ngens()
+    x = A.gens()
+    polys = []
+    m = n - 1
+    while m > 0 and P[m] == 0:
+        m += -1
+    if isinstance(A, ProjectiveSpace_ring):
+        a_m = P[m]
+        x_m = x[m]
+        for i in range(m):
+            ai = P[i]
+            if ai == 0:
+                polys.append(x[i])
+            else:
+                polys.append(a_m*x[i]-ai*x_m)
+    elif isinstance(A, AffineSpace_generic):
+        for i in range(m+1):
+            ai = P[i]
+            if ai == 0:
+                polys.append(x[i])
+            else:
+                polys.append(x[i]-ai)
+    for i in range(m+1,n):
+        polys.append(x[i])
+    return R.ideal(polys)
+
+
+def is_Divisor(x):
+    r"""
+    Test whether ``x`` is an instance of :class:`Divisor_generic`.
+
+    INPUT:
+
+    - ``x`` -- anything
+
+    OUTPUT: boolean
+
+    EXAMPLES::
+
+        sage: from sage.schemes.generic.divisor import is_Divisor
+        sage: x,y = AffineSpace(2, GF(5), names='xy').gens()
+        sage: C = Curve(y^2 - x^9 - x)
+        sage: is_Divisor(C.divisor([]))
+        doctest:warning...
+        DeprecationWarning: The function is_Divisor is deprecated;
+        use 'isinstance(..., Divisor_generic)' instead.
+        See https://github.com/sagemath/sage/issues/38277 for details.
+        True
+        sage: is_Divisor("Ceci n'est pas un diviseur")
+        False
+    """
+    from sage.misc.superseded import deprecation
+    deprecation(38277,
+                "The function is_Divisor is deprecated; "
+                "use 'isinstance(..., Divisor_generic)' instead.")
+    return isinstance(x, Divisor_generic)
+
+
+class Divisor_generic(FormalSum):
+    r"""
+    A Divisor.
+
+    TESTS::
+
+        sage: E = EllipticCurve([1, 2])
+        sage: P = E(-1, 0)
+        sage: Q = E(1, 2)
+        sage: Pd = E.divisor(P)
+        sage: Qd = E.divisor(Q)
+        sage: Pd + Qd == Qd + Pd
+        True
+        sage: Pd != Qd
+        True
+        sage: C = EllipticCurve([2, 1])
+        sage: R = C(1, 2)
+        sage: Rd = C.divisor(R)
+        sage: Qd == Rd
+        False
+        sage: Rd == Qd
+        False
+        sage: Qd == (2 * (Qd * 1/2))
+        True
+        sage: Qd == 1/2 * Qd
+        False
+    """
+
+    def __init__(self, v, parent, check=True, reduce=True):
+        r"""
+        Construct a :class:`Divisor_generic`.
+
+        INPUT:
+
+        INPUT:
+
+        - ``v`` -- object; usually a list of pairs ``(coefficient,divisor)``
+
+        - ``parent`` -- FormalSums(R) module (default: FormalSums(ZZ))
+
+        - ``check`` -- boolean (default: ``True``); whether to coerce
+          coefficients into base ring. Setting it to ``False`` can
+          speed up construction.
+
+        - ``reduce`` -- reduce (default: ``True``); whether to combine
+          common terms. Setting it to ``False`` can speed up
+          construction.
+
+        .. WARNING::
+
+            The coefficients of the divisor must be in the base ring
+            and the terms must be reduced. If you set ``check=False``
+            and/or ``reduce=False`` it is your responsibility to pass
+            a valid object ``v``.
+
+        EXAMPLES::
+
+            sage: from sage.schemes.generic.divisor import Divisor_generic
+            sage: from sage.schemes.generic.divisor_group import DivisorGroup
+            sage: Divisor_generic( [(4,5)], DivisorGroup(Spec(ZZ)), False, False)
+            4*V(5)
+        """
+        FormalSum.__init__(self, v, parent, check, reduce)
+
+    def _latex_(self):
+        r"""
+        Return a LaTeX representation of ``self``.
+
+        OUTPUT: string
+
+        TESTS::
+
+            sage: R.<x, y> = ZZ[]
+            sage: S = Spec(R)
+            sage: from sage.schemes.generic.divisor import Divisor_generic
+            sage: from sage.schemes.generic.divisor_group import DivisorGroup
+            sage: Div = DivisorGroup(S)
+            sage: D = Divisor_generic([(4, x), (-5, y), (1, x+2*y)], Div)
+            sage: D._latex_()
+            '\\mathrm{V}\\left(x + 2 y\\right)
+            + 4 \\mathrm{V}\\left(x\\right)
+            - 5 \\mathrm{V}\\left(y\\right)'
+        """
+        # The code is copied from _repr_ with latex adjustments
+        terms = list(self)
+        # We sort the terms by variety. The order is "reversed" to keep it
+        # straight - as the test above demonstrates, it results in the first
+        # generator being in front of the second one
+        terms.sort(key=lambda x: x[1], reverse=True)
+        return repr_lincomb([(r"\mathrm{V}\left(%s\right)" % latex(v), c) for c,v in terms],
+                            is_latex=True)
+
+    def _repr_(self):
+        r"""
+        Return a string representation of ``self``.
+
+        OUTPUT: string
+
+        TESTS::
+
+            sage: R.<x, y> = ZZ[]
+            sage: S = Spec(R)
+            sage: from sage.schemes.generic.divisor import Divisor_generic
+            sage: from sage.schemes.generic.divisor_group import DivisorGroup
+            sage: Div = DivisorGroup(S)
+            sage: D = Divisor_generic([(4, x), (-5, y), (1, x+2*y)], Div)
+            sage: D._repr_()
+            'V(x + 2*y) + 4*V(x) - 5*V(y)'
+        """
+        # The default representation coming from formal sums does not look
+        # very nice for divisors
+        terms = list(self)
+        # We sort the terms by variety. The order is "reversed" to keep it
+        # straight - as the test above demonstrates, it results in the first
+        # generator being in front of the second one
+        terms.sort(key=lambda x: x[1], reverse=True)
+        return repr_lincomb([("V(%s)" % v, c) for c,v in terms])
+
+    def scheme(self):
+        """
+        Return the scheme that this divisor is on.
+
+        EXAMPLES::
+
+            sage: A.<x, y> = AffineSpace(2, GF(5))
+            sage: C = Curve(y^2 - x^9 - x)
+            sage: pts = C.rational_points(); pts
+            [(0, 0), (2, 2), (2, 3), (3, 1), (3, 4)]
+            sage: D = C.divisor(pts[0])*3 - C.divisor(pts[1]); D
+            3*(x, y) - (x - 2, y - 2)
+            sage: D.scheme()
+            Affine Plane Curve over Finite Field of size 5 defined by -x^9 + y^2 - x
+        """
+        return self.parent().scheme()
+
+
+class Divisor_curve(Divisor_generic):
+    r"""
+    For any curve `C`, use ``C.divisor(v)`` to
+    construct a divisor on `C`. Here `v` can be either
+
+    - a rational point on `C`
+
+    - a list of rational points
+
+    - a list of 2-tuples `(c,P)`, where `c` is an
+      integer and `P` is a rational point
+
+    TODO: Divisors shouldn't be restricted to rational points. The
+    problem is that the divisor group is the formal sum of the group of
+    points on the curve, and there's no implemented notion of point on
+    `E/K` that has coordinates in `L`. This is what
+    should be implemented, by adding an appropriate class to
+    ``schemes/generic/morphism.py``.
+
+    EXAMPLES::
+
+        sage: E = EllipticCurve([0, 0, 1, -1, 0])
+        sage: P = E(0,0)
+        sage: 10*P
+        (161/16 : -2065/64 : 1)
+        sage: D = E.divisor(P)
+        sage: D
+        (x, y)
+        sage: 10*D
+        10*(x, y)
+        sage: E.divisor([P, P])
+        2*(x, y)
+        sage: E.divisor([(3,P), (-4,5*P)])
+        3*(x, y) - 4*(x - 1/4*z, y + 5/8*z)
+    """
+    def __init__(self, v, parent=None, check=True, reduce=True):
+        """
+        Construct a divisor on a curve.
+
+        INPUT:
+
+        - ``v`` -- list of pairs ``(c, P)``, where ``c`` is an
+          integer and ``P`` is a point on a curve. The P's must all
+          lie on the same curve.
+
+        To create the divisor 0 use ``[(0, P)]``, so as to give the curve.
+
+        EXAMPLES::
+
+            sage: E = EllipticCurve([0, 0, 1, -1, 0])
+            sage: P = E(0,0)
+            sage: from sage.schemes.generic.divisor import Divisor_curve
+            sage: from sage.schemes.generic.divisor_group import DivisorGroup
+            sage: Divisor_curve([(1, P)], parent=DivisorGroup(E))
+            (x, y)
+        """
+        from sage.schemes.generic.divisor_group import DivisorGroup_curve
+        if not isinstance(v, (list, tuple)):
+            v = [(1,v)]
+
+        if parent is None:
+            if v:
+                t = v[0]
+                if isinstance(t, tuple) and len(t) == 2:
+                    try:
+                        C = t[1].scheme()
+                    except (TypeError, AttributeError):
+                        raise TypeError("Argument v (= %s) must consist of multiplicities and points on a scheme.")
+                else:
+                    try:
+                        C = t.scheme()
+                    except TypeError:
+                        raise TypeError("Argument v (= %s) must consist of multiplicities and points on a scheme.")
+                parent = DivisorGroup_curve(C)
+            else:
+                raise TypeError("Argument v (= %s) must consist of multiplicities and points on a scheme.")
+        else:
+            if not isinstance(parent, DivisorGroup_curve):
+                raise TypeError("parent (of type %s) must be a DivisorGroup_curve" % type(parent))
+            C = parent.scheme()
+
+        if len(v) < 1:
+            check = False
+        know_points = False
+        if check:
+            w = []
+            points = []
+            know_points = True
+            for t in v:
+                if isinstance(t, tuple) and len(t) == 2:
+                    n = ZZ(t[0])
+                    I = t[1]
+                    points.append((n,I))
+                else:
+                    n = ZZ(1)
+                    I = t
+                if isinstance(I, SchemeMorphism):
+                    I = CurvePointToIdeal(C,I)
+                else:
+                    know_points = False
+                w.append((n,I))
+            v = w
+        Divisor_generic.__init__(
+            self, v, check=False, reduce=True, parent=parent)
+
+        if know_points:
+            self._points = points
+
+    def _repr_(self):
+        r"""
+        Return a string representation.
+
+        OUTPUT: string
+
+        EXAMPLES::
+
+            sage: E = EllipticCurve([0, 0, 1, -1, 0])
+            sage: E.divisor( E(0,0) )._repr_()
+            '(x, y)'
+        """
+        return repr_lincomb([(tuple(I.gens()), c) for c, I in self])
+
+    def support(self) -> list:
+        """
+        Return the support of this divisor, which is the set of points that
+        occur in this divisor with nonzero coefficients.
+
+        EXAMPLES::
+
+            sage: A = AffineSpace(2, GF(5), names='xy')
+            sage: x, y = A.gens()
+            sage: C = Curve(y^2 - x^9 - x)
+            sage: pts = C.rational_points(); pts
+            [(0, 0), (2, 2), (2, 3), (3, 1), (3, 4)]
+            sage: D = C.divisor_group()([(3, pts[0]), (-1, pts[1])]); D
+            3*(x, y) - (x - 2, y - 2)
+            sage: D.support()
+            [(0, 0), (2, 2)]
+
+        TESTS:
+
+        This checks that :issue:`10732` is fixed::
+
+            sage: R.<x, y, z> = GF(5)[]
+            sage: C = Curve(x^7 + y^7 + z^7)
+            sage: pts = C.rational_points()
+            sage: D = C.divisor([(2, pts[0])])
+            sage: D.support()
+            [(0 : 4 : 1)]
+            sage: (D + D).support()
+            [(0 : 4 : 1)]
+            sage: E = C.divisor([(-3, pts[1]), (1, pts[2])])
+            sage: (D - 2*E).support()
+            [(0 : 4 : 1), (1 : 2 : 1), (2 : 1 : 1)]
+            sage: (D - D).support()
+            []
+        """
+        try:
+            return self._support
+        except AttributeError:
+            try:
+                pts = self._points
+            except AttributeError:
+                # TODO: in the next line, we should probably replace
+                # rational_points() with irreducible_components()
+                # once Sage can deal with divisors that are not only
+                # rational points (see trac #16225)
+                self._points = [(m, self.scheme().ambient_space().subscheme(p).rational_points()[0]) for (m, p) in self]
+                pts = self._points
+            self._support = [s[1] for s in pts]
+            return self._support
+
+    def coefficient(self, P):
+        """
+        Return the coefficient of a given point P in this divisor.
+
+        EXAMPLES::
+
+            sage: x,y = AffineSpace(2, GF(5), names='xy').gens()
+            sage: C = Curve(y^2 - x^9 - x)
+            sage: pts = C.rational_points(); pts
+            [(0, 0), (2, 2), (2, 3), (3, 1), (3, 4)]
+            sage: D = C.divisor(pts[0])
+            sage: D.coefficient(pts[0])
+            1
+            sage: D = C.divisor([(3, pts[0]), (-1, pts[1])]); D
+            3*(x, y) - (x - 2, y - 2)
+            sage: D.coefficient(pts[0])
+            3
+            sage: D.coefficient(pts[1])
+            -1
+        """
+        P = self.parent().scheme()(P)
+        if P not in self.support():
+            return self.base_ring().zero()
+        t, i = search(self.support(), P)
+        assert t
+        try:
+            return self._points[i][0]
+        except AttributeError:
+            raise NotImplementedError