|
There are two ways to think of points.
If X is a scheme defined over a ring k and L is a k-algebra, then
there is a set, called a point set and denoted X(L) which is
the set of points of X having coordinates in L or, in Magma terminology,
the parent of such points.
Note that in Magma a k-algebra is interpreted to mean any ring which
admits coercion from k or which is the codomain of a ring homomorphism
whose domain is k.
When thinking of points as a sequence of coordinates on some scheme
this type of point should be used. It is created by coercing the
sequence of coordinates into the required point set using a statement such as
> X(L) ! [1,2,3];
Alternatively, if the universe of the sequence is equal to the base ring
of the scheme, one may simply coerce the sequence into the scheme.
> X ! [1,2,3];
When the universe of the sequence is the integers, Magma will coerce them
into the base ring of the scheme and again this shorthand will work.
The word point always refers to an object whose parent is some point set.
When a scheme is defined over a finite field, there are intrinsics
which list all of its points defined over that field or over any
finite extension of it.
An alternative approach is to consider points, or sets of points, as
schemes in their own right. They can be defined by equations, after all.
We call such zero-dimensional schemes clusters.
They are more general than simply collections of points since
their ideals could be nonradical.
They are discussed in the Section Zero-dimensional Schemes together with intrinsics
which translate between points and clusters.
If p is a point, there are two ways of accessing its coordinates.
The intrinsic Coordinates returns the sequence of all coordinates
of p while p[i] returns the i-th coordinate alone.
For example,
> p := X ! [1,2,3];
> Coordinates(p);
[ 1, 2, 3 ]
> p[1];
1
See Section Prelude to Points for descriptions of these and some other
basic functions.
PointSet(X,L) : Sch,Rng -> SetPt
X(m) : Sch,Map -> SetPt
PointSet(X,m) : Sch,Map -> SetPt
The point set of the scheme X of points whose coordinates lie in the
ring L or in the codomain of the map m.
The map m is a ring homomorphism from the base ring of X to some other ring.
Coercion from the base ring of X to L must be possible if m is not given.
Returns true if and only if the point sets P and Q where created
on the same scheme and with the same map from the base ring of that
scheme.
The scheme X associated to the point set P where
P is of the form X(L) for some extension L of the base ring of X.
The smallest scheme in the inclusion chain above the scheme associated to
the point set P which is a curve.
The ring L associated to the point set P where
P is of the form X(L) for some scheme X.
The map from the base ring of the scheme of P to the ring of the pointset P.
X(L) ! Q : SetPt,SeqEnum -> Pt
The point of the scheme X or the point set X(L) (where X is a scheme and
L is some extension ring of its base ring) determined by the sequence
of coordinates Q.
The universe of the sequence Q must be the base ring of X, or the ring L
or some ring from which coercion into one of these is possible.
Returns true if and only if the points p and q lie in some common scheme
(possibly after coercion) and their coordinates are equal.
Returns true if and only if the point p lies in the scheme X or is coercible into
it.
The scheme on which the point p lies.
The smallest scheme in the inclusion chain above the scheme on which the
point p lies which is a curve.
Returns true if and only if all of the points of the set or sequence Q lie in the
scheme X or are coercible into it.
Returns true if and only if all points of the set S lie in
the scheme X or are coercible into it.
RationalPoints(X,L) : Sch, Rng -> SetIndx
Points(X) : Sch -> SetIndx
Points(X,L) : Sch, Rng -> SetIndx
Bound: RngIntElt Default: 1000
SkipSingularityCheck: BoolElt Default: false
An indexed set containing points in the point set X(L), where L
is an extension of the base field of X.
When not specified, L is taken to be the base field of X.
This is implemented in the following situations:
(i) L is a finite field,
(ii) X has dimension zero,
(iii) L is Rationals().
In cases (i) and (ii), all the points in X(L) are found.
In case (iii), a call to PointSearch is made, which searches
for points with height up to the specified Bound (but note
that it does not guarantee finding all of them).
In most cases, the first step is to determine the dimension of X by
computing the Groebner basis of its defining ideal. This may be
time-consuming; to avoid this one may directly call the relevant
search: Ratpoints over finite fields, or PointSearch
(specifying the Dimension) over the Rationals().
If the parameter SkipSingularityCheck is set to {true}, then
the initial check for singularities is skipped at the beginning so
that the function does not fail on singular inputs.
UseHypersurface: BoolElt Default: false
This is one of the methods used by RationalPoints when X is an
affine or ordinary projective scheme over a finite field.
The basic idea is to work with a Noether Normalisation of the coordinate
ring of X which, in the affine or projective case, gives an everywhere
defined map with finite fibres to a linear subspace. We then run over all
the points in the subspace adding in the points of X in the finite fibre.
Determining the points on a zero-dimensional scheme is relatively fast
and so we get a fairly efficient method for listing all points.
There is a variant to the basic algorithm. Rather than running over
the linear subspace, it can take fibrations over a hypersurface
of dimension one bigger the linear subspace. The points on these as
fibred over the subspace may be quicker to find than for a general finite
fibration and the finite fibres over the hypersurface are of smaller
degree. For example, the general fibre contains only one point when
the extra hypersurface equation generates X generically over the
subspace.
However it is often slower to use the hypersurface because of the
extra computation at the start and the two-stage processing so
the default for UseHypersurface is false.
The user may set this parameter to true for the variant
to be applied.
Returns a random point in the pointset S = X(k) where X is a scheme
defined over a finite field, and k is a finite field. An error results
if the pointset is empty. (Here `random' simply means all points can
occur, but not with uniform distribution.)
This is implemented using the Noether normalisation of X (similarly
to RationalPointsByFibration).
HasNonsingularPoint(X,L) : Sch,FldFin -> BoolElt,Pt
Return true if and only if the scheme X defined over a finite field
contains a nonsingular point (defined over the
finite field L if it appears as a second argument).
In that case, also return such a point.
In this example we define a scheme over a finite field
and compute some points on it.
Note that there are two point constructors used here.
The first is simply X ! Q where Q is a sequence of integers
(or base ring elements).
In the second, we try to coerce a sequence Q whose elements do not
lie in the base ring.
The coercion into X cannot be used here. Instead one must be explicit
about the intended point set. We have used the IsCoercible
intrinsic which creates the point as a side-effect.
One could also use the X(L) ! Q coercion to create the same point.
> A<x,y> := AffineSpace(FiniteField(7),2);
> X := Scheme(A,x^2 + y^2 + 1);
> X ! [2,3];
(2, 3)
> L<w> := ext< BaseRing(X) | 2 >;
> IsCoercible(X,[w^4,w^4]);
false
> IsCoercible(X(L),[w^4,w^4]);
true (w^4, w^4)
Finding those points was not simply good luck.
In fact, we worked backwards and computed all points over the base field
or L and chose one from each of those sets.
> RationalPoints(X);
{@ (3, 2), (4, 2), (2, 3), (5, 3), (2, 4), (5, 4), (3, 5), (4, 5) @}
> #RationalPoints(X,L);
48
We now consider an example of a curve in projective 3-space. In
older versions of Magma this ran very slowly indeed. Now however,
finding points over a fibration, it only takes a few seconds on a
fast machine.
> k := GF(7823);
> R<x,y,z,w> := PolynomialRing(k, 4);
> I := ideal<R | 4*x*z + 2*x*w + y^2 + 4*y*w + 7821*z^2 + 7820*w^2,
> 4*x^2 + 4*x*y + 7821*x*w + 7822*y^2 + 7821*y*w +
> 7821*z^2 + 7819*z*w + 7820*w^2>;
> C := Curve(Proj(R), I);
> // a genus 0 curve with 1 cusp as singularities => 7823+1 points
> pts := RationalPointsByFibration(C); // could also just use RationalPoints
> #pts;
7824
Note that Magma has very fast machinery for computations like this
for elliptic and hyperelliptic curves.
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|