10 Geometry Morphisms

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 situations in **GAP**, the right thing to do is to embed one projective space into another, rather than having one projective space automatically as 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 described 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.

Note that quite some technicalities are needed in the implementation of some geometry morphisms. This chapters deals only with the user interface. Some low level functions for geometry morphisms are described in Appendix C.

`‣ 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 `ImageElm`

, and `PreImageElm`

, have methods installed for geometry morphisms, as well as the overload operator `\^`

.

`‣ 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). 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(p^{g})=f(p)^{φ(g)}.

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). This will make the attribute `Intertwiner`

available. Here is a simple example of the intertwiner for the isomorphism of two polar spaces (see `IsomorphismPolarSpaces`

(10.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`

(10.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 )

The Klein correspondence is a well known geometry morphism from the lines of PG(3,q) to the points of a hyperbolic quadric in PG(5,q). This morphism and some derived morphisms are provided in **FinInG**. The bare essential of the Klein corresondence is the so-called Plücker map.

`‣ PluckerCoordinates` ( line ) | ( operation ) |

This operation takes a line of PG(3,q) as argument. It returns the plucker coordinates of the argument as list of finite field elements. The retured list can be used in operations as `VectorSpaceToElement`

, and represents a point of the hyperbolic quadric in PG(5,q) with equation X_{0}X_{5}+X_{1}X_{4}+X_{2}X_{3} = 0

gap> pg := PG(3,169); ProjectiveSpace(3, 169) gap> l := Random(Lines(pg)); <a line in ProjectiveSpace(3, 169)> gap> vec := PluckerCoordinates(l); [ Z(13)^0, Z(13^2)^138, Z(13^2)^93, Z(13^2)^53, Z(13^2)^71, Z(13^2)^106 ] gap> mat := [[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(13)^0; [ [ 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), Z(13)^0 ], [ 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), Z(13)^0, 0*Z(13) ], [ 0*Z(13), 0*Z(13), 0*Z(13), Z(13)^0, 0*Z(13), 0*Z(13) ], [ 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13) ], [ 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13) ], [ 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13) ] ] gap> form := QuadraticFormByMatrix(mat,GF(169)); < quadratic form > gap> klein := PolarSpace(form); <polar space in ProjectiveSpace(5,GF(13^2)): x_1*x_6+x_2*x_5+x_3*x_4=0 > gap> VectorSpaceToElement(klein,vec); <a point in Q+(5, 169): x_1*x_6+x_2*x_5+x_3*x_4=0>

`‣ 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_{0}X_{5}+X_{1}X_{4}+X_{2}X_{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> k := KleinCorrespondence( 9 ); <geometry morphism from <lines of ProjectiveSpace(3, 9)> to <points of Q+(5, 9): x_1*x_6+x_2*x_5+x_3*x_4=0>> gap> Intertwiner(k); MappingByFunction( The FinInG collineation group PGammaL(4,9), <projective col lineation group with 3 generators>, function( g ) ... end, function( g ) ... end ) gap> pg := ProjectiveSpace(3, 9); ProjectiveSpace(3, 9) gap> AmbientGeometry(Range(k)); Q+(5, 9): x_1*x_6+x_2*x_5+x_3*x_4=0 gap> l := Random( Lines(pg) ); <a line in ProjectiveSpace(3, 9)> gap> l^k; <a point in Q+(5, 9): x_1*x_6+x_2*x_5+x_3*x_4=0>

`‣ 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 all the elements of PG(3,q) as source (not just the lines) 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

It is well known that the classical generalised quadrangles W(3,q) and Q(4,q) are dual incidence structures, the same holds for the classical generalised quadrangles Q^{-}(5,q) and H(3,q^{2}). Essentially, these dual dualities are based on the Klein correspondence, and 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), or H(3,q^{2}), in two directions. It is checked if the arguments are appropriate, i.e. the right type of generalised quadrangle(s). 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 elliptic 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 third version requires only one argument, either W(3,q), Q(4,q), Q^{-}(5,q), or H(3,q^{2}), standard or user specified 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 version 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); <geometry morphism from <Elements of W(3, 5)> to <Elements 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)> gap> hom := Intertwiner(duality); MappingByFunction( PGammaSp(4,5), <projective collineation group of size 9360000 with 4 generators>, function( g ) ... end, function( g ) ... end ) gap> q := 5; 5 gap> q5q := EllipticQuadric(5,q); Q-(5, 5) gap> mat := [[0,1,0,0],[1,0,0,0],[0,0,0,Z(q)],[0,0,Z(q),0]]*Z(q)^0; [ [ 0*Z(5), Z(5)^0, 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), Z(5) ], [ 0*Z(5), 0*Z(5), Z(5), 0*Z(5) ] ] gap> hform := HermitianFormByMatrix(mat,GF(q^2)); < hermitian form > gap> herm := PolarSpace(hform); <polar space in ProjectiveSpace( 3,GF(5^2)): x1^5*x2+x1*x2^5+Z(5)*x3^5*x4+Z(5)*x3*x4^5=0 > gap> duality := NaturalDuality(q5q,herm,true); <geometry morphism from <Elements of Q-(5, 5)> to <Elements of H(3, 5^2): x1^5*x2+x1*x2^5+Z(5)*x3^5*x4+Z(5)*x3*x4^5=0>> gap> hom := Intertwiner(duality); MappingByFunction( PDeltaO-(6,5), <projective collineation group of size 58968000000 with 3 generators>, function( g ) ... end, function( g ) ... end ) gap> g := Random(CollineationGroup(q5q)); < a collineation: <cmat 6x6 over GF(5,1)>, F^0> gap> g^hom; < a collineation: <cmat 4x4 over GF(5,2)>, F^5>

The combination of the isomorphism of the GQs W(3,q), Q(4,q) when q is even and the duality between the same GQs, yields a duality from each of these GQs itself. The operation `SelfDuality`

implements this combination.

`‣ SelfDuality` ( gq ) | ( operation ) |

`‣ SelfDuality` ( gq, boolean ) | ( operation ) |

Returns: a geometry morphism

It is checked wheter the base field of `gq` is a field of charateristic 2 and whether `gq` is a symplectic generalised quadrangle in 3-dimensional projective space or a parabolic quadric in 4-dimensional projective space. The first version will return, when possible, a geometry morphism equipped with an intertwiner. Using the boolean argument `false` will return a geometry morphism that is not equipped with an intertwiner. The example shows the use of the boolean argument.

gap> q := 16; 16 gap> mat := [[0,1,0,0,0],[0,0,0,0,0],[0,0,1,0,0],[0,0,0,0,0],[0,0,0,1,0]]*Z(q)^0; [ [ 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2) ], [ 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2) ], [ 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2) ], [ 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2) ], [ 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2) ] ] gap> form := QuadraticFormByMatrix(mat,GF(q)); < quadratic form > gap> q4q := PolarSpace(form); <polar space in ProjectiveSpace(4,GF(2^4)): x_1*x_2+x_3^2+x_4*x_5=0 > gap> em := SelfDuality(q4q); #I No intertwiner computed. The polar space must have a collineation group computed <geometry morphism from <Elements of Q(4, 16): x_1*x_2+x_3^2+x_4*x_5=0> to <Elements of Q(4, 16): x_1*x_2+x_3^2+x_4*x_5=0>> gap> CollineationGroup(q4q); #I Computing collineation group of canonical polar space... <projective collineation group of size 4380799795200 with 3 generators> gap> em := SelfDuality(q4q); <geometry morphism from <Elements of Q(4, 16): x_1*x_2+x_3^2+x_4*x_5=0> to <Elements of Q(4, 16): x_1*x_2+x_3^2+x_4*x_5=0>> gap> hom := Intertwiner(em); MappingByFunction( <projective collineation group of size 4380799795200 with 3 generators>, <projective collineation group of size 4380799795200 with 3 generators>, function( el ) ... end, function( el ) ... end ) gap> q := 16; 16 gap> w := SymplecticSpace(3,q); W(3, 16) gap> em := SelfDuality(w); <geometry morphism from <Elements of W(3, 16)> to <Elements of W(3, 16)>>

The most natural of geometry morphisms include, for example, the embedding of a projective space into another via a subspace, the embedding of a projective space over a field into a projective space of the same dimension over an extended field, or the embedding of a projective space over a field into a projective space of higher dimension over a subfield through so-called field reduction.

`‣ NaturalEmbeddingBySubspace` ( geom1, geom2, v ) | ( operation ) |

Returns: a geometry morphism

The arguments `geom1` and `geom2` are both projective spaces, and `v` is an element of a geom2. 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)>

`‣ NaturalEmbeddingBySubField` ( geom1, geom2 ) | ( operation ) |

`‣ NaturalEmbeddingBySubField` ( geom1, geom2, boolean ) | ( operation ) |

Returns: a geometry morphism

The arguments `geom1` and `geom2` are projective spaces of the same dimension. This function returns a geometry morphism representing the natural embedding of `geom1` into `geom2` as a subfield geometry. The geometry morphism also comes equipped with an intertwiner (see `Intertwiner`

(10.1-2)). 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 default (when calling the operation with two arguments) is set to `true`

. Note that the source of the intertwiner is the projectivity group of `geom1` and its range is a subgroup of the projectivity group of `geom2`. Here is a simple example where the geometry morphism embeds PG(2,3) into PG(2,9).

gap> pg1 := PG(2,3); ProjectiveSpace(2, 3) gap> pg2 := PG(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)> ] gap> hom := Intertwiner(em); MappingByFunction( The FinInG projectivity group PGL(3,3), <projective colline ation group of size 5616 with 2 generators>, function( x ) ... end, function( y ) ... end ) gap> group1 := ProjectivityGroup(pg1); The FinInG projectivity group PGL(3,3) gap> gens := GeneratorsOfGroup(group1); [ < a collineation: <cmat 3x3 over GF(3,1)>, F^0>, < a collineation: <cmat 3x3 over GF(3,1)>, F^0> ] gap> group1_image := Group(List(gens,x->x^hom)); <projective collineation group with 2 generators> gap> Order(group1_image); 5616 gap> group2 := ProjectivityGroup(pg2); The FinInG projectivity group PGL(3,9) gap> Order(group2); 42456960 gap> g := Random(group2); < a collineation: <cmat 3x3 over GF(3,2)>, F^0> gap> PreImageElm(hom,g); #I <el> is not in the range of the intertwiner fail

We briefly describe the mathematics behind field reduction. For more details we refer to [LV13]. Consider the fields K=GF(q) and L=GF(q^{t}). The field L is a t-dimensional vector space over K. Hence, with respect to a chosen basis B for L as a K-vectorspace, the bijection between the vectorspaces V(n,q^{t}) and V(tn,q) can be implemented. Consider the projective space PG(n-1,q^{t}). The elements are represented by subspaces of V(n,q^{t}). Clearly, a k dimensional subspace of V(n,q^{t}) is also a kn-dimensional subspace of the V(nt,q). This induces an embedding from PG(n-1,q^{t}) into PG(nt-1,q). The embedding will be determined by the chosen basis of L as a vector space over GF(q).

`‣ BlownUpSubspaceOfProjectiveSpace` ( B, subspace ) | ( operation ) |

Returns: a subspace of a projective space

Let `B` be a basis for the field L=GF(q^{t}) as GF(q) vector space, and let `subspace` be a k-1-dimensional subspace of PG(n-1,q^{t}) represented by a k-dimensional subspace S of V(n,q^{t}). This operation returns the kt-1-dimensional subspace of PG(nt-1,q) represented by blowing up S with respect to the base `B`. This operation relies on the **GAP** operation `BlownUpMat`

. In the example, the effect of chosen a different basis is shown.

gap> pg := PG(3,5^2); ProjectiveSpace(3, 25) gap> basis := Basis(AsVectorSpace(GF(5),GF(5^2))); CanonicalBasis( GF(5^2) ) gap> line := Random(Lines(pg)); <a line in ProjectiveSpace(3, 25)> gap> solid1 := BlownUpSubspaceOfProjectiveSpace(basis,line); <a solid in ProjectiveSpace(7, 5)> gap> BasisVectors(basis); [ Z(5)^0, Z(5^2) ] gap> basis := Basis(AsVectorSpace(GF(5),GF(5^2)),[Z(5),Z(5^2)^8]); Basis( GF(5^2), [ Z(5), Z(5^2)^8 ] ) gap> solid2 := BlownUpSubspaceOfProjectiveSpace(basis,line); <a solid in ProjectiveSpace(7, 5)> gap> solid1 = solid2; false

`‣ 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(q^{t}). 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,q^{t}) and PG(rt-1,q) respectively. As in the previous flavours, the argument `B` is optional.

An intertwiner is always available for this geometry morphism, and has source the homography group of `geom1` and as range a subgroup of the homography group of `geom2` (or the projective space of the appropriate dimension over `f2`. 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 := 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)>> 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 with 3 generators> 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

`‣ NaturalEmbeddingBySubspace` ( geom1, geom2, v ) | ( operation ) |

Returns: a geometry morphism

The arguments `geom1` and `geom2` both polar spaces, and `v` is an element of a projective space. This function returns a geometry morphism representing the natural embedding of `geom1` into the intersection of `geom2` and `v`. Hence the intersection of `geom2` and `v` must induce a polar space of the same type as `geom1` in `v`. This operation performs all necessary checks. An Intertwiner is not implemented for this geometry morphism.

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)>> gap> ps1 := ParabolicQuadric(4,4); Q(4, 4) gap> ps2 := ParabolicQuadric(6,4); Q(6, 4) gap> pg := AmbientSpace( ps2 ); ProjectiveSpace(6, 4) gap> pi := VectorSpaceToElement( pg, [[1,0,0,0,0,0,0],[0,1,0,0,0,0,0],[0,0,1,0,0,0,0], > [0,0,0,1,0,0,0],[0,0,0,0,1,0,0]] * Z(4)^0 ); <a proj. 4-space in ProjectiveSpace(6, 4)> gap> em := NaturalEmbeddingBySubspace( ps1, ps2, pi ); <geometry morphism from <Elements of Q(4, 4)> to <Elements of Q(6, 4)>> gap> List(Lines(ps1),x->x^em); [ <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)> ]

`‣ NaturalEmbeddingBySubField` ( geom1, geom2 ) | ( operation ) |

`‣ NaturalEmbeddingBySubField` ( geom1, geom2, boolean ) | ( operation ) |

Returns: a geometry morphism

The arguments `geom1` and `geom2` are projective or polar spaces with an underlying vector space of the same dimension and the basefield L of `geom2` is an extension of the basefield K of `geom1`. The form f determining `geom1` also defines a form over L, and determines a polar space. By considering the underlying vectorspaces determining the elements of `geom1` over the extension field L, there is an obvious embedding of `geom1` in the polar space over the extension field. Considering f over a field extension might change its type. The possible embeddings, where the polar spaces may be chosen up to equivalent form, are listed in the table below (see [KL90]):

Polar Space 1 | Polar Space 2 | Conditions |

W(2n-1,q) | W(2n-1,q^{a}) |
-- |

W(2n-1,q) | H(2n-1,q^{2}) |
-- |

H(d,q^{2}) |
H(d,q^{2r}) |
r odd |

O^{ε}(d,q) |
H(d,q^{2}) |
q odd |

O^{ε}(d,q) |
O^{ε'}(d,q^{r}) |
ε=(ε')^{r} |

The geometry morphism also comes equipped with an intertwiner (see `Intertwiner`

(10.1-2)). 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. When set `true`

, the intertwiner will be computed if `HasCollineationGroup(geom1)`

is true. The user may wish that the intertwiner is not computed when embedding large polar spaces. The default (when calling the operation with two arguments) is set to `true`

.

gap> w := SymplecticSpace(5, 3); W(5, 3) gap> h := HermitianPolarSpace(5, 3^2); H(5, 3^2) gap> em := NaturalEmbeddingBySubfield(w, h); #I No intertwiner computed. <geom1> must have a collineation group computed <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 gap> hq:=HyperbolicQuadric(3,4); Q+(3, 4) gap> eq:=EllipticQuadric(3,2); Q-(3, 2) gap> em:=NaturalEmbeddingBySubfield(eq,hq); #I No intertwiner computed. <geom1> must have a collineation group computed <geometry morphism from <Elements of Q-(3, 2)> to <Elements of Q+(3, 4)>> gap> eqpts:=ImagesSet(em,AsList(Points(eq))); [ <a point in Q+(3, 4)>, <a point in Q+(3, 4)>, <a point in Q+(3, 4)>, <a point in Q+(3, 4)>, <a point in Q+(3, 4)> ]

Field reduction for polar spaces is somewhat more involved than for projective spaces, and we give a brief description. Let P be a polar space over a field GF(q^{t}) and let K=GF(q). Let f be the form on the r dimensional vector space V over L determining P. Consider the trace map T: GF(q^{t}) → GF(q): x → x^{qt} + x^{qt-1} + … x. Define for any α ∈ L the map T_{α}: GF(q^{t})→ GF(q): x → T(α x). Consider the rt dimensional vector space W over K. There is a bijective map Φ from V to W and T_{α} • f • Φ ^{-1} defines a quadratic or sesquilinear form (depending on α, and f being quadratic or sesquilinear) acting on W, and hence, if not singular or degenerate, inducing a polar space S over the finite field GF(q). An element of P can be mapped onto an element of S by simply blowing up P using field reduction for projective spaces. So the resulting polar space W is dependent on the original form f, the parameter α and the blowing up of elements by field reduction, the latter being dependent on the basis of L as a K vector space. **FinInG** provides two approaches. The first approach starts from P and the parameters K, α and a basis for L as K vector space. Then the resulting form T_{α} • f • Φ ^{-1} is determined, and the associated polar space W will be the range of the embedding. Note that the resulting polar space will not necessarily be canonical. The second approach starts from two given polar spaces P and S. Based on this input, it is determined wheter an embedding based on the above described principle is possible, and the necessary parameters are computed. The resulting embedding is a geometry morhpism from P to S. Note that the polar spaces used as an argument may be freely chosen and are not required to be in the canonical form.

Fo the embeddings by field reduction of polar spaces, including conditions on the parameter α, we refer to [Gil08] and [LV13]. The possible embeddings are listed in the following table.

Polar Space 1 | Polar Space 2 | Conditions |

W(2n-1,q^{t}) |
W(2nt-1,q) | -- |

Q^{+}(2n-1,q^{t}) |
Q^{+}(2nt-1,q) |
-- |

Q^{-}(2n-1,q^{t}) |
Q^{-}(2nt-1,q) |
-- |

Q(2n,q^{2a+1}) |
Q((2a+1)(2n+1)-1,q) | q odd |

Q(2n,q^{2a}) |
Q^{-}(2a(2n+1)-1,q) |
q=1 mod 4 |

Q(2n,q^{4a+2}) |
Q^{+}((4a+2)(2n+1)-1,q) |
q=3 mod 4 |

Q(2n,q^{4a}) |
Q^{-}(4a(2n+1)-1,q) |
q=3 mod 4 |

H(n,q^{2a+1}) |
H((n+1)(2a+1)-1,q) | q square |

H(n,q^{2a}) |
W(2a(n+1)-1,q) | q even |

H(2n,q^{2a}) |
Q^{-}(2a(2n+1)-1,q) |
q odd |

H(2n+1,q^{2a}) |
Q^{+}(2a(2n+2)-1,q) |
q odd |

`‣ NaturalEmbeddingByFieldReduction` ( ps1, f2, alpha, basis, bool ) | ( operation ) |

`‣ NaturalEmbeddingByFieldReduction` ( ps1, f2, alpha, basis ) | ( operation ) |

`‣ NaturalEmbeddingByFieldReduction` ( ps1, f2, alpha, bool ) | ( operation ) |

`‣ NaturalEmbeddingByFieldReduction` ( ps1, f2, alpha ) | ( operation ) |

`‣ NaturalEmbeddingByFieldReduction` ( ps1, f2, bool ) | ( operation ) |

`‣ NaturalEmbeddingByFieldReduction` ( ps1, f2 ) | ( operation ) |

Returns: a geometry morphism

`ps1` is a polar space over a field extension L of `f2`, `basis` is a basis for L over `f2`, `alpha` is a non-zero element of L. The version of `NaturalEmbeddingByFieldReduction`

implements the first approach as explained in 10.5-3. When no argument `basis` is given, a basis for L over `f2` is computed using `Basis(AsVectorSpace(K,L))`

. When no argument `alpha` is given, `One(f2)`

is used as value for `alpha`. When `bool` is true or not given, an intertwiner is computed, when `bool` is `false`, no intertwiner is computed. This intertwiner has as its domain the **isometry group** of `ps1`. The user may wish that the intertwiner is not computed when embedding 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( PSp(2,27), <projective collineation group of size 9828 with 2 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 ] ]

`‣ NaturalEmbeddingByFieldReduction` ( ps1, ps2, bool ) | ( operation ) |

`‣ NaturalEmbeddingByFieldReduction` ( ps1, ps2 ) | ( operation ) |

Returns: a geometry morphism

If `ps1` and `ps2` are two polar spaces which are suitable for field reduction as listed in the table with possible embeddings in Section 10.5-3, then this operation returns the corresponding embedding. An intertwiner is computed if the third argument `bool` is true, or if there is no third argument. This intertwiner has as its domain the **isometry group** of `ps1`. The example shows two cases where a spread is computed, including a subgroup of its stabiliser group using the intertwiner.

gap> ps1 := SymplecticSpace(1,5^3); W(1, 125) gap> ps2 := SymplecticSpace(5,5); W(5, 5) gap> em := NaturalEmbeddingByFieldReduction(ps1,ps2); #I These polar spaces are suitable for field reduction <geometry morphism from <Elements of W(1, 125)> to <Elements of W(5, 5)>> gap> pts := Points(ps1); <points of W(1, 125)> gap> spread := List(pts,x->x^em);; gap> test := Union(List(spread,x->List(Points(x))));; gap> Set(test)=Set(AsList(Points(ps2))); true gap> hom := Intertwiner(em); MappingByFunction( PSp(2,125), <projective collineation group of size 976500 with 2 generators>, function( m ) ... end, function( m ) ... end ) gap> group := IsometryGroup(ps1); PSp(2,125) gap> Order(group); 976500 gap> gens := List(GeneratorsOfGroup(group),x->x^hom); [ < a collineation: <cmat 6x6 over GF(5,1)>, F^0>, < a collineation: <cmat 6x6 over GF(5,1)>, F^0> ] gap> group2 := Range(hom); <projective collineation group of size 976500 with 2 generators> gap> Order(group2); 976500 gap> biggroup := CollineationGroup(ps2); PGammaSp(6,5) gap> stab := FiningSetwiseStabiliser(biggroup,spread); #I Computing adjusted stabilizer chain... <projective collineation group with 7 generators> gap> time; 6907 gap> Order(stab); 5859000 gap> ps1 := HermitianPolarSpace(2,7^2); H(2, 7^2) gap> ps2 := EllipticQuadric(5,7); Q-(5, 7) gap> em := NaturalEmbeddingByFieldReduction(ps1,ps2); #I These polar spaces are suitable for field reduction <geometry morphism from <Elements of H(2, 7^2)> to <Elements of Q-(5, 7)>> gap> pts := Points(ps1); <points of H(2, 7^2)> gap> spread := List(pts,x->x^em);; gap> test := Union(List(spread,x->List(Points(x))));; gap> Set(test)=Set(AsList(Points(ps2))); true gap> hom := Intertwiner(em); MappingByFunction( PGU(3,7^2), <projective collineation group of size 5663616 with 2 generators>, function( m ) ... end, function( m ) ... end ) gap> group := IsometryGroup(ps1); PGU(3,7^2) gap> Order(group); 5663616 gap> gens := List(GeneratorsOfGroup(group),x->x^hom); [ < a collineation: <cmat 6x6 over GF(7,1)>, F^0>, < a collineation: <cmat 6x6 over GF(7,1)>, F^0> ] gap> group2 := Range(hom); <projective collineation group of size 5663616 with 2 generators> gap> Order(group2); 5663616 gap> biggroup := CollineationGroup(ps2); PDeltaO-(6,7) gap> stab := FiningSetwiseStabiliser(biggroup,spread); #I Computing adjusted stabilizer chain... <projective collineation group with 10 generators> gap> time; 3438 gap> Order(stab); 90617856

`‣ NaturalProjectionBySubspace` ( 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, the geometry of subspaces containing `v` is a projective space of lower dimension over the same basefield, and this operation returns the corresponding geometry morphism. In the case that `ps` is a polar space, the geometry of elements pf `ps` containing `v` is a polar space of lower rank and of the same type over the same basefield, and this operation returns the corresponding geometry morphism. It is checked 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. There is a shorthand for this operation which is basically an overload of the quotient operation. So, for example, `ps / v`

achieves the same thing as `AmbientGeometry(Range(NaturalProjectionBySubspace(ps, v)))`

. An intertwiner is not available for this geometry morphism.

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> ]

`‣ 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) is mapped onto 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)>

generated by GAPDoc2HTML