Set of homomorphisms between two affine schemes¶
For schemes \(X\) and \(Y\), this module implements the set of morphisms
\(Hom(X,Y)\). This is done by SchemeHomset_generic
.
As a special case, the Homsets can also represent the points of a
scheme. Recall that the \(K\)rational points of a scheme \(X\) over \(k\)
can be identified with the set of morphisms \(Spec(K) \to X\). In Sage
the rational points are implemented by such scheme morphisms. This is
done by SchemeHomset_points
and its subclasses.
Note
You should not create the Homsets manually. Instead, use the
Hom()
method that is inherited by all
schemes.
AUTHORS:
 William Stein (2006): initial version.
 Ben Hutz (2018): add numerical point support

class
sage.schemes.affine.affine_homset.
SchemeHomset_points_affine
(X, Y, category=None, check=True, base=Integer Ring)¶ Bases:
sage.schemes.generic.homset.SchemeHomset_points
Set of rational points of an affine variety.
INPUT:
See
SchemeHomset_generic
.EXAMPLES:
sage: from sage.schemes.affine.affine_homset import SchemeHomset_points_affine sage: SchemeHomset_points_affine(Spec(QQ), AffineSpace(ZZ,2)) Set of rational points of Affine Space of dimension 2 over Rational Field

numerical_points
(F=None, **kwds)¶ Return some or all numerical approximations of rational points of an affine scheme.
This is for dimension 0 subschemes only and the points are determined through a groebner calculation over the base ring and then numerically approximating the roots of the resulting polynomials. If the base ring is a number field, the embedding into
F
must be known.INPUT:
F
 numerical ringkwds:
zero_tolerance
 positive real number (optional, default=10^(10)). For numerically inexact fields, points are on the subscheme if they satisfy the equations to within tolerance.
OUTPUT: A list of points in the ambient space.
Warning
For numerically inexact fields the list of points returned may contain repeated or be missing points due to tolerance.
EXAMPLES:
sage: K.<v> = QuadraticField(3) sage: A.<x,y> = AffineSpace(K, 2) sage: X = A.subscheme([x^3  v^2*y, y  v*x^2 + 3]) sage: L = X(K).numerical_points(F=RR); L # abs tol 1e14 [(1.18738247880014, 0.558021142104134), (1.57693558184861, 1.30713548084184), (4.80659931965815, 37.0162574656220)] sage: L[0].codomain() Affine Space of dimension 2 over Real Field with 53 bits of precision
sage: A.<x,y> = AffineSpace(QQ, 2) sage: X = A.subscheme([y^2  x^2  3*x, x^2  10*y]) sage: len(X(QQ).numerical_points(F=ComplexField(100))) 4
sage: A.<x1, x2> = AffineSpace(QQ, 2) sage: E = A.subscheme([30*x1^100 + 1000*x2^2 + 2000*x1*x2 + 1, x1 + x2]) sage: len(E(A.base_ring()).numerical_points(F=CDF, zero_tolerance=1e9)) 100
sage: A.<x,y> = AffineSpace(QQ, 2) sage: X = A.subscheme([y^2  x^2  3*x, x^2  10*y]) sage: X(QQ).numerical_points(F=CC, zero_tolerance=1) Traceback (most recent call last): ... ValueError: tolerance must be positive

points
(**kwds)¶ Return some or all rational points of an affine scheme.
For dimension 0 subschemes points are determined through a groebner basis calculation. For schemes or subschemes with dimension greater than 1 points are determined through enumeration up to the specified bound.
Over a finite field, all points are returned. Over an infinite field, all points satisfying the bound are returned. For a zerodimensional subscheme, all points are returned regardless of whether the field is infinite or not.
For number fields, this uses the DoyleKrumm algorithm 4 (algorithm 5 for imaginary quadratic) for computing algebraic numbers up to a given height [DK2013].
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:
kwds:
bound
 real number (optional, default: 0). The bound for the height of the coordinates. Only used for subschemes with dimension at least 1.zero_tolerance
 positive real number (optional, default=10^(10)). For numerically inexact fields, points are on the subscheme if they satisfy the equations to within tolerance.tolerance
 a rational number in (0,1] used in doylekrumm algorithm4 for enumeration over number fields.precision
 the precision to use for computing the elements of bounded height of number fields.
OUTPUT:
 a list of rational points of a affine scheme
Warning
For numerically inexact fields such as ComplexField or RealField the list of points returned is very likely to be incomplete. It may also contain repeated points due to tolerance.
EXAMPLES: The bug reported at #11526 is fixed:
sage: A2 = AffineSpace(ZZ, 2) sage: F = GF(3) sage: A2(F).points() [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
sage: A.<x,y> = ZZ[] sage: I = A.ideal(x^2y^21) sage: V = AffineSpace(ZZ, 2) sage: X = V.subscheme(I) sage: M = X(ZZ) sage: M.points(bound=1) [(1, 0), (1, 0)]
sage: u = QQ['u'].0 sage: K.<v> = NumberField(u^2 + 3) sage: A.<x,y> = AffineSpace(K, 2) sage: len(A(K).points(bound=2)) 1849
sage: A.<x,y> = AffineSpace(QQ, 2) sage: E = A.subscheme([x^2 + y^2  1, y^2  x^3 + x^2 + x  1]) sage: E(A.base_ring()).points() [(1, 0), (0, 1), (0, 1), (1, 0)]
sage: A.<x,y> = AffineSpace(CC, 2) sage: E = A.subscheme([y^3  x^3  x^2, x*y]) sage: E(A.base_ring()).points() verbose 0 (124: affine_homset.py, points) Warning: computations in the numerical fields are inexact;points may be computed partially or incorrectly. [(1.00000000000000, 0.000000000000000), (0.000000000000000, 0.000000000000000)]
sage: A.<x1,x2> = AffineSpace(CDF, 2) sage: E = A.subscheme([x1^2 + x2^2 + x1*x2, x1 + x2]) sage: E(A.base_ring()).points() verbose 0 (124: affine_homset.py, points) Warning: computations in the numerical fields are inexact;points may be computed partially or incorrectly. [(0.0, 0.0)]


class
sage.schemes.affine.affine_homset.
SchemeHomset_points_spec
(X, Y, category=None, check=True, base=None)¶ Bases:
sage.schemes.generic.homset.SchemeHomset_generic
Set of rational points of an affine variety.
INPUT:
See
SchemeHomset_generic
.EXAMPLES:
sage: from sage.schemes.affine.affine_homset import SchemeHomset_points_spec sage: SchemeHomset_points_spec(Spec(QQ), Spec(QQ)) Set of rational points of Spectrum of Rational Field