passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/schemes/generic/spec.py

@@ -0,0 +1,199 @@
+# sage_setup: distribution = sagemath-categories
+"""
+The Spec functor
+
+AUTHORS:
+
+- William Stein (2006): initial implementation
+
+- Peter Bruin (2014): rewrite Spec as a functor
+"""
+
+# ******************************************************************************
+#  Copyright (C) 2006 William Stein
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# ******************************************************************************
+
+from sage.categories.functor import Functor
+from sage.rings.integer_ring import ZZ
+from sage.schemes.generic.scheme import AffineScheme
+from sage.structure.unique_representation import UniqueRepresentation
+
+
+def Spec(R, S=None):
+    r"""
+    Apply the Spec functor to `R`.
+
+    INPUT:
+
+    - ``R`` -- either a commutative ring or a ring homomorphism
+
+    - ``S`` -- a commutative ring (optional), the base ring
+
+    OUTPUT:
+
+    - ``AffineScheme`` -- the affine scheme `\mathrm{Spec}(R)`
+
+    EXAMPLES::
+
+        sage: Spec(QQ)
+        Spectrum of Rational Field
+        sage: Spec(PolynomialRing(QQ, 'x'))
+        Spectrum of Univariate Polynomial Ring in x over Rational Field
+        sage: Spec(PolynomialRing(QQ, 'x', 3))
+        Spectrum of Multivariate Polynomial Ring in x0, x1, x2 over Rational Field
+        sage: X = Spec(PolynomialRing(GF(49,'a'), 3, 'x')); X                           # needs sage.rings.finite_rings
+        Spectrum of Multivariate Polynomial Ring in x0, x1, x2
+         over Finite Field in a of size 7^2
+        sage: TestSuite(X).run()                                                        # needs sage.rings.finite_rings
+
+    Applying ``Spec`` twice to the same ring gives identical output
+    (see :issue:`17008`)::
+
+        sage: A = Spec(ZZ); B = Spec(ZZ)
+        sage: A is B
+        True
+
+    A :exc:`TypeError` is raised if the input is not a commutative ring::
+
+        sage: Spec(5)
+        Traceback (most recent call last):
+        ...
+        TypeError: x (=5) is not in Category of commutative rings
+        sage: Spec(FreeAlgebra(QQ, 2, 'x'))                                             # needs sage.combinat sage.modules
+        Traceback (most recent call last):
+        ...
+        TypeError: x (=Free Algebra on 2 generators (x0, x1) over Rational Field)
+        is not in Category of commutative rings
+
+    TESTS::
+
+        sage: X = Spec(ZZ)
+        sage: X
+        Spectrum of Integer Ring
+        sage: X.base_scheme()
+        Spectrum of Integer Ring
+        sage: X.base_ring()
+        Integer Ring
+        sage: X.dimension()
+        1
+        sage: Spec(QQ, QQ).base_scheme()
+        Spectrum of Rational Field
+        sage: Spec(RDF, QQ).base_scheme()
+        Spectrum of Rational Field
+    """
+    return SpecFunctor(S)(R)
+
+
+class SpecFunctor(Functor, UniqueRepresentation):
+    """
+    The Spec functor.
+    """
+    def __init__(self, base_ring=None):
+        """
+        EXAMPLES::
+
+            sage: from sage.schemes.generic.spec import SpecFunctor
+            sage: SpecFunctor()
+            Spec functor from Category of commutative rings to Category of schemes
+            sage: SpecFunctor(QQ)
+            Spec functor from Category of commutative rings to
+             Category of schemes over Rational Field
+        """
+        from sage.categories.commutative_rings import CommutativeRings
+        from sage.categories.schemes import Schemes
+
+        if base_ring is None:
+            domain = CommutativeRings()
+            codomain = Schemes()
+        elif base_ring in CommutativeRings():
+            # We would like to use CommutativeAlgebras(base_ring) as
+            # the domain; we use CommutativeRings() instead because
+            # currently many algebras are not yet considered to be in
+            # CommutativeAlgebras(base_ring) by the category framework.
+            domain = CommutativeRings()
+            codomain = Schemes(AffineScheme(base_ring))
+        else:
+            raise TypeError('base (= {}) must be a commutative ring'.format(base_ring))
+        self._base_ring = base_ring
+        super().__init__(domain, codomain)
+
+    def _repr_(self):
+        """
+        Return a string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: from sage.schemes.generic.spec import SpecFunctor
+            sage: SpecFunctor(QQ)
+            Spec functor from Category of commutative rings to
+             Category of schemes over Rational Field
+        """
+        return 'Spec functor from {} to {}'.format(self.domain(), self.codomain())
+
+    def _latex_(self):
+        r"""
+        Return a LaTeX representation of ``self``.
+
+        EXAMPLES::
+
+            sage: from sage.schemes.generic.spec import SpecFunctor
+            sage: latex(SpecFunctor())
+            \mathrm{Spec}\colon \mathbf{CommutativeRings} \longrightarrow \mathbf{Schemes}
+        """
+        return r'\mathrm{{Spec}}\colon {} \longrightarrow {}'.format(
+               self.domain()._latex_(), self.codomain()._latex_())
+
+    def _apply_functor(self, A):
+        """
+        Apply the Spec functor to the commutative ring ``A``.
+
+        EXAMPLES::
+
+            sage: from sage.schemes.generic.spec import SpecFunctor
+            sage: F = SpecFunctor()
+            sage: F(RR)  # indirect doctest                                             # needs sage.rings.real_mpfr
+            Spectrum of Real Field with 53 bits of precision
+        """
+        # The second argument of AffineScheme defaults to None.
+        # However, AffineScheme has unique representation, so there is
+        # a difference between calling it with or without explicitly
+        # giving this argument.
+        if self._base_ring is None:
+            return AffineScheme(A)
+        return AffineScheme(A, self._base_ring)
+
+    def _apply_functor_to_morphism(self, f):
+        """
+        Apply the Spec functor to the ring homomorphism ``f``.
+
+        EXAMPLES::
+
+            sage: from sage.schemes.generic.spec import SpecFunctor
+            sage: F = SpecFunctor(GF(7))
+            sage: A.<x, y> = GF(7)[]
+            sage: B.<t> = GF(7)[]
+            sage: f = A.hom((t^2, t^3))
+            sage: Spec(f)  # indirect doctest
+            Affine Scheme morphism:
+              From: Spectrum of Univariate Polynomial Ring in t over Finite Field of size 7
+              To:   Spectrum of Multivariate Polynomial Ring in x, y over Finite Field of size 7
+              Defn: Ring morphism:
+                     From: Multivariate Polynomial Ring in x, y over Finite Field of size 7
+                     To:   Univariate Polynomial Ring in t over Finite Field of size 7
+                     Defn: x |--> t^2
+                           y |--> t^3
+        """
+        A = f.domain()
+        B = f.codomain()
+        return self(B).hom(f, self(A))
+
+
+SpecZ = Spec(ZZ)
+
+
+# Compatibility with older versions of this module
+
+from sage.misc.persist import register_unpickle_override
+register_unpickle_override('sage.schemes.generic.spec', 'Spec', AffineScheme)

sage/schemes/product_projective/all.py

@@ -0,0 +1,6 @@
+# sage_setup: distribution = sagemath-categories
+from sage.misc.lazy_import import lazy_import
+
+lazy_import('sage.schemes.product_projective.space', 'ProductProjectiveSpaces')
+lazy_import('sage.schemes.product_projective.space', 'is_ProductProjectiveSpaces')
+del lazy_import

sage/schemes/product_projective/homset.py

@@ -0,0 +1,236 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Set of homomorphisms
+
+AUTHORS:
+
+- Volker Braun and Ben Hutz (2014): initial version
+
+- Raghukul Raman (2018): code cleanup and added support for rational field
+"""
+
+#*****************************************************************************
+# Copyright (C) 2014 Volker Braun <vbraun.name@gmail.com>
+#                    Ben Hutz <bn4941@gmail.com>
+#
+# Distributed under the terms of the GNU General Public License (GPL)
+# as published by the Free Software Foundation; either version 2 of
+# the License, or (at your option) any later version.
+# http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.categories.fields import Fields
+from sage.categories.number_fields import NumberFields
+from sage.misc.mrange import xmrange
+from sage.misc.misc_c import prod
+from sage.rings.finite_rings.finite_field_base import FiniteField
+from sage.rings.rational_field import RationalField
+from sage.schemes.generic.algebraic_scheme import AlgebraicScheme_subscheme
+from sage.schemes.generic.homset import SchemeHomset_points
+
+
+class SchemeHomset_points_product_projective_spaces_ring(SchemeHomset_points):
+    r"""
+    Set of rational points of a product of projective spaces.
+
+    INPUT: See :class:`~sage.schemes.generic.homset.SchemeHomset_generic`.
+
+    EXAMPLES::
+
+        sage: from sage.schemes.product_projective.homset import SchemeHomset_points_product_projective_spaces_ring
+        sage: SchemeHomset_points_product_projective_spaces_ring(
+        ....:     Spec(QQ), ProductProjectiveSpaces([1, 1], QQ, 'z'))
+        Set of rational points of Product of projective spaces P^1 x P^1 over Rational Field
+    """
+
+    def _element_constructor_(self, v, **kwds):
+        r"""
+        The element constructor.
+
+        INPUT:
+
+        - ``v`` -- anything that determines a scheme morphism in the Hom-set
+
+        OUTPUT: the scheme morphism determined by ``v``
+
+        EXAMPLES::
+
+            sage: P = ProductProjectiveSpaces([1, 1], ZZ, 'z')
+            sage: Q = P([4, 6, 6, 2]); Q
+            (4 : 6 , 6 : 2)
+            sage: type(Q)
+            <class 'sage.schemes.product_projective.point.ProductProjectiveSpaces_point_ring'>
+            sage: P(QQ)._element_constructor_([4, 2, 2, 0])
+            (4 : 2 , 2 : 0)
+        """
+        return self.codomain()._point(self, v, **kwds)
+
+
+class SchemeHomset_points_product_projective_spaces_field(SchemeHomset_points_product_projective_spaces_ring):
+    def points(self, **kwds):
+        r"""
+        Return some or all rational points of a projective scheme.
+
+        Over a finite field, all points are returned. Over an infinite field, all points satisfying the bound
+        are returned. For a zero-dimensional subscheme, all points are returned regardless of whether the base
+        ring is a field or not.
+
+        For number fields, this uses the
+        Doyle-Krumm algorithm 4 (algorithm 5 for imaginary quadratic) for
+        computing algebraic numbers up to a given height [DK2013]_ or
+        uses the chinese remainder theorem and points modulo primes
+        for larger bounds.
+
+        The algorithm requires floating point arithmetic, so the user is
+        allowed to specify the precision for such calculations.
+        Additionally, due to floating point issues, points
+        slightly larger than the bound may be returned. This can be controlled
+        by lowering the tolerance.
+
+
+        INPUT:
+
+        - ``bound`` -- a real number
+
+        - ``tolerance`` -- a rational number in (0,1] used in Doyle-Krumm
+          algorithm 4
+
+        - ``precision`` -- the precision to use for computing the elements of
+          bounded height of number fields
+
+        - ``algorithm`` -- either ``'sieve'`` or ``'enumerate'`` algorithms can
+          be used over `\QQ`. If not specified, ``'enumerate'`` is used only
+          for small height bounds
+
+        OUTPUT: list of rational points of the projective scheme
+
+        EXAMPLES::
+
+            sage: P.<x,y,z,w> = ProductProjectiveSpaces([1, 1], QQ)
+            sage: X = P.subscheme([x - y, z^2 - 2*w^2])
+            sage: X(P.base_ring()).points()                                             # needs sage.libs.singular
+            []
+
+        ::
+
+            sage: u = QQ['u'].0
+            sage: K = NumberField(u^2 - 2, 'v')                                         # needs sage.rings.number_field
+            sage: P.<x,y,z,w> = ProductProjectiveSpaces([1, 1], K)                      # needs sage.rings.number_field
+            sage: X = P.subscheme([x^2 - y^2, z^2 - 2*w^2])
+            sage: sorted(X(P.base_ring()).points())                                     # needs sage.libs.singular sage.rings.number_field
+            [(-1 : 1 , -v : 1), (-1 : 1 , v : 1), (1 : 1 , -v : 1), (1 : 1 , v : 1)]
+
+        ::
+
+            sage: u = QQ['u'].0
+            sage: K = NumberField(u^2 + 1, 'v')                                         # needs sage.rings.number_field
+            sage: P.<x,y,z,w> = ProductProjectiveSpaces([1, 1], K)                      # needs sage.rings.number_field
+            sage: P(K).points(bound=1)                                                  # needs sage.libs.singular sage.rings.number_field
+            [(-1 : 1 , -1 : 1), (-1 : 1 , -v : 1), (-1 : 1 , 0 : 1), (-1 : 1 , v : 1),
+             (-1 : 1 , 1 : 0), (-1 : 1 , 1 : 1), (-v : 1 , -1 : 1), (-v : 1 , -v : 1),
+             (-v : 1 , 0 : 1), (-v : 1 , v : 1), (-v : 1 , 1 : 0), (-v : 1 , 1 : 1),
+             (0 : 1 , -1 : 1), (0 : 1 , -v : 1), (0 : 1 , 0 : 1), (0 : 1 , v : 1),
+             (0 : 1 , 1 : 0), (0 : 1 , 1 : 1), (v : 1 , -1 : 1), (v : 1 , -v : 1),
+             (v : 1 , 0 : 1), (v : 1 , v : 1), (v : 1 , 1 : 0), (v : 1 , 1 : 1),
+             (1 : 0 , -1 : 1), (1 : 0 , -v : 1), (1 : 0 , 0 : 1), (1 : 0 , v : 1),
+             (1 : 0 , 1 : 0), (1 : 0 , 1 : 1), (1 : 1 , -1 : 1), (1 : 1 , -v : 1),
+             (1 : 1 , 0 : 1), (1 : 1 , v : 1), (1 : 1 , 1 : 0), (1 : 1 , 1 : 1)]
+
+        ::
+
+            sage: P.<x,y,z,u,v> = ProductProjectiveSpaces([2, 1], GF(3))
+            sage: P(P.base_ring()).points()
+            [(0 : 0 : 1 , 0 : 1), (0 : 0 : 1 , 1 : 0), (0 : 0 : 1 , 1 : 1), (0 : 0 : 1 , 2 : 1),
+             (0 : 1 : 0 , 0 : 1), (0 : 1 : 0 , 1 : 0), (0 : 1 : 0 , 1 : 1), (0 : 1 : 0 , 2 : 1),
+             (0 : 1 : 1 , 0 : 1), (0 : 1 : 1 , 1 : 0), (0 : 1 : 1 , 1 : 1), (0 : 1 : 1 , 2 : 1),
+             (0 : 2 : 1 , 0 : 1), (0 : 2 : 1 , 1 : 0), (0 : 2 : 1 , 1 : 1), (0 : 2 : 1 , 2 : 1),
+             (1 : 0 : 0 , 0 : 1), (1 : 0 : 0 , 1 : 0), (1 : 0 : 0 , 1 : 1), (1 : 0 : 0 , 2 : 1),
+             (1 : 0 : 1 , 0 : 1), (1 : 0 : 1 , 1 : 0), (1 : 0 : 1 , 1 : 1), (1 : 0 : 1 , 2 : 1),
+             (1 : 1 : 0 , 0 : 1), (1 : 1 : 0 , 1 : 0), (1 : 1 : 0 , 1 : 1), (1 : 1 : 0 , 2 : 1),
+             (1 : 1 : 1 , 0 : 1), (1 : 1 : 1 , 1 : 0), (1 : 1 : 1 , 1 : 1), (1 : 1 : 1 , 2 : 1),
+             (1 : 2 : 1 , 0 : 1), (1 : 2 : 1 , 1 : 0), (1 : 2 : 1 , 1 : 1), (1 : 2 : 1 , 2 : 1),
+             (2 : 0 : 1 , 0 : 1), (2 : 0 : 1 , 1 : 0), (2 : 0 : 1 , 1 : 1), (2 : 0 : 1 , 2 : 1),
+             (2 : 1 : 0 , 0 : 1), (2 : 1 : 0 , 1 : 0), (2 : 1 : 0 , 1 : 1), (2 : 1 : 0 , 2 : 1),
+             (2 : 1 : 1 , 0 : 1), (2 : 1 : 1 , 1 : 0), (2 : 1 : 1 , 1 : 1), (2 : 1 : 1 , 2 : 1),
+             (2 : 2 : 1 , 0 : 1), (2 : 2 : 1 , 1 : 0), (2 : 2 : 1 , 1 : 1), (2 : 2 : 1 , 2 : 1)]
+
+        ::
+
+            sage: PP.<x,y,z,u,v> = ProductProjectiveSpaces([2, 1], QQ)
+            sage: X = PP.subscheme([x + y, u*u - v*u])
+            sage: X.rational_points(bound=2)                                            # needs sage.libs.singular
+            [(-2 : 2 : 1 , 0 : 1),
+             (-2 : 2 : 1 , 1 : 1),
+             (-1 : 1 : 0 , 0 : 1),
+             (-1 : 1 : 0 , 1 : 1),
+             (-1 : 1 : 1 , 0 : 1),
+             (-1 : 1 : 1 , 1 : 1),
+             (-1/2 : 1/2 : 1 , 0 : 1),
+             (-1/2 : 1/2 : 1 , 1 : 1),
+             (0 : 0 : 1 , 0 : 1),
+             (0 : 0 : 1 , 1 : 1),
+             (1/2 : -1/2 : 1 , 0 : 1),
+             (1/2 : -1/2 : 1 , 1 : 1),
+             (1 : -1 : 1 , 0 : 1),
+             (1 : -1 : 1 , 1 : 1),
+             (2 : -2 : 1 , 0 : 1),
+             (2 : -2 : 1 , 1 : 1)]
+
+        better to enumerate with low codimension::
+
+            sage: PP.<x,y,z,u,v,a,b,c> = ProductProjectiveSpaces([2, 1, 2], QQ)
+            sage: X = PP.subscheme([x*u^2*a, b*z*u*v, z*v^2*c])
+            sage: len(X.rational_points(bound=1, algorithm='enumerate'))                # needs sage.libs.singular
+            232
+        """
+        B = kwds.pop('bound', 0)
+        X = self.codomain()
+
+        from sage.schemes.product_projective.space import ProductProjectiveSpaces_ring
+        if not isinstance(X, ProductProjectiveSpaces_ring) and X.base_ring() in Fields():
+            # no points
+            if X.dimension() == -1:
+                return []
+            # if X is zero-dimensional
+            if X.dimension() == 0:
+                points = set()
+                # find points from all possible affine patches
+                for I in xmrange([n + 1 for n in X.ambient_space().dimension_relative_components()]):
+                    Y, phi = X.affine_patch(I, True)
+                    aff_points = Y.rational_points()
+                    for PP in aff_points:
+                        points.add(phi(PP))
+                return list(points)
+        R = self.value_ring()
+        points = []
+        if isinstance(R, RationalField):
+            if not B > 0:
+                raise TypeError("a positive bound B (= %s) must be specified" % B)
+            alg = kwds.pop('algorithm', None)
+            if alg is None:
+                # sieve should only be called for subschemes and if the bound is not very small
+                N = prod([k+1 for k in X.ambient_space().dimension_relative_components()])
+                if isinstance(X, AlgebraicScheme_subscheme) and B**N > 5000:
+                    from sage.schemes.product_projective.rational_point import sieve
+                    return sieve(X, B)
+                else:
+                    from sage.schemes.product_projective.rational_point import enum_product_projective_rational_field
+                    return enum_product_projective_rational_field(self, B)
+            elif alg == 'sieve':
+                from sage.schemes.product_projective.rational_point import sieve
+                return sieve(X, B)
+            elif alg == 'enumerate':
+                from sage.schemes.product_projective.rational_point import enum_product_projective_rational_field
+                return enum_product_projective_rational_field(self, B)
+            else:
+                raise ValueError("algorithm must be 'sieve' or 'enumerate'")
+        elif R in NumberFields():
+            if not B > 0:
+                raise TypeError("a positive bound B (= %s) must be specified" % B)
+            from sage.schemes.product_projective.rational_point import enum_product_projective_number_field
+            return enum_product_projective_number_field(self, bound=B)
+        elif isinstance(R, FiniteField):
+            from sage.schemes.product_projective.rational_point import enum_product_projective_finite_field
+            return enum_product_projective_finite_field(self)
+        else:
+            raise TypeError("unable to enumerate points over %s" % R)