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 Hom-sets 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 Hom-sets 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)

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 ring

kwds:

• 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 1e-14
[(-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=1e-9))
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 zero-dimensional subscheme, all points are returned regardless of whether the field is infinite 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].

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 doyle-krumm algorithm-4 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^2-y^2-1)
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)

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