|
For the purposes of this chapter, any scheme is contained in some ambient
space, either an affine space or one of a small number of standard
projective spaces: these are projective space itself, possibly weighted, and
rational scrolls.
The basic property of these spaces is that they have some kind of coordinate
ring that is a polynomial ring. It happens again and again that we lift
polynomials to these polynomial rings before working with them.
It is possible to define schemes without reference to such an ambient
space, but one will be created in the background in any case.
Listed in this section are the basic creation methods for ambient spaces.
Names for the coordinates will usually be required for creating polynomials
later on.
Names of coordinate functions may be defined using the diamond bracket
notation in the same way as for polynomial rings.
Coordinate names defined using this will be globally defined and
retained even outside the context in which they were set.
Alternatively, explicit naming functions may be used after creation.
These are the basic ambient spaces. They are used in many situations
and are usually sufficient, although there are more in the next section.
Create an n-dimensional affine space over the ring k.
The integer n must be positive.
Names can be assigned using
the angle bracket notation, e.g.
A<x, y, z> := AffineSpace(Rationals(), 3), which will assign the names
to the coordinate ring, usually a multivariate polynomial ring, in
the same way as the angle bracket notation works for the multivariate
polynomial rings.
ProjectiveSpace(k,W) : Rng,[RngIntElt] -> Prj
Create an n-dimensional projective space over the ring k.
The integer n must be positive.
The second argument to this intrinsic can be a sequence of positive
integer weights. These weights will be
assigned to the coordinate functions of the space.
The dimension of the space is one less than the length of this sequence.
(At present there are very few functions to perform analysis on weighted
projective spaces, but maps between them are treated correctly.)
Names can be assigned using the angle bracket notation, e.g.
P<x, y, z> := ProjectiveSpace(Rationals(), 2), which will assign
the names to the coordinate ring, usually a multivariate polynomial ring,
in the same way as the angle bracket notation works for multivariate
polynomial rings.
ProjectiveLine(k) : RngOrdRes -> SetIndx, UserProgram
Type: MonStgElt Default: "Vector"
Given a quotient ring R of an order O of some number field, returns
an indexed set containing standard representatives (u, v) ∈P1(R),
where u, v ∈O. Also returns a function which identifies
the standard representative of any given element (u', v') ∈P1(R).
The optional argument Type should be either "Vector" or "Matrix",
which determines the type of the elements in the returned set.
ProjectiveLineProcess(k, n) : FldFin, RngIntElt -> ProcPL
Given a vector space V over a finite field k, or its dimension n,
returns a process which enumerates the lines in V (elements of P(V)).
The number of lines in P = P(V).
A vector spanning the next line in the process P = P(V).
Returns the zero vector if no more elements are left.
Spec(R) : RngMPol -> Aff
Create the affine space whose coordinate ring is the multivariate
polynomial ring R.
The coordinate names for the affine space will be inherited from R.
Proj(R) : RngMPol -> Prj
Create the projective plane whose homogeneous coordinate ring is the
multivariate polynomial ring R.
If R has been assigned a grading then that grading will be used otherwise it
will be considered to have the standard grading by degree.
A procedure to change the print names of the coordinate
functions of the ambient space A. It leaves A unchanged except that
the visible names of the first #N coordinate functions are replaced
by the strings of N and the rest return to their default. It does
not assign the coordinate functions
themselves to any identifiers. That must be done by hand, for instance
by the command x := A.1;.
Note that this will change the variable names of the coordinate (polynomial)
ring.
Name(A,i) : Sch,RngIntElt -> RngMPolElt
The ith coordinate function of A as an element of the coordinate ring
of A.
An affine 3-space over the finite field of 11 2 elements is created.
Initially only the first two coordinate functions are named.
The third adopts the default name $.3.
The identifier which refers to it is A.3.
Then new names are assigned to all coordinate functions and new identifiers
set to refer to them.
(Check what happens if the identifiers are not assigned.)
Notice that the previous identifiers, x, y, are not erased, although
their print values have been updated.
> A<x,y> := AffineSpace(FiniteField(11,2),3);
> A;
Affine Space of dimension 3
Variables : x, y, $.3
> AssignNames(~A,["u","v","w"]);
> u := A.1; v := A.2; w := A.3;
> A;
Affine Space of dimension 3
Variables : u, v, w
> x;
u
> u eq x;
true
Print values are global in Magma, meaning that even if they are changed
in the local environment of a function or procedure the new names
will persist.
Returns true if and only if the ambient spaces A and B are identical.
This will only be the case if both A and B refer to the same instance
of creation of the space.
These spaces are created using multiple gradings.
They are not as fundamental as the affine and projective spaces of the
previous section and may be passed over on first reading.
As we have said, the important thing about ambient spaces in this
system is that their
coordinate rings are essentially polynomial rings. For affine spaces, this is
literally true. For projective spaces, one talks about the homogeneous
coordinate ring and restricts attention to homogeneous polynomials, that is,
polynomials whose terms all have the same weight with respect to a single
grading, but nonetheless one is working inside a polynomial ring.
This trick can be pushed further by admitting more than one grading on a
polynomial ring. The standard example of this is the family of rational ruled
surfaces, or rational surface scrolls, which have a bihomogeneous coordinate
ring with four variables u, v, x, y and two gradings which are
often chosen to be
[1, 1, - n, 0] (and) [0, 0, 1, 1]
for some nonnegative integer n.
Now we restrict attention to polynomials of some homogeneous bidegree
(or more generally, multidegree) of the form [a, b].
As with ordinary projective space, polynomials of a given bidegree form
a vector space with a favourite basis of monomials.
For example, if n=3, then monomials of bidegree [2, 1] have as their basis
u5x, u4vx, ..., v5x, uy, vy.
As with ordinary projective space, one can ask which polynomials have
negative degree. The difference is that this time there is just a little
room for manoeuvre: with the same n the monomials of degree [ - 4, 2] are
u2x2, uvx2, v2x2.
We consider the geometric object having this coordinate ring to be a
primitive object of the system. It is called a ruled surface and
denoted Fn.
This seems to be a rather implicit approach at first, but is very similar
to the way one works with projective space itself:
at first one learns about homogeneous polynomials, degree 0 rational
polynomials, affine patches and so on, but once used to that one gets on
and uses it.
There are affine patches on Fn --- a standard `first' patch is the
affine plane
where v not=0 and y not=0 --- and one can study them to get an idea of what
this surface looks like. In this case it is a P1 bundle over P1,
the map to P1 given by the bidegree [0, 0] ratio u/v and the fibre
coordinate being the ratio x/y, not of trivial bidegree on the whole
surface, but well-defined for any fixed value of u/v.
We think of the gradings as forming a matrix and allow more general scrolls
arising from matrices which are partially row reduced to have rows of the form
[1, ...,1, *, ... ],
[0, ...,0,1, ...,1, *, ... ], ...,
[0, ...,0,1, ...,1 ]
where the * entries may be any integers.
To get products of projective spaces we simply set all the * entries
to be 0. Thinking about which multihomogeneous polynomials arise in
this ring and comparing with functions on products of projective spaces
is a first exercise.
A reference for the point of view we take on these scrolls is
[Rei97] Chapter 2.
The product of the ambient spaces A and B together with a sequence
containing the two projection maps.
This returns the ruled surface defined over the ring k whose negative
section has selfintersection ∓(a - b), where a, b are non-negative
integers.
If n is a nonnegative integer, this returns the ruled surface defined
over the ring k whose negative section has selfintersection -n.
The integer n must be non-negative.
In terms of the gradings, this means using the standard gradings as
described in the introduction with the top-right-hand entries being -n, 0.
If N is a sequence nonnegative integers this returns the rational scroll
with base ring k and gradings with * entries being -N.
If N=[n1, ..., nr] is a sequence of positive integers this
returns the product of ordinary projective spaces
Pn1 x ... x Pnr
of dimensions of N over the ring k.
This does not create independent copies of the projective factors
and in particular does not return projection maps to the factors.
Computes the product X of a finite sequence of schemes Xs lying in
ordinary projective space. The scheme X is constructed in ordinary
projective space. It is embedded there via an iterated Segre embedding
(see Ex. 2.14, Section 2, Chapter 1 of [Har77]). This
intrinsic is provided because it is often easier to work in ordinary
projective space. However, the user should be warned that the dimension
of the ambient increases markedly with Segre embeddings. If the r schemes
Xs[i] lie in (P)ni, then X will lie in (P)N
where N is (n1 + 1) * (n2 + 1) * ... (nr + 1) - 1.
A sequence containing the r projection maps from X to the Xs[i] is
also returned.
The scheme X should lie in a product projective ambient (or be the ambient
itself!). Computes and returns the image Y of X in ordinary projective
space under the iterated Segre embedding (see the preceding intrinsic) along with a
scheme isomorphism from X to Y. This is a specialised intrinsic that is
generally much faster than using the general machinery to construct the Segre
map on the ambient of X and ask for the image of X.
In the following example, we Segre embed the product of an elliptic curve E with
itself into ordinary projective space using the two intrinsics.
> Q := RationalField();
> P2<x,y,z> := ProjectiveSpace(Q,2);
> E := Curve(P2,y^2*z-x^3-x^2*z-z^3);
> ExE := SegreProduct([E,E]);
> P8<a,b,c,d,e,f,g,h,i> := Ambient(ExE);
> ExE;
Scheme over Rational Field defined by
-f*h + e*i,
-c*h + b*i,
-f*g + d*i,
-e*g + d*h,
-c*g + a*i,
-b*g + a*h,
-c*e + b*f,
-c*d + a*f,
-b*d + a*e,
-g^3 - g^2*i + h^2*i - i^3,
-d^3 - d^2*f + e^2*f - f^3,
-c^3 - c^2*i + f^2*i - i^3,
-b^3 - b^2*h + e^2*h - h^3,
-a^3 - a^2*g + d^2*g - g^3,
-a^3 - a^2*c + b^2*c - c^3
> // or we could have started with ExE in product projective space
> P22<x,y,z,s,t,u> := ProductProjectiveSpace(Q,[2,2]);
> EE := Scheme(P22,[y^2*z-x^3-x^2*z-z^3, t^2*u-s^3-s^2*u-u^3]);
> EE;
Scheme over Rational Field defined by
-x^3 - x^2*z + y^2*z - z^3,
-s^3 - s^2*u + t^2*u - u^3
> ExE_1 := SegreEmbedding(EE);
> // transfer ExE_1 to the Ambient of ExE to compare
> ExE_1 := Scheme(P8,[Evaluate(pol,[a,b,c,d,e,f,g,h,i]) : pol in
> DefiningPolynomials(ExE_1)]);
> ExE eq ExE_1;
true
HasFunctionField(A) : Sch -> BoolElt
The coordinate ring of the ambient space A.
This is some polynomial ring of appropriate rank over the base ring.
Gradings on this ring are usually independent of those of the scheme.
Note that if the coordinate ring has zero rank then it will be the base ring.
The function field of the ambient space A of dimension 1. This is a field isomorphic
to the field of fractions of the coordinate ring of A.
While it is possible to give input of dimension greater than 1 for backward
compatibility, it is preferrable to instead use
FieldOfFractions(CoordinateRing(X)).
A sequence containing all the gradings on the projective space X.
Each such grading is a sequence of integers whose length is the same
as the number of coordinate functions of X.
The same sequence is returned when this function is applied to any
scheme contained in X.
NGrad(X) : Sch -> RngIntElt
The number of independent gradings on the projective space X.
The same number is returned when this function is applied to any
scheme contained in X.
Length(X) : Sch -> RngIntElt
The number of coordinate functions of the ambient space of the scheme X.
This is equal to the number of coordinates of any point of X.
The lengths of the groups of ones in the gradings of a scroll X.
IsHomogeneous(X,f) : Sch,FldFunRatMElt -> BoolElt
Returns true if and only if the polynomial or rational function
f is homogeneous with
respect to all of the gradings on the scheme X. The rational function
must be of the coordinate ring of the ambient of X
and true is returned if and only if f is a quotient of polynomials
homogeneous with respect to all gradings.
Degrees(X,f) : Sch, RngMPolElt -> SeqEnum
The sequence of homogeneous degrees of the polynomial f with respect to
the gradings on the scheme X.
Points of schemes are handled in an extremely flexible way: their coordinates
need not be elements of the base ring, for instance.
We do not discuss the details here but simply show how to create points in
ambient spaces and illustrate with an example.
This is already enough for non-specialised purposes: intrinsics which
take point arguments for computing, say, the tangent space to a curve at a
point, can take the underlying point of the ambient space or the point of the
curve equally well.
Having said that, the later section on points, Section Rational Points and Point Sets,
should be taken as the
definitive reference.
A(L) ! [a,b,...] : SetPt,[RngElt] -> Pt
For elements a, b, ... in the base ring of the scheme
A this creates the set-theoretic
point (a, b, ... ) in the affine case, or (a:b: ... ) in the projective case.
Over a field, the projective point will be normalised so that its final
nonzero coordinate entry is 1 (and further analogous normalisations when
there are at least two gradings as in the case of surface scrolls).
The first constructor can only be used if the sequence contains elements
of the base ring of A.
The second version of the constructor is the standard one. Using it rather
than the first allows the user to specify the ring in which the coefficients
are to be considered.
See the discussion of point sets in the section below on points.
We create some points with identical coordinates. They are deemed to be
unequal by the equality test, but if what you really care about is their
coordinates you can check that those are equal.
> k<w> := FiniteField(3^2);
> A := AffineSpace(k,2);
> p := A ! [1,2];
> K := ext< k | 2 >;
> q := A(K) ! [1,2];
> m := hom< k -> k | w^3 >; // Frobenius
> r := A(m) ! [1,2];
> p eq q;
true
> p eq r;
>> p eq r;
^
Runtime error in 'eq': Arguments are not compatible
Argument types given: Pt, Pt
> q eq r;
>> q eq r;
^
Runtime error in 'eq': Arguments are not compatible
Argument types given: Pt, Pt
In the example above, the first method used for the creation of a point is
sufficient if you only want to create a point with coefficients in the
base ring.
The second and third point creations are more precise: they decree
exactly the k-algebra in which the coefficients will lie.
One should think of the expression A ! [1,2] as merely being a
convenient shorthand, analogous to defining a sequence without being
explicit about its universe.
The origin of the affine space A.
The sequence of points of the ambient space A having coordinates
(1, 0, ..., 0), ... (0, ..., 0, 1)
and (1, ..., 1) whether A is affine or projective space.
The sequence of ring elements corresponding to the coordinates of
the point p.
Coordinate(p,i) : Pt,RngIntElt -> SeqEnum
The ith coordinate of the point p.
f(p) : Pt, FldFunFracSchElt -> RngElt
Evaluate(f, p) : RngElt,Pt -> RngElt
Evaluate the function f of the function field of the scheme X or
its ambient at point p which lies on X.
Although there are many rings which may appear as function fields
in various contexts, their elements can all be evaluated at points.
(Section Function Fields
discusses the function field of a curve which is being used here only
as an example.)
> A<x,y> := AffineSpace(Rationals(),2);
> FA<X,Y> := FieldOfFractions(CoordinateRing(A));
> C := Curve(A,x^3 - y^2 + 3*x);
> FC<u,v> := FunctionField(C);
> p := A ! [1,2];
> q := C ! [1,2];
> f := x/y;
> g := X/Y;
> h := u/v;
> Evaluate(f,p), Evaluate(f,q);
1/2 1/2
> Evaluate(g,p), Evaluate(g,q);
1/2 1/2
> Evaluate(h,q);
1/2
> Evaluate(h,p);
1/2
> Evaluate(h,C!p);
1/2
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|