|
|
[____]
Schemes are rather general objects of algebraic geometry.
A standard reference is Hartshorne's introductory text [Har77].
Included among all schemes are many familiar geometric objects such as
plane curves.
In Magma, one can work with many of these
familiar objects but not with entirely general schemes.
Roughly speaking, a scheme in Magma is any geometric object defined by
the vanishing of polynomial equations in affine or projective space.
In particular, there is no facility for defining a scheme a priori
in terms of a collection of affine patches.
Schemes are not automatically normalized.
Maps between schemes can be defined by polynomials or quotients of polynomials.
The sections in this introduction contain examples covering the basic idioms
understood by Magma, especially those for creation of geometric objects,
and are intended to be the first place of reference for newcomers to
this module.
The design of the general scheme module is not particularly subtle or difficult
but the philosophy behind it does require a small amount of understanding.
There are two things in particular.
Firstly, while constructing geometric objects is easy, many of the
constructors take an ambient scheme as an argument as well as some polynomials.
Thus one's initial step is often to create some large ambient space
which is not of primary interest but in which many schemes will lie.
In doing so, one usually assigns names to the coordinate functions of this
space, and it is these names which are used when writing the
polynomials which define some scheme.
Secondly, points are not considered to be elements of schemes, but rather
elements of one of a series of point sets of schemes indexed by the rings
containing the coefficients.
(Mathematically speaking, these rings are really algebras over the base ring
of the scheme, but in Magma the algebra structure is usually implicitly
determined by coercion.)
The objects that can be created include
 - ambient spaces: affine space, projective space, rational
scrolls or weighted projective space over a ring
- schemes as subschemes: the zero locus of polynomials defined on a particular
ambient space or on any other scheme
- points of schemes: sequences of ring elements, possibly defined
over some extension of the base ring
- maps: sequences of polynomials or rational functions defined
on the domain
- linear systems: linear spaces of polynomials defined on ambient spaces
Schemes may be defined quite generally over any ring k, although
of course many functions require k to lie in some restricted class.
The following restrictions hold:
Gröbner basis calculations may only be performed over an exact field or
Euclidean domain;
resultant calculations may only be carried out over a unique factorization domain;
GCD calculations work over any exact field and the integers and over polynomial
rings over either of these;
the factorisation of polynomials is possible only over the integers,
rationals, finite fields, algebraically closed fields, number fields and
function fields.
Linear systems are based on the linear algebra module in Magma and
so are restricted to ambient spaces defined over fields.
The functions described in this chapter are general ones that apply
to all schemes. In particular situations additional functions are
provided.
For example, see
Chapter ALGEBRAIC CURVES
for many specialised functions that apply in the case of curves.
In the final subsection of this introduction
we say a few words about the various
different types of schemes that Magma admits.
To some extent we try to emulate Hartshorne's text [Har77]
although we remain only a fraction of the way through the material of that
book and, of course, we have made innumerable compromises.
In the examples below, > at the start of a line is the Magma prompt.
It is followed by input which may be typed into a Magma session.
The remaining lines are output which has been edited slightly in some
circumstances, but should nonetheless match closely what appears on screen.
Most schemes are considered to live in an ambient space.
These include affine and projective spaces, rational scrolls and products.
They may be defined over any base ring.
The main technical point is that they have an associated coordinate ring (or a
homogeneous coordinate ring) that is a polynomial ring, possibly with one
or more gradings associated to it.
The syntax for defining an affine space over a ring is similar to that
employed when defining a polynomial ring over another ring. The angled bracket
notation is used for assigning names to the coordinate functions.
It is optional as in the case of polynomial rings.
We illustrate by creating an affine 3-space over the finite field of 23
elements with coordinates x, y, z.
Having defined an ambient space A, polynomials in its coordinate functions
can be created.
These polynomials are elements of the coordinate ring of A.
These polynomials (and sometimes also quotients of them) can be used to define
geometric objects related to A. Elements of other polynomial rings
have no meaning on A and their use will result in an error.
> k := FiniteField(23);
> A<x,y,z> := AffineSpace(k,3);
> A;
Affine Space of dimension 3
Variables : x, y, z
Various attributes of A are cached and may be subsequently retrieved.
> BaseRing(A);
Finite field of size 23
> Dimension(A);
3
> A.1;
x
> CoordinateRing(A);
Polynomial ring of rank 3 over GF(23)
Lexicographical Order
Variables: x, y, z
Projective spaces are normally defined in the same way, but they can
also be defined with weights.
> P<u,v,w> := ProjectiveSpace(k,[1,2,3]);
> P;
Projective Space of dimension 2
Variables : u, v, w
Gradings :
1 2 3
Subschemes of ambient spaces prescribed by the vanishing of finitely many
polynomials may be defined.
Just as a polynomial ideal in Magma belongs to some polynomial ring,
so any scheme defined by polynomials is contained in some ambient space.
In the case of ideals of polynomial rings the function Generic()
recovers the polynomial overring. For schemes the analogous function is
AmbientSpace() (or Ambient) which recovers the ambient space.
At the time a scheme is created the system only checks that the defining
equations make sense --- that they are defined on the nominated ambient space,
and are homogeneous if necessary --- and does not check other properties such as
whether or not the scheme is empty.
In fact, it is possible to create schemes without reference to an ambient space.
For instance, the intrinsic Spec may be applied to an affine algebra.
But even so, the ambient space defined by the polynomial overring of that
algebra is created in the background and may be recovered using the intrinsic
Ambient.
Many constructors require a reference to some overscheme to be
clear about which scheme the new object is meant to live in.
We note here that there is an important difference between affine schemes
and projective ones.
For affine schemes, the defining ideal (generated by the
defining equations) is unique. That is, there is a 1 - 1 correspondence
between subschemes of an affine ambient space and the ideals of the
coordinate ring of that ambient.
On the other hand, for projective ambients, a given subscheme is defined by
multiple homogeneous ideals of the ambient coordinate ring. In this case
however, there is a largest defining ideal for each subscheme, which
we refer to as the saturated one.
The practical effect of this is that Magma may have to replace the original
defining ideal of a projective scheme with the saturated ideal to
guarantee the correct result of certain functions
(see section Constructing Schemes for more details).
In this example, the twisted cubic curve in projective 3-space is defined
in terms of equations. The constructor takes these equations in a sequence
as one of its arguments.
> k := Rationals();
> P<u,v,w,t> := ProjectiveSpace(k,3);
> M := Matrix(CoordinateRing(P),2,3,[u,v,w,v,w,t]);
> eqns := Minors(M,2);
> C := Scheme(P,eqns);
> C;
Scheme over Rational Field defined by
u*w - v^2
-u*t + v*w
v*t - w^2
> AmbientSpace(C);
Projective Space of dimension 3
Variables : u, v, w, t
> Dimension(C);
1
> IsNonsingular(C);
true
Although closed points of schemes may be defined as schemes in terms of
polynomials, there is a far more convenient way to define them:
simply coerce the coordinates of the point into the scheme.
This is to allow points to be used in a mathematically
colloquial way: one understands the statement "the point p lies on the
curve C" to mean that the coordinates of p satisfy the equation of C,
rather than to mean an inclusion between the two defining ideals.
(It also avoids the ideal inclusion test which would be a much more
expensive calculation.)
The points p=( - 1, 1), q=(1, 2) are created in the affine plane over the
finite field of 31 elements. Magma's coercion operator, the !
symbol, provides a concise notation for specifying natural reinterpretations
of objects. In this case a
sequence of integers is reinterpreted as a point of the finite plane.
One of the points created below lies on the standard parabola C.
> k := GF(31);
> A<x,y> := AffineSpace(k,2);
> p := A ! [-1,1];
> q := A ! [1,2];
> p,q;
(30, 1) (1, 2)
> C := Scheme(A,y-x^2);
> p in C;
true (30,1)
> q in C;
false
> [-1,1] in C;
true (30, 1)
But this is only the beginning of the story.
Objects in Magma are always considered to lie in some set or structure called
their parent.
Although it would be natural to take the scheme
as the parent of points, instead points have a point set as
their parent. Point sets are the Magma equivalent of "L-valued points"
of schemes. If k is the base ring of a scheme X and L is some k-algebra,
then the point set of X over L, denoted X(L),
comprises points with coordinates in L.
In the previous example, the sequences of coordinates were defined over
the base ring k and the coercion created elements in the point set A(k).
Predicates such as p in C were evaluated by testing whether the
coordinates of p satisfied the equations of the scheme rather than by
consulting their parents.
If the point does happen to lie on C, then p is returned as a point of
C as second return value. Note the difference between the apparently
identical points (30, 1): the first, (p), lies in a point set of A while
the second lies in a point set of C.
The same effect was achieved using the sequence alone in the last line.
Point sets thus allow one to define points over
extensions of k without having to define a new scheme over that extension.
In the next fragment, we show how to make a point of C over an
extension.
> k1<w> := ext< k | 2 >;
> C(k1) ! [w^16,3];
(w^16, 3)
An error is signalled if a point set is not nominated.
> C ! [w^16,3];
>> C ! [w^16,3];
^
Runtime error in '!': Illegal coercion
LHS: Sch
RHS: [FldFinElt]
The moral is:
A point of a scheme is created by coercing a sequence of
coordinates into a point set of the scheme.
While it is true that the "scheme ! coordinates" operation applies
when the sequence is defined over the base ring, it might best be thought
of as a convenient shorthand in predictable and simple situations.
This is analogous to the situation when constructing sets or sequences.
> C(k1) ! [w,w^2];
(w, w^2)
> C(k) ! [w,w^2];
>> C ! [w,w^2];
^
Runtime error in '!': Illegal coercion
This coercion fails since the coordinates do not belong to a field that
embeds into k.
Affine schemes have projective closures and projective schemes have
standard affine patches.
For example, the projective plane has three standard affine patches,
each of which may be recovered as illustrated in the following example.
Here we compute the third affine patch, that is the patch
whose points have nonzero first coefficient (in the projective space).
Although the coercion of points is very flexible --- the affine point p
can usually be used in place of the projective point PX ! p even when
working in PX --- code which is explicit about this kind of coercion
is probably more clear.
> P<x,y,z> := ProjectiveSpace(Rationals(),2);
> A := AffinePatch(P,3);
> A;
Affine Space of dimension 2
Variables : $.1, $.2
> A<u,v> := A;
> A;
Affine Space of dimension 2
Variables : u, v
> P eq Codomain(ProjectiveClosureMap(A));
true
Note that variable names on the patch, and also on closures, are not
created automatically.
Also, the relationship between patch and closure is cemented by a map.
The projective closures of all schemes contained in a
single affine space will lie in a common projective space.
Moreover, the closures of schemes lying in distinct affine patches of a
single projective space will lie in that same space.
In particular, the projective closures of different patches of a projective
scheme will be identical.
> X := Scheme(A,[u^2-v^3,u^2+v^3]);
> PX := ProjectiveClosure(X);
> PX;
Scheme over Rational Field defined by
z^3
y^2
> AffinePatch(PX,3) eq X; // (1)
true
> aX1:=AffinePatch(PX,1);
> IsEmpty(aX1); // (2)
true
> ProjectiveClosure(aX1) eq PX; // (2)
true
> Y := Scheme(P,[x*y^2-z^3,x*y^2+z^3]);
> AffinePatch(Y,3);
Scheme over Rational Field defined by
u^2 - v^3
u^2 + v^3
> AffinePatch(Y,3) eq X; // (3)
true
> Y eq PX;
false
This example shows several things. First it shows that taking the appropriate
affine patch of a projective closure returns the same scheme again (1). Second,
it shows that the projective closure of an affine patch always returns the
exactly the same scheme and not a newly created version. This is not always
mathematically correct and means that projective closure is dependent on how a
scheme was created. Finally, it shows that projective schemes are "saturated
at
infinity", thereby removing the unnecessary x factor (3).
Points are handled cleanly with respect to projective closure.
> p := A ! [0,0];
> PX ! p;
(1 : 0 : 0)
Maps between schemes are defined in terms of either polynomials
or rational polynomials. When a function field exists for the domain,
function field elements may also be used.
When the domain or codomain is projective,
that is, has at least one grading, then compatibility of the
defining functions with the gradings will be checked.
Maps to projective spaces are normalised by clearing polynomial denominators.
This code computes the intersection of the scheme which is image
of f with the conic S (although note that S is defined only
as a scheme here and not as a conic).
Moving to an algebraic closure one sees a Galois 3-cycle of points
among the rational points.
Additional functions for analysis of the multiplicities of these
intersections are described in
Chapter ALGEBRAIC CURVES.
> k := Rationals();
> P1<s,t> := ProjectiveSpace(k,1);
> P2<x,y,z> := ProjectiveSpace(k,2);
> f := map< P1 -> P2 | [s/t,s^2/(s^2 - t^2),t/s] >;
> f;
Mapping from: Prj: P1 to Prj: P2
with equations :
s^4 - s^2*t^2
s^3*t
s^2*t^2 - t^4
> IsRegular(f);
true
> Image(f);
Scheme over Rational Field defined by
-x^3*z + x^2*y^2 - 2*x*y^2*z + y^2*z^2
The images of points may be computed in the natural way:
> p := P1 ! [3,2];
> f(p);
(9/4 : 27/10 : 1)
> f(p) in Image(f);
true (9/4 : 27/10 : 1)
And schemes may be pulled back by maps.
> S := Scheme(P2,x^2 - y*z);
> Z := Pullback(f,S);
> Z;
Scheme over Rational Field defined by
s^8 - 2*s^6*t^2 - s^5*t^3 + s^4*t^4 + s^3*t^5
> RationalPoints(Z);
{@ (1 : 1), (-1 : 1), (0 : 1) @}
> P := PointsOverSplittingField(Z); P;
{@ (0 : 1), (-1 : 1), (1 : 1), (r1 : 1), (r2 : 1), (r3 : 1) @}
> Ring(Universe($1));
Algebraically closed field with 3 variables
Defining relations:
[
r3^3 - r3 - 1,
r2^3 - r2 - 1,
r1^3 - r1 - 1
]
Linear systems in projective space are simply collections of hypersurfaces
having a common degree which are parametrised linearly by a vector space.
The set of all conics in the plane is an example, being parametrised by
the 6-dimensional vector space of possible coefficients of a general
conic:
(a, b, c, d, e, f) -> (ax2 + bxy + cy2 + dxz + eyz + fz2 = 0).
A linear system in Magma has associated with it a fixed basis of forms,
called its sections, of the given degree which allows vectors of
coefficients to be interpreted as hypersurfaces.
In the example above, the basis is the set of monomials of degree 2
and the bijection between vectors of coefficients and hypersurfaces is explicit.
Linear systems are closely related to maps since their sections may be
used to define a map from the space on which they are defined
to some other projective space.
Let P be a projective plane over some field k with coordinates
x, y, z.
The linear system of conics on P is created.
> Q := RationalField();
> P<x,y,z> := ProjectiveSpace(Q,2);
> L := LinearSystem(P,2);
> L;
Linear system on Projective Space of dimension 2
Variables : x, y, z
with 6 sections: x^2 x*y x*z y^2 y*z z^2
> Sections(L);
[ x^2, x*y, x*z, y^2, y*z, z^2 ]
These sections are now used to make a map from the plane P to 5-space.
Its image is the Veronese surface.
> P5<u0,u1,u2,u3,u4,u5> := ProjectiveSpace(Q,5);
> phi := map< P -> P5 | Sections(L) >;
> Image(phi);
Scheme over Rational Field defined by
-u0*u3 + u1^2
-u0*u4 + u1*u2
-u0*u5 + u2^2
-u1*u4 + u2*u3
-u1*u5 + u2*u4
-u3*u5 + u4^2
Geometrical conditions may also be imposed on a linear system.
For example, given a linear system L and a point p lying in the projective
space on which L is defined, a subsystem of
L consisting of those hypersurfaces of L which contain p
may be defined implicitly.
It may be checked (choosing more convenient coordinates) that
the image of this new system is a projection of the Veronese surface from the
point f(3, 2, 1) = (9, 6, 4, 3, 2, 1) lying on it.
This is an embedding of the blowup of the plane P at the point (3, 2, 1)
also known as the cubic scroll.
> p := P ! [3,2,1];
> L1 := LinearSystem(L, p);
> L1;
Linear system on Projective Space of dimension 2
Variables : x, y, z
with 5 sections:
x^2 - 9*z^2
x*y - 6*z^2
x*z - 3*z^2
y^2 - 4*z^2
y*z - 2*z^2
> P4<v0,v1,v2,v3,v4> := ProjectiveSpace(Q,4);
> phi := map< P -> P4 | Sections(L1) >;
> Image(phi);
Scheme over Rational Field defined by
-v0*v3 + v1^2 - 4*v2^2 + 12*v2*v4 - 9*v4^2
-v0*v4 + v1*v2 - 2*v2^2 + 3*v2*v4
-v1*v4 + v2*v3 - 2*v2*v4 + 3*v4^2
It may also be checked that this image can be described as the vanishing of
the two by two minors of a certain matrix.
> M := Matrix(3,[v0, v1 + (2*v2 - 3*v4), v2, v1 - (2*v2 - 3*v4), v3, v4]);
> Minors(M,2);
[
v0*v4 - v1*v2 + 2*v2^2 - 3*v2*v4,
v1*v4 - v2*v3 + 2*v2*v4 - 3*v4^2,
v0*v3 - v1^2 + 4*v2^2 - 12*v2*v4 + 9*v4^2
]
> ideal< CoordinateRing(P4) | $1 > eq Ideal(Image(phi));
true
This section gives a general overview of the types of scheme that
Magma admits. While it is not necessary to know this for most applications,
it is a useful guide to our point of view and gives some indication of the
different data structures used.
The main type is Sch.
Very general functions such as BaseRing() apply at this level.
Gröbner basis calculations also apply.
One level below this there are
- Aff --- a type for affine spaces
- Prj --- a type for projective spaces
- Crv --- a type for curves
- Clstr --- a type for zero-dimensional schemes, or clusters
These inherit all the operations which apply at the level of Sch.
The affine type is straightforward.
The projective type contains spaces with graded polynomial coordinate rings.
There are a number of subtypes of this which identify
spaces with more than one grading.
Objects of the curve type Crv currently only include schemes defined by
a single nontrivial equation in a two-dimensional ambient space.
Functions which apply to the curve type are detailed in
Chapter ALGEBRAIC CURVES.
The most powerful of those require certain irreducibility and separability
conditions to be satisfied by the equation.
More specialised curve types are derived from Crv.
They include CrvCon for plane conics especially those
defined over the rationals where fast point-finding algorithms exist;
CrvRat for rational curves for which a parametrisation algorithm exists;
CrvEll for elliptic curves, probably the
most sophisticated part of the entire geometry module; and
CrvHyp for hyperelliptic curves where there are fast algorithms
for computing on the jacobian.
Each of these has a handbook chapter which presents their
specialised functions.
[Next][Prev] [Right] [____] [Up] [Index] [Root]
|
|