12 Generalised Polygons

12.6 Elation generalised quadrangles

12.6-1 Elation generalised quadrangles and Kantor families

12.6-2 Categories

12.6-3 Kantor families

12.6-4 EGQByKantorFamily

12.6-5 Representation of elements and underlying objects

12.6-6 Elation group and natural action on elements

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

12.6-8 qClan

12.6-9 Particular q-clans

12.6-10 KantorFamilyByqClan

12.6-11 EGQByqClan

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

12.6-13 IsEGQByBLTSet

12.6-14 BLTSetByqClan

12.6-15 EGQByBLTSet

12.6-16 DefiningPlanesOfEGQByBLTSet

12.6-17 Representation of elements and underlying objects

12.6-18 CollineationSubgroup

12.6-1 Elation generalised quadrangles and Kantor families

12.6-2 Categories

12.6-3 Kantor families

12.6-4 EGQByKantorFamily

12.6-5 Representation of elements and underlying objects

12.6-6 Elation group and natural action on elements

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

12.6-8 qClan

12.6-9 Particular q-clans

12.6-10 KantorFamilyByqClan

12.6-11 EGQByqClan

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

12.6-13 IsEGQByBLTSet

12.6-14 BLTSetByqClan

12.6-15 EGQByBLTSet

12.6-16 DefiningPlanesOfEGQByBLTSet

12.6-17 Representation of elements and underlying objects

12.6-18 CollineationSubgroup

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.

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

.

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

.

`‣ IsWeakGeneralisedPolygon` | ( category ) |

`IsWeakGeneralisedPolygon`

is the category for weak generalised polygons.

`IsProjectivePlaneCategory`

`‣ IsDesarguesianPlane` | ( category ) |

`IsDesarguesianPlane`

is declared as a subcategory of `IsProjectivePlaneCategory`

and `IsProjecticeSpace`

. Projective spaces of dimension 2 constructed using `ProjectiveSpace`

belong to `IsDesarguesianPlane`

.

`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 discussed 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

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

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

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

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

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

.

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

`‣ IncidenceGraphAttr` ( gp ) | ( attribute ) |

This attribute is declared for objects in `IsGeneralisedPolygon`

. It is a mutable attribute and can be accessed by the operation `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

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

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

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

`‣ 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 acquired 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"); ----------------------------------------------------------------------------- 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)

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

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

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

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

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

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

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

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

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)} \to 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 explicitly 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)} \to 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-trivial 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 triality 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.

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

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

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

`‣ vector spaceToElement` ( gh, vec ) | ( operation ) |

Returns: an element of a classical generalized hexagon

The argument `vec` is one vector or a list of vectors from the underlying vector space 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;

`‣ ObjectToElement` ( gh, obj ) | ( operation ) |

Returns: an element of a classical generalized hexagon

The argument `obj` is one vector or a list of vectors from the underlying vector space 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>

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

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

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

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

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

.

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

.

`‣ 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" ]

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

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

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

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

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

`‣ 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^* .

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

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.

`‣ IsEGQByBLTSet` | ( category ) |

`IsEGQByBLTSet`

is a subcategory of `IsElationGQ`

. It contains all elations generalised quadrangles that are constructed from a BLT set.

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

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

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

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

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

generated by GAPDoc2HTML