GAP (FinInG) - Chapter 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 unnecessary, 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.

10.1 Geometry morphisms in FinInG

10.1-1 IsGeometryMorphism

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 \^.

10.1-2 Intertwiner

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

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 )

10.2 Type preserving bijective geometry morphisms

An important class of geometry morphisms in FinInG are the isomorphisms between polar spaces of the same kind that are induced by coordinate transformations.

10.2-1 IsomorphismPolarSpaces

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 characteristic 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 )

10.3 Klein correspondence and derived dualities

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

10.3-1 PluckerCoordinates

This operation takes a line of \(\mathrm{PG}(3,q)\) as argument. It returns the plucker coordinates of the argument as list of finite field elements. The returned list can be used in operations as vector spaceToElement, and represents a point of the hyperbolic quadric in \(\mathrm{PG}(5,q)\) with equation \(X_0X_5+X_1X_4+X_2X_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>

10.3-2 KleinCorrespondence

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 \(\mathrm{Q}^+(5,q)\) with equation The returned geometry morphism has the lines of \(\mathrm{PG}(3,q)\) as source and the points of \(\mathrm{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>

10.3-3 KleinCorrespondence

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 \(\mathrm{PG}(3,q)\) as source and the points of \(\mathrm{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>

10.3-4 KleinCorrespondenceExtended

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 \(\mathrm{PG}(3,q)\) as source (not just the lines) and the elements of \(\mathrm{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 \(\mathrm{W}(3,q)\) and \(\mathrm{Q}(4,q)\) are dual incidence structures, the same holds for the classical generalised quadrangles \(\mathrm{Q}^-(5,q)\) and \(\mathrm{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.

10.3-5 NaturalDuality

The operation allows the construction of the duality between \(\mathrm{W}(3,q)\) and \(\mathrm{Q}(4,q)\), respectively \(\mathrm{Q}^-(5,q)\), 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 \(\mathrm{W}(3,q)\), \(\mathrm{Q}(4,q)\), \(\mathrm{Q}^-(5,q)\), or \(\mathrm{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 \(\mathrm{W}(3,q)\), \(\mathrm{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.

10.3-6 SelfDuality

It is checked whether the base field of gq is a field of characteristic 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)>>

10.4 Embeddings of projective spaces

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.

10.4-1 NaturalEmbeddingBySubspace

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

10.4-2 NaturalEmbeddingBySubField

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 \(\mathrm{PG}(2,3)\) into \(\mathrm{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

10.4-3 Embedding of projective spaces by field reduction

We briefly describe the mathematics behind field reduction. For more details we refer to [LVdV13]. Consider the fields \(\mathrm{GF}(q)\) and \(\mathrm{GF}(q^t)\). The field \(\mathrm{GF}(q^t)\) is a \(t\)-dimensional vector space over \(\mathrm{GF}(q)\). Hence, with respect to a chosen basis \(B\) for \(\mathrm{GF}(q^t)\) as a \(\mathrm{GF}(q)\)-vector space, the bijection between the vector spaces \(V(n,q^t)\) and \(V(tn,q)\) can be implemented. Consider the projective space \(\mathrm{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 \(V(nt,q)\). This induces an embedding from \(\mathrm{PG}(n-1,q^t)\) into \(\mathrm{PG}(nt-1,q)\). The embedding will be determined by the chosen basis of \(\mathrm{GF}(q^t)\) as a vector space over \(\mathrm{GF}(q)\)

10.4-4 BlownUpSubspaceOfProjectiveSpace

Let B be a basis for the field \(\mathrm{GF}(q^t)\) as \(\mathrm{GF}(q)\) vector space, and let subspace be a \(k-1\)-dimensional subspace of \(\mathrm{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 \(\mathrm{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 choosing 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

10.4-5 NaturalEmbeddingByFieldReduction

This operation comes in four flavours. For the first flavour, the argument geom1 is a projective space over a field \(\mathrm{GF}(q^t)\). The argument f2 is a subfield \(\mathrm{GF}(q)\) of \(\mathrm{GF}(q^t)\). The argument \(B\) is a basis for \(\mathrm{GF}(q^t)\) as a \(\mathrm{GF}(q)\)-vector space. When this argument is not given, a basis for \(\mathrm{GF}(q^t)\) over \(\mathrm{GF}(q)\) is computed using Basis(Asvector space(GF(q),GF(q^t))). It is checked whether f2 is a subfield of the base field of geom1. The third and fourth flavour are comparable, where now \(\mathrm{GF}(q)\) is found as the base field of geom2. In fact the arguments geom1 and geom2 are the projective spaces \(\mathrm{PG}(n-1,q^t)\) and \(\mathrm{PG}(nt-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 restricting the homomorphism to the homography group, which differs 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

10.5 Embeddings of polar spaces

10.5-1 NaturalEmbeddingBySubspace

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

10.5-2 NaturalEmbeddingBySubField

The arguments geom1 and geom2 are projective or polar spaces with an underlying vector space of the same dimension and the base field \(L\) of geom2 is an extension of the base field \(K\) of geom1. The form \(f\) determining geom1 also defines a form over \(L\), and determines a polar space. By considering the underlying vector spaces 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]):

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

10.5-3 Embedding of polar spaces by field reduction

Field reduction for polar spaces is somewhat more involved than for projective spaces, and we give a brief description. Let \(L\) be the field \(\mathrm{GF}(q^t)\) and let \(K\) be the field \(\mathrm{GF}(q)\) Let \(P\) be a polar space over a field \(L\). Let \(f\) be the form on the \(r\) dimensional vector space \(V\) over \(L\) determining \(P\). Consider the trace map

Consider the \(rt\) dimensional vector space \(W\) over \(K\). There is a bijective map \(\Phi\): \(V \to W\) and \(T_{\alpha} \circ f \circ \Phi^{-1}\) defines a quadratic or sesquilinear form (depending on \(\alpha\), 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 \(S\) is dependent on the original form \(f\), the parameter \(\alpha\) 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\), \(\alpha\) and a basis for \(L\) as \(K\) vector space. Then the resulting form \(T_{\alpha} \circ f \circ \Phi^{-1}\) is determined, and the associated polar space \(S\) 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 whether an embedding based on the above described principle is possible, and the necessary parameters are computed. The resulting embedding is a geometry morphism 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.

For more information on the embeddings by field reduction of polar spaces, including conditions on the parameter \(\alpha\), we refer to [Gil08] and [LVdV13]. The possible embeddings are listed in the following table.

**Table:** Field reduction of polar spaces
Polar Space 1	Polar Space 2	Conditions
\(\mathrm{W}(2n-1,q^t)\)	\(\mathrm{W}(2nt-1,q)\)	--
\(\mathrm{Q}^+(2n-1,q^t)\)	\(\mathrm{Q}^+(2nt-1,q)\)	--
\(\mathrm{Q}^-(2n-1,q^t)\)	\(\mathrm{Q}^-(2nt-1,q)\)	--
\(\mathrm{Q}(2n,q^{2a+1})\)	\(\mathrm{Q}((2a+1)(2n+1)-1,q)\)	\(q\) odd
\(\mathrm{Q}(2n,q^{2a})\)	\(\mathrm{Q}^-(2a(2n+1)-1,q)\)	\(q \equiv 1 \pmod{4}\)
\(\mathrm{Q}(2n,q^{4a+2})\)	\(\mathrm{Q}^+((4a+2)(2n+1)-1,q)\)	\(q \equiv 3 \pmod{4}\)
\(\mathrm{Q}(2n,q^{4a})\)	\(\mathrm{Q}^-(4a(2n+1)-1,q)\)	\(q \equiv 3 \pmod{4}\)
\(\mathrm{H}(n,q^{2a+1})\)	\(\mathrm{H}((2a+1)(n+1)-1,q)\)	\(q\) square
\(\mathrm{H}(n,q^{2a})\)	\(\mathrm{W}(2a(n+1)-1,q)\)	\(q\) even
\(\mathrm{H}(2n,q^{2a})\)	\(\mathrm{Q}^-(2a(2n+1)-1,q)\)	\(q\) odd
\(\mathrm{H}(2n+1,q^{2a})\)	\(\mathrm{Q}^+(2a(2n+2)-1,q)\)	\(q\) odd

10.5-4 NaturalEmbeddingByFieldReduction

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(Asvector space(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 \(\mathrm{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 ] ]

10.5-5 NaturalEmbeddingByFieldReduction

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

10.6 Projections

10.6-1 NaturalProjectionBySubspace

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 base field, 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 base field, 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> ]

10.7 Projective completion

10.7-1 ProjectiveCompletion

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

Polar Space 1	Polar Space 2	Conditions
\(\mathrm{W}(2n-1,q)\)	\(\mathrm{W}(2n-1,q^a)\)	--
\(\mathrm{W}(2n-1,q)\)	\(\mathrm{H}(2n-1,q^a)\)	--
\(\mathrm{H}(d,q^2)\)	\(\mathrm{H}(d,q^{2r})\)	\(r\) odd
\(\mathrm{O}^{\epsilon}(d,q)\)	\(\mathrm{H}(d,q^2)\)	\(q\) odd
\(\mathrm{O}^{\epsilon}(d,q)\)	\(\mathrm{O}^{\epsilon'}(d,q^r)\)	\(\epsilon=(\epsilon')^r\)

10 Geometry Morphisms