Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 Bib Ind
 Top of Book   Previous Chapter   Next Chapter 

12 Generalised Polygons
 12.1 Projective planes
  12.1-1 ProjectivePlaneByBlocks

  12.1-2 ProjectivePlaneByIncidenceMatrix
 12.2 Generalised quadrangles
  12.2-1 IsKantorFamily

  12.2-2 EGQByKantorFamily

  12.2-3 IsqClan

  12.2-4 EGQByqClan

  12.2-5 KantorFamilyByqClan

  12.2-6 BLTSetByqClan

  12.2-7 EGQByBLTSet

  12.2-8 ElationGroup

  12.2-9 BasePointOfEGQ
 12.3 Generalised hexagons and octagons
  12.3-1 SplitCayleyHexagon

  12.3-2 TwistedTrialityHexagon
 12.4 General attributes and operations of generalised polygons
  12.4-1 Order

  12.4-2 AmbientSpace

  12.4-3 CollineationGroup

  12.4-4 CollineationAction

  12.4-5 BlockDesignOfGeneralisedPolygon

  12.4-6 IncidenceGraphOfGeneralisedPolygon

  12.4-7 IncidenceMatrixOfGeneralisedPolygon

12 Generalised Polygons

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

12.1 Projective planes

12.1-1 ProjectivePlaneByBlocks
> 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>
 

12.1-2 ProjectivePlaneByIncidenceMatrix
> 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>
 

12.2 Generalised quadrangles

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 ABcap C=1. The standard text for generalised quadrangles is Payne and Thas [PT84].

12.2-1 IsKantorFamily
> 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. See the example for "EGQByKantorFamily".

12.2-2 EGQByKantorFamily
> 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 (12.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 );
true
gap> egq := EGQByKantorFamily(g, flist1, flist2);
<EGQ of order [ 3, 3 ] and basepoint 0>
 

Let C be a set of 2x 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. These sets of matrices were introduced by Stanley Payne [Pay85] to construct Kantor families for flock generalised quadrangles.

12.2-3 IsqClan
> IsqClan( qclan, f )( operation )

Returns: true or false

This operation tests to see if qclan defines a q-Clan over the field f. See the example for EGQByqClan (12.2-4).

12.2-4 EGQByqClan
> EGQByqClan( qclan, f )( operation )

Returns: an elation generalised quadrangle

The argument qclan is a list of matrices (i.e., IsFFECollCollColl) which form a q-Clan, and f is the defining field. In the following example, we construct the classical generalised quadrangle of order (9, 3) (i.e., H(3,9)).

gap> f := GF(3);
GF(3)
gap> id := IdentityMat(2, f);;
gap> clan := List( f, t -> t * id );;
gap> IsqClan( clan, f );
true
gap> egq := EGQByqClan( clan, f );
<EGQ of order [ 9, 3 ] and basepoint 0>
 

12.2-5 KantorFamilyByqClan
> KantorFamilyByqClan( qclan, f )( operation )

Returns: a kantor family

The argument qclan is a list of matrices (i.e., IsFFECollCollColl) which form a q-Clan, and f is the defining field. The operation returns a triple [g, list1, list2] where g is a group of order s^2t, list1 is a list of subgroups os order s and list2 is a list of subgroups of order st.

A BLT-set is a set S of points of the parabolic quadric Q(4, q) such that for any three points of S, there is no point of Q(4, q) collinear (in a line of Q(4, q)) with all three of the points. BLT-sets, which were introduced by Bader, Lunardon and Thas [BLT90], give rise to q-clans and hence flock quadrangles.

12.2-6 BLTSetByqClan
> 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

 
0 0 0 0 1
0 0 0 1 0
0 0 w(q+1)/2 0 0
0 1 0 0 0
1 0 0 0 0
 
where w is a primitive root of GF(q). See EGQByBLTSet (12.2-7) for an example of how to use this operation.

12.2-7 EGQByBLTSet
> 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 ParabolicQuadric(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> f := GF(3);
GF(3)
gap> id := IdentityMat(2, f);;
gap> clan := List( f, t -> t * id );;
gap> bltset := BLTSetByqClan( clan, f );
[ <a point in Q(4, 3)>, <a point in Q(4, 3)>, <a point in Q(4, 3)>, <a point in Q(4, 3)> ]
gap> geo := AmbientGeometry( bltset[1] );
Q(4, 3)
gap> Display( geo );
Q(4, 3)
Non-degenerate parabolic bilinear form
Gram Matrix:
 . . . . 1
 . . . 1 .
 . . 1 . .
 . 1 . . .
 1 . . . .
Witt Index: 2
gap> egq := EGQByBLTSet( bltset );
<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) ]>
 

12.2-8 ElationGroup
> ElationGroup( egq )( attribute )

Returns: a group

This method returns the elation group of order s^2t of the elation generalised quadrangle egq, which has order (s,t). This is the stored as an attribute of egq.

12.2-9 BasePointOfEGQ
> 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. (Note, some elation generalised quadrangles are known to have more than choice of base point; so we are assuming that egq has a particular choice for its base point.)

12.3 Generalised hexagons and octagons

Due to the sheer sizes of generalised octagons, they have not yet been included into FinInG, and there is (at the moment) limited functionality with the twisted triality hexagons. The only other known family of generalised hexagons (up to duality) are the Split Cayley hexagons.

12.3-1 SplitCayleyHexagon
> 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.

gap> hexagon := SplitCayleyHexagon( 3 );
<generalised hexagon of order [ 3, 3 ]>
gap> points := Points( hexagon );
<points of <generalised hexagon of order [ 3, 3 ]>>
gap> lines := AsList( Lines(hexagon) );;
gap> lines[1];
<a line in Q(6, 3)>
gap> AmbientSpace( hexagon );
Q(6, 3)
gap> coll := CollineationGroup( hexagon );
G_2(3)
gap> DisplayCompositionSeries( coll );
G (size 4245696)
 | G(2,3)
1 (size 1)
 

12.3-2 TwistedTrialityHexagon
> TwistedTrialityHexagon( f )( operation )
> TwistedTrialityHexagon( q )( operation )

Returns: a generalised hexagon of order (q,sqrt[3]q)

Just like the Split Cayley hexagons (see SplitCayleyHexagon (12.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). The smallest Twisted Triality hexagon has 2457 points and 819 lines.

12.4 General attributes and operations of generalised polygons

12.4-1 Order
> Order( gp )( attribute )

Returns: a pair of positive integers

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

12.4-2 AmbientSpace
> 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.

12.4-3 CollineationGroup
> 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 via using the package Grape. We refer to CollineationAction (12.4-4) for an example.

12.4-4 CollineationAction
> 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 (3 gens, size 60480)
 | Z(3)
S (2 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> Print("Collineations of generalised hexagons...\n");
Collineations of generalised hexagons...
gap> hex := SplitCayleyHexagon( 5 );
<generalised hexagon of order [ 5, 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);
<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

 

12.4-5 BlockDesignOfGeneralisedPolygon
> BlockDesignOfGeneralisedPolygon( gp )( attribute )

Returns: a block design

This method allows one to use the GAP package DESIGN to analyse a generalised polygon, so the user must first load this package. The argument gp is a generalised polygon, and if it has a collineation group, 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> f := GF(3);
GF(3)
gap> id := IdentityMat(2, f);;
gap> clan := List( f, t -> t*id );;
gap> egq := EGQByqClan( clan, f );
<EGQ of order [ 9, 3 ] and basepoint 0>
gap> HasElationGroup( egq );
true
gap> design := BlockDesignOfGeneralisedPolygon( egq );;
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)

 

12.4-6 IncidenceGraphOfGeneralisedPolygon
> 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)

 

12.4-7 IncidenceMatrixOfGeneralisedPolygon
> IncidenceMatrixOfGeneralisedPolygon( gp )( attribute )

Returns: a matrix

This method returns the incidence matrix of the generalised polygon via the operation CollapsedAdjacencyMat in the GRAPE package (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.

 Top of Book   Previous Chapter   Next Chapter 
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 Bib Ind

generated by GAPDoc2HTML