Given schemes X and Y one can define a map f: X -> Y in a number of ways. The basic method is to give a sequence of polynomials or quotients of polynomials defined on X.
There are some natural functions associated to a map f and some other more complicated functions. The most natural things are, for a point p of X, computing the image point f(p) and, for a subscheme S subset Y computing the preimage scheme S @@ f. More complicated functions include the standard Gröbner basis algorithm for computing images f(T) subset Y of subschemes T of X.
For some functions such as the image computation just mentioned, it is a requirement that the schemes X and Y be defined over a common base ring and that the map f be defined over the identity map (or coercion map) of this common base ring.
Maps respect point set structures. Indeed, given a map f as above and an extension L of k, the base ring of X, there is a map f(L): X(L) -> Y(L). The point set of Y is determined by the composition of the map of base rings with the extension map k -> L. This map f(L) cannot be created without creating the scheme map f first, and in any case it is not usually explicitly required: the evaluation of f(p) will invoke it in the background, for example. But when the main purpose of f is to transfer a large number of points from X(L) to Y(L) then it is best to assign g := f(L) explicitly and use the map g. In this way the small additional overheads involved in constructing f(L) are avoided. Perhaps more importantly, it also ensures that the image points all lie in the same point set.
Maps respect projective closures of schemes. That is, given f as above one can compute the projective closure of f which is a map from the projective closure of X to that of Y and which agrees with f where they are both defined.
The most basic map constructors are described here. It is possible to create maps defined over a map of the base rings of the schemes.
Create the map X -> Y of schemes determined by the sequence F of polynomials or rational functions defined on X. The two schemes X and Y must be defined over compatible base rings, that is, there must exist a ring map u from the base ring of Y to that of X. The polynomials can be elements of the coordinate ring of the ambient space containing X or elements of the coordinate ring of X itself. In any case, the polynomials will be lifted to elements of the coordinate ring of the ambient space and any ring elements which admit this operation could be used.The argument u is a map from the base ring of Y to that of X. If it is omitted then natural coercion map is assumed. In practice, the base rings are often identical in which case coercion will simply be the identity map.
An inverse specified by polynomials or rational functions on Y can be given as G.
Create the map X -> Y of schemes determined by the sequence F for which the map Y -> X determined by the sequence G is an inverse. The sequences F and G should contain polynomials or rational functions defined on X and Y respectively. The two schemes X and Y must be defined over the same base ring.
> k := Rationals(); > A<t> := AffineSpace(k,1); > B<x,y> := AffineSpace(k,2); > f := map< A -> B | [t^3 + t, t^2 - 3] >; > f; Mapping from: Aff: A to Aff: B with equations : t^3 + t t^2 - 3Features of the map can be computed. Of course, the domain and codomain are trivial attributes of the map while its image requires a Gröbner basis computation.
> Domain(f) eq A; true Variables : t > Codomain(f); Affine Space of dimension 2 Variables : x, y > Image(f); Scheme over Rational Field defined by -x^2 + y^3 + 11*y^2 + 40*y + 48
> k<w> := FiniteField(3^2); > u := hom< k -> k | w^3 >; > A<t> := AffineSpace(k,1); > f := map< A -> A | u, [t^3] >; > f; Mapping from: Aff: A to Aff: A with equations : t^3 and map between base rings Mapping from: FldFin: k to FldFin: k given by a rule [no inverse]Notice next how the map f fixes points defined over the prime subfield of k but moves those points with coordinates having nontrivial w component.
> p := A ! [w]; > f(p); (w^3) > f(A ! [2]); (2)
Create the identity map of the scheme X.
The map taking all points of the scheme X to the point p of scheme Y where Q is the sequence of coordinates of p.
The linear projection from projective space X to projective space Y that omits the first dim X - dim Y coordinates.
The projection of the scheme X from the nonsingular (and rational) point p of X. The projection map is returned as a second value. The image of the blowup of p as a point of X is returned as a third value. If this is a point, it is returned as a point type.
The affine scheme obtained by eliminating the ambient variables of the affine scheme X whose indices appear in V from the equations of X. Thus if V=[2, 5] then the result will be a scheme in the affine subspace u=v=0 where u and v are the second and fifth variables of the ambient space of X.
The inverse of the map of schemes f if it is an isomorphism, otherwise an error.
The composition g o f, but note the convention for order of composition: the order of mapping is that g acts first and is followed by f. Strictly speaking, one might want to see evaluation of points done on the left to make sense of this, (this can be done using p @ f instead of f(p)). Since one would usually assign a new identifier to this composition, this is not a large problem. Only simple error checking is done --- domain-codomain matching and that the composition doesn't have so many zero components that it is projectively illegal.
> A<s,t> := ProjectiveSpace(Rationals(),1); > B<x,y,z> := ProjectiveSpace(Rationals(),2); > phi := map< A -> B | [0,0,1] >; > psi := map< B -> A | [x,y] >; > psi * phi; Mapping from: Prj: B to Prj: B with equations : 0 0 1
> phi * psi; >> phi * psi; ^ Runtime error in '*': Polynomials must not all be zero where the gradings are one
> k := Rationals(); > P<x,y,z,t> := ProjectiveSpace(k,3); > A := Scheme(P,Minors(M,2)) > where M is Matrix(CoordinateRing(P),2,3,[x,y,z,y,z,t]); > B := Scheme(P,x*t - y*z); > F<r,s,u,v> := RuledSurface(k,0,0); > HomAF := Maps(A,F); > HomBF := Maps(B,F); > HomAF; Set of all maps from A to FGiven a map A -> B we make the map from HomBF to HomAF given by composition. Although A lies inside B, we choose a map A -> B which isn't this inclusion.
> i := map< A -> B | [y,x,t,z] >; > ii := map< HomBF -> HomAF | g :-> i * g >;The map ii of Hom spaces realises the composition of maps with i. We test this on a single map f: B -> F.
> f := map< B -> F | [x,y,z,t] >; > ii(f) eq i*f; trueHowever, in Magma it is not possible to go further with this. The natural desire would be to construct Maps(HomAF,HomBF) together with a map from Maps(A,B), but the former construction is not allowed.
The restriction of the map of schemes f to the scheme X in its domain. The codomain of the new map is considered to be the scheme Y which must either contain the codomain of f, or lie in that codomain and satisfy f(X) subset Y.
The domain of the map of schemes f.
The codomain of the map of schemes f.
The normalised sequence of functions used to define the map of schemes f.
The normalised sequence of functions used to define the inverse of the map of schemes f.
The underlying map of polynomial rings determining the map of schemes f. Thus if F is the sequence of defining equations of f and x is the first variable of the codomain then F[1] will be the image of x under AlgebraMap(f).
The degree of the normalised homogeneous polynomials which define the map f of projective spaces.
Returns true if and only if the maps of schemes f and g have the same domain and codomain and are defined by the same functions (which will have been normalised in the projective case).
Returns true if and only if f is defined at all points of its domain.
Returns true if and only if the map of schemes f: X -> Y an isomorphism. If so, return a map g: X -> Y which is of the recognised isomorphism type as a second value.
Returns true if and only if the closure of the image of the map of schemes f is the whole of its codomain.
Returns true if and only if the map of schemes f is a regular map defined by linear polynomials.
Returns true if and only if the map of schemes f is a map between affine spaces defined by polynomials of degree at most 1.
Given a map f: X -> Y of schemes and point p of X then the image f(p) is a point of Y. Moreover, given an extension K of the base rings of X and Y, there is a map of point sets f(K): X(K) -> Y(K). This isn't often needed, but should be used as in the example below, when very many point images are required. Note that it will ensure that all points are returned in the same determined point set. Maps also behave well with respect to sets and sequences of points.
The point f(p) if the point p is in a point set of the domain of the map of schemes f. Sets and sequences of points are handled in the same way.
The preimage of the point p under the map of schemes f. This preimage is usually considered as a subscheme of the domain of f. If f has an inverse (that is, if f is an isomorphism) then the return value will be a point (instead of the scheme containing that one point).
The map induced by the map of schemes f: X -> Y on point sets X(K) -> Y(K). If m is a ring map from the base ring of X and u is the map of base rings from Y to X then f(m) will be the map of point sets X(m) -> Y(m(u)).
> P1<s,t> := ProjectiveSpace(Rationals(),1); > P3<w,x,y,z> := ProjectiveSpace(Rationals(),3); > f := map< P1 -> P3 | [s^4,s^3*t,s*t^3,t^4] >; > p := P1 ! [2,1]; > f(p); (16 : 8 : 2 : 1)If many points need to be mapped from a fixed point set, a small overhead can be avoided by working with the map of point sets directly.
> K := QuadraticField(5); > g := f(K); > ims := []; > for i in [1..100] do > Append( ims, g(P1 ! [i,1])); > end for;This example could also have been handled in one step using a sequence constructor.
> pts := [ P1 ! [i,1] : i in [1..100] ]; > f(pts) eq ims; true
The natural operation for maps on schemes is pullback, that is, compute the preimage. This is rather trivial. On the other hand, computing the image of schemes under a map requires a Gröbner basis calculation so is much harder. If the map has an inverse this image calculation is automatically replaced by the more simple pullback using the inverse map.
Note that, strictly speaking, the image algorithm computes the closure of the image of the map. We still call it the image, though, and don't worry that there may be some points of the image that are not the set-theoretic image of any point of the domain.
Over a field, the equations of the image of a map in a particular degree can be computed using linear algebra, so a distinct intrinsic is provided for this.
Other schemes related to a map are also discussed here.
The scheme in the domain of the map of schemes f given by the pullback of the equations defining the subscheme X of the codomain of f.
The closure of the image f(X) where X is a subscheme of the domain of the map of schemes f. For the first signature the image of the entire domain is returned. Moreover, it is stored with the map f so can be called again later without any recomputation.
A basis of the polynomials of degree d in the codomain of the map of schemes f which contain the image f(X). The scheme X must be a subscheme of the domain of f and d must be a positive integer.
> P1<s,t> := ProjectiveSpace(Rationals(),1); > P3<w,x,y,z> := ProjectiveSpace(Rationals(),3); > f := map< P1 -> P3 | [s^4,s^3*t,s*t^3,t^4] >; > Image(f); Scheme over Rational Field defined by -w^2*y + x^3 w*y^2 - x^2*z -x*z^2 + y^3 -w*z + x*y > IsNonsingular(Image(f)); true > f(p) in Image(f) where p is P1 ! [2,1]; true (16 : 8 : 2 : 1)If the Gröbner basis computation is too expensive, or if a partial solution for the image computation would be acceptable, the function Image(f,C,d) described above and illustrated in the next example calculates those hypersurfaces of degree d containing f(C). Given a bound on d, the equations of the image could also be calculated using this function.
Here we simply assert that the curve C has genus 5 and that the map f is the canonical map of the curve C. Chapter PLANE ALGEBRAIC CURVES describes functions that determine both invariants.
> k := Rationals(); > P2<X,Y,Z> := ProjectiveSpace(k,2); > P4<a,b,c,d,e> := ProjectiveSpace(k,4); > C := Curve(P2, X^5 + X*Y^3*Z + Z^5); > f := map< P2 -> P4 | [Y*Z, X*Y, Z^2, X*Z, X^2] >; > S := Image(f,C,2); > S; Scheme over Rational Field defined by a*d - b*c a*e - b*d c*e - d^2 > Dimension(S); 2 > f(C); Scheme over Rational Field defined by a^3*d + c^4 + c*d*e^2 a^3*e + c^3*d + c*e^3 a^2*b + c^3 + d*e^2 a*b^2 + c^2*d + e^3 -a*d + b*c -a*e + b*d -c*e + d^2In this case both image computations are fast so the timing difference between them is tiny. But pushing the genus a little higher soon makes the point.
It is easy to see that S is a scroll: its equations are the rank 2 minors of the matrix
(matrix( a & c & d cr b & d & e ) ).
The subscheme of the domain of the map of schemes f where the map is not defined. In the projective case, common factors will have already been cleared from the defining polynomials to remove the apparent codimension 1 base locus.
If the base scheme of the map of schemes f is finite, this returns a sequence containing those points defined over the base ring which lie in it. Otherwise an error is reported. If a second argument L is included which is an extension field of the base field then base points defined over L are returned.
> k := GF(7);
> P<x,y,z> := ProjectiveSpace(k,2);
> p := x^2 + y^2;
> f := map< P -> P | [p*x,p*y,z^2*(z-x)] >;
> BasePoints(f);
{}
> Degree(BaseScheme(f));
6
> HasPointsOverExtension(BaseScheme(f));
true
Clearly we are not seeing all the points of indeterminacy of f.
We clumsily extend the base field until we do see enough points.
Of course, it is clear that the problem is the polynomial p, so a degree
2 extension will be enough.
> BasePoints(f,ext<k|2>);
{ (1 : $.1^36 : 1), ($.1^12 : 1 : 0), ($.1^36 : 1 : 0), (1 : $.1^12 : 1) }
> HasPointsOverExtension(BaseScheme(f),ext<k|2>);
false
> Q := Rationals(); > F<u,v,x,y> := RuledSurface(Q,2); > G<a,b,r,s> := RuledSurface(Q,3); > F; Rational Scroll of dimension 2 Variables : u, v, x, y Gradings : 1 1 -2 0 0 0 1 1 > phi := map< F -> G | [u,v,x,y*u] >;Next we find the base points of the map phi by hand.
> Scheme(F,[u,v]) join Scheme(F,[x,u*y]);
Scheme over Rational Field defined by
u*x
v*x
u*y
> Support($1);
{ (0 : 1 : 0 : 1) }
The map phi is the elementary transformation in the point (0:1:0:1)
of F. That is, it is the blowup of this point followed by the contraction
of the birational transform of the fibre through this point.
The map induced by the map of schemes f between the projective closure of its domain and codomain. If either domain or codomain is already projective, then it remains unchanged in the new map. In particular, if both domain and codomain are already projective, then the returned map is simply f itself.
If A is an affine space and P a projective space and if S is a sequence of polynomials on A defining a map from A to P (or if m is such a map) then this map is set as the projective closure map of A. There is very little functionality for projective closure maps which are not the standard ones, so this intrinsic is usually used in cases where no relationship between A and P yet exists but the user would like A to behave as a standard patch on P so that the closure of a scheme in A is a scheme in P.
The restriction of the map f, a map of schemes from an affine scheme to a projective scheme, to a rational map from its domain to the jth standard affine patch of its codomain.
The restriction of the map f, a map between two projective schemes, to a rational map from the ith standard affine patch of its domain to the jth patch of its codomain.
> P<w,x,y,z> := ProjectiveSpace(Rationals(),3); > f := map< P -> P | [1/w,1/x,1/y,1/z] >; > f12 := RestrictionToPatch(f,1,2); > f12; Map of affine spaces defined by [ $.3/$.1, $.3/$.2, $.3 ]The functions are inevitably rational so cannot be expressed in any coordinates that might already exist on the affine patches. Instead they are expressed in terms of the generators of the function fields.
> ProjectiveClosure(f12); Map of projective spaces defined by [ x*y*z, w*y*z, w*x*z, w*x*y ] > ProjectiveClosure(f12) eq f; trueHowever, as seen in the final line above, the relationship between a map and its closure is maintained.
Automorphisms of schemes defined over a field may be constructed. The main cases where there is significant functionality is for automorphisms of affine and projective spaces. Recall that for projective spaces the only regular automorphisms are the linear maps. However there are many more rational automorphisms, often called Cremona transformations. In the case of the projective plane, these form a group generated by linear automorphisms together with a single quadratic transformation. In higher dimensions, the structure of this group is unknown.
Affine spaces have much more complicated automorphism groups. Decomposition results are known in the case of the affine plane over certain fields (the complex numbers for instance), but otherwise no general statements are known. More information and references can be found in [vdE00], especially in the opening essay.
Although automorphisms can be computed, groups of automorphisms cannot be computed except in a very few cases. In Magma Version EXPVERS there is a function AutomorphismGroup which returns a group together with a map matching group elements with the automorphism they represent only in the case of linear automorphisms of projective spaces defined over a finite field.
The automorphism of the scheme X determined by the sequence of polynomials F defined on X. This function uses a Gröbner basis calculation. If the inverse functions are already known then one can use the map< | > constructor and then a type change or the iso< | > constructor. This is illustrated in Example H81E21.
The identity map X -> X.
Returns true if and only if the domain and range of f are equal.
Returns true if and only if f is an automorphism of its domain. In this case f is returned as an automorphism as the second value.
In this example we show how to make an automorphism from equations, and also how to include the equations of the inverse map if they are already known. The automorphism is the hyperelliptic involution on a hyperelliptic curve, although we don't use the machinery of hyperelliptic curves here.
> A<u,v> := AffineSpace(Rationals(),2); > f := v^5 + 2*v^3 + 5; > C := Curve(A,u^2 - f); > phi := Automorphism(C,[-u,v]); > Type(phi); MapAutSch > phi; Mapping from: Crv: C to Crv: C with equations : -u v and inverse -u vIn this case we clearly know the inverse map in advance. We can make an automorphism of C as follows.
> psi := map< C -> C | [-u,v],[-u,v] >; > psi eq phi; true > Type(psi); MapSchThe map psiis fine, but it is not of the same type as phi. We make the type change, if desired, as follows.
> bool,psi1 := IsAutomorphism(psi); > bool; true > Type(psi1); MapAutSch
> A<u,v> := AffineSpace(Rationals(),2); > f := u^3 + 3*u^2*v^2 + 3*u^2 + 3*u*v^4 + 6*u*v^2 + v^6 + 3*v^4 + v + 3; > g := u + v^2 + 1; > J := JacobianMatrix([f,g]); > Determinant(J); -1 > m := map< A -> A | [f,g] >; > m; Mapping from: Aff: A to Aff: A with equations : u^3 + 3*u^2*v^2 + 3*u^2 + 3*u*v^4 + 6*u*v^2 + v^6 + 3*v^4 + v + 3 u + v^2 + 1 > IsAutomorphism(m); true > m; Mapping from: Aff: A to Aff: A with equations : u^3 + 3*u^2*v^2 + 3*u^2 + 3*u*v^4 + 6*u*v^2 + v^6 + 3*v^4 + v + 3 u + v^2 + 1 and inverse -u^2 + 2*u*v^3 - 6*u*v + 10*u - v^6 + 6*v^4 - 10*v^3 - 9*v^2 + 31*v - 26 u - v^3 + 3*v - 5 > Type(m); MapSch > Inverse(m); Mapping from: Aff: A to Aff: A with equations : -u^2 + 2*u*v^3 - 6*u*v + 10*u - v^6 + 6*v^4 - 10*v^3 - 9*v^2 + 31*v - 26 u - v^3 + 3*v - 5 and inverse u^3 + 3*u^2*v^2 + 3*u^2 + 3*u*v^4 + 6*u*v^2 + v^6 + 3*v^4 + v + 3 u + v^2 + 1The automorphism test returns two values. The first, true, confirms that the map m is an automorphism. In doing this test, Magma computes the inverse and stores it with m. The second is the same map m, now with its inverse computed, but with the type of an automorphism.
> _,maut := IsAutomorphism(m); > maut; Mapping from: Aff: A to Aff: A with equations : u^3 + 3*u^2*v^2 + 3*u^2 + 3*u*v^4 + 6*u*v^2 + v^6 + 3*v^4 + v + 3 u + v^2 + 1 and inverse -u^2 + 2*u*v^3 - 6*u*v + 10*u - v^6 + 6*v^4 - 10*v^3 - 9*v^2 + 31*v - 26 u - v^3 + 3*v - 5 > Type(maut); MapAutSch
The first constructor below checks that the proposed map is indeed an automorphism by computing an inverse for the map determined by the arguments. It is a potentially expensive test. The other constructors are all either clearly automorphisms or else require only very simple tests.
The automorphism of the affine space A determined by the sequence of functions F defined on A.
The linear automorphism of the affine space A determined by the matrix of ring elements M (acting on the left of coordinate functions).
The translation map of the affine space A taking the rational point p to the origin.
The automorphism of the affine space A that permutes its coordinates according to the permutation g.
> A := AffineSpace(Rationals(),5); > g := SymmetricGroup(5) ! (1,2,3); > f := PermutationAutomorphism(A,g); > p := A ! [1,2,3,4,5]; > f(p); (2, 3, 1, 4, 5)
The automorphism which takes the first coordinate x of the affine space A to x + p. The polynomial p must be a function on A which does not involve x.
If f is an affine linear endomorphism, that is, an automorphism of some affine space defined by polynomials of degree at most 1, this returns a linear endomorphism ell and a translation t such that, in Magma notation, f eq l * t.
> A<x,y,z> := AffineSpace(Rationals(),3); > f := Automorphism(A,2*y+3*z) * Translation(A,A ! [2,3,5]); > l,t := AffineDecomposition(f); > l,t; Mapping from: Aff: A to Aff: A with equations : x + 2*y + 3*z y z and inverse x - 2*y - 3*z y z Mapping from: Aff: A to Aff: A with equations : x - 2 y - 3 z - 5 and inverse x + 2 y + 3 z + 5 > f eq l * t; trueNote that the composition l * t in Magma means that the map ell is applied first followed by t.
> p := A ! [1,2,3]; > f(p); (12, -1, -2) > t(l(p)); (12, -1, -2)
This intrinsic returns the Nagata automorphism in a standard form:(u, v, w) |-> ( - u^2w^3 - 2uv^2w^2 - 2uvw + u - v^4w - 2v^3, uw^2 + v^2w + v, w).
Recall that this is an automorphism of affine 3-space which is not known to be tame, that is, admits no known factorisation into automorphisms of the types listed above.
The restriction to A of the linear automorphism of its projective closure determined by M. Note that this map is not usually regular on A but it is an isomorphism where it is defined.
> k := FiniteField(23); > A<x,y,z> := AffineSpace(k,3); > M := Matrix(k,4,4,[1,2,3,-4,2,3,5,6,3,4,5,9,4,5,6,0]); > phi := Projectivity(A,M); > KA<u,v,w> := Parent(x/y); > phi; Mapping from: Aff: A to Aff: A with equations : (6*u + 12*v + 18*w + 22)/(u + 7*v + 13*w) (12*u + 18*v + 7*w + 13)/(u + 7*v + 13*w) (18*u + v + 7*w + 8)/(u + 7*v + 13*w) and inverse (11*u + 15*v + 5)/(u + 20*w + 2) (9*u + 16*v + w + 12)/(u + 20*w + 2) (12*u + 15*v + 3*w + 16)/(u + 20*w + 2)Notice that the inverse of phi has also been computed. In fact, phi has been returned as an automorphism even though it is not regular.
> Type(phi); MapAutSch > IsRegular(phi); false
As in the case of affine spaces, a version of the automorphism constructor is provided which takes a sequence of polynomials as second argument. It is included mainly for completeness whereas the other constructors are more appropriate for constructing automorphisms in the contexts in which they often arise.
Projective automorphisms (which are regular) are always linear so they have an associated matrix with respect to the basis of monomials. A function is provided to retrieve this matrix, and conversely automorphisms may be created using matrices. In fact, if the projective space is defined over a finite field, then the automorphism group can be computed (as a group in Magma) and its elements can be realised as matrices.
Also included are functions for creating a nonregular birational automorphism of projective space, the standard quadratic transformation. When working in the plane, this together with linear automorphisms generates the group of birational automorphisms. An example of factorising a birational automorphism in this group is given.
The automorphism of the projective space P determined by the sequence of polynomials F defined on P.
The matrix corresponding to the linear automorphism f of a projective space.
The linear automorphism of the projective space P determined by the entries of the matrix of base ring elements M acting on the left of coordinates.
The parent of automorphisms of the projective space P.
The automorphism group of the projective space P together with a map from this group to the set of automorphisms of P, that is, the parent of such automorphisms. The space P must be defined over a finite field for this intrinsic. Note that in Magma Version EXPVERS the group returned is a general linear group rather than the projectivised version. This will be changed in the future, but in any case does not create much confusion.
> P<x,y,z> := ProjectiveSpace(GF(5),2); > phi := Automorphism(P,[x+y,y,z]); > M := Matrix(phi); > M; [1 1 0] [0 1 0] [0 0 1] > Automorphism(P,M) eq phi; trueSince P is a projective space defined over a finite field, we can actually work with a group which is isomorphic to its automorphism group. The map m computed below maps matrices to automorphisms and conversely its inverse constructs a matrix from an automorphism.
> G,m := AutomorphismGroup(P); > G; GL(3, GF(5, 1)) > m; Mapping from: GrpMat: G to Parent structure for automorphisms of P > phi eq m(M); true > phi @@ m; [1 1 0] [0 1 0] [0 0 1]The parent of automorphisms is also an object in Magma. It can be created using Aut(P).
> Aut(P); Parent structure for automorphisms of Projective Space of dimension 2 Variables : x, y, z > Aut(P) eq Codomain(m); true
The unique automorphism of the n-dimensional projective space P taking the n + 2 standard simplex points (1:0 ... :0), ... and (1:1 ... :1) to the points of the sequence Q. The sequence Q must comprise n + 2 linearly independent rational points of P.
This function returns an automorphism which translates the standard coordinate points to the points of the sequence Q. The sequence Q must comprise n + 1 linearly independent rational points of the projective space P where n is the dimension of P. This intrinsic puts no condition on the usual final point (1:1 ... :1) of the standard simplex. In other words, it creates the automorphism of P by the matrix having the coordinates of the n + 1 points of Q as its columns. This automorphism is not uniquely determined since ( PGL)(n, k) is n + 2 transitive.
A choice of linear automorphism of the projective space P which takes the rational point p to the rational point q.
A choice of linear automorphism of the projective space P taking the point (0: ... :0:1) to the rational point p.
> A<u,v> := AffineSpace(Rationals(),2); > Translation(A,A![1,2]); Mapping from: Aff: A to Aff: A with equations : u - 1 v - 2 and inverse u + 1 v + 2In the projective case, the resulting translation moves the point p to the image of the origin on the first affine patch. When the point p lies on the first affine patch, then the translation is the obvious one. But when it doesn't a permutation of the coordinates is made first.
> P<x,y,z> := ProjectiveSpace(Integers(),2); > p := P ! [3,2,1]; > f := Translation(P,p); > f; Mapping from: Prj: P to Prj: P with equations : -x + 3*z -y + 2*z z and inverse -x + 3*z -y + 2*z z > f(p); (0 : 0 : 1) > p := P ! [0,1,0]; > f := Translation(P,p); > f(p); (0 : 0 : 1) > f; Mapping from: Prj: P to Prj: P with equations : -x -z y and inverse x -z y
The first function is the standard quadratic transformation of projective space P taking its coordinates to their reciprocals, that is (x:y: ... ) |-> (1/x:1/y: ... ). The second conjugates the standard map with a translation of the points of Q to the standard basis vectors. The sequence Q must comprise n + 1 linearly independent rational points of P where n is the dimension of P.
The birational pullback of the projective scheme X by the quadratic transformation. In the first intrinsic the transformation used is QuadraticTransformation(P) while in the second, the transformation is QuadraticTransformation(P,Q) where P is the ambient projective space of X. Thus Q must comprise n + 1 linearly independent rational points of P where n is the dimension of P. Exceptional components in the total pullback of X are removed.
> k := RationalField();
> P<x,y,z> := ProjectiveSpace(k, 2);
> funs := [ 2/3*x^2*y^2 + 2/3*x^2*y*z + x*y^2*z + x*y*z^2,
> 1/3*x^2*y^2 + 4/3*x^2*y*z + x^2*z^2 + 1/2*x*y^2*z + 1/2*x*y*z^2,
> 2/9*x^2*y^2 + 2/3*x^2*y*z + 2/3*x*y^2*z + x*y*z^2 + 1/2*y^2*z^2 ];
> g := map< P -> P | funs >;
> FunctionDegree(g);
4
> Support(BaseScheme(g));
{(3/4 : -1 : 1), (0 : 1 : 0), (0 : 0 : 1), (-3/2 : -1 : 1), (1 : 0 : 0)}
Our aim is to precompose g with quadratic transformations which will
reduce the degree of its defining polynomials, currently 4.
When the function degree is reduced to 1 the factorisation is complete
since the inverse sequence of quadratic transformations will comprise
a factorisation of g up to a translation.
(Draw the diagram of maps!)
That will be done at the end.
First a quadratic transformation in the three coordinate points is made
since these points are the simplest appearing in the list of base points.
(The complete mathematical theory works hard to make the choice of map here
the right one: clearly no hard work has been done here in making the
choice of coordinate points.)
> std_quad := QuadraticTransformation(P);
> g1 := std_quad * g;
> FunctionDegree(g1);
2
> Support(BaseScheme(g1));
{ (4/3 : -1 : 1), (-2/3 : -1 : 1), (-2/3 : 0 : 1) }
> HasPointsOverExtension(BaseScheme(g1));
false
Good! With only three non-collinear points of indeterminacy (the final
line makes sure there aren't further points defined over some extension
of the base ring) we are only one step away from completing the factorisation.
We make a quadratic transformation in these three noncollinear points.
> Q := SetToSequence($2); > tr := Translation(P,Q); > quad := std_quad * tr; > g2 := quad * g1; > FunctionDegree(g2); 1So g is seen to be the composition of linear translations and standard quadratic transformations: g_2 is itself a linear translation. This sequence of maps is reconstructed in reverse order to get g. All the maps should be inverted, but note that the quadratic transformations are selfinverse so that this is rather easy. Of course, composing the maps in the order they were discovered above produces the birational inverse of g.
> f3 := f2 * g2 > where f2 is f1 * std_quad > where f1 is std_quad * Inverse(tr); > f3 eq g; true