Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 A B C Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

12 Generalised Polygons
 12.1 Categories
 12.2 Generic functions to create generalised polygons
 12.3 Attributes and operations for generalised polygons
 12.4 Elements of generalised polygons
 12.5 The classical generalised hexagons
 12.6 Elation generalised quadrangles

12 Generalised Polygons

A generalised n-gon is a point/line geometry whose incidence graph is bipartite of diameter n and girth 2n. Although these rank 2 structures are very much a subdomain of GRAPE and Design, their significance in finite geometry warrants their inclusion in FinInG. By the famous theorem of Feit and Higman, a generalised n-gon which has at least three points on every line, must have \(n\) in \(\{2,3,4,6,8\}\). The case \(n=2\) concerns the complete multipartite graphs, which we disregard. The more interesting cases are accordingly projective planes (\(n=3\)), generalised quadrangles (\(n=4\)), generalised hexagons (\(n=6\)), and generalised octagons (\(n=8\)).

FinInG provides some basic functionality to deal with generalised polygons as incidence geometries. A lot of non-trivial interaction with the package GRAPE has been very useful and even necessary. Currently, generic functions to create generalised polygons, to create elements of generalised polygons, and to explore the elements are implemented. This generic functionality allows the user to construct generalised polygons through many different objects available in GAP and FinInG. Apart from these generic functions, some particular generalised polygons are available: the classical generalised hexagons and elation generalised quadrangles from different perspectives can be constructed.

12.1 Categories

12.1-1 IsGeneralisedPolygon
‣ IsGeneralisedPolygon( category )
‣ IsGeneralisedPolygonRep( representation )

This category is a subcategory of IsIncidenceGeometry, and contains all generalised polygons. Generalised polygons constructed through functions described in this chapter, all belong to IsGeneralisedPolygonRep.

12.1-2 Subcategories in IsGeneralisedPolygon
‣ IsProjectivePlaneCategory( category )
‣ IsGeneralisedQuadrangle( category )
‣ IsGeneralisedHexagon( category )
‣ IsGeneralisedOctagon( category )

All generalised polygons in FinInG belong to one of these four categories. It is not possible to construct generalised polygons of which the gonality is not known (or checked). Note that the classical generalised quadrangles (which are the classical polar spaces of rank 2) belong also to IsGeneralisedQuadrangle and that the desarguesian projective planes (which are the projective spaces of dimension 2) also belong to IsProjectivePlaneCategory, but both do not belong to IsGeneralisedPolygonRep.

12.1-3 IsWeakGeneralisedPolygon
‣ IsWeakGeneralisedPolygon( category )

IsWeakGeneralisedPolygon is the category for weak generalised polygons.

12.1-4 Subcategories in IsProjectivePlaneCategory
‣ IsDesarguesianPlane( category )

IsDesarguesianPlane is declared as a subcategory of IsProjectivePlaneCategory and IsProjecticeSpace. Projective spaces of dimension 2 constructed using ProjectiveSpace belong to IsDesarguesianPlane.

12.1-5 Subcategories in IsGeneralisedQuadrangle
‣ IsClassicalGQ( category )
‣ IsElationGQ( category )

IsClassicalGQ is declared as a subcategory of IsGeneralisedQuadrangle and IsClassicalPolarSpace. All classical polar spaces of rank 2 belong to IsClassicalGQ. IsElationGQ is declared as subcategory of IsGeneralisedQuadrangle. Elation GQs will be discusedd in detail in Section 12.6

gap> gp := SymplecticSpace(3,2);
W(3, 2)
gap> IsGeneralisedPolygon(gp);
true
gap> IsGeneralisedQuadrangle(gp);
true
gap> IsClassicalGQ(gp);
true
gap> IsGeneralisedPolygonRep(gp);
false

12.1-6 IsClassicalGeneralisedHexagon
‣ IsClassicalGeneralisedHexagon( category )

IsClassicalGeneralisedHexagon is declared as subcategory of IsGeneralisedHexagon and IsLieGeometry. The so called classical generalised hexagons are the hexagons that come from the triality of the hyperbolic quadric \(\mathrm{Q}^+(7,q)\). The Split Cayley hexagon is embedded in the parabolic quadric \(\mathrm{Q}(6,q)\), or \(\mathrm{W}(5,q)\) in even characteristic. The twisted triality hexagon is embedded in the hyperbolic quadric \(\mathrm{Q}^+(7,q)\). The construction of these hexagons in a subcategory of IsLieGeometry means that the usual operations for Lie geometries become applicable. The classical generalised hexagons are in detail discussed in Section 12.5

gap> gp := SplitCayleyHexagon(3);
H(3)
gap> IsGeneralisedHexagon(gp);
true
gap> IsClassicalGeneralisedHexagon(gp);
true
gap> IsLieGeometry(gp);
true
gap> IsGeneralisedPolygonRep(gp);
true

12.2 Generic functions to create generalised polygons

12.2-1 GeneralisedPolygonByBlocks
‣ GeneralisedPolygonByBlocks( l )( operation )

Returns: a generalised polygon

The argument l is a finite homogeneous list consisting of ordered sets of a common size \(n+1\). This operation will assume that each element of l represents a line of the generalised polygon. Its points are assumed to be the union of all elements of l. The incidence is assumed to be symmetrised containment. From this information, an incidence graph is computed using GRAPE. If this graph has diameter \(d\) and girth \(2d\), a generalised polygon is returned. The thickness condition is not checked. If \(d \in \{3,4,6,8\}\), a projective plane, a generalised quadrangle, a generalised hexagon, a generalised octagon respectively, is returned. Note that for large input, this operation can be time consuming.

gap> blocks := [ 
>   [ 1, 2, 3, 4, 5 ], [ 1, 6, 7, 8, 9 ], [ 1, 10, 11, 12, 13 ],
>   [ 1, 14, 15, 16, 17 ], [ 1, 18, 19, 20, 21 ], [ 2, 6, 10, 14, 18 ], 
>   [ 2, 7, 11, 15, 19 ], [ 2, 8, 12, 16, 20 ], [ 2, 9, 13, 17, 21 ], 
>   [ 3, 6, 11, 16, 21 ], [ 3, 7, 10, 17, 20 ], [ 3, 8, 13, 14, 19 ], 
>   [ 3, 9, 12, 15, 18 ], [ 4, 6, 12, 17, 19 ], [ 4, 7, 13, 16, 18 ], 
>   [ 4, 8, 10, 15, 21 ], [ 4, 9, 11, 14, 20 ], [ 5, 6, 13, 15, 20 ], 
>   [ 5, 7, 12, 14, 21 ], [ 5, 8, 11, 17, 18 ], [ 5, 9, 10, 16, 19 ] ];;
gap> gp := GeneralisedPolygonByBlocks( blocks );
<projective plane order 4>

12.2-2 GeneralisedPolygonByIncidenceMatrix
‣ GeneralisedPolygonByIncidenceMatrix( incmat )( operation )

Returns: a generalised polygon

The argument \(incmat\) is a matrix representing the incidence matrix of a point line geometry. The points are represented by the columns, the rows represent the lines. From incmat a homogeneous list of sets of column entries is derived, which is then passed to GeneralisedPolygonByBlocks. When incmat indeed represents a generalised polygon, it is returned. The checks are performed by GeneralisedPolygonByBlocks.

gap> incmat := [ 
>   [ 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], 
>   [ 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], 
>   [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 ], 
>   [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0 ], 
>   [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1 ], 
>   [ 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0 ], 
>   [ 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0 ], 
>   [ 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0 ], 
>   [ 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1 ], 
>   [ 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ], 
>   [ 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0 ], 
>   [ 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0 ], 
>   [ 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0 ], 
>   [ 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0 ], 
>   [ 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0 ], 
>   [ 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1 ], 
>   [ 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0 ], 
>   [ 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0 ], 
>   [ 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1 ], 
>   [ 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0 ], 
>   [ 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0 ] ];;
gap> pp := GeneralisedPolygonByIncidenceMatrix( incmat );
<projective plane order 4>

12.2-3 GeneralisedPolygonByElements
‣ GeneralisedPolygonByElements( pts, lns, inc )( operation )
‣ GeneralisedPolygonByElements( pts, lns, inc, grp, act )( operation )

Returns: a generalised polygon

The argument pts, lns and inc are respectively a set of objects, a set of objects and a function. The function inc must represent an incidence relation between objects of pts and lns. The first version of GeneralisedPolygonByElements will construct an incidence graph, and if this graph has diameter \(d\) and girth \(2d\), a generalised polygon is returned. The thickness condition is not checked. If \(d \in \{3,4,6,8\}\), a projective plane, a generalised quadrangle, a generalised hexagon, a generalised octagon respectively, is returned. The argument grp is a group, and act a function, representing an action of the elements of grp on the objects in the lists pts and lns, preserving the incidence. The second version of GeneralisedPolygonByElements acts as the first version, but uses grp and act to construct the incidence graph in a more efficient way, so if grp is a non trivial group, the construction of the graph will be faster. This operation can typically be used to construct generalised polygons from objects that are available in FinInG. This difference in time is shown in the first two examples. The third examples shows the construction of the generalised quadrangle \(T_2(O)\).

gap> pg := PG(2,25);
ProjectiveSpace(2, 25)
gap> pts := Set(Points(pg));;
gap> lns := Set(Lines(pg));;
gap> inc := \*;
<Operation "*">
gap> gp := GeneralisedPolygonByElements(pts,lns,inc);
<projective plane order 25>
gap> time;
26427
gap> grp := CollineationGroup(pg);
The FinInG collineation group PGammaL(3,25)
gap> act := OnProjSubspaces;
function( var, el ) ... end
gap> gp := GeneralisedPolygonByElements(pts,lns,inc,grp,act);
<projective plane order 25>
gap> time;
127
gap> q := 4;
4
gap> conic := Set(Points(ParabolicQuadric(2,q)));
[ <a point in Q(2, 4)>, <a point in Q(2, 4)>, <a point in Q(2, 4)>, 
  <a point in Q(2, 4)>, <a point in Q(2, 4)> ]
gap> pg := PG(3,q);
ProjectiveSpace(3, 4)
gap> hyp :=  HyperplaneByDualCoordinates(pg,[1,0,0,0]*Z(q)^0);
<a plane in ProjectiveSpace(3, 4)>
gap> em := NaturalEmbeddingBySubspace(PG(2,q),pg,hyp);
<geometry morphism from <All elements of ProjectiveSpace(2, 
4)> to <All elements of ProjectiveSpace(3, 4)>>
gap> O := List(conic,x->x^em);;
gap> group := CollineationGroup(pg);
The FinInG collineation group PGammaL(4,4)
gap> stab := FiningSetwiseStabiliser(group,O);
#I  Computing adjusted stabilizer chain...
<projective collineation group with 6 generators>
gap> points1 := Set(Filtered(Points(pg),x->not x in hyp));;
gap> tangents := List(conic,x->TangentSpace(x)^em);
[ <a line in ProjectiveSpace(3, 4)>, <a line in ProjectiveSpace(3, 4)>, 
  <a line in ProjectiveSpace(3, 4)>, <a line in ProjectiveSpace(3, 4)>, 
  <a line in ProjectiveSpace(3, 4)> ]
gap> planes := List(tangents,x->Filtered(Planes(x),y->not y in hyp));;
gap> points2 := Union(planes);;
gap> points3 := [hyp];
[ <a plane in ProjectiveSpace(3, 4)> ]
gap> linesa := Union(List(O,x->Filtered(Lines(x),y->not y in hyp)));;
gap> linesb := Set(O);;
gap> pts := Union(points1,points2,points3);;
gap> lns := Union(linesa,linesb);;
gap> inc := \*;
<Operation "*">
gap> gp := GeneralisedPolygonByElements(pts,lns,inc,stab,\^);
<generalised quadrangle of order [ 4, 4 ]>
gap> time;
50

12.3 Attributes and operations for generalised polygons

All operations described in this section are applicable on objects in the category IsGeneralisedPolygon.

12.3-1 Order
‣ Order( gp )( attribute )

Returns: a pair of positive integers

This method returns the parameters \((s,t)\) of the generalised polygon gp. That is, \(s+1\) is the number of points on any line of gp, and \(t+1\) is the number of lines incident with any point of gp.

gap> gp := TwistedTrialityHexagon(2^3);
T(8, 2)
gap> Order(gp);
[ 8, 2 ]
gap> gp := HermitianPolarSpace(4,25);
H(4, 5^2)
gap> Order(gp);
[ 25, 125 ]
gap> gp := EGQByqClan(LinearqClan(3));
#I  Computed Kantor family. Now computing EGQ...
<EGQ of order [ 9, 3 ] and basepoint 0>
gap> Order(gp);
[ 9, 3 ]

12.3-2 IncidenceGraphAttr
‣ IncidenceGraphAttr( gp )( attribute )

This attribute is declared for objects in IsGeneralisedPolygon. It is a mutable attribute and can be accessed by the operation IncidenceGraph.

12.3-3 IncidenceGraph
‣ IncidenceGraph( gp )( operation )

Returns: a graph

The argument gp is a generalised polygon. This operation returns the incidence graph of gp. If gp is constructed using GeneralisedPolygonByBlocks, GeneralisedPolygonByElements or GeneralisedPolygonByIncidenceMatrix, an incidence graph is computed to check the input, and is stored as an attribute. For the particular generalised polygons available in FinInG, there is no precomputed incidence graph. Note that computing an incidence graph may require some time, especially when the gp has no collineation group computed. Therefore, this operation will return an error when gp has no collineation group computed. As CollineationGroup is an attribute for objects in IsGeneralisedPolygon, the user should compute the collineation group and then reissue the command to compute the incidence graph.

We should also point out that this method returns a mutable attribute of gp, so that acquired information about the incidence graph can be added. For example, the automorphism group of the incidence graph may be computed and stored as a record component after the incidence graph is stored as an attribute of gp. Normally, attributes of GAP objects are immutable.

Note that the factor 2 as difference in the order of the collineation group of \(Q(4,4)\) and the order of the automorphism group of its incidence graph is easily explained by the fact that the \(Q(4,4)\) is self dual.

gap> blocks := [ 
>    [ 1, 2, 3, 4, 5 ], [ 1, 6, 7, 8, 9 ], [ 1, 10, 11, 12, 13 ],
>    [ 1, 14, 15, 16, 17 ], [ 1, 18, 19, 20, 21 ], [ 2, 6, 10, 14, 18 ], 
>    [ 2, 7, 11, 15, 19 ], [ 2, 8, 12, 16, 20 ], [ 2, 9, 13, 17, 21 ], 
>    [ 3, 6, 11, 16, 21 ], [ 3, 7, 10, 17, 20 ], [ 3, 8, 13, 14, 19 ], 
>    [ 3, 9, 12, 15, 18 ], [ 4, 6, 12, 17, 19 ], [ 4, 7, 13, 16, 18 ], 
>    [ 4, 8, 10, 15, 21 ], [ 4, 9, 11, 14, 20 ], [ 5, 6, 13, 15, 20 ], 
>    [ 5, 7, 12, 14, 21 ], [ 5, 8, 11, 17, 18 ], [ 5, 9, 10, 16, 19 ] ];;
gap> gp := GeneralisedPolygonByBlocks( blocks );
<projective plane order 4>
gap> incgraph := IncidenceGraph( gp );;
gap> Diameter( incgraph );
3
gap> Girth( incgraph );
6
gap> VertexDegrees( incgraph );
[ 5 ]
gap> aut := AutGroupGraph( incgraph );
<permutation group with 9 generators>
gap> DisplayCompositionSeries(aut);
G (9 gens, size 241920)
 | Z(2)
S (5 gens, size 120960)
 | Z(2)
S (5 gens, size 60480)
 | Z(3)
S (4 gens, size 20160)
 | A(2,4) = L(3,4)
1 (0 gens, size 1)
gap> gp := ParabolicQuadric(4,4);
Q(4, 4)
gap> incgraph := IncidenceGraph( gp );;
Error, No collineation group computed. Please compute collineation group before compu
ting incidence graph,n called from
<function "unknown">( <arguments> )
 called from read-eval loop at line 24 of *stdin*
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
brk> quit;
gap> CollineationGroup(gp);
PGammaO(5,4)
gap> Order(last);
1958400
gap> incgraph := IncidenceGraph( gp );;
#I  Computing incidence graph of generalised polygon...
gap> aut := AutGroupGraph( incgraph );
<permutation group with 10 generators>
gap> Order(aut);
3916800
 

12.3-4 IncidenceMatrixOfGeneralisedPolygon
‣ IncidenceMatrixOfGeneralisedPolygon( gp )( attribute )

Returns: a matrix

This method returns the incidence matrix of the generalised polygon via the operation CollapsedAdjacencyMat in the GRAPE package. The rows of the matrix correspond to the points of gp, and the columns correspond to the lines. Note that since this operation relies on IncidenceGraph, for some generalised polygons, it is necessary to compute a collineation group first.

gap> gp := SymplecticSpace(3,2);
W(3, 2)
gap> CollineationGroup(gp);
PGammaSp(4,2)
gap> mat := IncidenceMatrixOfGeneralisedPolygon(gp);
#I  Computing incidence graph of generalised polygon...
[ [ 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ], 
  [ 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ], 
  [ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 ], 
  [ 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ], 
  [ 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0 ], 
  [ 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0 ], 
  [ 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ], 
  [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 ], 
  [ 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0 ], 
  [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0 ], 
  [ 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0 ], 
  [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1 ], 
  [ 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1 ], 
  [ 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0 ], 
  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1 ] ]
 

12.3-5 CollineationGroup
‣ CollineationGroup( gp )( attribute )

Returns: a group

This attribute returns the full collineation group of the generalised polygon gp. For some particular generalised polygons, a (subgroup) of the full collineation group can be computed efficiently without computing the incidence graph of gp: the full collineation group of classical generalised quadrangles and classical generalised hexagons; and an elation group with relation to a base-point of an elation generalised quadrangle. For generalised polygons constructed by the operations GeneralisedPolygonByBlocks, GeneralisedPolygonByElements or GeneralisedPolygonByIncidenceMatrix, the full collineation group is computed using the full automorphism group of the underlying incidence graph, the latter being computed by the package GRAPE.

The collineation groups computed for classical generalised quadrangles and classical generalised hexagons are collineation groups in the sense of FinInG, and come equipped with a NiceMonomorphism. The collineation groups computed in all other cases are permutations groups, acting on the vertices of the underlying incidence graph.

Note that the computation of the automorphism group of the underlying graph can be time consuming, also if the complete collineation group of the generalised polygon has been used as an argument in e.g. GeneralisedPolygonByElements.

The first example illustrates that CollineationGroup is naturally applicable to all classical generalised Polygons.

gap> gp := PG(2,2);
ProjectiveSpace(2, 2)
gap> CollineationGroup(gp);
The FinInG collineation group PGL(3,2)
gap> gp := EllipticQuadric(5,4);
Q-(5, 4)
gap> CollineationGroup(gp);
PGammaO-(6,4)
gap> gp := TwistedTrialityHexagon(3^3);
T(27, 3)
gap> CollineationGroup(gp);
#I  Computing nice monomorphism...
#I  Found permutation domain...
3D_4(27)
gap> time;
40691

The second example illustrates the computation of collineation groups of generalised polygons constructed using different objects.

gap> mat := [ [ 1, 1, 0, 0, 0, 1, 0 ], [ 1, 0, 0, 1, 1, 0, 0 ],
>          [ 1, 0, 1, 0, 0, 0, 1 ], [ 0, 1, 1, 1, 0, 0, 0 ],
>          [ 0, 1, 0, 0, 1, 0, 1 ], [ 0, 0, 0, 1, 0, 1, 1 ],
>          [ 0, 0, 1, 0, 1, 1, 0 ] ];
[ [ 1, 1, 0, 0, 0, 1, 0 ], [ 1, 0, 0, 1, 1, 0, 0 ], [ 1, 0, 1, 0, 0, 0, 1 ], 
  [ 0, 1, 1, 1, 0, 0, 0 ], [ 0, 1, 0, 0, 1, 0, 1 ], [ 0, 0, 0, 1, 0, 1, 1 ], 
  [ 0, 0, 1, 0, 1, 1, 0 ] ]
gap> gp := GeneralisedPolygonByIncidenceMatrix(mat);
<projective plane order 2>
gap> group := CollineationGroup(gp);
Group([ (3,4)(5,7)(9,10)(13,14), (3,7)(4,5)(11,12)(13,14), (2,3)(6,7)(8,9)
(12,13), (2,6)(4,5)(11,13)(12,14), (1,2)(4,7)(9,11)(10,12) ])
gap> gp := EGQByqClan(FisherqClan(3));
#I  Computed Kantor family. Now computing EGQ...
<EGQ of order [ 9, 3 ] and basepoint 0>
gap> group := CollineationGroup(gp);
#I  Computing incidence graph of generalised polygon...
#I  Using elation of the collineation group...
<permutation group of size 26127360 with 8 generators>
gap> Order(group);
26127360
gap> Random(group);
(1,75,27,191,96,50,9,110,88,53,63,154,115,213,229,19,236,226,49,143,16,266,58,
245,11,270,57,44)(2,181,116,225,262,223,17)(3,33,187,149,108,120,177,164,167,
261,198,26,196,276,52,73,94,222,101,176,32,39,43,89,31,280,65,71)(4,250,173,
112,246,38,142,138,54,208,69,243,197,42,269,242,125,8,134,265,67,206,20,13,29,
182,205,36)(5,109,129,82,210,277,185,56,104,114,90,68,61,228,132,235,78,257,
10,238,145,184,241,170,153,263,45,179)(6,159,230,106,147,91,22,137,256,113,
117,180,7,133,279,100,55,156,168,86,122,131,12,35,273,264,254,152)(14,62,66,
268,51,233,253,218,172,130,144,25,169,83,234,127,171,221,34,190,21,46,272,224,
239,267,60,98)(15,40,278,128,160,215,87,178,203,166,247,119,209,84,255,271,
232,81,193,252,92,95,111,201,107,140,135,258)( [...] )
gap> q := 4;
4
gap> conic := ParabolicQuadric(2,q);
Q(2, 4)
gap> nucleus := NucleusOfParabolicQuadric(conic);
<a point in ProjectiveSpace(2, 4)>
gap> conic := ParabolicQuadric(2,q);
Q(2, 4)
gap> nucleus := NucleusOfParabolicQuadric(conic);
<a point in ProjectiveSpace(2, 4)>
gap> hyperoval := Union(List(Points(conic)),[nucleus]);
[ <a point in ProjectiveSpace(2, 4)>, <a point in Q(2, 4)>, 
  <a point in Q(2, 4)>, <a point in Q(2, 4)>, <a point in Q(2, 4)>, 
  <a point in Q(2, 4)> ]
gap> pg := PG(3,q);
ProjectiveSpace(3, 4)
gap> hyp :=  HyperplaneByDualCoordinates(pg,[1,0,0,0]*Z(q)^0);
<a plane in ProjectiveSpace(3, 4)>
gap> em := NaturalEmbeddingBySubspace(PG(2,q),pg,hyp);
<geometry morphism from <All elements of ProjectiveSpace(2, 
4)> to <All elements of ProjectiveSpace(3, 4)>>
gap> O := List(hyperoval,x->x^em);
[ <a point in ProjectiveSpace(3, 4)>, <a point in ProjectiveSpace(3, 4)>, 
  <a point in ProjectiveSpace(3, 4)>, <a point in ProjectiveSpace(3, 4)>, 
  <a point in ProjectiveSpace(3, 4)>, <a point in ProjectiveSpace(3, 4)> ]
gap> points := Set(Filtered(Points(pg),x->not x in hyp));;
gap> lines := Union(List(O,x->Filtered(Lines(x),y->not y in hyp)));;
gap> inc := \*;
<Operation "*">
gap> gp := GeneralisedPolygonByElements(points,lines,inc);
<generalised quadrangle of order [ 3, 5 ]>
gap> coll := CollineationGroup(gp);
<permutation group of size 138240 with 8 generators>
gap> Order(coll);
138240
gap> Random(coll);
(1,29,60,40)(2,42,4,10,3,61,59,19,57,51,58,8)(5,21,17,25,52,13,64,48,44,36,9,
56)(6,34,41,55,50,45,63,27,20,14,11,24)(7,53,18,46,12,35,62,16,43,23,49,
26)(15,32,47,31,28,39,54,37,22,38,33,30)(65,74,83,111,66,117,149,104,70,151,
142,78)(67,135,139,136,68,109,98,125,69,95,120,137)(71,92,73,128,77,106,141,
105,145,150,88,155)(72,121,158,160,76,143,119,103,138,152,134,84)(75,153,133,
107,115,122,118,85,154,116,147,91)(79,110,101,159,126,90,157,81,112,100,89,
108)(80,99,97,86,156,129,144,94,127,114,148,82)(87,132,102,131,123,130,124,96,
93,113,146,140)

In the third example, the use of an precomputed automorphism group is illustrated. It speeds up the construction of the underlying graph and the computation of the automorphism group of the underlying graph. However, as is also illustrated in the example, despite that the precomputed automorphism group of the generalised polygon is actually the full collineation group, still some time is needed to compute the automorphism group of the underlying graph. The timings after both CollineationGroup commands are wrong. This is because GRAPE relies on an external binary to computed the automorphism group of a graph. The generalised quadrangle in this example is known as \(T_2^*(O)\).

gap> q := 8;
8
gap> conic := ParabolicQuadric(2,q);
Q(2, 8)
gap> nucleus := NucleusOfParabolicQuadric(conic);
<a point in ProjectiveSpace(2, 8)>
gap> hyperoval := Union(List(Points(conic)),[nucleus]);
[ <a point in ProjectiveSpace(2, 8)>, <a point in Q(2, 8)>, 
  <a point in Q(2, 8)>, <a point in Q(2, 8)>, <a point in Q(2, 8)>, 
  <a point in Q(2, 8)>, <a point in Q(2, 8)>, <a point in Q(2, 8)>, 
  <a point in Q(2, 8)>, <a point in Q(2, 8)> ]
gap> pg := PG(3,q);
ProjectiveSpace(3, 8)
gap> hyp :=  HyperplaneByDualCoordinates(pg,[1,0,0,0]*Z(q)^0);
<a plane in ProjectiveSpace(3, 8)>
gap> em := NaturalEmbeddingBySubspace(PG(2,q),pg,hyp);
<geometry morphism from <All elements of ProjectiveSpace(2, 
8)> to <All elements of ProjectiveSpace(3, 8)>>
gap> O := List(hyperoval,x->x^em);
[ <a point in ProjectiveSpace(3, 8)>, <a point in ProjectiveSpace(3, 8)>, 
  <a point in ProjectiveSpace(3, 8)>, <a point in ProjectiveSpace(3, 8)>, 
  <a point in ProjectiveSpace(3, 8)>, <a point in ProjectiveSpace(3, 8)>, 
  <a point in ProjectiveSpace(3, 8)>, <a point in ProjectiveSpace(3, 8)>, 
  <a point in ProjectiveSpace(3, 8)>, <a point in ProjectiveSpace(3, 8)> ]
gap> points := Set(Filtered(Points(pg),x->not x in hyp));;
gap> lines := Union(List(O,x->Filtered(Lines(x),y->not y in hyp)));;
gap> inc := \*;
<Operation "*">
gap> gp := GeneralisedPolygonByElements(points,lines,inc);
<generalised quadrangle of order [ 7, 9 ]>
gap> time;
17466
gap> coll := CollineationGroup(gp);
<permutation group of size 5419008 with 9 generators>
gap> time;
69
gap> group := CollineationGroup(pg);
The FinInG collineation group PGammaL(4,8)
gap> stab := FiningSetwiseStabiliser(group,O);
#I  Computing adjusted stabilizer chain...
<projective collineation group with 11 generators>
gap> time;
2045
gap> gp := GeneralisedPolygonByElements(points,lines,inc,stab,\^);
<generalised quadrangle of order [ 7, 9 ]>
gap> time;
394
gap> coll := CollineationGroup(gp);
<permutation group of size 5419008 with 9 generators>
gap> time;
62
gap> Order(coll);
5419008
gap> Order(stab);
5419008

12.3-6 CollineationAction
‣ CollineationAction( group )( attribute )

Returns: a function

group is a collineation group of a generalised polygon, computed using CollineationGroup. The collineation group of classical generalised polygons will be a collineation group in the sense of FinInG. The natural action is OnProjectiveSubspaces. The collineation group of any other generalised polygons will be a permutation group. The result of CollineationAction for such a group is a function with input a pair (x,g) where x is an element of the generalised polygon, and g is a collineation of the generalised polygon, so an element of group. The example illustrates the use in the generalised quadrangle.

gap> q := 4;
4
gap> conic := ParabolicQuadric(2,q);
Q(2, 4)
gap> nucleus := NucleusOfParabolicQuadric(conic);
<a point in ProjectiveSpace(2, 4)>
gap> hyperoval := Union(List(Points(conic)),[nucleus]);
[ <a point in ProjectiveSpace(2, 4)>, <a point in Q(2, 4)>, 
  <a point in Q(2, 4)>, <a point in Q(2, 4)>, <a point in Q(2, 4)>, 
  <a point in Q(2, 4)> ]
gap> pg := PG(3,q);
ProjectiveSpace(3, 4)
gap> hyp :=  HyperplaneByDualCoordinates(pg,[1,0,0,0]*Z(q)^0);
<a plane in ProjectiveSpace(3, 4)>
gap> em := NaturalEmbeddingBySubspace(PG(2,q),pg,hyp);
<geometry morphism from <All elements of ProjectiveSpace(2, 
4)> to <All elements of ProjectiveSpace(3, 4)>>
gap> O := List(hyperoval,x->x^em);
[ <a point in ProjectiveSpace(3, 4)>, <a point in ProjectiveSpace(3, 4)>, 
  <a point in ProjectiveSpace(3, 4)>, <a point in ProjectiveSpace(3, 4)>, 
  <a point in ProjectiveSpace(3, 4)>, <a point in ProjectiveSpace(3, 4)> ]
gap> points := Set(Filtered(Points(pg),x->not x in hyp));;
gap> lines := Union(List(O,x->Filtered(Lines(x),y->not y in hyp)));;
gap> inc := \*;
<Operation "*">
gap> gp := GeneralisedPolygonByElements(points,lines,inc);
<generalised quadrangle of order [ 3, 5 ]>
gap> coll := CollineationGroup(gp);
<permutation group of size 138240 with 8 generators>
gap> act := CollineationAction(coll);
function( el, g ) ... end
gap> g := Random(coll);
(1,37,45,63,27,19)(2,53,13,64,11,51)(3,33,38,61,31,28)(4,49,6,62,15,60)(5,46,
47,59,20,17)(7,42,40,57,24,26)(8,58)(9,55)(10,39,41,56,25,23)(12,35,34,54,29,
32)(14,48,43,52,18,21)(16,44,36,50,22,30)(65,132,90,157,89,105)(66,68,131,143,
119,103)(67,135,76,123,130,106)(69,133,112,100,81,107)(70,134,150,88,155,
104)(71,99,79,144,93,149)(72,153,95,120,73,122)(74,125,115,128,140,87)(75,121,
136,117,113,91)(77,124,98,83,147,146)(78,145,84,118,85,142)(80,92,137,141,108,
97)(82,86,116,111,138,101)(94,127,126,102,109,96)(110,152,151,154,156,
129)(114,160,139,158,148,159)
gap> l := Random(Lines(gp));
<a line in <generalised quadrangle of order [ 3, 5 ]>>
gap> act(l,g);
<a line in <generalised quadrangle of order [ 3, 5 ]>>
gap> p := Random(Points(gp));
<a point in <generalised quadrangle of order [ 3, 5 ]>>
gap> act(p,g);
<a point in <generalised quadrangle of order [ 3, 5 ]>>
gap> stab := Stabilizer(coll,p,act);
<permutation group of size 2160 with 3 generators>
gap> List(Orbits(stab,List(Points(gp)),act),x->Length(x));
[ 45, 18, 1 ]
gap> List(Orbits(stab,List(Lines(gp)),act),x->Length(x));
[ 90, 6 ]

12.3-7 BlockDesignOfGeneralisedPolygon
‣ BlockDesignOfGeneralisedPolygon( gp )( attribute )

Returns: a block design

This method allows one to use the GAP package DESIGN to analyse a generalised polygon, so the user must first load this package. The argument gp is a generalised polygon, and if it has a collineation group, the block design is computed with this extra information and thus the resulting design is easier to work with. Likewise, if gp is an elation generalised quadrangle and it has an elation group, then we use the elation group's action to efficiently compute the block design. We should also point out that this method returns a mutable attribute of gp, so that accquired information about the block design can be added. For example, the automorphism group of the block design may be computed after the design is stored as an attribute of gp. Normally, attributes of GAP objects are immutable.

gap> LoadPackage("design");
#W BIND_GLOBAL: variable `BlockDesign' already has a value
-----------------------------------------------------------------------------
Loading  DESIGN 1.6 (The Design Package for GAP)
by Leonard H. Soicher (http://www.maths.qmul.ac.uk/~leonard/).
Homepage: http://www.designtheory.org/software/gap_design/
-----------------------------------------------------------------------------
true
gap> gh := SplitCayleyHexagon(2);
H(2)
gap> CollineationGroup(gh);
#I  for Split Cayley Hexagon
#I  Computing nice monomorphism...
#I  Found permutation domain...
G_2(2)
gap> des := BlockDesignOfGeneralisedPolygon(gh);
rec( autSubgroup := <permutation group with 3 generators>, 
  blocks := [ [ 1, 29, 52 ], [ 1, 34, 36 ], [ 1, 37, 48 ], [ 2, 13, 60 ], 
      [ 2, 44, 53 ], [ 2, 45, 52 ], [ 3, 17, 35 ], [ 3, 22, 51 ], 
      [ 3, 23, 48 ], [ 4, 16, 57 ], [ 4, 19, 36 ], [ 4, 54, 56 ], 
      [ 5, 22, 63 ], [ 5, 31, 57 ], [ 5, 49, 52 ], [ 6, 7, 60 ], 
      [ 6, 28, 57 ], [ 6, 35, 43 ], [ 7, 26, 27 ], [ 7, 33, 34 ], 
      [ 8, 9, 53 ], [ 8, 22, 33 ], [ 8, 38, 56 ], [ 9, 25, 61 ], 
      [ 9, 28, 37 ], [ 10, 18, 53 ], [ 10, 32, 35 ], [ 10, 36, 62 ], 
      [ 11, 12, 63 ], [ 11, 26, 54 ], [ 11, 37, 42 ], [ 12, 41, 43 ], 
      [ 12, 44, 50 ], [ 13, 15, 42 ], [ 13, 19, 51 ], [ 14, 15, 31 ], 
      [ 14, 17, 61 ], [ 14, 34, 50 ], [ 15, 20, 38 ], [ 16, 23, 44 ], 
      [ 16, 40, 59 ], [ 17, 45, 54 ], [ 18, 24, 26 ], [ 18, 30, 31 ], 
      [ 19, 25, 41 ], [ 20, 21, 62 ], [ 20, 23, 27 ], [ 21, 28, 55 ], 
      [ 21, 39, 45 ], [ 24, 29, 59 ], [ 24, 51, 55 ], [ 25, 27, 49 ], 
      [ 29, 38, 43 ], [ 30, 39, 41 ], [ 30, 46, 48 ], [ 32, 40, 42 ], 
      [ 32, 47, 49 ], [ 33, 39, 40 ], [ 46, 47, 56 ], [ 46, 58, 60 ], 
      [ 47, 50, 55 ], [ 58, 59, 61 ], [ 58, 62, 63 ] ], isBlockDesign := true,
  v := 63 )
gap> f := GF(3);
GF(3)
gap> id := IdentityMat(2, f);;
gap> clan := List( f, t -> t*id );;
gap> clan := qClan(clan,f);
<q-clan over GF(3)>
gap> egq := EGQByqClan( clan );
#I  Computed Kantor family. Now computing EGQ...
<EGQ of order [ 9, 3 ] and basepoint 0>
gap> HasElationGroup( egq );
true
gap> design := BlockDesignOfGeneralisedPolygon( egq );;
#I  Computing orbits on lines of gen. polygon...
#I  Computing block design of generalised polygon...
gap> aut := AutGroupBlockDesign( design );
<permutation group with 6 generators>
gap> NrBlockDesignPoints( design );
280
gap> NrBlockDesignBlocks( design );
112
gap> DisplayCompositionSeries(aut);
G (6 gens, size 26127360)
 | Z(2)
S (5 gens, size 13063680)
 | Z(2)
S (5 gens, size 6531840)
 | Z(2)
S (4 gens, size 3265920)
 | 2A(3,3) = U(4,3) ~ 2D(3,3) = O-(6,3)
1 (0 gens, size 1)

12.4 Elements of generalised polygons

12.4-1 Collections of elements of generalised polygons
‣ ElementsOfIncidencStructure( gp, i )( attribute )
‣ Points( gp )( attribute )
‣ Lines( gp )( attribute )

Returns: a collection of elements of a generalised polygon

gp is any generalised polygon, i is a natural number, necessarily \(1\) or \(2\). ElementsOfIncidenceStructure returns the elements of type \(i\) of gp, Points and Lines are the usual shortcuts.

12.4-2 Size
‣ Size( els )( operation )

Returns: a number

els is a collection of elements of a generalised polygon. This operation returns the number of element in els.

12.4-3 Creating elements from objects and retrieving objects from elements
‣ ObjectToElement( gp, obj )( operation )
‣ ObjectToElement( gp, type, obj )( operation )
‣ UnderlyingObject( el )( operation )

Returns: a collection of elements of a generalised polygon

To create elements in gp (of type type), one of the versions of ObjectToElement can be used. It is checked whether obj represents an element (of type type). To retrieve an underlying object of an element el, UnderlyingObject can be used.

gap> mat := [ [ 1, 1, 0, 0, 0, 1, 0 ], [ 1, 0, 0, 1, 1, 0, 0 ],
>          [ 1, 0, 1, 0, 0, 0, 1 ], [ 0, 1, 1, 1, 0, 0, 0 ],
>          [ 0, 1, 0, 0, 1, 0, 1 ], [ 0, 0, 0, 1, 0, 1, 1 ],
>          [ 0, 0, 1, 0, 1, 1, 0 ] ];
[ [ 1, 1, 0, 0, 0, 1, 0 ], [ 1, 0, 0, 1, 1, 0, 0 ], [ 1, 0, 1, 0, 0, 0, 1 ], 
  [ 0, 1, 1, 1, 0, 0, 0 ], [ 0, 1, 0, 0, 1, 0, 1 ], [ 0, 0, 0, 1, 0, 1, 1 ], 
  [ 0, 0, 1, 0, 1, 1, 0 ] ]
gap> gp := GeneralisedPolygonByIncidenceMatrix(mat);
<projective plane order 2>
gap> p := Random(Points(gp));
<a point in <projective plane order 2>>
gap> UnderlyingObject(p);
7
gap> l := Random(Lines(gp));
<a line in <projective plane order 2>>
gap> UnderlyingObject(l);
[ 4, 6, 7 ]
gap> ObjectToElement(gp,1,4);
<a point in <projective plane order 2>>
gap> ObjectToElement(gp,2,5);
Error, <obj> does not represent a line of <gp> called from
<function "unknown">( <arguments> )
 called from read-eval loop at line 18 of *stdin*
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
brk> quit;
gap> ObjectToElement(gp,2,[1,2,3]);
Error, <obj> does not represent a line of <gp> called from
<function "unknown">( <arguments> )
 called from read-eval loop at line 18 of *stdin*
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
brk> quit;
gap> ObjectToElement(gp,[1,2,6]);
<a line in <projective plane order 2>>

12.4-4 Incidence
‣ IsIncident( v, w )( operation )
‣ \*( v, w )( operation )

Returns: true or false

Let v and w be two elements of a generalised polygon. It is checked if the ambient geometry of the two elements are identical, and true is returned if and only if the two elements are incident in their ambient geometry.

12.4-5 Span
‣ Span( v, w )( operation )

Returns: a line of a generalised polygon or fail

Let v and w be two elements of a generalised polygon. It is checked if the ambient geometries of the two elements are identical, and if the two elements are points. If v and w are incidence with a common line, this line is returned. Otherwise fail is returned. For generalised polygons constructed with GeneralisedPolygonByBlocks, GeneralisedPolygonByElements an GeneralisedPolygonByInidenceMatrix, the underlying graph is used. Note that the behaviour of Span is different for elements of generalised polygons that belong to IsLieGeometry, see 4.2-16.

gap> mat := [ [ 1, 1, 0, 0, 0, 1, 0 ], [ 1, 0, 0, 1, 1, 0, 0 ],
>          [ 1, 0, 1, 0, 0, 0, 1 ], [ 0, 1, 1, 1, 0, 0, 0 ],
>          [ 0, 1, 0, 0, 1, 0, 1 ], [ 0, 0, 0, 1, 0, 1, 1 ],
>          [ 0, 0, 1, 0, 1, 1, 0 ] ];
[ [ 1, 1, 0, 0, 0, 1, 0 ], [ 1, 0, 0, 1, 1, 0, 0 ], [ 1, 0, 1, 0, 0, 0, 1 ], 
  [ 0, 1, 1, 1, 0, 0, 0 ], [ 0, 1, 0, 0, 1, 0, 1 ], [ 0, 0, 0, 1, 0, 1, 1 ], 
  [ 0, 0, 1, 0, 1, 1, 0 ] ]
gap> gp := GeneralisedPolygonByIncidenceMatrix(mat);
<projective plane order 2>
gap> p := Random(Points(gp));
<a point in <projective plane order 2>>
gap> q := Random(Points(gp));
<a point in <projective plane order 2>>
gap> Span(p,q);
<a line in <projective plane order 2>>
gap> ps := ParabolicQuadric(4,3);
Q(4, 3)
gap> gp := GeneralisedPolygonByElements(Set(Points(ps)),Set(Lines(ps)),\*);
<generalised quadrangle of order [ 3, 3 ]>
gap> p := Random(Points(gp));
<a point in <generalised quadrangle of order [ 3, 3 ]>>
gap> q := Random(Points(gp));
<a point in <generalised quadrangle of order [ 3, 3 ]>>
gap> Span(p,q);
#I  <x> and <y> do not span a line of gp
fail

12.4-6 Meet
‣ Meet( v, w )( operation )

Returns: a point of a generalised polygon or fail

Let v and w be two elements of a generalised polygon. It is checked if the ambient geometries of the two elements are identical, and if the two elements are lines. If v and w are incidence with a common point, this point is returned. Otherwise fail is returned. For generalised polygons constructed with GeneralisedPolygonByBlocks, GeneralisedPolygonByElements an GeneralisedPolygonByInidenceMatrix, the underlying graph is used. Note that the behavior of Meet is different for elements of generalised polygongs that belong to IsLieGeometry, see 4.2-17

gap> mat := [ [ 1, 1, 0, 0, 0, 1, 0 ], [ 1, 0, 0, 1, 1, 0, 0 ],
>          [ 1, 0, 1, 0, 0, 0, 1 ], [ 0, 1, 1, 1, 0, 0, 0 ],
>          [ 0, 1, 0, 0, 1, 0, 1 ], [ 0, 0, 0, 1, 0, 1, 1 ],
>          [ 0, 0, 1, 0, 1, 1, 0 ] ];
[ [ 1, 1, 0, 0, 0, 1, 0 ], [ 1, 0, 0, 1, 1, 0, 0 ], [ 1, 0, 1, 0, 0, 0, 1 ], 
  [ 0, 1, 1, 1, 0, 0, 0 ], [ 0, 1, 0, 0, 1, 0, 1 ], [ 0, 0, 0, 1, 0, 1, 1 ], 
  [ 0, 0, 1, 0, 1, 1, 0 ] ]
gap> gp := GeneralisedPolygonByIncidenceMatrix(mat);
<projective plane order 2>
gap> l := Random(Lines(gp));
<a line in <projective plane order 2>>
gap> m := Random(Lines(gp));
<a line in <projective plane order 2>>
gap> Meet(l,m);
<a point in <projective plane order 2>>
gap> ps := ParabolicQuadric(4,3);
Q(4, 3)
gap> gp := GeneralisedPolygonByElements(Set(Points(ps)),Set(Lines(ps)),\*);
<generalised quadrangle of order [ 3, 3 ]>
gap> l := Random(Lines(gp));
<a line in <generalised quadrangle of order [ 3, 3 ]>>
gap> m := Random(Lines(gp));
<a line in <generalised quadrangle of order [ 3, 3 ]>>
gap> Meet(l,m);
#I  <x> and <y> do meet in a common point of gp
fail

12.4-7 Shadow elements
‣ ShadowOfElement( geo, v, j )( operation )
‣ Points( el )( operation )
‣ Lines( el )( operation )
‣ ElementsIncidentWithElementOfIncidenceStructure( el, i )( operation )

Returns: A collection of elements

geo is a generalised polygon, v must be an element of geo, j is an integer equal to 1 or 2, since geo is a rank two geometry. The operation ShadowOfElement returns the collection of elements of geo of type j, incident with the element v. The operations Points and Lines with argument are the usual shortcuts to ShadowOfElement with j respectively equal to 1, 2. The operation ElementsIncidentWithElementOfIncidenceStructure is the usual shortcut to ShadowOfElement.

gap> blocks := [
>   [ 1, 2, 3, 4, 5 ], [ 1, 6, 7, 8, 9 ], [ 1, 10, 11, 12, 13 ],
>   [ 1, 14, 15, 16, 17 ], [ 1, 18, 19, 20, 21 ], [ 2, 6, 10, 14, 18 ],
>   [ 2, 7, 11, 15, 19 ], [ 2, 8, 12, 16, 20 ], [ 2, 9, 13, 17, 21 ],
>   [ 3, 6, 11, 16, 21 ], [ 3, 7, 10, 17, 20 ], [ 3, 8, 13, 14, 19 ],
>   [ 3, 9, 12, 15, 18 ], [ 4, 6, 12, 17, 19 ], [ 4, 7, 13, 16, 18 ],
>   [ 4, 8, 10, 15, 21 ], [ 4, 9, 11, 14, 20 ], [ 5, 6, 13, 15, 20 ],
>   [ 5, 7, 12, 14, 21 ], [ 5, 8, 11, 17, 18 ], [ 5, 9, 10, 16, 19 ] ];; 
gap> gp := GeneralisedPolygonByBlocks( blocks ); 
<projective plane order 4>
gap> l := Random(Lines(gp)); 
<a line in <projective plane order 4>>
gap> pts := ShadowOfElement(gp,l,1);
<shadow points in <projective plane order 4>>
gap> List(pts);
[ <a point in <projective plane order 4>>, 
  <a point in <projective plane order 4>>, 
  <a point in <projective plane order 4>>, 
  <a point in <projective plane order 4>>, 
  <a point in <projective plane order 4>> ]
gap> p := Random(Points(gp));
<a point in <projective plane order 4>>
gap> lines := Lines(p);
<shadow lines in <projective plane order 4>>
gap> List(lines);
[ <a line in <projective plane order 4>>, <a line in <projective plane order 
    4>>, <a line in <projective plane order 4>>, 
  <a line in <projective plane order 4>>, <a line in <projective plane order 
    4>> ]

12.4-8 DistanceBetweenElements
‣ DistanceBetweenElements( v, w )( operation )

Returns: a number

Let v and w be two elements of a generalised polygon. It is checked if the ambient geometry of the two elements are identical, and the distance between the two elements in the incidence graph of their ambient geometry is returned.

gap> g := ElementaryAbelianGroup(27);
<pc group of size 27 with 3 generators>
gap> flist1 := [ Group(g.1), Group(g.2), Group(g.3), Group(g.1*g.2*g.3) ];;
gap> flist2 := [ Group([g.1, g.2^2*g.3]), Group([g.2, g.1^2*g.3 ]),
>             Group([g.3, g.1^2*g.2]), Group([g.1^2*g.2, g.1^2*g.3 ]) ];;
gap> egq := EGQByKantorFamily(g, flist1, flist2);
<EGQ of order [ 3, 3 ] and basepoint 0>
gap> p := Random(Points(egq));
<a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>
gap> q := Random(Points(egq));
<a point of class 3 of <EGQ of order [ 3, 3 ] and basepoint 0>>
gap> DistanceBetweenElements(p,q);
2
gap> gh := SplitCayleyHexagon(3);
H(3)
gap> l := Random(Lines(gh));
#I  for Split Cayley Hexagon
#I  Computing nice monomorphism...
#I  Found permutation domain...
<a line in H(3)>
gap> m := First(Lines(gh),x->DistanceBetweenElements(l,x)=6);
<a line in H(3)>

12.5 The classical generalised hexagons

12.5-1 Trialities of the hyperbolic quadric and generalised hexagons

Consider the hyperbolic quadric \(\mathrm{Q}^+(7,q)\). This is a polar space of rank 4. It is well known that its generators fall into two systems. Each system contains exactly \((q^3+q^2+q+1)(q^2+q+1)\) generators, which is equal to the number of points of \(\mathrm{Q}^+(7,q)\). Generators from the same system meet each other in an empty subspace or in a line, Generators from a different system meet each other in a point or a plane. One defines the rank \(4\) geometry \(\Omega(7,q)\) as follows. The 0-points are the points of \(\mathrm{Q}^+(7,q)\), the 1-points are the generators of the first system, the 2-points are the generators of the second system, and the lines are the lines of \(\mathrm{Q}^+(7,q)\). The incidence is the natural incidence of the underlying projective space. Denote the set of \(i\)-points as \(P^{(i)}\) , \(i=0,1,2\).

A triality of \(\Omega(7,q)\) is a map \(\tau: P^{(i)} \rightarrow P^{(i+1)}\) (where \(i+1\) is computed modulo 3) preserving the incidence and for which \(\tau^3 = 1\). Note that the image of a line under \(\tau\) is determined by the image of the points incident with the line.

An \(i\)-point is absolute with respect to a fixed triality if it is incident with its image under the triality. Consequently, a line is absolute with if it is fixed by the triality.

A generalised hexagon can be constructed as geometry of absolute points of one kind and absolute lines with relation to a fixed triality. Note that not all trialities yield (thick) generalised quadrangles. There are different types of trialities, for some of them the absolute geometry is degenerate.

The triality used in FinInG to construct the classical generalised hexagons is fixed. It is described explicitely in [VM98]. To describe the triality, a trilinear form expressing the incidence between \(i\)-points of \(\Omega(7,q)\) is used. Given the fact that, because of the existence of a triality, the role of the 0, 1 and 2 points are the same, each of the 1 and 2 points can be labelled the same way as the 0-points, which are effectively labelled by 8-tuples \((x_0,\ldots,x_7) \in V(8,q)=V\) where each 8-tuples represents a projective point of \(\mathrm{Q}^+(7,q)\).

Consider the hyperbolic quadric determined by the quadratic form \(X_0X_4+X_1X_5+X_2X_6+X_3X_7\) . Consider the trilinear map \(T\),

\(T(x,y,z) = \left|\begin{array}{ccc} x_0 & x_1 & x_2 \\ y_0 & y_1 & y_2 \\ z_0 & z_1 & z_2 \\ \end{array}\right| + \left|\begin{array}{ccc} x_4 & x_5 & x_6 \\ y_4 & y_5 & y_6 \\ z_4 & z_5 & z_6 \\ \end{array}\right| + x_3(z_0y_4+z_1y_5+z_2y_6) + x_7(y_0z_4+y_1z_5+y_2z_6) + y_3(x_0z_4+x_1z_5+x_2z_6) + \\ y_7(z_0x_4+z_1x_5+z_2x_6) + z_3(y_0x_4+y_1x_5+y_2x_6) + z_7(x_0y_4+x_1y_5+x_2y_6) - x_3y_3z_3 - x_7y_7z_7.\)

Now a pair \((x,y) \in V \times V\) represents an incident 0-1 pair of points if and only if \(T(x,y,z)\) vanishes in the variable \(z\), and similarly for any cyclic permutation of the letters \(x,y,z\). So given a \(1\)-point \(y\), \(T(x,y,z) = 0\), where \(z\) is a variable, and \(x\) is an unknown, gives a set of equations representing a generator of \(\mathrm{Q}^+(7,q)\) this is the generator of \(\mathrm{Q}^+(7,q)\) represented by \(y\) as label of a \(1\)-point.

Let \(\sigma\) be an automorphism of \(\mathrm{GF}(q)\) of order \(3\), or the identity. Consider the map

\(\tau_{\sigma}: P^{(i)} \rightarrow P^{(i+1)}\)

\((x_j) \mapsto (x_j^{\sigma})\), \(j=0\ldots 7\) .

This map clearly preserves \(T(x,y,z)\), so preserves the incidence, and has order three, so it is a triality of \(\Omega(7,q)\). We call an element \(p\) absolute with respect to a triality \(\tau\) if and only if \(p \mathrm{I} p^\tau\) . Consequently, a line is absolute if and only if it is fixed by the triality. Denote the set of \(i\)-points that are absolute with respect to the triality as \(P_{\mathrm{abs}}^{(i)}\) , and the set of absolute lines with respect to the triality as \(L_{\mathrm{abs}}\). Then a famous theorem of Tits ([Tit59]) says that for the triality \(\tau_{\sigma}\) , the point-line geometry \(\Gamma^{(i)} = (P^{(i)}_{\mathrm{abs}},L_{\mathrm{abs}},\mathrm{I})\) is a generalised hexagon of order \((|K|,|L|)\), \(K\) the field \(\mathrm{GF}(q)\) and \(L\) the subfield of invariant elements of \(K\) under the field automorphism \(\sigma\). Note that a finite field has a field automorphism of order three if and only if its order equals \(q^3\). So, for \(K\) equal to \(\mathrm{GF}(q)\) and \(\sigma=1\), \(\Gamma^{(i)}\) is a generalised hexagon of order \(q\), which is called the split Cayley hexagon of order \(q\), denoted \(H(q)\). For \(K\) equal to \(\mathrm{GF}(q^3)\), and \(\sigma\) a non-trival field automorphism of order \(3\), \(\Gamma^{(i)}\) is a generalised hexagon of order \((q^3,q)\) , which is called the twisted triality hexagon of order \((q^3,q)\) , denoted \(T(q^3,q)\) . Note that for a given triality, the hexagons \(\Gamma^{(i)}\), \(i=0,1,2\) are isomorphic. Consequently, \(\Gamma^{(0)}\) is a point-line geometry of which the point set, line set respectively, is a subset of the points, lines respectively of \(\mathrm{Q}^+(7,q)\). Finally, we mention the following important theorem, which was shown by Tits ([Tit59]): the split Cayley hexagon, obtained by the triliaty with \(\sigma=1\), is contained in the hyperplane with equation \(X_3+X_7=0\) , which intersects the hyperbolic quadric in the parabolic quadric \(\mathrm{Q}(6,q)\). The points of the split Cayley hexagon are the points of \(\mathrm{Q}(6,q)\).

This above description of the triality and the associated generalised hexagons, contains sufficient analytical information to implement the split Cayley hexagon and the twisted triality hexagon in an efficient way. The user is allowed to choose a representation for the ambient polar space. For \(q=2^h\) the polar spaces \(\mathrm{Q}(6,q)\) and \(\mathrm{W}(5,q)\) are isomorphic. Consequently, the user may choose \(\mathrm{W}(5,q)\) as ambient polar space for the split Cayley hexagon of even order. This embedding in \(\mathrm{W}(5,q)\) is called the perfect symplectic embedding of the split Cayley hexagon. Finally, [VM98] contains an explicit description of the generators of the collineation groups of both generalised hexagons.

12.5-2 IsLieGeometry
‣ IsLieGeometry( category )

Recall that the classical generalised hexagons are constructed as an object in IsLieGeometry. This makes most operations described in the appropriate chapters on Lie geometries, projective spaces and polar spaces applicable.

12.5-3 SplitCayleyHexagon
‣ SplitCayleyHexagon( q )( operation )
‣ SplitCayleyHexagon( f )( operation )
‣ SplitCayleyHexagon( ps )( operation )

Returns: a generalised hexagon

gap> hexagon := SplitCayleyHexagon( 3 );
H(3)
gap> AmbientPolarSpace(hexagon);
Q(6, 3): -x_1*x_5-x_2*x_6-x_3*x_7+x_4^2=0
gap> ps := ParabolicQuadric(6,3);
Q(6, 3)
gap> hexagon := SplitCayleyHexagon( ps );
H(3) in Q(6, 3)
gap> AmbientPolarSpace(hexagon);
Q(6, 3)
gap> hexagon := SplitCayleyHexagon( 4 );
H(4)
gap> AmbientPolarSpace(hexagon);
W(5, 4): x1*y4+x2*y5+x3*y6+x4*y1+x5*y2+x6*y3=0
gap> ps := ParabolicQuadric(6,4);
Q(6, 4)
gap> hexagon := SplitCayleyHexagon( ps );
H(4) in Q(6, 4)
gap> AmbientPolarSpace(hexagon);
Q(6, 4)

12.5-4 TwistedTrialityHexagon
‣ TwistedTrialityHexagon( q )( operation )
‣ TwistedTrialityHexagon( f )( operation )
‣ TwistedTrialityHexagon( ps )( operation )

Returns: a generalised hexagon

gap> hexagon := TwistedTrialityHexagon(2^3);
T(8, 2)
gap> AmbientPolarSpace(hexagon);
<polar space in ProjectiveSpace(
7,GF(2^3)): x_1*x_5+x_2*x_6+x_3*x_7+x_4*x_8=0 >
gap> ps := HyperbolicQuadric(7,2^3);
Q+(7, 8)
gap> hexagon := TwistedTrialityHexagon(ps);
T(8, 2) in Q+(7, 8)
gap> AmbientPolarSpace(hexagon);
Q+(7, 8)

12.5-5 VectorSpaceToElement
‣ VectorSpaceToElement( gh, vec )( operation )

Returns: an element of a classical generlised hexagon

The argument vec is one vector or a list of vectors from the underlying vectorspace of gh. This operation checks whether vec represents a point or a line of gh. Note that vectors and matrices in different representations are allowed as argument.

gap> ps := ParabolicQuadric(6,9);
Q(6, 9)
gap> gh := SplitCayleyHexagon(ps);
H(9) in Q(6, 9)
gap> vec := [ Z(3)^0, Z(3^2), 0*Z(3), Z(3^2), Z(3^2)^3, Z(3^2)^5, 0*Z(3) ];
[ Z(3)^0, Z(3^2), 0*Z(3), Z(3^2), Z(3^2)^3, Z(3^2)^5, 0*Z(3) ]
gap> p := VectorSpaceToElement(gh,vec);
<a point in H(9) in Q(6, 9)>
gap> vec := [ [ Z(3)^0, 0*Z(3), Z(3^2)^7, 0*Z(3), Z(3)^0, Z(3^2)^2, Z(3^2)^2 ], 
>   [ 0*Z(3), Z(3)^0, 0*Z(3), Z(3)^0, 0*Z(3), Z(3^2)^3, 0*Z(3) ] ];
[ [ Z(3)^0, 0*Z(3), Z(3^2)^7, 0*Z(3), Z(3)^0, Z(3^2)^2, Z(3^2)^2 ], 
  [ 0*Z(3), Z(3)^0, 0*Z(3), Z(3)^0, 0*Z(3), Z(3^2)^3, 0*Z(3) ] ]
gap> line := VectorSpaceToElement(gh,vec);
Error, <x> does not generate an element of <geom> called from
<function "unknown">( <arguments> )
 called from read-eval loop at line 14 of *stdin*
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
brk> quit;

12.5-6 ObjectToElement
‣ ObjectToElement( gh, obj )( operation )

Returns: an element of a classical generlised hexagon

The argument obj is one vector or a list of vectors from the underlying vectorspace of gh. This operation checks whether obj represents a point or a line of gh. Note that vectors and matrices in different representations are allowed as argument.

gap> mat := IdentityMat(8,GF(5^3));
< mutable compressed matrix 8x8 over GF(125) >
gap> form := BilinearFormByMatrix(mat,GF(5^3));
< bilinear form >
gap> ps := PolarSpace(form);
<polar space in ProjectiveSpace(
7,GF(5^3)): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2+x_7^2+x_8^2=0 >
gap> gh := TwistedTrialityHexagon(ps);
T(125, 5) in Q+(7, 125): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2+x_7^2+x_8^2
gap> vec := [ Z(5)^0, Z(5^3)^55, Z(5^3)^99, Z(5^3)^107, Z(5^3)^8, Z(5^3)^35, Z(5^3)^73, 
>   Z(5^3)^115 ];
[ Z(5)^0, Z(5^3)^55, Z(5^3)^99, Z(5^3)^107, Z(5^3)^8, Z(5^3)^35, Z(5^3)^73, 
  Z(5^3)^115 ]
gap> p := ObjectToElement(gh,vec);
<a point in T(125, 5) in Q+(7, 125): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2+x_7^2
+x_8^2>
gap> vec := [ [ Z(5)^0, 0*Z(5), Z(5^3)^76, Z(5^3)^117, Z(5^3)^80, Z(5^3)^19, Z(5^3)^48, 
>       Z(5^3)^100 ], 
>   [ 0*Z(5), Z(5)^0, Z(5^3)^115, Z(5^3)^14, Z(5^3)^40, Z(5^3)^67, Z(5^3)^123, 
>       Z(5^3)^3 ] ];
[ [ Z(5)^0, 0*Z(5), Z(5^3)^76, Z(5^3)^117, Z(5^3)^80, Z(5^3)^19, Z(5^3)^48, 
      Z(5^3)^100 ], 
  [ 0*Z(5), Z(5)^0, Z(5^3)^115, Z(5^3)^14, Z(5^3)^40, Z(5^3)^67, Z(5^3)^123, 
      Z(5^3)^3 ] ]
gap> line := ObjectToElement(gh,vec);
<a line in T(125, 5) in Q+(7, 125): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2+x_7^2+
x_8^2>

12.5-7 UnderlyingObject
‣ UnderlyingObject( gh, obj )( operation )

Returns: a vector or a matrix

12.5-8 \in
‣ \in( x, gh )( operation )

Returns: true or false

gap> ps := HyperbolicQuadric(7,5^3);
Q+(7, 125)
gap> gh := TwistedTrialityHexagon(ps);
T(125, 5) in Q+(7, 125)
gap> repeat
> p := Random(Points(ps));
> until p in gh;
gap> time;
18399
gap> p in gh;
true
gap> q := ElementToElement(gh,p);
<a point in T(125, 5) in Q+(7, 125)>
gap> l := Random(Lines(p));
<a line in Q+(7, 125)>
gap> l in gh;
false
gap> List(Lines(q),x->x in gh);
[ true, true, true, true, true, true ]

12.5-9 Span and meet of elements
‣ Span( x, y )( operation )
‣ Meet( x, y )( operation )

Returns: a subspace of a projective space

x and y are two elements of a classical generalised hexagon. The operation Span returns the projective line spanned by x and y. The operation Meet returns the intersection of the elements x and y. Note that the classical generalised hexagons are Lie geometries, so their elements belong to a subcategory of IsSubspaceOfProjectiveSpace. Therefore, the operations Span and Meet behave as described in 7.5-2 and 7.5-3.

gap> ps := SymplecticSpace(5,8);
W(5, 8)
gap> gh := SplitCayleyHexagon(ps);
H(8) in W(5, 8)
gap> vec := [ Z(2)^0, Z(2^3)^6, Z(2^3)^5, Z(2^3)^6, Z(2)^0, Z(2^3) ];
[ Z(2)^0, Z(2^3)^6, Z(2^3)^5, Z(2^3)^6, Z(2)^0, Z(2^3) ]
gap> p := VectorSpaceToElement(gh,vec);
<a point in H(8) in W(5, 8)>
gap> vec := [ Z(2)^0, Z(2^3)^2, Z(2^3), Z(2^3)^3, Z(2^3)^5, Z(2^3)^5 ];
[ Z(2)^0, Z(2^3)^2, Z(2^3), Z(2^3)^3, Z(2^3)^5, Z(2^3)^5 ]
gap> q := VectorSpaceToElement(gh,vec);
<a point in H(8) in W(5, 8)>
gap> span := Span(p,q);
<a line in ProjectiveSpace(5, 8)>
gap> ElementToElement(gh,span);
<a line in H(8) in W(5, 8)>
gap> vec := [ [ Z(2)^0, 0*Z(2), Z(2^3)^6, Z(2)^0, 0*Z(2), Z(2^3) ], 
>   [ 0*Z(2), Z(2)^0, Z(2^3)^6, Z(2^3)^4, Z(2^3)^4, 0*Z(2) ] ];
[ [ Z(2)^0, 0*Z(2), Z(2^3)^6, Z(2)^0, 0*Z(2), Z(2^3) ], 
  [ 0*Z(2), Z(2)^0, Z(2^3)^6, Z(2^3)^4, Z(2^3)^4, 0*Z(2) ] ]
gap> l := VectorSpaceToElement(gh,vec);
<a line in H(8) in W(5, 8)>
gap> vec := [ [ Z(2)^0, 0*Z(2), Z(2)^0, Z(2^3), 0*Z(2), Z(2^3) ], 
>   [ 0*Z(2), Z(2)^0, Z(2)^0, Z(2^3)^2, Z(2^3)^4, Z(2^3)^4 ] ];
[ [ Z(2)^0, 0*Z(2), Z(2)^0, Z(2^3), 0*Z(2), Z(2^3) ], 
  [ 0*Z(2), Z(2)^0, Z(2)^0, Z(2^3)^2, Z(2^3)^4, Z(2^3)^4 ] ]
gap> m := VectorSpaceToElement(gh,vec);
<a line in H(8) in W(5, 8)>
gap> Meet(l,m);
< empty subspace >
gap> DistanceBetweenElements(l,m);
6

12.5-10 CollineationGroup
‣ CollineationGroup( gh )( attribute )

Returns: a group of collineations

gh is a classical generalised hexagon. This attribute returns the full collineation group, equipped with a nice monomorphism.

gap> mat := IdentityMat(7,GF(9));
< mutable compressed matrix 7x7 over GF(9) >
gap> form := BilinearFormByMatrix(mat,GF(9));
< bilinear form >
gap> ps := PolarSpace(form);
<polar space in ProjectiveSpace(
6,GF(3^2)): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2+x_7^2=0 >
gap> gh := SplitCayleyHexagon(ps);
H(9) in Q(6, 9): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2+x_7^2
gap> group := CollineationGroup(gh);
#I  for Split Cayley Hexagon
#I  Computing nice monomorphism...
#I  Found permutation domain...
<projective collineation group with 18 generators>
gap> time;
19602
gap> HasNiceMonomorphism(group);
true
gap> gh := TwistedTrialityHexagon(2^3);
T(8, 2)
gap> group := CollineationGroup(gh);
#I  Computing nice monomorphism...
#I  Found permutation domain...
3D_4(8)

12.6 Elation generalised quadrangles

12.6-1 Elation generalised quadrangles and Kantor families

Suppose \(S=(P,B,I)\) is a generalised quadrangle of order \((s,t)\) for which there exists a point \(p\) and a group of collineations \(G\) fixing \(p\) and each line through \(p\), with the extra property that \(G\) acts regularly on the points not collinear with \(p\). Then \(S\) is called an elation generalised quadrangle with base-point \(p\) and elation group \(G\), and \(G\) has order \(s^2t\). Let \(y\) be a fixed point of \(S\), not collinear with \(p\). Denote the \(t+1\) lines incident with \(p\) as \(L_i, i=0 \ldots t\) . Define for each line \(L_i\) the unique point-line pair \((z_i,M_i)\) such that \(L_i I z_i I M_i I y\) . Define the groups \(S_i\) as the subgroups of \(G\) fixing the lines \(M_i\), and define the groups \(S_i^*\) as the subgroups of \(G\) fixing the point \(z_i\) . Define the set \(J = \{S_i: i=0 \ldots t\}\) , and the set \(J^* = \{S_i: i=0 \ldots t\}\) . Since \(S\) is an elation generalised quadrangle, \(J\) is a collection of \(t+1\) subgroups of \(G\) of order \(s\), and each \(S_i^*\) contains has order \(st\) and contains \(S_i\) as a subgroup. Furthermore, the following two conditions are satisfied.

(K1) \(S_iS_j \cap S_k = \{1\}\) , for distinct \(i,j,k\).

(K2) \(S_i \cap S_j^* = \{1\}\) , for distinct \(i,j\).

The pair \((J,J^*)\) is called a 4-gonal family or Kantor family in \(G\).

Remarkably, each Kantor family in a group of order \(s^2t\) gives rise to an elation generalised quadrangle. Kantor families and elation generalised quadrangles are equivalent objects, and one of the motivations to study Kantor families in groups was to find examples of non-classical elation generalised quadrangles.

Given a group \(G\), together with a Kantor family \((J,J^*)\) , a generalised quadrangle is defined as follows.

The points are of three types:

(i) points of type 1 are the elements of \(G\);

(ii) points of of type 2 are the right cosets \(S^*g, s^* \in J^*\)

(iii) the unique point of type (iii) is the symbol \((\infty)\) .

The lines are of two types:

(a) lines of type (a) are the right cosets \(Sg\), \(S \in J\);

(b) Lines of type (b) are the symbols \([S], S \in J\).

Incidence is defined as follows. A point \(g\) of type (i) is incident with each line \(Sg, S \in J\) of type (a). A point of type (ii) \(S^*g\) is incident the line \([S]\) of type (b) and the \(t\) lines of type (a) for which \(Sh \subset S^*g\) . Finally, the unique point of type (iii) is incident with the lines of type (b), and there are no further incidences.

It is shown, see e.g. the standard work in this field of Payne and Thas [PT84], that this point-line geoemtry is a generalised quadrangle of order \((s,t)\).

FinInG provides functions to construct elation generalised quadrangles directly from a Kantor family. The constructed generalised quadrangles are generalised polygons in the sense of FinInG, i.e. all generic operations described in Sections 12.3 and 12.4.

12.6-2 Categories
‣ IsEGQByKantorFamily( category )
‣ IsElementOfKantorFamily( category )

IsEGQByKantorFamily is a subcategory of IsElationGQ. It contains all elations generalised quadrangles that are constructed from a Kantor family. IsElementOfKantorFamily is a subcategory of IsElementOfGeneralisedPolygon. It contains the elements from generalised quadrangles in the category IsEGQByKantorFamily.

12.6-3 Kantor families
‣ IsKantorFamily( g, f, fstar )( operation )

Returns: true or false

There is no specific way to construct a Kantor family in FinInG. However, given a group \(G\) and two collections of subgroups, IsKantorFamily will check whether the input satisfies the conditions of a Kantor family. If so, the input can be used directly for the operation EGQByKantorFamily.

12.6-4 EGQByKantorFamily
‣ EGQByKantorFamily( g, f, fstar )( operation )

Returns: a generalised quadrangle

Let g be a group and f and fstar two collections of subgroups, satisfying the conditions of a Kantor family. This operation returns the corresponding elation generalised quadrangle. Note that this operation does not check if the input satisfies the conditions to be a Kantor family, it only checks whether the group f[i] is a subgroup of the group fstar[i]. In the example below, the use of IsKantorFamily is also demonstrated, and some categories are displayed.

gap> g := ElementaryAbelianGroup(27);
<pc group of size 27 with 3 generators>
gap> flist1 := [ Group(g.1), Group(g.2), Group(g.3), Group(g.1*g.2*g.3) ];;
gap> flist2 := [ Group([g.1, g.2^2*g.3]), Group([g.2, g.1^2*g.3 ]), 
>             Group([g.3, g.1^2*g.2]), Group([g.1^2*g.2, g.1^2*g.3 ]) ];; 
gap> IsKantorFamily( g, flist1, flist2 );
#I  Checking tangency condition...
#I  Checking triple condition...
true
gap> egq := EGQByKantorFamily(g, flist1, flist2);
<EGQ of order [ 3, 3 ] and basepoint 0>
gap> CategoriesOfObject(egq);
[ "IsIncidenceStructure", "IsIncidenceGeometry", "IsGeneralisedPolygon", 
  "IsGeneralisedQuadrangle", "IsElationGQ", "IsElationGQByKantorFamily" ]
gap> p := Random(Points(egq));
<a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>
gap> CategoriesOfObject(p);
[ "IsElementOfIncidenceStructure", "IsElementOfIncidenceGeometry", 
  "IsElementOfGeneralisedPolygon", "IsElementOfKantorFamily" ]

12.6-5 Representation of elements and underlying objects
‣ ObjectToElement( egq, t, obj )( operation )
‣ ObjectToElement( egq, obj )( operation )
‣ BasePointOfEGQ( egq )( operation )
‣ UnderlyingObject( el )( operation )

For technical reasons, the underlying objects of the elements of an elation generalised quadrangle constructed from a Kantor family, are not exactly the mathematical objects from the definition. However, these technicalities are almost completely hidden for the user, except for the representation of lines of type (b), which are represented in FinInG by the elements of the collection \(J^*\) (instead of the elements of the collection \(J\)). This change from the original definition has no mathematical implications, since there is a bijective correspondence between the elements of \(J^*\) and \(J\). Notice also that it is only possible to obtain the base-point of an elation generalised quadrangle constructed from a Kantor family through calling the attribute BasePointOfEGQ.

gap> g := ElementaryAbelianGroup(27);
<pc group of size 27 with 3 generators>
gap> flist1 := [ Group(g.1), Group(g.2), Group(g.3), Group(g.1*g.2*g.3) ];;
gap> flist2 := [ Group([g.1, g.2^2*g.3]), Group([g.2, g.1^2*g.3 ]),
>             Group([g.3, g.1^2*g.2]), Group([g.1^2*g.2, g.1^2*g.3 ]) ];;
gap> egq := EGQByKantorFamily(g, flist1, flist2);
<EGQ of order [ 3, 3 ] and basepoint 0>
gap> h := Random(g);
f1*f2^2
gap> p := ObjectToElement(egq,h);
<a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>
gap> coset := RightCoset(flist1[1],h);
RightCoset(Group( [ f1 ] ),f1*f2^2)
gap> l := ObjectToElement(egq,coset);
<a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>
gap> p * l;
true
gap> S := flist2[2];
<pc group of size 9 with 2 generators>
gap> m := ObjectToElement(egq,S);
<a line of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>
gap> q := BasePointOfEGQ(egq);
<a point of class 3 of <EGQ of order [ 3, 3 ] and basepoint 0>>
gap> m * q;
true
gap> lines := List(Lines(p));
[ <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>> ]
gap> pts1 := List(Points(m));
[ <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 3 of <EGQ of order [ 3, 3 ] and basepoint 0>> ]
gap> pts2 := List(Points(l));
[ <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>> ]
gap> List(pts2,x->UnderlyingObject(x));
[ f2^2, f1*f2^2, f1^2*f2^2, RightCoset(Group( [ f1, f2^2*f3 ] ),f3^2) ]
gap> UnderlyingObject(q);
0

12.6-6 Elation group and natural action on elements
‣ ElationGroup( egq )( attribute )
‣ OnKantorFamily( g, el )( function )
‣ CollineationAction( g )( attribute )

The attribute ElationGroup is naturally set upon creation of an elation generalised quadrangle from a Kantor family. The elements of the elation group act "naturally" on the elements of the elation generalised quadrangle. This natural action is implemented in the action function OnKantorFamily. When g is the elation group of an elation generalised quadrangle constructed from a Kantor family, the attribute CollineationAction will return the action function OnKantorFamily. The action function makes use of generic GAP operations possible, as is demonstrated in the example.

gap> g := ElementaryAbelianGroup(27);
<pc group of size 27 with 3 generators>
gap> flist1 := [ Group(g.1), Group(g.2), Group(g.3), Group(g.1*g.2*g.3) ];;
gap> flist2 := [ Group([g.1, g.2^2*g.3]), Group([g.2, g.1^2*g.3 ]),
>             Group([g.3, g.1^2*g.2]), Group([g.1^2*g.2, g.1^2*g.3 ]) ];;
gap> egq := EGQByKantorFamily(g, flist1, flist2);
<EGQ of order [ 3, 3 ] and basepoint 0>
gap> group := ElationGroup(egq);
<pc group of size 27 with 3 generators>
gap> CollineationAction(group) = OnKantorFamily;
true
gap> l := ObjectToElement(egq,RightCoset(flist1[1],One(g)));
<a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>
gap> stab := Stabilizer(group,l,OnKantorFamily);
Group([ f1 ])
gap> pts := List(Points(egq));
[ <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a point of class 3 of <EGQ of order [ 3, 3 ] and basepoint 0>> ]
gap> Orbits(group,pts,OnKantorFamily);
[ [ <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>> ], 
  [ <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>> ], 
  [ <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>> ], 
  [ <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>> ], 
  [ <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a point of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>> ], 
  [ <a point of class 3 of <EGQ of order [ 3, 3 ] and basepoint 0>> ] ]
gap> lines := List(Lines(egq));
[ <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
  <a line of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>> ]
gap> Orbits(group,lines,OnKantorFamily);
[ [ <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>> ], 
  [ <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>> ], 
  [ <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>> ], 
  [ <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>>, 
      <a line of class 1 of <EGQ of order [ 3, 3 ] and basepoint 0>> ], 
  [ <a line of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>> ], 
  [ <a line of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>> ], 
  [ <a line of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>> ], 
  [ <a line of class 2 of <EGQ of order [ 3, 3 ] and basepoint 0>> ] ]

12.6-7 Kantor families, q-clans, and elation generalised quadrangles

Let \(C=\{A_i: i=1 \ldots q\}\) be a set of \(q\) distinct upper triangle \(2 \times 2\) matrices over the finite field \(\mathrm{GF}(q)\). Then \(C\) is called a q-clan if \(A_r - A_t\) is anistropic for \(r \neq t\).

Define \(G = \{(\alpha,c,\beta): \alpha,\beta \in GF(q)^2, c \in GF(q)\}\) , and define the binary operator \(\times\) as \((\alpha,c,\beta) \times (\alpha',c',\beta') = (\alpha + \alpha',c+c'+\beta \cdot \alpha'^{T},\beta + \beta')\) . Then \(G,\times\) is a group with center \(Z(G)=\{(0,c,0): c \in GF(q)\}\). Consider a q-clan \(C=\{A_i: i=1 \ldots q\}\), define \(K_i = A_i+A_i^T\). Now define the following subgroups of \(G\)

\(A(i) = \{(\alpha,\alpha A_t,\alpha K_t): \alpha \in GF(q)^2, i=1\ldots q\}\) and \(A(\infty) = \{(0,0,\gamma): \gamma \in GF(q)^2\}\) , and

\(A^*(i) = \{(\alpha,b,\alpha K_t): \alpha \in GF(q)^2, b \in GF(q), i=1\ldots q\}\) and \(A^*(\infty) = \{(0,b,\gamma): \gamma \in GF(q)^2, b \in GF(q)\}\)

Define \(J=\{A(i):i=1\ldots q\} \cup \{A(\infty)\}\) and \(J^*=\{A^*(i):i=1\ldots q\} \cup \{A^*(\infty)\}\)

A combination of results of Payne and Kantor yield the famous theorem that (J,J^*) is a Kantor family in \(G\) if and only if \(C\) is a q-clan. FinInG provides functionality to construct q-clans and to construct the corresponding Kantor family. As such, elation generalised quadrangles can directly constructed from q-clans.

12.6-8 qClan
‣ qClan( list, f )( operation )

Returns: a q-clan.

Given a list list of \(2 \times\) matrices over the field f, it is checked if the matrices in the list satisfy the condition to constitute a q-clan over \(f\). If so, the q-clan is returned.

12.6-9 Particular q-clans
‣ LinearqClan( q )( operation )
‣ FisherThasWalkerKantorBettenqClan( q )( operation )
‣ KantorMonomialqClan( q )( operation )
‣ KantorKnuthqClan( q )( operation )
‣ FisherqClan( q )( operation )

Returns: a q-clan

Some famous q-clans are built in. We refer to ... for more information on these.

12.6-10 KantorFamilyByqClan
‣ KantorFamilyByqClan( clan )( operation )

Returns: A Kantor family.

The Kantor family constructed from a q-clan will be a matrix group together with the corresponding collections \(J\) and J^* .

12.6-11 EGQByqClan
‣ EGQByqClan( clan )( operation )

Returns: An elation generalised quadrangle constructed from a q-clan.

Given a q-clan clan, the operation KantorFamilyByqClan will be used to construct the Kantor family from clan, followed by the construction of the elation generalised quadrangle using the operation EGQByKantorFamily. The first example shows also the use of qClan, and shows that a linear q-clan yields a classical generalised quadrangle.

gap> f := GF(3);
GF(3)
gap> id := IdentityMat(2, f);;
gap> list := List( f, t -> t * id );;
gap> clan := qClan(list,f);
<q-clan over GF(3)>
gap> egq := EGQByqClan(clan);
#I  Computed Kantor family. Now computing EGQ...
<EGQ of order [ 9, 3 ] and basepoint 0>
gap> incgraph := IncidenceGraph(egq);;
#I  Computing incidence graph of generalised polygon...
#I  Using elation of the collineation group...
gap> group := AutomorphismGroup(incgraph);
<permutation group with 6 generators>
gap> Order(group);
26127360
gap> Order(CollineationGroup(HermitianPolarSpace(3,9)));
26127360
gap> clan := KantorKnuthqClan(9);
<q-clan over GF(3^2)>
gap> egq := EGQByqClan(clan);
#I  Computed Kantor family. Now computing EGQ...
<EGQ of order [ 81, 9 ] and basepoint 0>
gap> clan := FisherThasWalkerKantorBettenqClan(11);
<q-clan over GF(11)>

12.6-12 BLT-sets, flocks, q-clans, and elation generalised quadrangles

A flock is a partition of the points of a quadratic cone in \(\mathrm{PG}(3,q)\) minus its vertex into conics. Each conic is determined by a plane, and each plane is determined uniquely by a triple of elements of the field \(\mathrm{GF}(q)\). So a flock is determined by \(q\) such triples. Remarkably, as was shown by J.A. Thas, the conditions for these triples to constitute a flock, are exactly the same conditions for these triples to constitute \(q\) upper triangle matrices making a q-clan over \(\mathrm{GF}(q)\). Hence, q-clans and flocks, and thus flocks and elation generalised quadrangles, are equivalent objects.

The quadratic cone can be embedded as a hyperplane section into the parabolic quadric \(\mathrm{Q}(4,q)\). L. Bader, G. Lunardon and J.A. Thas observed that a set of \(q\) points of \(\mathrm{Q}(4,q)\) can be constructed from the \(q\) planes determining the flock, and this set of points satisfies certain geometric conditions. Such a set is called a BLT-set. Dually, a BLT-set corresponds to a set of lines of \(\mathrm{W}(3,q)\). Furthermore, from this BLT-set of lines, it is possible to construct directly an elation generalised quadrangle from carefully selecting points and lines from the symplectic space \(\mathrm{W}(5,q)\). This construction is called the Knarr construction.

Consider the symplectic polar space \(\mathrm{W}(5,q)\) and choose a point \(P \in W(5,q)\). Its tangent space is a \(4\)-dimensional space \(F\). Embed \(\mathrm{W}(3,q)\) in a solid of \(F\) not on the point \(p\), and let \(L\) be the set of BLT lines. Each line spans with \(p\) a plane of \(\mathrm{W}(5,q)\), call these \(q\) planes the BLT-planes. Now we can define the points an lines of the elation generalised quadrangle as follows.

Points of type (i) are the points of \(W(5,q) \setminus F\), points of type (ii) are the lines of each BLT-plane not on \(p\) and the unique point of type (iii) is the point \(p\). Lines of type (a) are the planes of \(\mathrm{W}(5,q)\) meeting a BLT-plane in a line. Note that no plane of \(\mathrm{W}(5,q)\) meeting two BLT planes in a line can exist. Lines of type (b) are the BLT-planes. Incidence is the natural incidence (so the incidence inherited) from the polar space \(\mathrm{W}(5,q)\), and this geometry is a elation generalised quadrangle with base-point \(p\) and of order \((q^2,q)\) .

FinInG provides functions to construct elation generalised quadrangles using this model from BLT-sets, and provides a function to compute a BLT set from a q-clan directly. The advantage of constructing a elation generalised from elements of Lie geometries is the availability of the underlying projective groups and their action on elements of Lie geometries.

12.6-13 IsEGQByBLTSet
‣ IsEGQByBLTSet( category )

IsEGQByBLTSet is a subcategory of IsElationGQ. It contains all elations generalised quadrangles that are constructed from a BLT set.

12.6-14 BLTSetByqClan
‣ BLTSetByqClan( clan )( operation )

Returns: A BLT-set.

The BLT-set is a set of points of the parabolic quadric in \(PG(4,q)\) with particular equation \(2X_1x_5+2X_2X_4+w^{(q+1)/2}=0\) , where \(w\) is a primitive element of the underlying field of clan.

gap> clan := KantorKnuthqClan(9);
<q-clan over GF(3^2)>
gap> blt := BLTSetByqClan(clan);
[ <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0> ]
gap> clan := FisherThasWalkerKantorBettenqClan(11);
<q-clan over GF(11)>
gap> blt := BLTSetByqClan(clan);
[ <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0> ]

12.6-15 EGQByBLTSet
‣ EGQByBLTSet( blt )( operation )

Returns: An elation generalised quadrangle.

blt is a BLT-set, this operation returns an elation generalised quadrangle constructed as described above consisting of elements of \(\mathrm{W}(5,q)\). Notice in the example that computing the full collineation group of the GQ constructed directly from the q-clan (hence a group coset geometry) is substantially slower than computing the full collineation group of the GQ constructed from the BLT-set.

gap> clan := LinearqClan(3);
<q-clan over GF(3)>
gap> bltset := BLTSetByqClan( clan);
[ <a point in Q(4, 3): -x_1*x_5-x_2*x_4+x_3^2=0>, 
  <a point in Q(4, 3): -x_1*x_5-x_2*x_4+x_3^2=0>, 
  <a point in Q(4, 3): -x_1*x_5-x_2*x_4+x_3^2=0>, 
  <a point in Q(4, 3): -x_1*x_5-x_2*x_4+x_3^2=0> ]
gap> egq := EGQByBLTSet( bltset );
#I  Now embedding dual BLT-set into W(5,q)...
#I  Computing elation group...
<EGQ of order [ 9, 3 ] and basepoint in W(5, 3 ) >
gap> p := BasePointOfEGQ(egq);
<a point in <EGQ of order [ 9, 3 ] and basepoint in W(5, 3 ) >>
gap> UnderlyingObject(p);
<a point in W(5, 3)>
gap> l := Random(Lines(egq));
<a line in <EGQ of order [ 9, 3 ] and basepoint in W(5, 3 ) >>
gap> UnderlyingObject(l);
<a plane in W(5, 3)>
gap> group := ElationGroup(egq);
<projective collineation group with 5 generators>
gap> Order(group);
243
gap> CollineationGroup(egq);
#I  Using elation group to enumerate elements
#I  Using elation group to enumerate elements
#I  Computing incidence graph of generalised polygon...
#I  Using elation of the collineation group...
#I  Using elation group to enumerate elements
<permutation group of size 26127360 with 7 generators>
gap> time;
147
gap> egq := EGQByqClan(clan);
#I  Computed Kantor family. Now computing EGQ...
<EGQ of order [ 9, 3 ] and basepoint 0>
gap> CollineationGroup(egq);
#I  Computing incidence graph of generalised polygon...
#I  Using elation of the collineation group...
<permutation group of size 26127360 with 6 generators>
gap> time;
1139

12.6-16 DefiningPlanesOfEGQByBLTSet
‣ DefiningPlanesOfEGQByBLTSet( egq )( attribute )

For an elation generalised quadrangle in the category IsEGQByBLTSet (constructed from a BLT-set), the planes of the polar space \(\mathrm{W}(5,q)\), as described in the introduction, determine the generalised quadrangle completely. This attribute returns these \(q\) planes of \(\mathrm{W}(5,q)\).

gap> clan := KantorKnuthqClan(9);
<q-clan over GF(3^2)>
gap> blt := BLTSetByqClan(clan);
[ <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0>, 
  <a point in Q(4, 9): -x_1*x_5-x_2*x_4+Z(3^2)^5*x_3^2=0> ]
gap> egq := EGQByBLTSet(blt);
#I  Now embedding dual BLT-set into W(5,q)...
#I  Computing elation group...
<EGQ of order [ 81, 9 ] and basepoint in W(5, 9 ) >
gap> DefiningPlanesOfEGQByBLTSet(egq);
[ <a plane in W(5, 9)>, <a plane in W(5, 9)>, <a plane in W(5, 9)>, 
  <a plane in W(5, 9)>, <a plane in W(5, 9)>, <a plane in W(5, 9)>, 
  <a plane in W(5, 9)>, <a plane in W(5, 9)>, <a plane in W(5, 9)>, 
  <a plane in W(5, 9)> ]

12.6-17 Representation of elements and underlying objects
‣ ObjectToElement( egq, t, obj )( operation )
‣ ObjectToElement( egq, obj )( operation )
‣ UnderlyingObject( el )( operation )

The underlying objects of the elements of an elation generalised quadrangle in the category IsEGQByBLTSet are elements of the polar space \(\mathrm{W}(5,q)\) in its standard representation. These elements can be used as underlying object to construct elements of egq. The example also demonstrates the use of DistanceBetweenElements.

gap> clan := FisherThasWalkerKantorBettenqClan(11);
<q-clan over GF(11)>
gap> blt := BLTSetByqClan(clan);
[ <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0>, 
  <a point in Q(4, 11): Z(11)*x_1*x_5+Z(11)*x_2*x_4+Z(11)^6*x_3^2=0> ]
gap> egq := EGQByBLTSet(blt);
#I  Now embedding dual BLT-set into W(5,q)...
#I  Computing elation group...
<EGQ of order [ 121, 11 ] and basepoint in W(5, 11 ) >
gap> planes := DefiningPlanesOfEGQByBLTSet(egq);
[ <a plane in W(5, 11)>, <a plane in W(5, 11)>, <a plane in W(5, 11)>, 
  <a plane in W(5, 11)>, <a plane in W(5, 11)>, <a plane in W(5, 11)>, 
  <a plane in W(5, 11)>, <a plane in W(5, 11)>, <a plane in W(5, 11)>, 
  <a plane in W(5, 11)>, <a plane in W(5, 11)>, <a plane in W(5, 11)> ]
gap> p := BasePointOfEGQ(egq);
<a point in <EGQ of order [ 121, 11 ] and basepoint in W(5, 11 ) >>
gap> up := UnderlyingObject(p);
<a point in W(5, 11)>
gap> ps := SymplecticSpace(5,11);
W(5, 11)
gap> uq := VectorSpaceToElement(ps,[1,1,0,0,0,0]*Z(11)^0);
<a point in W(5, 11)>
gap> q := ObjectToElement(egq,1,uq);
<a point in <EGQ of order [ 121, 11 ] and basepoint in W(5, 11 ) >>
gap> DistanceBetweenElements(p,q);
4
gap> l := ObjectToElement(egq,2,planes[1]);
<a line in <EGQ of order [ 121, 11 ] and basepoint in W(5, 11 ) >>
gap> DistanceBetweenElements(p,l);
1
gap> DistanceBetweenElements(q,l);
3
gap> um := VectorSpaceToElement(ps,[[1,0,0,0,1,1],[0,1,0,9,1,0],[0,0,1,9,9,9]]*Z(11)^0);
<a plane in W(5, 11)>
gap> m := ObjectToElement(egq,2,um);
<a line in <EGQ of order [ 121, 11 ] and basepoint in W(5, 11 ) >>
gap> DistanceBetweenElements(p,m);
3
gap> DistanceBetweenElements(q,m);
3
gap> DistanceBetweenElements(l,m);
2

12.6-18 CollineationSubgroup
‣ CollineationSubgroup( egq )( attribute )

For an elation generalised quadrangle in the category IsEGQByBLTSet (constructed from a BLT set), the planes of the polar space \(\mathrm{W}(5,q)\), as described in the introduction, determine the generalised quadrangle completely. The setwise stabiliser of these planes in the collineation group of \(\mathrm{W}(5,q)\) is a subgroup of the completely collineation group of the elation generalised quadrangle, and can be computed much faster than the complete collineation group. This attribute returns this setwise stabiliser. The returned group is equipped with the CollineationACtion attribute. If CollineationSubgroup is computed, this group will be used instead of the elation group to compute the incidence graph.

gap> clan := FisherThasWalkerKantorBettenqClan(5);
<q-clan over GF(5)>
gap> blt := BLTSetByqClan(clan);
[ <a point in Q(4, 5): Z(5)*x_1*x_5+Z(5)*x_2*x_4+Z(5)^3*x_3^2=0>, 
  <a point in Q(4, 5): Z(5)*x_1*x_5+Z(5)*x_2*x_4+Z(5)^3*x_3^2=0>, 
  <a point in Q(4, 5): Z(5)*x_1*x_5+Z(5)*x_2*x_4+Z(5)^3*x_3^2=0>, 
  <a point in Q(4, 5): Z(5)*x_1*x_5+Z(5)*x_2*x_4+Z(5)^3*x_3^2=0>, 
  <a point in Q(4, 5): Z(5)*x_1*x_5+Z(5)*x_2*x_4+Z(5)^3*x_3^2=0>, 
  <a point in Q(4, 5): Z(5)*x_1*x_5+Z(5)*x_2*x_4+Z(5)^3*x_3^2=0> ]
gap> egq := EGQByBLTSet(blt);
#I  Now embedding dual BLT-set into W(5,q)...
#I  Computing elation group...
<EGQ of order [ 25, 5 ] and basepoint in W(5, 5 ) >
gap> coll := CollineationSubgroup(egq);
#I  Computing adjusted stabilizer chain...
<projective collineation group with 13 generators>
gap> Order(coll);
9000000
gap> act := CollineationAction(coll);
function( el, x ) ... end
gap> orbs := Orbits(coll,Points(egq),act);;
#I  Using elation group to enumerate elements
gap> List(orbs,x->Length(x));
[ 1, 3125, 150 ]
gap> el := ElationGroup(egq);
<projective collineation group with 5 generators>
gap> orbs := Orbits(el,Points(egq),act);;
#I  Using elation group to enumerate elements
gap> List(orbs,x->Length(x));
[ 1, 3125, 25, 25, 25, 25, 25, 25 ]

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 A B C Bib Ind

generated by GAPDoc2HTML