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).
‣ ProjectivePlaneByBlocks( l ) | ( operation ) |
Returns: a projective plane
The argument l is a finite homogeneous list consisting of ordered sets of a common size n+1 from the number 1 up to n^2+n+1. This operation returns the projective plane of order n.
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> pp := ProjectivePlaneByBlocks( blocks ); <projective plane of order 4>
‣ ProjectivePlaneByIncidenceMatrix( mat ) | ( operation ) |
Returns: a projective plane
The argument mat is a square matrix with entries from {0,1}; the incidence matrix of a projective plane. The rows represent the lines of the projective plane and the columns represent the points. That is, the (i,j)-entry of mat is equal to 0 or 1 according to whether the i-th line is incident or not incident with the j-th points.
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 := ProjectivePlaneByIncidenceMatrix( incmat ); <projective plane of order 4>
The classical generalised quadrangles were treated in the chapter on polar spaces (Chapter 8), and here we provide operations which create elation generalised quadrangles arising from Kantor families. Suppose we have 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 we have an elation generalised quadrangle with base point P and elation group G. Such an elation generalised quadrangle is equivalent to a Kantor family of subgroups of G: a set of t+1 subgroups F of order s and a set of t+1 subgroups F* of order st such that (i) each element of F is a subgroup of one element of F* and intersects the other elements of F* trivially, and (ii) any three elements A,B,C of F satisfy AB ∩ C = 1. For more information, we refer to the standard work in this field of Payne and Thas [PT84].
‣ IsKantorFamily( grp, f1, f2 ) | ( operation ) |
Returns: true or false
This operation tests to see if (f1, f2) forms a Kantor family of subgroups for the group grp. The elements of f1 are smaller than the elements of f2.
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) ]; [ <pc group with 1 generators>, <pc group with 1 generators>, <pc group with 1 generators>, <pc group with 1 generators> ] 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 ]) ]; [ <pc group with 2 generators>, <pc group with 2 generators>, <pc group with 2 generators>, <pc group with 2 generators> ] gap> IsKantorFamily( g, flist1, flist2 ); #I Checking tangency condition... #I Checking triple condition... true
explain how to construct an EGQ from a Kantor family?
‣ EGQByKantorFamily( grp, f1, f2 ) | ( operation ) |
Returns: an elation generalised quadrangle
The argument grp is a finite group and f1 and f2 are each lists of subgroups of grp which form a Kantor family. The i-th member of f1 must be a subgroup of the i-th member of f2. We should mention that this operation does not check that the input is a valid Kantor family, as this would slow this operation down. Thus if the user is unsure of their input, they would best use the operation IsKantorFamily (13.2-1) beforehand. In the following example we construct the unique generalised quadrangle of order 3.
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); #I Computing points from Kantor family... #I Computing lines from Kantor family... <EGQ of order [ 3, 3 ] and basepoint 0>
Let C be a set of 2 x 2 upper triangular matrices over GF(q), which are indexed by GF(q). If the pairwise difference of any two elements of C is anisotropic, that is, represents a nondegenerate binary quadratic form, then we say that C is a q-clan. This concept was introduced by Stanley Payne [Pay85] to construct Kantor families for flock generalised quadrangles.
‣ IsqClan( list, f ) | ( operation ) |
Returns: true or false
This operation tests to see if list defines a q-Clan over the field f.
gap> f := GF(3); GF(3) gap> id := IdentityMat(2, f);; gap> clan := List( f, t -> t * id );; gap> IsqClan( clan, f ); true
‣ qClan( list, f ) | ( operation ) |
Returns: the q clan of matrices in list
This operation tests to see if list defines a q-Clan over the field f, and returs the q-Clan.
gap> f := GF(7); GF(7) gap> id := IdentityMat(2, f);; gap> clan := List( f, t -> t * id );; gap> clan := qClan( clan, f ); <q-clan over GF(7)>
‣ EGQByqClan( qclan ) | ( operation ) |
Returns: an elation generalised quadrangle
The argument qclan is a q-Clan. In the following example, we construct an elation generalised quadrangle from a q-Clan that is actually isomorphic with the classical generalised quadrangle of order (9, 3) (i.e., H(3,9)). We do not explicitely compute the isomorphism, but compute, using a detour via the incidence graph, a group isomorphic with the complete collineation group of the elation GQ, which turns out the have the same size as PΓU(4,9)
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... #I Computing points from Kantor family... #I Computing lines from Kantor family... <EGQ of order [ 9, 3 ] and basepoint 0> gap> incgraph := IncidenceGraphOfGeneralisedPolygon(egq);; #I Computing incidence graph of generalised polygon... gap> group := AutomorphismGroup(incgraph); <permutation group with 6 generators> gap> Order(group); 26127360 gap> Order(CollineationGroup(HermitianPolarSpace(3,9))); #I Computing nice monomorphism... 26127360
‣ KantorFamilyByqClan( qclan, f ) | ( operation ) |
Returns: a kantor family
The argument qclan is a q-Clan, and the corresponding Kantor family is returned. Internally, the operation EGQByqClan EGQByqClan (13.2-5) will use this method to construct the elation generalised quadrangle with the operation EGQByKantorFamily.
gap> f := GF(7); GF(7) gap> id := IdentityMat(2, f);; gap> list := List( f, t -> t * id );; gap> clan := qClan(list,f); <q-clan over GF(7)> gap> fam := KantorFamilyByqClan(clan); [ <matrix group with 8 generators>, [ <matrix group with 2 generators>, <matrix group with 2 generators>, <matrix group with 2 generators>, <matrix group with 2 generators>, <matrix group with 2 generators>, <matrix group with 2 generators>, <matrix group with 2 generators>, <matrix group with 4 generators> ], [ <matrix group with 4 generators>, <matrix group with 4 generators>, <matrix group with 4 generators>, <matrix group with 4 generators>, <matrix group with 4 generators>, <matrix group with 4 generators>, <matrix group with 4 generators>, <matrix group with 6 generators> ] ] gap> egq := EGQByKantorFamily(fam[1],fam[2],fam[3]); #I Computing points from Kantor family... #I Computing lines from Kantor family... <EGQ of order [ 49, 7 ] and basepoint 0>
‣ LinearqClan( q ) | ( operation ) |
‣ FisherThasWalkerKantorBettenqClan( q ) | ( operation ) |
‣ KantorMonomialqClan( q ) | ( operation ) |
‣ KantorKnuthqClan( q ) | ( operation ) |
‣ FisherqClan( q ) | ( operation ) |
Returns: a q-Clan
The argument q is a prime power. These operations return a particular q-Clan. Should we add references here since describing all these q-Clans is definitely beyond the scope here?
gap> LinearqClan(4); Error, Couldn't find nonsquare called from <function>( <arguments> ) called from read-eval-loop Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' to continue brk> quit; gap> LinearqClan(5); <q-clan over GF(5)> gap> FisherThasWalkerKantorBettenqClan(9); Error, q must be congruent to 2 mod (3) called from <function>( <arguments> ) called from read-eval-loop Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' to continue brk> quit; gap> FisherThasWalkerKantorBettenqClan(11); <q-clan over GF(11)> gap> KantorMonomialqClan(17); <q-clan over GF(17)> gap> KantorKnuthqClan(25); <q-clan over GF(5^2)> gap> FisherqClan(23); <q-clan over GF(23)>
A BLT-set is a set S of points of the parabolic quadric Q(4,q), which is a classial generalised quadrangle, such that for any three points of S, there is no point of Q(4,q) collinear with all three of the points. BLT-sets, which were introduced by Bader, Lunardon and Thas [BLT90], give rise to q-clans, and hence to flock generalised quadrangles.
‣ BLTSetByqClan( qclan, f ) | ( operation ) |
Returns: a list of points of Q(4,q)
The argument qclan is a list of matrices (i.e., IsFFECollCollColl) which form a q-Clan, and f is the defining field. This field must have odd order. This operation returns a BLT-set for the parabolic quadric defined by the bilinear form with Gram matrix
|
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> Span(blt); <a solid in ProjectiveSpace(4, 9)> gap> clan := LinearqClan(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> Span(blt); <a plane in ProjectiveSpace(4, 9)>
‣ EGQByBLTSet( list, point, solid ) | ( operation ) |
‣ EGQByBLTSet( list ) | ( operation ) |
Returns: an elation generalised quadrangle
The argument list is a list of points of a BLT-set of Q(4,q), where q is odd. The user may enter the point and solid as extra arguments which are used in the Knarr construction of the elation generalised quadrangle from the BLT-set. Otherwise, we take the W(5,q) in the Knarr construction to be defined by the canonical form used in FinInG, and we take point and solid to be the elements [1,0,0,0,0,0] and [[1,0,0,0,0,1],[0,0,1,0,0,0],[0,0,0,1,0,0],[0,0,0,0,1,0]] respectively. We show how we can construct the classical generalised quadrangle of order (9, 3) (i.e., H(3,9)) from a conic of Q(4,3).
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> geo := AmbientGeometry( bltset[1] ); Q(4, 3): -x_1*x_5-x_2*x_4+x_3^2=0 gap> Display( geo ); Q(4, 3) Non-degenerate parabolic bilinear form Gram Matrix: . . . . 1 . . . 1 . . . 1 . . . 1 . . . 1 . . . . Polynomial: -x_1*x_5-x_2*x_4+x_3^2 Witt Index: 2 gap> egq := EGQByBLTSet( bltset ); #I No intertwiner computed. One of the polar spaces must have a collineation group computed #I Computing nice monomorphism... #I Now embedding dual BLT-set into W(5,q)... #I Computing points(1) of Knarr construction... #I Computing lines(1) of Knarr construction... #I Computing points(2) of Knarr construction... #I Computing lines(2) of Knarr construction...please wait #I Computing elation group... <EGQ of order [ 9, 3 ] and basepoint [ Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3) ]>
‣ ElationGroup( egq ) | ( attribute ) |
Returns: a group
This method returns the elation group of order s2t of the elation generalised quadrangle egq, which has order (s,t). This is the stored as an attribute of egq. Note that the type of the group is of course dependent on the model from which egq was constructed.
gap> clan := FisherThasWalkerKantorBettenqClan(11); <q-clan over GF(11)> gap> egq := EGQByqClan(clan); #I Computed Kantor family. Now computing EGQ... #I Computing points from Kantor family... #I Computing lines from Kantor family... <EGQ of order [ 121, 11 ] and basepoint 0> gap> group := ElationGroup(egq); <matrix group of size 161051 with 8 generators>
‣ BasePointOfEGQ( egq ) | ( attribute ) |
Returns: a point of egq
This method returns the base point for the elation generalised quadrangle egq, that is, a point for which the elation group of egq fixes every line through it. This is the stored as an attribute of egq.
gap> clan := LinearqClan(3); <q-clan over GF(3)> gap> egq := EGQByqClan(clan); #I Computed Kantor family. Now computing EGQ... #I Computing points from Kantor family... #I Computing lines from Kantor family... <EGQ of order [ 9, 3 ] and basepoint 0> gap> blt := 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> egq2 := EGQByBLTSet(blt); #I No intertwiner computed. One of the polar spaces must have a collineation group computed #I Computing nice monomorphism... #I Now embedding dual BLT-set into W(5,q)... #I Computing points(1) of Knarr construction... #I Computing lines(1) of Knarr construction... #I Computing points(2) of Knarr construction... #I Computing lines(2) of Knarr construction...please wait #I Computing elation group... <EGQ of order [ 9, 3 ] and basepoint [ Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3) ]> gap> BasePointOfEGQ(egq); <a point of a Kantor family> gap> Display(last); 0 gap> BasePointOfEGQ(egq2); <a point of <EGQ of order [ 9, 3 ] and basepoint [ Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3) ]>> gap> Display(last); [ Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3) ]
Due to the sheer sizes of generalised octagons, they have not yet been included into FinInG. The only other known families of generalised hexagons (up to duality) are the Split Cayley hexagons and the Twisted Triality hexagons.
‣ SplitCayleyHexagon( f ) | ( operation ) |
‣ SplitCayleyHexagon( q ) | ( operation ) |
Returns: a generalised hexagon of order (q,q)
The Split Cayley hexagons were first constructed by Jacques Tits via the absolute points and lines of a triality of the 7-dimensional hyperbolic quadric. The input is either a finite field f or a prime power q, and a generalised hexagon is returned consisting of points and lines of Q(6, q) if q is odd, or of W(5,q) if q is even. The forms for these polar spaces are, respectively, Q(x):= x_1x_5+x_2x_6+x_3x_7-x_4^2 and B(x,y):=x_1y_4+x_2y_5+x_3y_6+x_4y_1+x_5y_2+x_6y_3.
gap> hexagon := SplitCayleyHexagon( 3 ); Split Cayley Hexagon of order 3 gap> points := Points( hexagon ); <points of Split Cayley Hexagon of order 3> gap> lines := AsList( Lines(hexagon) );; gap> lines[1]; <a line of Split Cayley Hexagon of order 3> gap> AmbientSpace( hexagon ); ProjectiveSpace(6, 3) gap> coll := CollineationGroup( hexagon ); G_2(3) gap> DisplayCompositionSeries( coll ); G (size 4245696) | G(2,3) 1 (size 1)
‣ TwistedTrialityHexagon( f ) | ( operation ) |
‣ TwistedTrialityHexagon( q ) | ( operation ) |
Returns: a generalised hexagon of order (q,sqrt[3]q)
Just like the Split Cayley hexagons (see SplitCayleyHexagon (13.3-1)), the Twisted Triality hexagons arise as absolute points and lines of a triality. The input is either a finite field f or a prime power q, where the order of the field is a cube, and a generalised hexagon is returned consisting of points and lines of Q^+(7, q), defined by the form Q(x):= x_1x_5+x_2x_6+x_3x_7+x_4x_8. The smallest Twisted Triality hexagon has 2457 points and 819 lines.
‣ AmbientSpace( geo ) | ( attribute ) |
‣ AmbientPolarSpace( geo ) | ( attribute ) |
Returns: a projective space, a classical polar space respectively
All generalised hexagons in FinInG are Lie geometries, constructed inside a classical polar space. As for all Lie geometries, the first attribute will return the ambient projective space. The second attribute returns the polar space in which geo is constructed.
gap> hexagon := SplitCayleyHexagon( 3 ); Split Cayley Hexagon of order 3 gap> AmbientSpace(hexagon); ProjectiveSpace(6, 3) gap> AmbientPolarSpace(hexagon); standard Q(6, 3) gap> hexagon := SplitCayleyHexagon( 4 ); Split Cayley Hexagon of order 4 gap> AmbientSpace(hexagon); ProjectiveSpace(5, 4) gap> AmbientPolarSpace(hexagon); standard W(5, 4) gap> hexagon := TwistedTrialityHexagon( 5^3 ); Twisted Triality Hexagon of order [ 125, 5 ] gap> AmbientSpace(hexagon); ProjectiveSpace(7, 125) gap> AmbientPolarSpace(hexagon); standard Q+(7, 125)
‣ 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.
‣ AmbientSpace( gp ) | ( attribute ) |
Returns: an incidence geometry
Some of our generalised polygons have a natural ambient space, for example, the Split Cayley hexagons in odd characteristic are naturally embedded in the 6-dimensional parabolic quadrics. Therefore, for some generalised polygons the user can use this method to return the natural ambient geometry for the generalised polygon, provided such a geometry exists.
‣ CollineationGroup( gp ) | ( attribute ) |
Returns: a group
Some of our generalised polygons come equipped automatically with a collineation group. For example, the generalised hexagons have their collineation groups already installed, and so do the classical generalised quadrangles. However, the collineation group of a projective plane is calculated using the package Grape. We refer to CollineationAction (13.4-4) for an example.
‣ CollineationAction( gp ) | ( attribute ) |
Returns: a function
Unlike some of the other geometries in FinInG, the collineations of generalised polygons to not have a uniform representation. Thus depending on the generalised polygon we are working with, a group element and its action could be very different. For example, we use ordinary permutations when acting on the elements of a projective plane (modulo some wrapping), whereas elation generalised quadrangles arising from Kantor families must employ a completely different group action. So our collineation groups come equipped with the attribute CollineationAction, which is a function with input a pair (x,g) where x is an element of gp, and g is a collineation.
gap> LoadPackage("grape"); true gap> Print("Collineations of projective planes...\n"); Collineations of projective planes... 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> pp := ProjectivePlaneByBlocks( blocks ); <projective plane of order 4> gap> coll := CollineationGroup( pp ); #I Computing incidence graph of projective plane... <permutation group with 8 generators> gap> DisplayCompositionSeries( coll ); G (8 gens, size 120960) | Z(2) S (4 gens, size 60480) | Z(3) S (3 gens, size 20160) | A(2,4) = L(3,4) 1 (0 gens, size 1) gap> Display( CollineationAction(coll) ); function ( x, g ) if x!.type = 1 then return Wrap( plane, 1, OnPoints( x!.obj, g ) ); elif x!.type = 2 then return Wrap( plane, 2, OnSets( x!.obj, g ) ); fi; return; end gap> gap> Print("Collineations of generalised hexagons...\n"); Collineations of generalised hexagons... gap> hex := SplitCayleyHexagon( 5 ); Split Cayley Hexagon of order 5 gap> coll := CollineationGroup( hex ); G_2(5) gap> CollineationAction(coll) = OnProjSubspaces; true gap> Print("Collineations of elation generalised quadrangles...\n"); Collineations of elation generalised quadrangles... 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); #I Computing points from Kantor family... #I Computing lines from Kantor family... <EGQ of order [ 3, 3 ] and basepoint 0> gap> elations := ElationGroup( egq ); <pc group of size 27 with 3 generators> gap> CollineationAction(elations) = OnKantorFamily; true gap> HasCollineationGroup( egq ); false
‣ 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, then the block design is computed with this extra information and thus the resulting design is easier to work with. Likewise, if gp is an elation generalised quadrangle and it has an elation group, then we use the elation group's action to efficiently compute the block design. We should also point out that this method returns a mutable attribute of gp, so that accquired information about the block design can be added. For example, the automorphism group of the block design may be computed after the design is stored as an attribute of gp. Normally, attributes of GAP objects are immutable.
gap> LoadPackage("design"); ----------------------------------------------------------------------------- Loading DESIGN 1.4 (The Design Package for GAP) by Leonard H. Soicher (http://www.maths.qmul.ac.uk/~leonard/). ----------------------------------------------------------------------------- #W BIND_GLOBAL: variable `BlockDesign' already has a value true 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... #I Computing points from Kantor family... #I Computing lines from Kantor family... <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 5 generators> gap> NrBlockDesignPoints( design ); 280 gap> NrBlockDesignBlocks( design ); 112 gap> DisplayCompositionSeries(aut); G (5 gens, size 26127360) | Z(2) S (4 gens, size 13063680) | Z(2) S (4 gens, size 6531840) | Z(2) S (3 gens, size 3265920) | 2A(3,3) = U(4,3) ~ 2D(3,3) = O-(6,3) 1 (0 gens, size 1)
‣ IncidenceGraphOfGeneralisedPolygon( gp ) | ( attribute ) |
Returns: a graph
This method allows one to use the GAP package GRAPE 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, then the incidence graph is computed with this extra information and thus the resulting graph 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 incidence graph. We should also point out that this method returns a mutable attribute of gp, so that accquired 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.
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> pp := ProjectivePlaneByBlocks( blocks ); <projective plane of order 4> gap> incgraph := IncidenceGraphOfGeneralisedPolygon( pp );; 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 (3 gens, size 120960) | Z(2) S (3 gens, size 60480) | Z(3) S (2 gens, size 20160) | A(2,4) = L(3,4) 1 (0 gens, size 1)
‣ IncidenceMatrixOfGeneralisedPolygon( gp ) | ( attribute ) |
Returns: a matrix
This method returns the incidence matrix of the generalised polygon via the operation CollapsedAdjacencyMat in the GRAPE package (so you need to load this package first). The rows of the matrix correspond to the points of gp, and the columns correspond to the lines.
gap> gp := SymplecticSpace(3,2); W(3, 2) gap> mat := IncidenceMatrixOfGeneralisedPolygon(gp); #I Computing nice monomorphism... #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 ] ]
generated by GAPDoc2HTML