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.
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.
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.
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.
The ith coordinate function of A as an element of the coordinate ring of A.
> 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; truePrint 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 spacesPn1 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.
> 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
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.
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.
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.
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.
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.
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.
> 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.
The ith coordinate of the point p.
Evaluate the function f of the function field of the scheme X or its ambient at point p which lies on X.
> 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