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 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 non-negative. 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 non-negative. 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. This is synonymous with the dot operator A.i.
> 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.
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 and has nothing to do with equality of their characteristics.
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
u^5x, u^4vx, ..., v^5x, 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
u^2x^2, uvx^2, v^2x^2.
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 FF_n. 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 FF_n --- 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 PP^1 bundle over PP^1, the map to PP^1 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=[n_1, ..., n_r] is a sequence of positive integers this returns the product of ordinary projective spacesPP^(n_1) x ... x PP^(n_r)
of dimensions of N. This does not create independent copies of the projective factors and in particular does not return projection maps to the factors.
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 rational function field of the ambient space A. For any ambient space this is a rational function field of appropriate rank. At this stage it is not closely tied to the coordinate ring and its homogeneous field of fractions except in the affine case.
True if and only if the polynomial f is defined on the ambient space A. The point is that schemes in A will be defined by elements of the coordinate ring of A. Polynomials in an ideal of that coordinate ring are not strictly considered to lie in the ring itself by Magma, so will be coerced there as necessary. This intrinsic will return true whenever that coercion is carried out automatically, that is, whenever the function f can be used for defining schemes in A.
Returns true if and only if f is a quotient of polynomials of the coordinate ring of the ambient space A.
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.
Returns true if and only if the polynomial f is homogeneous with respect to all of the gradings on the scheme X.
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 don't 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 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; trueIn 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.
> 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
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 ambient coordinate ring at the point p. Most functionality exists for function fields of curves so it is often the case that the point must lie on some curve for this evaluation to work.
> A<x,y> := AffineSpace(Rationals(),2); > FA<X,Y> := FunctionField(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/2The function h is an element of the function field of the curve C so requires the point p to be coerced explicitly in to C.
> Evaluate(h,p) >> Evaluate(h,p) ^ Runtime error in 'Evaluate': No routine to work with this function > Evaluate(h,C!p); 1/2
As shown in the examples in the introduction to this chapter, schemes are defined inside some ambient space, either affine or projective space, by a collection of polynomials from the coordinate ring associated with that space. Schemes may also be defined inside other schemes using polynomials from the coordinate ring of the bigger scheme or polynomials from the ambient space.
There is very little difference between creation methods for affine and projective schemes. Of course, in the projective case, the defining polynomials are checked for homogeneity or if an ideal is used, a check is made that its basis contains only homogeneous elements. Otherwise, the only check made at the time of creation is that the polynomials used to define the scheme really do lie in, or are coerced automatically into, the coordinate ring of the chosen ambient space.
Create the scheme (or cluster) inside the scheme X defined by the vanishing of the polynomial f, or the sequence of polynomials F, or the ideal of polynomials I, or the ideal in the denominator of the quotient ring Q = R/I. In each case, the polynomials must be elements of the coordinate ring of A or automatically coercible into it.
> A<x,y,z> := AffineSpace(Rationals(),3); > X := Scheme(A,x-y); > X; Scheme over Rational Field defined by x - y > Y := Scheme(X,[x^2 - z^3,y^3 - z^4]); > Y; Scheme over Rational Field defined by x^2 - z^3 y^3 - z^4 x - y > Ambient(Y) eq A; trueNote that since Y was created as a subscheme of X it inherits the equations of X. The ambient space of Y is still considered to be A.
The scheme ( Spec)(R) associated to the affine algebra R. A new affine space Spec(Generic(R)) will be created as the ambient space of this scheme.
The scheme ( Proj)(R) associated to the affine algebra R which will be interpreted with its grading (which will be the standard grading by degree if no other has been assigned). A new projective space Proj(Generic(R)) will be created as the ambient space of this scheme.
The scheme defined by the trivial polynomial 1 on the scheme X.
The intersection of schemes X and Y in their common ambient space. This simply concatenates their defining equations without testing for emptiness.
The union of schemes X and Y in their common ambient space. This is formed by creating the intersection of their defining ideals which is done using a Gröbner basis computation.
Assign the strings in the sequence N to the ambient coordinate functions of the scheme X.
The ith coordinate function of the ambient space of the scheme X. The dot notation X.i may also be used.
As discussed briefly in Section Aside: Types of Schemes, there are a number of different increasingly specialised data types for schemes. It is often useful to check whether a given scheme can be thought of as belonging to one of these more specialised classes, and if so then actually making the type change. In this section we document a number of such type-change intrinsics, most of which are of the form IsSpecialisedType. These intrinsics always return a boolean value. If that value is true then they typically also return a new scheme of the given specialised type, although in some trivial cases this does not happen. Of course, each of the different types of scheme has its own methods of construction independently of these intrinsics.
Returns true if and only if X is an affine space.
Returns true if and only if X is a projective space. Projective space here includes the case of scrolls.
Returns true if and only if X is a projective space in the usual sense: its coordinate ring has a single grading in which all the variables have weight one.
Returns true if and only if X is a zero-dimensional scheme (but not the empty scheme). See Section Zero-dimensional Schemes for intrinsics which apply to clusters.
Returns true if and only if X is a one-dimensional scheme which arises as the scheme defined by a single equation in a two-dimensional ambient space. See Chapter PLANE ALGEBRAIC CURVES for intrinsics which apply to curves.
Returns true if and only if X is a curve (in the sense of IsCurve(X)) which is nonsingular and defined by an equation of degree 2. See Chapter RATIONAL CURVES AND CONICS for intrinsics which apply to such conics.
Returns true if and only if X is a curve (in the sense of IsCurve(X)) which has genus 0. See Section Rational Curves for intrinsics which apply to rational curves.
These intrinsics report on basic features of the ambient space of a scheme or the equations defining a scheme. In many cases they simply call the corresponding function of the ambient space; the intrinsic BaseRing() is an example. The first set of these functions consists of those that only make reference to the ambient space, while the second set is concerned with the defining equations of the scheme.
The ambient space containing the scheme X.
The base ring of the scheme X.
The base ring of the scheme X if it is a field, otherwise an error.
Returns true if and only if the ambient space of the scheme X is affine.
Returns true if and only if the ambient space of the scheme X is projective.
Returns true if and only if the ambient space of the scheme X is an ordinary projective space, that is, its coordinate ring is generated in degree 1 with respect to the grading on the space.
There are many ways to recover the equations which define a scheme. The standard method is to use the Equations() function (or its singular versions) since it doesn't involve ideal theory overheads and certainly won't call any Gröbner basis functions.
The equations defining the scheme X.
The defining polynomial of the scheme X if it is a hypersurface. If X is not a hypersurface, an error is reported.
The ideal of polynomials defining the scheme X.
The quotient of the coordinate ring of the ambient space of the scheme X by the ideal of X.
The smallest scheme in the inclusion chain above X which is a curve.
Return a sequence containing the polynomials of a Gröbner basis of the defining ideal of the scheme X. Note that the equations of X will not be changed, but that the basis of the ideal of X will be updated with the Gröbner basis as is the standard in the multivariate polynomial ring module.
Return a minimal basis of the defining ideal of the scheme X, that is, a sequence of equations, no subsequence of which forms a basis of the ideal of X. Note that the equations of X will not be changed. This is the best human readable basis that Magma can supply.
Returns true if and only if the scheme X is defined by one equation. This function will perform a GCD calculation to simplify the equations if possible. The equation is returned as a second value.
The ideal of partial derivatives of the polynomials which define the scheme X.
The matrix (partial f_i/partial x_j) of partial derivatives of the equations which define the scheme X.
The hessian matrix (partial^2f/partial x_i partial x_j) of the hypersurface X where f is the polynomial which defines X.
Returns true if and only if the schemes X and Y are identical. The notion of `identical' used here simply means that X and Y refer to the same instance of the creation of a scheme. It is unrelated to the properties of X and Y. Quite often, it is the case that one really wants to know that X and Y are defined by the same ideal of functions on the same ambient space. In that case, if Gröbner basis is available, the test Ideal(X) eq Ideal(Y) should be employed.
Returns true if and only if the scheme X is contained in the scheme Y. A Gröbner basis calculation checks the inclusion of the corresponding ideals.
> P<u,v,w> := ProjectiveSpace(GF(11),2); > C := Scheme(P,u^2*w + 6*v^3); > Z := Scheme(C,w); > Z subset C; trueNow we will make another scheme which has the same equations as C but which is written in disguise. While the disguise in this case is simply to multiply the polynomial by 2 --- the rather-too-obvious false nose and eyebrows among polynomials --- the point is to note that while one's natural reaction is to assert that D and C are equal, this is not the result of the scheme equality test in Magma.
> D := Scheme(P,2*u^2*w + v^3); > D eq C; false > Polynomial(D) eq Polynomial(C); false > D subset C and C subset D; true > Ideal(D) eq Ideal(C); trueAs we see in the final line above, checking the equality of ideals corresponds to the natural interpretation of equality.
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]; 1See Section Prelude to Points for descriptions of these and some other basic functions.
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 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.
Returns true if and only if the sequence Q is the sequence of coordinates of some point of the scheme X. In that case, also return the point.
An indexed set containing all the points of some point set of the scheme X which must be defined over a finite field. Which point set is listed depends on the arguments. If X is the only argument, then the base point set is listed. When there is a second argument, it determines the point set as being that of some finite extension of the base field. There are three cases: either the finite extension L is named explicitly; or the desired degree of the extension is used as the second argument; or a map of rings from the base field to the finite extension L is used as the second argument.
An indexed set containing all the points of the scheme X whose coordinates lie in its base ring k which must a finite field.
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.
> 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) @}
> #Points(X,L);
48
> [ #Points(X,n) : n in [1..5] ];
[ 8, 48, 344, 2400, 16808 ]
The final line computes the number of points of X over extensions
of its base field, although it does get very slow already by the
time n is 5.
Note that Magma has very fast machinery for computations like this
for elliptic and hyperelliptic curves.
This section describes intrinsics for creating zero-dimensional schemes or clusters. It also discusses those functions which convert points of schemes into clusters and vice versa. Throughout this subsection, a lowercase p denotes a point of a scheme.
The word cluster refers to schemes that are known to be zero dimensional. In general, the intrinsic Cluster converts points to clusters while the function Support converts clusters to sets of points.
Note that there are four constructors of the form Cluster(X,data) analogous to the four Scheme(X,data) constructors but which make an additional dimension test and type change before returning a cluster determined as a subscheme of X by the data of the second argument.
The reduced scheme supported at the point p, or supported at the set of points S.
The set of rational points of the cluster Z. If an extension of the base field L is given as a second argument, the set of points of Z(L), those points whose coordinates lie in L, is returned.
If Z is a cluster this will determine some (not necessarily optimal) point set Z(L) in which all points of Z having coordinates in an algebraic closure of the base field lie and will return all points of Z(L).
Returns false if and only if all points in the support of the scheme X over an algebraic closure of its base field are already defined over its current base field, or all lie in the point set X(L) if the second argument L is given. This intrinsic is most useful when trying to decide whether or not to make an extension of the base field of X to reveal non-rational points. The base field of X does not need to be a finite field.
The degree of the cluster Z. If Z is reduced, this is equal to the maximum number of points in the support over Z over some extension of its base ring.
> k := FiniteField(5);
> P<x,y,z> := ProjectiveSpace(k,2);
> C := Scheme(P,x^3 + y^3 - z^3);
> D := Scheme(P,x^2 + y^2 - z^2);
> Z := Intersection(C,D);
> IsCluster(Z);
true
> Degree(Z);
6
> Support(Z);
{ (1 : 0 : 1), (0 : 1 : 1) }
> HasPointsOverExtension(Z);
true
If C and D were rather general, that is, if Z was reduced, then
we would expect 6 points in their intersection.
We can't expect that here, but the final line above does confirm that
we haven't yet seen all the points of intersection.
We allow Magma to compute directly over a splitting field.
> SupportOverSplittingField(Z);
{ (0 : 1 : 1), ($.1^14 : $.1^22 : 1), ($.1^22 : $.1^14 : 1), (1 : 0 : 1) }
> L<w> := Ring(Universe($1));
> L;
Finite field of size 5^2
> SupportOverSplittingField(Z);
{ (0 : 1 : 1), (w^14 : w^22 : 1), (w^22 : w^14 : 1), (1 : 0 : 1) }
In this case we see that the support is not six points but only four.
We now discuss intrinsics which apply to a scheme at a single point. At the expense of increasing the number of intrinsics, we try to follow the convention that an intrinsic may simply take a point as its argument or it may take both a point and a scheme as its arguments. In the former case, the implicit scheme argument is taken to be the scheme associated to the point set of the point. In the latter case, it is first checked that the point can be coerced into some point set of the given scheme argument. There are reasons for allowing both methods. Of course, if one is confident about which scheme, X say, a point p lies on then there is no ambiguity about writing, say, IsNonsingular(p) rather than IsNonsingular(X,p). On the other hand, the second expression is easier to read, and also guards against the possibility of accidentally referring to the wrong scheme; that is a particular risk here since the answer makes sense even if p lies on some other scheme---imagine the confusion that could arise given a point of a nonsingular curve lying on a singular surface inside a nonsingular ambient space, for instance. But also there are trivial cases when scheme arguments are necessary, IntersectionNumber(C,D,p) for example. In fact, that particular example exemplifies the value of points being highly coercible---it is very convenient that the point p could lie in a point set of either C or D or indeed neither of these as long as it could be coerced to them if necessary.
Sometimes a function will require that the point argument is rational, that is, has coordinates in the base ring.
Returns true if and only if the point p is a singular point of the scheme X.
Returns true if and only if the point p is a nonsingular point of the scheme X.
Returns true if and only if the tangent cone to the scheme X at the point p is reduced and X is singular at p. In Magma Version EXPVERS, the scheme X must be a hypersurface.
The multiplicity of the point p as a point of the scheme X. In Magma Version EXPVERS, the scheme X must be a hypersurface.
The tangent space to the scheme X at the point p. This linear space is embedded as a scheme in the same ambient space as X. An error will be signalled if p is a singular point of X or is not a rational point of X.
The tangent cone to X at p embedded as a scheme in the same ambient space. In Magma Version EXPVERS, the scheme X must be a hypersurface for the tangent cone to be defined. We anticipate a new implementation of Mora's tangent cone algorithm in the near future and this intrinsic will be updated to use it.
Many of the names of intrinsics in this section come from the usual terminology of algebraic geometry. A reference for them is Hartshorne's book [Har77], especially Chapter II, Section 3.
The dimension of the ideal defining the scheme X. If X is irreducible then the meaning of this is clear, but in general it returns only the dimension of the highest dimensional component of X. The dimension of an empty scheme will be returned as -1. If the dimension is not already known, a Gröbner basis calculation is employed.
The codimension of the scheme X in its ambient space. In fact, this number is calculated as the difference of Dimension(A) and Dimension(X) where A is the ambient space, so if X is not irreducible this number is the codimension of a highest dimensional component of X.
The degree of the scheme X.
Returns true if and only if the scheme X has no points over any algebraic closure of its base field. This intrinsic tests if the ideal of X is trivial (in a sense to be interpreted separately according to whether X is affine or projective) and then applies the Nullstellensatz.
Returns true if and only if the scheme X is nonsingular and equidimensional over an algebraic closure of its base field. The test IsEmpty for the emptiness of the scheme is applied to the scheme defined by the vanishing of appropriately sized minors of the jacobian matrix of X.
Returns true if and only if the scheme X either has a singular point or fails to be equidimensional over an algebraic closure of its base field.
The subscheme of the scheme X defined by the vanishing of the appropriately sized minors of the jacobian matrix of X. If X is not equidimensional, its lower dimensional components will be contained in this scheme whether they are singular or not.
A sequence containing the prime components of the scheme X.
A sequence containing the primary components of the scheme X.
The scheme X with its reduced scheme structure. This function uses a Gröbner basis.
Returns true if and only if the defining equation of the hypersurface X does not factorise over the base field.
Returns true if and only if the defining ideal of the scheme X is radical. If X is a hypersurface the evaluation of this intrinsic uses only derivatives so works more generally than the situations where a Gröbner basis calculation is necessary.
Returns true if and only if the defining ideal of the scheme X is not radical.
> A<x,y,z> := AffineSpace(Rationals(),3);
> X := Scheme(A,[x*y^3,x^3*z]);
> Dimension(X);
2
> IsReduced(X);
false
> PrimaryComponents(X);
[
Scheme over Rational Field defined by
x,
Scheme over Rational Field defined by
x^3
y^3,
Scheme over Rational Field defined by
y^3
z
]
> ReducedScheme(X);
Scheme over Rational Field defined by
x*y
x*z
The reduced scheme of X is clearly the union of a line and a plane.
The scheme X itself is more complicated, having another line embedded
in the plane component.
Let A be some ambient space in Magma. For example, think of A as being the affine plane. Let k be its base ring and R_A its coordinate ring. If m: k -> L is a map of rings (a coercion map, for instance) then there is a new ambient space denoted A_L and called the base change of A to L which has coordinate ring R_(A_L) with coefficient ring L instead of k. (Mathematically, one simply tensors R_A with L over k. In Magma the equivalent function at the level of polynomial rings is ChangeRing.) There is a base change function described below which takes A and L (or the map k -> L) as arguments and creates this new space A_L. Note that there is a map from the coordinate ring of A to that of A_L determined by the map m.
This operation is called base extension since one often thinks of the map m as being an extension of fields. Of course, the map m could be many other things. One key example where the name extension is a little unusual would be when m is the map from the integers to some finite field.
Now let X be a scheme in Magma. Thus X is defined by some polynomials f_1, ..., f_r on some ambient space A. Given a ring map k -> L there is a base change operation for X which returns the base change of X to L, denoted X_L. This is done by first making the base change of A to L and then using the map from the coordinate ring of A to that of A_L to translate the polynomials f_i into polynomials defined on A_L. These polynomials can then be used to define a scheme in A_L. It is this resulting scheme which is the base change of X to L.
If one has a number of schemes in the same ambient space and wants to base change them all at the same time, a little care is required. The function which takes a scheme and a map of rings as argument will create a new ambient space each time so is unsuitable. Better would be to base change the ambient space and then use the base change function which takes the scheme and the desired new ambient space as argument. (This latter base change function appears to be different from the other ones. In fact it is not. We described base change above as a function of maps of rings. Of course, there is a natural extension to maps of schemes. With that extension, this final base change intrinsic really is base change with respect to map of ambient spaces.)
If A is a scheme defined over a field k and K is an extension into which elements of k can be automatically coerced then this returns a new scheme A_K defined over K. No cached data about A will be transferred to A_K and coordinate names will have to be defined again on A_K if needed.
If m is a map of rings whose domain is the base ring of A, this returns the base change of A to the codomain of m. The equations of A, if any, are mapped to the new ambient coordinate ring using m.
If F is a sequence of schemes lying in a common ambient space whose base ring admits automatic coercion to K or is the domain of a ring map m then this returns the base change of the elements of F as a new sequence.
If X is any scheme whose ambient space B is of the same type (affine or projective) and dimension as A but either has a base ring which admits coercion to that of A or the map m is a ring map from the base ring of B to that of A then this returns a scheme with the equations of X as a subscheme of A. The equations are transferred to A using coercion or the map m.
The base change of X, where the base ring of X is a finite field to the finite field which is a degree n extension of the base field of X.
> A<x,y> := AffineSpace(Rationals(),2);
> C := Curve(A,x^2 + y^2);
> IsIrreducible(C);
true
> D := Curve(A,x - 1);
> IntersectionPoints(C,D);
{}
> Qi<i> := QuadraticField(-1);
> IntersectionPoints(C,D,Qi);
{ (0, i), (0, -i) }
So we have found the intersection points (although we haven't explained
how we chose the right field extension).
Now we do the same calculation again but by making the base change of
all schemes to the field Qi. Over this field the intersection points
are immediately visible, but also the curve C splits into two
components.
> B<u,v> := BaseChange(A,Qi);
> C1 := BaseChange(C,B);
> D1 := BaseChange(D,B);
> IsIrreducible(C1);
false
> IntersectionPoints(C1,D1);
{ (0, i), (0, -i) }
> PrimeComponents(C1);
[
Scheme over Qi defined by u + i*v,
Scheme over Qi defined by u - i*v
]
In Magma, any affine ambient space A has a unique projective closure. This may be assigned different variable names just like any projective space. The projective closure intrinsics applied to affine schemes in A will return projective schemes in the projective closure of A. Conversely, a projective space has a number of standard affine patches. These will be the ambient spaces of the standard affine patches of a projective scheme. In this way, the closures of any two schemes lying in the same space will also lie in the same space. The same goes for standard affine patches. These relationships between affine and projective objects are very tightly fixed: asking for the projective closure of an affine scheme will always return the identical object, for instance.
The projective closure of the scheme X. If the projective closure has already been computed, this scheme will be returned. If X is an affine space for which no projective closure has been computed, the projective closure will be a projective space with this space as its first standard patch. Otherwise, the result will lie in the projective closure of the ambient space of X.
The ith affine patch of the scheme X. The number of affine patches is dependent on the type of projective ambient space in which X lies, but for instance, the standard projective space of dimension n has n + 1 affine patches. In that case, i can be any integer in the range 1, ..., n + 1. The order for affine patches is the natural one once you decide that the first patch is that with final coordinate entry nonzero (in the projective closure).
A standard affine patch of the scheme X containing the point p. The second return value is the point corresponding to p in that patch.
> A1<u,v> := AffineSpace(GF(5),2); > X := Scheme(A1,u^2 - v^5); > PX<U,V,W> := ProjectiveClosure(X); > PX; Scheme over GF(5) defined by U^2*W^3 + 4*V^5 > AffinePatch(PX,1) eq X; true > X2<u2,w2> := AffinePatch(PX,2); > X2; Scheme over GF(5) defined by u2^2*w2^3 + 4 > ProjectiveClosure(X2) eq ProjectiveClosure(X); true
The hyperplane complement of the scheme X in its projective closure.
The map from the affine space A to its projective closure.
Projective spaces have a standard disjoint decomposition into affine pieces---not the same thing as the affine patches---of the form[Next][Prev] [Right] [Left] [Up] [Index] [Root]PP^n = AA^n union AA^(n - 1) union⋅sunion AA^1 union p
where AA^n is the first affine patch, AA^(n - 1) is the first affine patch on the hyperplane at infinity and so on. Finally, p is the point (1:0: ... :0). This intrinsic returns a sequence of maps from affine spaces to the projective space P whose images are these affine pieces of a decomposition. The point p is returned as a second value.