Here we describe what is meant by a geometry morphism in FinInG and the various operations and tools available to the user. When using groups in GAP, we often use homomorphisms to pass from one situation to another, even though mathematically it may appear to be unneccessary, there can be ambiguities if the functionality is too flexible. This also applies to finite geometry. Take for example the usual exercise of thinking of a hyperplane in a projective space as another projective space. To conform with similar things in GAP, the right thing to do is to embed one projective space into another, rather than having one projective space automatically a substructure of another. The reason for this is that there are many ways one can do this embedding, even though we may dispense with this choice when we are working mathematically. So to avoid ambiguity, we stipulate that one should construct the embedding explicitly. How this is done will be the subject of this chapter.
Suppose that S and S' are two incidence geometries. A geometry morphism from S to S' is defined to be a map from the elements of S to the elements of S' which preserves incidence and induces a function from the type set of S to the type set of S'. For instance, a correlation and a collineation are examples of geometry morphisms, but they have been dealt with in more specific ways in FinInG. We will mainly be concerned with geometry morphisms where the source and range are different. Hence, the natural embedding of a projective space in a larger projective space, the mapping induced by field reduction, and e.g. the Klein correspondence are examples of such geometry morphisms.
As a geometry morphism from S to S' preserves incidence, it also preserves the symmetry, and hence it induces also a map from the collineation group of S into the collineation group of S'. Such a map will be called an Intertwiner, and FinInG can provide these maps for some of the geometry morphisms.
‣ IsGeometryMorphism | ( family ) |
The category IsGeometryMorphism represents a special object in FinInG which carries attributes and the given element map. The element map is given as a IsGeneralMapping, and so has a source and range.
gap> ShowImpliedFilters(IsGeometryMorphism); Implies: IsGeneralMapping IsTotal Tester(IsTotal) IsSingleValued Tester(IsSingleValued)
The usual operations of ImagesElm, ImagesSet, PreImagesElm, PreImagesSet work for geometry morphisms, as well as the overload operator \^. Since Image is a GAP function, we advise the user to not use this for geometry morphisms.
For most geometry morphisms, there is also an accompanying intertwiner for the automorphism groups of the source and range. Given a geometry morphism f from S to S', an intertwiner φ is a map from the automorphism group of S to the automorphism group of S', such that for every element p of S and every automorphism g of S, we have
f(pg)=f(p)φ(g).
‣ Intertwiner( f ) | ( attribute ) |
Returns: a group homomorphism
The argument f is a geometry morphism. If f comes equipped with a natural intertwiner from an automorphism group of the source of f to the automorphism group to the image of f, then the user may is able to obtain the intertwiner by calling this operation (see the individual geometry morphism constructions). There is no method to compute an intertwiner for a given geometry morphism, the attribute is or is not set during the construction of the geometry morphism, depending whether the Source and Range of the morphism have the appropriate automorphism group known as an attribute. When this condition is not satisfied, the user is expected to call the appropriate automorphism groups, so that they are computed, and to recompute the geometry morphism (which will not cost a lot of computation time then), such that the attribute Intertwiner becomes available. Here is a simple example of the intertwiner for the isomorphism of two polar spaces (see IsomorphismPolarSpaces (11.2-1)). The source of the homomorphism is dependent on the geometry.
gap> form := BilinearFormByMatrix( IdentityMat(3,GF(3)), GF(3) ); < bilinear form > gap> ps := PolarSpace(form); <polar space in ProjectiveSpace(2,GF(3)): x_1^2+x_2^2+x_3^2=0 > gap> pq := ParabolicQuadric(2,3); standard Q(2, 3) gap> iso := IsomorphismPolarSpaces(ps, pq); #I Computing nice monomorphism... <geometry morphism from <Elements of <polar space in ProjectiveSpace(2,GF( 3)): x_1^2+x_2^2+x_3^2=0 >> to <Elements of standard Q(2, 3)>> gap> KnownAttributesOfObject(iso); [ "Range", "Source", "Intertwiner" ] gap> hom := Intertwiner(iso); MappingByFunction( <projective semilinear group with 3 generators>, PGammaO(3,3), function( y ) ... end, function( x ) ... end )
An important class of geometry morphisms in FinInG are the isomorphisms between polar spaces of the same kind that are induced by coordinate transformations.
‣ IsomorphismPolarSpaces( ps1, ps2 ) | ( operation ) |
‣ IsomorphismPolarSpaces( ps1, ps2, boolean ) | ( operation ) |
Returns: a geometry morphism
The arguments ps1 and ps2 are equivalent polar spaces, i.e. up to coordinate transformation, the underlying sesquilinear or quadratic form determines the same polar space, or, ps1 is a parabolic quadric over a finite field f of even charateristic in dimension 2n and ps2 is a symplectic space over f in dimension 2n-1, then this operation returns a geometry isomorphism between them. The optional third argument boolean can take either true or false as input, and then the operation will or will not compute the intertwiner accordingly. The user may wish that the intertwiner is not computed when working with large polar spaces. The default (when calling the operation with two arguments) is set to true, and in this case, if at least one of ps1 or ps2 has a collineation group installed as an attribute, then an intertwining homomorphism is installed as an attribute of the resulting geometry morphism. Hence we also obtain a natural group isomorphism from the collineation group of ps1 onto the collineation group of ps2 (see also Intertwiner (11.1-2)).
gap> mat1 := IdentityMat(6,GF(5)); < mutable compressed matrix 6x6 over GF(5) > gap> form1 := BilinearFormByMatrix(mat1,GF(5)); < bilinear form > gap> ps1 := PolarSpace(form1); <polar space in ProjectiveSpace( 5,GF(5)): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2=0 > gap> mat2 := [[0,0,0,0,0,1],[0,0,0,0,1,0],[0,0,0,1,0,0], > [0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]]*Z(5)^0; [ [ 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), Z(5)^0 ], [ 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), Z(5)^0, 0*Z(5) ], [ 0*Z(5), 0*Z(5), 0*Z(5), Z(5)^0, 0*Z(5), 0*Z(5) ], [ 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5) ], [ 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5) ], [ 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5) ] ] gap> form2 := QuadraticFormByMatrix(mat2,GF(5)); < quadratic form > gap> ps2 := PolarSpace(form2); <polar space in ProjectiveSpace(5,GF(5)): x_1*x_6+x_2*x_5+x_3*x_4=0 > gap> iso := IsomorphismPolarSpaces(ps1,ps2,true); #I No intertwiner computed. One of the polar spaces must have a collineation \ group computed <geometry morphism from <Elements of Q+(5, 5): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2=0> to <Elements of Q+(5, 5): x_1*x_6+x_2*x_5+x_3*x_4=0>> gap> CollineationGroup(ps1); #I Computing collineation group of canonical polar space... <projective collineation group of size 58032000000 with 4 generators> gap> CollineationGroup(ps2); #I Computing collineation group of canonical polar space... <projective collineation group of size 58032000000 with 4 generators> gap> iso := IsomorphismPolarSpaces(ps1,ps2,true); <geometry morphism from <Elements of Q+(5, 5): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2=0> to <Elements of Q+(5, 5): x_1*x_6+x_2*x_5+x_3*x_4=0>> gap> hom := Intertwiner( iso ); MappingByFunction( <projective collineation group of size 58032000000 with 4 generators>, <projective collineation group of size 58032000000 with 4 generators>, function( y ) ... end, function( x ) ... end ) gap> ps1 := ParabolicQuadric(6,8); Q(6, 8) gap> ps2 := SymplecticSpace(5,8); W(5, 8) gap> em := IsomorphismPolarSpaces(ps1,ps2); #I Have 36171 points. #I Have 37381 points in new orbit. #I Have 36171 points. #I Have 37388 points in new orbit. <geometry morphism from <Elements of Q(6, 8)> to <Elements of W(5,\ 8)>> gap> hom := Intertwiner(em); MappingByFunction( PGammaO(7,8), <projective collineation group of size 27231016821530296320 with 3 generators>, function( el ) ... end, function( el ) ... end )
It is well known that the classical generalised quadrangles W(3,q) and Q(4,q) are dually isomorphic, the same holds for the classical generalised quadrangles Q-(5,q) and H(3,q2). These isomorphisms are implemented through the operation NaturalDuality, this operation will return a geometry morphism with ElementsOfIncidenceStructure(gq1) as source and ElementsOfIncidenceStructure(gq2) as range, in other words, it is a geometry morphism from all the elements of gq1 onto all the elements of gq2, preserving the incidence, and swapping the types.
‣ NaturalDuality( gq1, gq2 ) | ( operation ) |
‣ NaturalDuality( gq1, gq2, boolean ) | ( operation ) |
‣ NaturalDuality( gq ) | ( operation ) |
‣ NaturalDuality( gq, boolean ) | ( operation ) |
Returns: a geometry morphism
The operation allows the construction of the duality between W(3,q) and Q(4,q), respectively Q^-(5,q) and H(3,q^2), in two directions. Checks on the correctness of the basefields done, and it is checked that the input generalised quadrangle(s) are appropriate, i.e. the right type and of rank 2. The first version requires two arguments: either the symplectic or parabolic quadrangle, in any order, and defined by any suitable bilinear/quadratic and bilinear form; or the ellipitc or hermitian quadrangle (in dimension 3), in any order, and defined by any suitable bilinear/quadratic and hermitian form. In all cases the generalised quadrangles may be the standard one provided by the package FinInG.
The thrid version requires only one argument, either W(3,q), Q(4,q), Q-(5,q), or H(3,q2), standard or specified by the users using an appropriate bilinear, quadratic or hermitian form. The range of the returned geometry morphism will be the set of all elements of a suitable generalised quadrangle, in standard form.
The first and third verion without a boolean as argument will, if possible return a geometry morphism equipped with an intertwiner. Using the boolean argument false will return a geometry morphism that is not equipped with an intertwiner.
gap> w := SymplecticSpace(3,5); W(3, 5) gap> lines:=AsList(Lines(w));; gap> duality := NaturalDuality(w); #I No intertwiner computed. One of the polar spaces must have a collineation group computed <geometry morphism from <lines of W(3, 5)> to <points of Q(4, 5)>> gap> l:=lines[1]; <a line in W(3, 5)> gap> l^duality; <a point in Q(4, 5)> gap> PreImageElm(duality,last); <a line in W(3, 5)>
The most natural of geometry morphisms include, for example, the embedding of a projective space into another via a subspace, or the projection of a polar space to a smaller polar space of the same type via a totally isotropic subspace.
‣ NaturalEmbeddingBySubspace( geom1, geom2, v ) | ( operation ) |
Returns: a geometry morphism
The arguments geom1 and geom2 are both projective spaces, or both polar spaces, and v is an element of a projective or polar space. This function returns a geometry morphism representing the natural embedding of geom1 into geom2 as the subspace v. Hence geom1 and v must be equivalent as geometries. An Intertwiner is not implemented for this geometry morphism.
gap> geom1 := ProjectiveSpace(2, 3); ProjectiveSpace(2, 3) gap> geom2 := ProjectiveSpace(3, 3); ProjectiveSpace(3, 3) gap> planes := Planes(geom2); <planes of ProjectiveSpace(3, 3)> gap> hyp := Random(planes); <a plane in ProjectiveSpace(3, 3)> gap> em := NaturalEmbeddingBySubspace(geom1, geom2, hyp); <geometry morphism from <All elements of ProjectiveSpace(2, 3)> to <All elements of ProjectiveSpace(3, 3)>> gap> points := Points(geom1); <points of ProjectiveSpace(2, 3)> gap> x := Random(points); <a point in ProjectiveSpace(2, 3)> gap> x^em; <a point in ProjectiveSpace(3, 3)>
Another example, this time with polar spaces:
gap> h1 := HermitianPolarSpace(2, 3^2); H(2, 3^2) gap> h2 := HermitianPolarSpace(3, 3^2); H(3, 3^2) gap> pg := AmbientSpace( h2 ); ProjectiveSpace(3, 9) gap> pi := VectorSpaceToElement( pg, [[1,0,0,0],[0,1,0,0],[0,0,1,0]] * Z(9)^0 ); <a plane in ProjectiveSpace(3, 9)> gap> em := NaturalEmbeddingBySubspace( h1, h2, pi ); <geometry morphism from <Elements of H(2, 3^2)> to <Elements of H(3, 3^2)>>
‣ NaturalEmbeddingByFieldReduction( geom1, f2, B ) | ( operation ) |
‣ NaturalEmbeddingByFieldReduction( geom1, f2 ) | ( operation ) |
‣ NaturalEmbeddingByFieldReduction( geom1, geom2 ) | ( operation ) |
‣ NaturalEmbeddingByFieldReduction( geom1, geom2, B ) | ( operation ) |
Returns: a geometry morphism
This operation comes in four flavours. For the first flavour, the argument geom1 is a projective space over a field L=GF(qt). The argument f2 is a subfield K=GF(q) of L. The argument B is a basis for L as a K-vectorspace. When this argument is not given, a basis for L over K is computed using Basis(AsVectorSpace(K,L)). It is checked whether f2 is a subfield of the basefield of geom1. The third and fourth flavour are comparable, where now K is found as the basefield of geom2. In fact the arguments geom1 and geom2 are the projective spaces PG(r-1,qt) and PG(rt-1,q) respectively. As in the previous flavours, the argument B is optional. An intertwiner is only implemented for this geometry morphism with projective spaces as argument.
gap> pg1 := ProjectiveSpace(2,81); ProjectiveSpace(2, 81) gap> f2 := GF(9); GF(3^2) gap> em := NaturalEmbeddingByFieldReduction(pg1,f2); <geometry morphism from <All elements of ProjectiveSpace(2, 81)> to <All elements of ProjectiveSpace(5, 9)>> gap> f2 := GF(3); GF(3) gap> em := NaturalEmbeddingByFieldReduction(pg1,f2); <geometry morphism from <All elements of ProjectiveSpace(2, 81)> to <All elements of ProjectiveSpace(11, 3)>> gap> pg2 := ProjectiveSpace(11,3); ProjectiveSpace(11, 3) gap> em := NaturalEmbeddingByFieldReduction(pg1,pg2); <geometry morphism from <All elements of ProjectiveSpace(2, 81)> to <All elements of ProjectiveSpace(11, 3)>>
‣ Intertwiner( em ) | ( operation ) |
Returns: an intertwiner for a geometry morphism
The argument em is a geometry morphism constructed from PG(r-1,qt) into PG(rt-1,q). The intertwiner of em will return a homomorphisms from the homography group of PG(r-1,qt) into the collineation group of PG(rt-1,q). Notice in the example below the difference of a factor 2 in the orders of the group, which comes of course from restricing the homomorphism to the homography group, which differes a factor 2 from the collineation group of the projective line, that has an extra automorphism of order two, corresponding with the Frobenius automorphism.
gap> pg1 := PG(1,9); ProjectiveSpace(1, 9) gap> em := NaturalEmbeddingByFieldReduction(pg1,GF(3)); <geometry morphism from <All elements of ProjectiveSpace(1, 9)> to <All elements of ProjectiveSpace(3, 3)>> gap> i := Intertwiner(em); MappingByFunction( The FinInG projectivity group PGL(2,9), <projective colline ation group of size 720 with 2 generators>, function( m ) ... end, function( m ) ... end ) gap> spread := List(Points(pg1),x->x^em); [ <a line in ProjectiveSpace(3, 3)>, <a line in ProjectiveSpace(3, 3)>, <a line in ProjectiveSpace(3, 3)>, <a line in ProjectiveSpace(3, 3)>, <a line in ProjectiveSpace(3, 3)>, <a line in ProjectiveSpace(3, 3)>, <a line in ProjectiveSpace(3, 3)>, <a line in ProjectiveSpace(3, 3)>, <a line in ProjectiveSpace(3, 3)>, <a line in ProjectiveSpace(3, 3)> ] gap> stab := Stabilizer(CollineationGroup(PG(3,3)),Set(spread),OnSets); <projective collineation group of size 5760> gap> hom := HomographyGroup(pg1); The FinInG projectivity group PGL(2,9) gap> gens := GeneratorsOfGroup(hom);; gap> group := Group(List(gens,x->x^i)); <projective collineation group with 2 generators> gap> Order(group); 2880 gap> IsSubgroup(stab,group); true
‣ NaturalEmbeddingByFieldReduction( geom1, f2 ) | ( operation ) |
‣ NaturalEmbeddingByFieldReduction( geom1, f2, B ) | ( operation ) |
‣ NaturalEmbeddingByFieldReduction( geom1, f2, boolean ) | ( operation ) |
Returns: a geometry morphism
The argument geom1 is a classical polar space over a field L and f2 is a subfield K of L, GF(qt) and K=GF(q). This function returns a geometry morphism representing the natural embedding of geom1 into a classical polar space S via field reduction, based on the following principle. Consider the trace map T: GF(qt) → GF(q): x → xqt + xqt-1 + … x. The polar space geom1 is the geometry associated to a quadratic or sequilinear form f, acting on an r-dimensional vector space V1 over the finite field GF(qt). We first consider the rt-dimensional vector space V2 over the finite field GF(q). There is a bijective map Φ from V1 to V2. Now it is easy to see that T • f • Φ -1 will be a quadratic or sesquilinear form (depending on f being quadratic or sesquilinear) acting on V2, and hence, if not singular or degenerate, induce a polar space over the finite field GF(q). An element of geom1 is mapped to an element of the induced polar space over GF(q) using the same principle as for the natural embedding by field reduction for projective spaces, of course now restricted to the elements of geom1. The only such possible embeddings are listed in the table below (see [Gil08]):
| Polar Space 1 | Polar Space 2 | Conditions |
| W(2n-1,qt) | W(2nt-1,q) | -- |
| Q+(2n-1,qt) | Q+(2nt-1,q) | -- |
| Q-(2n-1,qt) | Q-(2nt-1,q) | -- |
| Q(2n,q2a+1) | Q((2a+1)(2n+1)-1,q) | q odd |
| Q(2n,q2a) | Q-(2a(2n+1)-1,q) | q=1 mod 4 |
| Q(2n,q4a+2) | Q+((4a+2)(2n+1)-1,q) | q=3 mod 4 |
| Q(2n,q4a) | Q-(4a(2n+1)-1,q) | q=3 mod 4 |
| H(n,q2a+1) | H((n+1)(2a+1)-1,q) | q square |
| H(n,q2a) | W(2a(n+1)-1,q) | q even |
| H(2n,q2a) | Q-(2a(2n+1)-1,q) | q odd |
| H(2n+1,q2a) | Q+(2a(2n+2)-1,q) | q odd |
The geometry morphism also comes equipped with an intertwiner (see Intertwiner (11.4-3)). This intertwiner has as its domain the isometry group of geom1. The optional third argument boolean can take either true or false as input, and then this operation will or will not compute the intertwiner accordingly. The user may wish that the intertwiner is not computed when embedding into large polar spaces. The default (when calling the operation with two arguments) is set to true. In the first example, we construct a spread of maximal subspaces (solids) in a 7 dimensional symplectic space. We compute a subgroup of its stabilizer group using the intertwiner. In the second example, we construct a linear blocking set of the symplectic generalised quadrangle over GF(9).
gap> ps1 := SymplecticSpace(1,3^3); W(1, 27) gap> em := NaturalEmbeddingByFieldReduction(ps1,GF(3),true); <geometry morphism from <Elements of W(1, 27)> to <Elements of <polar space in ProjectiveSpace( 5,GF(3)): -x1*y6-x2*y5-x3*y4-x3*y6+x4*y3+x5*y2+x6*y1+x6*y3=0 >>> gap> ps2 := AmbientGeometry(Range(em)); <polar space in ProjectiveSpace( 5,GF(3)): -x1*y6-x2*y5-x3*y4-x3*y6+x4*y3+x5*y2+x6*y1+x6*y3=0 > gap> spread := List(Points(ps1),x->x^em);; gap> i := Intertwiner(em); MappingByFunction( PGSp(2,27), <projective collineation group of size 19656 with 3 generators>, function( m ) ... end, function( m ) ... end ) gap> coll := CollineationGroup(ps2); #I Computing collineation group of canonical polar space... <projective collineation group of size 9170703360 with 4 generators> gap> stab := Group(ImagesSet(i,GeneratorsOfGroup(IsometryGroup(ps1)))); <projective collineation group with 2 generators> gap> IsSubgroup(coll,stab); true gap> List(Orbit(stab,spread[1]),x->x in spread); [ true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true ] gap> ps1 := SymplecticSpace(3,9); W(3, 9) gap> em := NaturalEmbeddingByFieldReduction(ps1,GF(3),true); <geometry morphism from <Elements of W(3, 9)> to <Elements of <polar space in ProjectiveSpace( 7 ,GF(3)): -x1*y3+x1*y4+x2*y3+x3*y1-x3*y2-x4*y1-x5*y7+x5*y8+x6*y7+x7*y5-x7*y6-x8 *y5=0 >>> gap> ps2 := AmbientGeometry(Range(em)); <polar space in ProjectiveSpace( 7 ,GF(3)): -x1*y3+x1*y4+x2*y3+x3*y1-x3*y2-x4*y1-x5*y7+x5*y8+x6*y7+x7*y5-x7*y6-x8 *y5=0 > gap> pg := AmbientSpace(ps2); ProjectiveSpace(7, 3) gap> spread := List(Points(ps1),x->x^em);; gap> el := Random(ElementsOfIncidenceStructure(pg,5)); <a proj. 4-space in ProjectiveSpace(7, 3)> gap> prebs := Filtered(spread,x->Meet(x,el) <> EmptySubspace(pg));; gap> bs := List(prebs,x->PreImageElm(em,x));; gap> Length(bs); 118 gap> lines := List(Lines(ps1));; gap> Collected(List(lines,x->Length(Filtered(bs,y->y * x)))); [ [ 1, 702 ], [ 4, 117 ], [ 10, 1 ] ]
‣ NaturalEmbeddingBySubField( geom1, geom2 ) | ( operation ) |
‣ NaturalEmbeddingBySubField( geom1, geom2, boolean ) | ( operation ) |
Returns: a geometry morphism
The arguments geom1 and geom2 are projective or polar spaces of the same dimension. This function returns a geometry morphism representing the natural embedding of geom1 into geom2 as a subfield geometry. If geom1 and geom2 are polar spaces, then the only such possible embeddings are listed in the table below (see [KL90]):
| Polar Space 1 | Polar Space 2 | Conditions |
| W(2n-1,q) | W(2n-1,qa) | -- |
| W(2n-1,q) | H(2n-1,q2) | -- |
| H(d,q2) | H(d,q2r) | r odd |
| Oε(d,q) | H(d,q2) | q odd |
| Oε(d,q) | Oε'(d,qr) | ε=(ε')r |
The geometry morphism also comes equipped with an intertwiner (see Intertwiner (11.4-3)). The optional third argument boolean can take either true or false as input, and then our operation will or will not compute the intertwiner accordingly. The user may wish that the intertwiner is not computed when embedding into large polar spaces. The default (when calling the operation with two arguments) is set to true. Here is a simple example where the geometry morphism takes the points of PG(2,3) and embeds them into PG(2,9).
gap> pg1 := ProjectiveSpace(2, 3); ProjectiveSpace(2, 3) gap> pg2 := ProjectiveSpace(2, 9); ProjectiveSpace(2, 9) gap> em := NaturalEmbeddingBySubfield(pg1,pg2); <geometry morphism from <All elements of ProjectiveSpace(2, 3)> to <All elements of ProjectiveSpace(2, 9)>> gap> points := AsList(Points( pg1 )); [ <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)> ] gap> image := ImagesSet(em, points); [ <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)> ]
In this example, we embed W(5,3) in H(5,32).
gap> w := SymplecticSpace(5, 3); W(5, 3) gap> h := HermitianPolarSpace(5, 3^2); H(5, 3^2) gap> em := NaturalEmbeddingBySubfield(w, h); <geometry morphism from <Elements of W(5, 3)> to <Elements of H(5, 3^2)>> gap> points := AsList(Points(w));; gap> image := ImagesSet(em, points);; gap> ForAll(image, x -> x in h); true
‣ ProjectiveCompletion( as ) | ( operation ) |
Returns: a geometry morphism
The argument as is an affine space. This operation returns an embedding of as into the projective space ps of the same dimension, and over the same field. For example, the point (x, y, z) goes to the projective point with homogeneous coordinates (1, x, y, z). An intertwiner is unnecessary, CollineationGroup(as) is a subgroup of CollineationGroup(ps).
gap> as := AffineSpace(3,5);
AG(3, 5)
gap> map := ProjectiveCompletion(as);
<geometry morphism from <Elements of AG(3,
5)> to <All elements of ProjectiveSpace(3, 5)>>
gap> p := Random( Points(as) );
<a point in AG(3, 5)>
gap> p^map;
<a point in ProjectiveSpace(3, 5)>
‣ NaturalProjectionBySubspace( ps, v ) | ( operation ) |
‣ NaturalProjectionBySubspaceNC( ps, v ) | ( operation ) |
Returns: a geometry morphism
The argument ps is a projective or polar space, and v is a subspace of ps. In the case that ps is a projective space, this operation returns a geometry morphism from the subspaces containing v to the subspaces of a smaller projective space over the same field. Similarly, if ps is a polar space, this operation returns a geometry morphism from the totally singular subspaces containing v to a polar space of smaller dimension, but of the same polar space type. The operation NaturalProjectionBySubspaceNC performs in exactly the same way as NaturalProjectionBySubspace except that there are fewer checks such as whether v is a subspace of ps, and whether the input of the function and preimage of the returned geometry morphism is valid or not. We should also mention here a shorthand for this operation which is basically and overload of the quotient operation. So, for example, SymplecticSpace(3, 3) / v achieves the same thing as NaturalProjectionBySubspace(SymplecticSpace(3,3), v).
gap> ps := HyperbolicQuadric(5,3); Q+(5, 3) gap> x := Random(Points(ps));; gap> planes_on_x := AsList( Planes(x) ); [ <a plane in Q+(5, 3)>, <a plane in Q+(5, 3)>, <a plane in Q+(5, 3)>, <a plane in Q+(5, 3)>, <a plane in Q+(5, 3)>, <a plane in Q+(5, 3)>, <a plane in Q+(5, 3)>, <a plane in Q+(5, 3)> ] gap> proj := NaturalProjectionBySubspace(ps, x); <geometry morphism from <Elements of Q+(5, 3)> to <Elements of <polar space in ProjectiveSpace( 3,GF(3)): x_1*x_2+x_3*x_4=0 >>> gap> image := ImagesSet(proj, planes_on_x); [ <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0>, <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0>, <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0>, <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0>, <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0>, <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0>, <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0>, <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0> ]
In this section we provide some more specialised geometry morphisms, that are commonly used in finite geometry.
‣ KleinCorrespondence( f ) | ( operation ) |
‣ KleinCorrespondence( f, boolean ) | ( operation ) |
‣ KleinCorrespondence( q ) | ( operation ) |
‣ KleinCorrespondence( q, boolean ) | ( operation ) |
Returns: a geometry morphism
The argument f is a finite field, the argument q is a prime power. The first an the third version use true as value for boolean. When using true as value for the boolean, the intertwiner is computed. This variant of the operation KleinCorrespondence has always as ambient geometry of its range the hyperbolic quadric Q+(5,q) with equation X_0X_5+X_1X_4+X_2X_3 = 0. The returned geometry morphism has the lines of PG(3,q) as source and the points of Q-(5,q) as range.
gap> quadric := HyperbolicQuadric(5,3); Q+(5, 3) gap> k := KleinCorrespondence( quadric ); <geometry morphism from <lines of ProjectiveSpace(3, 3)> to <points of Q+(5, 3)>> gap> pg := ProjectiveSpace(3, 3); ProjectiveSpace(3, 3) gap> l := Random( Lines(pg) ); <a line in ProjectiveSpace(3, 3)> gap> l^k; <a point in Q+(5, 3)>
‣ KleinCorrespondence( quadric ) | ( operation ) |
‣ KleinCorrespondence( quadric, boolean ) | ( operation ) |
Returns: a geometry morphism
The argument quadric is a hyperbolic quadric in a 5 dimensional projective space. If boolean is true or not given, this operation returns the geometry morphism equipped with an intertwiner. The returned geometry morphism has the lines of PG(3,q) as source and the points of Q+(5,q) as range.
gap> quadric := HyperbolicQuadric(5,3); Q+(5, 3) gap> k := KleinCorrespondence( quadric ); <geometry morphism from <lines of ProjectiveSpace(3, 3)> to <points of Q+(5, 3)>> gap> pg := ProjectiveSpace(3, 3); ProjectiveSpace(3, 3) gap> l := Random( Lines(pg) ); <a line in ProjectiveSpace(3, 3)> gap> l^k; <a point in Q+(5, 3)> gap> id := IdentityMat(6,GF(13)); < mutable compressed matrix 6x6 over GF(13) > gap> form := QuadraticFormByMatrix(id,GF(13)); < quadratic form > gap> quadric := PolarSpace(form); <polar space in ProjectiveSpace( 5,GF(13)): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2=0 > gap> k := KleinCorrespondence( quadric ); <geometry morphism from <lines of ProjectiveSpace(3, 13)> to <points of Q+(5, 13): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2=0>> gap> pg := AmbientGeometry(Source(k)); ProjectiveSpace(3, 13) gap> l := Random(Lines(pg)); <a line in ProjectiveSpace(3, 13)> gap> l^k; <a point in Q+(5, 13): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2=0>
‣ KleinCorrespondenceExtended( quadric ) | ( operation ) |
‣ KleinCorrespondenceExtended( quadric, boolean ) | ( operation ) |
Returns: a geometry morphism
The argument quadric is a hyperbolic quadric in a 5 dimensional projective space. If boolean is true or not given, this operation returns the geometry morphism equipped with an intertwiner. The returned geometry morphism has the elements of PG(3,q) as source and the elements of Q+(5,q) as range, hence this operation is a kind of extension of KleinCorrespondence.
gap> ps := HyperbolicQuadric(5,7); Q+(5, 7) gap> em := KleinCorrespondenceExtended(ps); <geometry morphism from <All elements of ProjectiveSpace(3, 7)> to <Elements of Q+(5, 7)>> gap> hom := Intertwiner(em); MappingByFunction( The FinInG collineation group PGL(4,7), <projective colline ation group with 2 generators>, function( g ) ... end, function( g ) ... end ) gap> mat := [[0,0,0,0,0,1],[0,0,0,0,1,0],[0,0,0,1,0,0], > [0,0,1,0,0,0],[0,1,0,0,0,0],[1,0,0,0,0,0]]*Z(7)^0; [ [ 0*Z(7), 0*Z(7), 0*Z(7), 0*Z(7), 0*Z(7), Z(7)^0 ], [ 0*Z(7), 0*Z(7), 0*Z(7), 0*Z(7), Z(7)^0, 0*Z(7) ], [ 0*Z(7), 0*Z(7), 0*Z(7), Z(7)^0, 0*Z(7), 0*Z(7) ], [ 0*Z(7), 0*Z(7), Z(7)^0, 0*Z(7), 0*Z(7), 0*Z(7) ], [ 0*Z(7), Z(7)^0, 0*Z(7), 0*Z(7), 0*Z(7), 0*Z(7) ], [ Z(7)^0, 0*Z(7), 0*Z(7), 0*Z(7), 0*Z(7), 0*Z(7) ] ] gap> g := Projectivity(mat,GF(7)); < a collineation: <cmat 6x6 over GF(7,1)>, F^0> gap> g in CollineationGroup(ps); true gap> PreImageElm(hom,g); #I <el> is not inducing a collineation of PG(3,q) fail
‣ IsomorphismPolarSpacesNC( ps1, ps2 ) | ( operation ) |
‣ IsomorphismPolarSpacesNC( ps1, ps2, boolean ) | ( operation ) |
IsomorphismPolarSpacesNC is the version of IsomorphismPolarSpaces where no checks are built in, and the isomorphism between parabolic quadrics and symplectic spaces is not implemented. This version is used internally.
‣ NaturalEmbeddingBySubspaceNC( geom1, geom2, v ) | ( operation ) |
The operation NaturalEmbeddingBySubspaceNC is the ``no check'' version of NaturalEmbeddingBySubspace.
‣ BlownUpProjectiveSpace( basis, pg1 ) | ( operation ) |
Returns: a projective space
Blows up the projective space pg1 with respect to the basis using field reduction. If the argument pg1 is has projective dimension r-1 over the finite field GF(qt), and basis is a basis of GF(qt) over GF(q), then this functions returns a projective space of dimension rt-1 over GF(q).
‣ BlownUpProjectiveSpaceBySubfield( subfield, pg ) | ( operation ) |
Returns: a projective space
Blows up a projective space pg with respect to the standard basis of the basefield of pg over the subfield.
‣ BlownUpSubspaceOfProjectiveSpace( basis, subspace ) | ( operation ) |
Returns: a subspace of a projective space
Blows up a subspace of a projective space with respect to the basis using field reduction and returns it a subspace of the projective space obtained from blowing up the ambient projective space of subspace with respect to basis using field reduction.
‣ BlownUpSubspaceOfProjectiveSpaceBySubfield( subfield, subspace ) | ( operation ) |
Returns: a subspace of a projective space
Blows up a subspace of a projective space with respect to the standard basis of the basefield of subspace over the subfield, using field reduction and returns it a subspace of the projective space obtained from blowing up the ambient projective space of subspace over the subfield.
‣ IsDesarguesianSpreadElement( basis, subspace ) | ( operation ) |
Returns: true or false
Checks wether the subspace is a subspace which is obtained from a blowing up a projective point using field reduction with respect to basis.
generated by GAPDoc2HTML