SSL chap12_mj.html Sprache: HTML

products/Sources/formale Sprachen/GAP/pkg/fining/doc/chap12_mj.html

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<script type="text/javascript"
 src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
<title>GAP (FinInG) - Chapter 12: Generalised Polygons</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<meta name="generator" content="GAPDoc2HTML" />
<link rel="stylesheet" type="text/css" href="manual.css" />
<script src="manual.js" type="text/javascript"></script>
<script type="text/javascript">overwriteStyle();</script>
</head>
<body class="chap12" onload="jscontent()">

<div class="chlinktop">Goto Chapter: <a href="chap0_mj.html">Top</a> <a href="chap1_mj.html">1</a> <a href="chap2_mj.html">2</a> <a href="chap3_mj.html">3</a> <a href="chap4_mj.html">4</a> <a href="chap5_mj.html">5</a> <a href="chap6_mj.html">6</a> <a href="chap7_mj.html">7</a> <a href="chap8_mj.html">8</a> <a href="chap9_mj.html">9</a> <a href="chap10_mj.html">10</a> <a href="chap11_mj.html">11</a> <a href="chap12_mj.html">12</a> <a href="chap13_mj.html">13</a> <a href="chap14_mj.html">14</a> <a href="chapA_mj.html">A</a> <a href="chapB_mj.html">B</a> <a href="chapC_mj.html">C</a> <a href="chapBib_mj.html">Bib</a> <a href="chapInd_mj.html">Ind</a> </div>

<div class="chlinkprevnexttop"> <a href="chap0_mj.html">[Top of Book]</a> <a href="chap0_mj.html#contents">[Contents]</a> <a href="chap11_mj.html">[Previous Chapter]</a> <a href="chap13_mj.html">[Next Chapter]</a> </div>

<a href="chap12.html">[MathJax off]</a>
<a id="X7E1F10767D2A4D6A" name="X7E1F10767D2A4D6A"></a>
<div class="ChapSects"><a href="chap12_mj.html#X7E1F10767D2A4D6A">12 Generalised Polygons</a>
<div class="ContSect"> <a href="chap12_mj.html#X7CC6903E78F24167">12.1 Categories</a>

<div class="ContSSBlock">
 <a href="chap12_mj.html#X8141DFFF7B352E2D">12.1-1 IsGeneralisedPolygon</a>
 <a href="chap12_mj.html#X832E75AE7CCC5BB2">12.1-2 Subcategories in <code class="code">IsGeneralisedPolygon</code></a>

 <a href="chap12_mj.html#X86C124B3804C7569">12.1-3 IsWeakGeneralisedPolygon</a>
 <a href="chap12_mj.html#X8540C04887CF8824">12.1-4 Subcategories in <code class="code">IsProjectivePlaneCategory</code></a>

 <a href="chap12_mj.html#X7CF10DAE7847939D">12.1-5 Subcategories in <code class="code">IsGeneralisedQuadrangle</code></a>

 <a href="chap12_mj.html#X7A2ABB0B818E25C5">12.1-6 IsClassicalGeneralisedHexagon</a>
</div></div>
<div class="ContSect"> <a href="chap12_mj.html#X8614D6A779F9B1AA">12.2 Generic functions to create generalised polygons</a>

<div class="ContSSBlock">
 <a href="chap12_mj.html#X849A83597CC78B5F">12.2-1 GeneralisedPolygonByBlocks</a>
 <a href="chap12_mj.html#X8751B0FB8500D0B1">12.2-2 GeneralisedPolygonByIncidenceMatrix</a>
 <a href="chap12_mj.html#X7A6169127CE8ABC0">12.2-3 GeneralisedPolygonByElements</a>
</div></div>
<div class="ContSect"> <a href="chap12_mj.html#X864C966D8184A9C0">12.3 Attributes and operations for generalised polygons</a>

<div class="ContSSBlock">
 <a href="chap12_mj.html#X84F59A2687C62763">12.3-1 Order</a>
 <a href="chap12_mj.html#X836C15B57968A511">12.3-2 IncidenceGraphAttr</a>
 <a href="chap12_mj.html#X815BE6D57D623452">12.3-3 IncidenceGraph</a>
 <a href="chap12_mj.html#X81F531BB7DEA127D">12.3-4 IncidenceMatrixOfGeneralisedPolygon</a>
 <a href="chap12_mj.html#X83FF6FA0790D5747">12.3-5 CollineationGroup</a>
 <a href="chap12_mj.html#X8074EDB381D97984">12.3-6 CollineationAction</a>
 <a href="chap12_mj.html#X7D75521986B958DA">12.3-7 BlockDesignOfGeneralisedPolygon</a>
</div></div>
<div class="ContSect"> <a href="chap12_mj.html#X7A13D5EB82E01576">12.4 Elements of generalised polygons</a>

<div class="ContSSBlock">
 <a href="chap12_mj.html#X7E7607CA7D59D086">12.4-1 Collections of elements of generalised polygons</a>

 <a href="chap12_mj.html#X858ADA3B7A684421">12.4-2 Size</a>
 <a href="chap12_mj.html#X7E9B2A217DBF2849">12.4-3 Creating elements from objects and retrieving objects from elements</a>

 <a href="chap12_mj.html#X83B0FA9E7AE3DF01">12.4-4 Incidence</a>

 <a href="chap12_mj.html#X875BE2957FAF6209">12.4-5 Span</a>
 <a href="chap12_mj.html#X8469B54180FE1E4C">12.4-6 Meet</a>
 <a href="chap12_mj.html#X8154BB13844AA0FD">12.4-7 Shadow elements</a>

 <a href="chap12_mj.html#X7807682E86D3BE10">12.4-8 DistanceBetweenElements</a>
</div></div>
<div class="ContSect"> <a href="chap12_mj.html#X7934EB788049B533">12.5 The classical generalised hexagons</a>

<div class="ContSSBlock">
 <a href="chap12_mj.html#X7BF1D2E57B7630CB">12.5-1 Trialities of the hyperbolic quadric and generalised hexagons</a>

 <a href="chap12_mj.html#X7C35384980AA9B77">12.5-2 IsLieGeometry</a>
 <a href="chap12_mj.html#X7A05FF0079F55291">12.5-3 SplitCayleyHexagon</a>
 <a href="chap12_mj.html#X7E17977384011587">12.5-4 TwistedTrialityHexagon</a>
 <a href="chap12_mj.html#X807A60A28264BD93">12.5-5 vector spaceToElement</a>
 <a href="chap12_mj.html#X7809B7C183FA7213">12.5-6 ObjectToElement</a>
 <a href="chap12_mj.html#X810D4D6D87069697">12.5-7 UnderlyingObject</a>
 <a href="chap12_mj.html#X87BDB89B7AAFE8AD"><code>12.5-8 \in</code></a>
 <a href="chap12_mj.html#X7B1380878358938C">12.5-9 Span and meet of elements</a>

 <a href="chap12_mj.html#X83FF6FA0790D5747">12.5-10 CollineationGroup</a>
</div></div>
<div class="ContSect"> <a href="chap12_mj.html#X7BA462527B2777BC">12.6 Elation generalised quadrangles</a>

<div class="ContSSBlock">
 <a href="chap12_mj.html#X86BD86C77BAAF887">12.6-1 Elation generalised quadrangles and Kantor families</a>

 <a href="chap12_mj.html#X7CC6903E78F24167">12.6-2 Categories</a>

 <a href="chap12_mj.html#X820A2D6A84A259FC">12.6-3 Kantor families</a>

 <a href="chap12_mj.html#X7B80E3AC7DEAF948">12.6-4 EGQByKantorFamily</a>
 <a href="chap12_mj.html#X80C93974807A342B">12.6-5 Representation of elements and underlying objects</a>

 <a href="chap12_mj.html#X7DCD7EAB839BD97F">12.6-6 Elation group and natural action on elements</a>

 <a href="chap12_mj.html#X8462F11584736E32">12.6-7 Kantor families, q-clans, and elation generalised quadrangles</a>

 <a href="chap12_mj.html#X806527387F1D5D42">12.6-8 qClan</a>
 <a href="chap12_mj.html#X858A1EA8843BEC13">12.6-9 Particular q-clans</a>

 <a href="chap12_mj.html#X7C59CF8079EA33D3">12.6-10 KantorFamilyByqClan</a>
 <a href="chap12_mj.html#X830222B084BF866D">12.6-11 EGQByqClan</a>
 <a href="chap12_mj.html#X7FAE48497B2F658A">12.6-12 BLT-sets, flocks, q-clans, and elation generalised quadrangles</a>

 <a href="chap12_mj.html#X7A8438537D2F1374">12.6-13 IsEGQByBLTSet</a>
 <a href="chap12_mj.html#X7ECC1871866AC286">12.6-14 BLTSetByqClan</a>
 <a href="chap12_mj.html#X84700DDF80B39332">12.6-15 EGQByBLTSet</a>
 <a href="chap12_mj.html#X79186E29799355BD">12.6-16 DefiningPlanesOfEGQByBLTSet</a>
 <a href="chap12_mj.html#X80C93974807A342B">12.6-17 Representation of elements and underlying objects</a>

 <a href="chap12_mj.html#X7C57B0BD7A2E5877">12.6-18 CollineationSubgroup</a>
</div></div>
</div>

<h3>12 Generalised Polygons</h3>

A generalised n-gon is a point/line geometry whose incidence graph is bipartite of diameter <var class="Arg">n</var> and girth <var class="Arg">2n</var>. 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.

<a id="X7CC6903E78F24167" name="X7CC6903E78F24167"></a>

<h4>12.1 Categories</h4>

<a id="X8141DFFF7B352E2D" name="X8141DFFF7B352E2D"></a>

<h5>12.1-1 IsGeneralisedPolygon</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsGeneralisedPolygon</code></td><td class="tdright">( category )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsGeneralisedPolygonRep</code></td><td class="tdright">( representation )</td></tr></table></div>
This category is a subcategory of <code class="code">IsIncidenceGeometry</code>, and contains all generalised polygons. Generalised polygons constructed through functions described in this chapter, all belong to <code class="code">IsGeneralisedPolygonRep</code>.

<a id="X832E75AE7CCC5BB2" name="X832E75AE7CCC5BB2"></a>

<h5>12.1-2 Subcategories in <code class="code">IsGeneralisedPolygon</code></h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsProjectivePlaneCategory</code></td><td class="tdright">( category )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsGeneralisedQuadrangle</code></td><td class="tdright">( category )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsGeneralisedHexagon</code></td><td class="tdright">( category )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsGeneralisedOctagon</code></td><td class="tdright">( category )</td></tr></table></div>
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 <code class="code">IsGeneralisedQuadrangle</code> and that the desarguesian projective planes (which are the projective spaces of dimension 2) also belong to <code class="code">IsProjectivePlaneCategory</code>, but both do not belong to <code class="code">IsGeneralisedPolygonRep</code>.

<a id="X86C124B3804C7569" name="X86C124B3804C7569"></a>

<h5>12.1-3 IsWeakGeneralisedPolygon</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsWeakGeneralisedPolygon</code></td><td class="tdright">( category )</td></tr></table></div>
<code class="code">IsWeakGeneralisedPolygon</code> is the category for weak generalised polygons.

<a id="X8540C04887CF8824" name="X8540C04887CF8824"></a>

<h5>12.1-4 Subcategories in <code class="code">IsProjectivePlaneCategory</code></h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsDesarguesianPlane</code></td><td class="tdright">( category )</td></tr></table></div>
<code class="code">IsDesarguesianPlane</code> is declared as a subcategory of <code class="code">IsProjectivePlaneCategory</code> and <code class="code">IsProjecticeSpace</code>. Projective spaces of dimension 2 constructed using <code class="file">ProjectiveSpace</code> belong to <code class="code">IsDesarguesianPlane</code>.

<a id="X7CF10DAE7847939D" name="X7CF10DAE7847939D"></a>

<h5>12.1-5 Subcategories in <code class="code">IsGeneralisedQuadrangle</code></h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsClassicalGQ</code></td><td class="tdright">( category )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsElationGQ</code></td><td class="tdright">( category )</td></tr></table></div>
<code class="code">IsClassicalGQ</code> is declared as a subcategory of <code class="code">IsGeneralisedQuadrangle</code> and <code class="code">IsClassicalPolarSpace</code>. All classical polar spaces of rank 2 belong to <code class="code">IsClassicalGQ</code>. <code class="code">IsElationGQ</code> is declared as subcategory of <code class="code">IsGeneralisedQuadrangle</code>. Elation GQs will be discussed in detail in Section <a href="chap12_mj.html#X7BA462527B2777BC">12.6</a>

<div class="example"><pre>
gap> gp := SymplecticSpace(3,2);
W(3, 2)
gap> IsGeneralisedPolygon(gp);
true
gap> IsGeneralisedQuadrangle(gp);
true
gap> IsClassicalGQ(gp);
true
gap> IsGeneralisedPolygonRep(gp);
false

</pre></div>

<a id="X7A2ABB0B818E25C5" name="X7A2ABB0B818E25C5"></a>

<h5>12.1-6 IsClassicalGeneralisedHexagon</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsClassicalGeneralisedHexagon</code></td><td class="tdright">( category )</td></tr></table></div>
<code class="code">IsClassicalGeneralisedHexagon</code> is declared as subcategory of <code class="code">IsGeneralisedHexagon</code> and <code class="code">IsLieGeometry</code>. 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 <code class="code">IsLieGeometry</code> means that the usual operations for Lie geometries become applicable. The classical generalised hexagons are in detail discussed in Section <a href="chap12_mj.html#X7934EB788049B533">12.5</a>

<div class="example"><pre>
gap> gp := SplitCayleyHexagon(3);
H(3)
gap> IsGeneralisedHexagon(gp);
true
gap> IsClassicalGeneralisedHexagon(gp);
true
gap> IsLieGeometry(gp);
true
gap> IsGeneralisedPolygonRep(gp);
true

</pre></div>

<a id="X8614D6A779F9B1AA" name="X8614D6A779F9B1AA"></a>

<h4>12.2 Generic functions to create generalised polygons</h4>

<a id="X849A83597CC78B5F" name="X849A83597CC78B5F"></a>

<h5>12.2-1 GeneralisedPolygonByBlocks</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ GeneralisedPolygonByBlocks</code>( <var class="Arg">l</var> )</td><td class="tdright">( operation )</td></tr></table></div>
Returns: a generalised polygon

The argument <var class="Arg">l</var> is a finite homogeneous list consisting of ordered sets of a common size \(n+1\). This operation will assume that each element of <var class="Arg">l</var> represents a line of the generalised polygon. Its points are assumed to be the union of all elements of <var class="Arg">l</var>. 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.

<div class="example"><pre>
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>

</pre></div>

<a id="X8751B0FB8500D0B1" name="X8751B0FB8500D0B1"></a>

<h5>12.2-2 GeneralisedPolygonByIncidenceMatrix</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ GeneralisedPolygonByIncidenceMatrix</code>( <var class="Arg">incmat</var> )</td><td class="tdright">( operation )</td></tr></table></div>
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 <var class="Arg">incmat</var> a homogeneous list of sets of column entries is derived, which is then passed to <code class="file">GeneralisedPolygonByBlocks</code>. When <var class="Arg">incmat</var> indeed represents a generalised polygon, it is returned. The checks are performed by <code class="file">GeneralisedPolygonByBlocks</code>.

<div class="example"><pre>
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>

</pre></div>

<a id="X7A6169127CE8ABC0" name="X7A6169127CE8ABC0"></a>

<h5>12.2-3 GeneralisedPolygonByElements</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ GeneralisedPolygonByElements</code>( <var class="Arg">pts</var>, <var class="Arg">lns</var>, <var class="Arg">inc</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ GeneralisedPolygonByElements</code>( <var class="Arg">pts</var>, <var class="Arg">lns</var>, <var class="Arg">inc</var>, <var class="Arg">grp</var>, <var class="Arg">act</var> )</td><td class="tdright">( operation )</td></tr></table></div>
Returns: a generalised polygon

The argument <var class="Arg">pts</var>, <var class="Arg">lns</var> and <var class="Arg">inc</var> are respectively a set of objects, a set of objects and a function. The function <var class="Arg">inc</var> must represent an incidence relation between objects of <var class="Arg">pts</var> and <var class="Arg">lns</var>. The first version of <code class="file">GeneralisedPolygonByElements</code> 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 <var class="Arg">grp</var> is a group, and <var class="Arg">act</var> a function, representing an action of the elements of <var class="Arg">grp</var> on the objects in the lists <var class="Arg">pts</var> and <var class="Arg">lns</var>, preserving the incidence. The second version of <code class="file">GeneralisedPolygonByElements</code> acts as the first version, but uses <var class="Arg">grp</var> and <var class="Arg">act</var> to construct the incidence graph in a more efficient way, so if <var class="Arg">grp</var> 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)\).

<div class="example"><pre>
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

</pre></div>

<a id="X864C966D8184A9C0" name="X864C966D8184A9C0"></a>

<h4>12.3 Attributes and operations for generalised polygons</h4>

All operations described in this section are applicable on objects in the category <code class="code">IsGeneralisedPolygon</code>.

<a id="X84F59A2687C62763" name="X84F59A2687C62763"></a>

<h5>12.3-1 Order</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Order</code>( <var class="Arg">gp</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
Returns: a pair of positive integers

This method returns the parameters \((s,t)\) of the generalised polygon <var class="Arg">gp</var>. That is, \(s+1\) is the number of points on any line of <var class="Arg">gp</var>, and \(t+1\) is the number of lines incident with any point of <var class="Arg">gp</var>.

<div class="example"><pre>
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 ]

</pre></div>

<a id="X836C15B57968A511" name="X836C15B57968A511"></a>

<h5>12.3-2 IncidenceGraphAttr</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IncidenceGraphAttr</code>( <var class="Arg">gp</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
This attribute is declared for objects in <code class="code">IsGeneralisedPolygon</code>. It is a mutable attribute and can be accessed by the operation <code class="file">IncidenceGraph</code>.

<a id="X815BE6D57D623452" name="X815BE6D57D623452"></a>

<h5>12.3-3 IncidenceGraph</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IncidenceGraph</code>( <var class="Arg">gp</var> )</td><td class="tdright">( operation )</td></tr></table></div>
Returns: a graph

The argument <var class="Arg">gp</var> is a generalised polygon. This operation returns the incidence graph of <var class="Arg">gp</var>. If <var class="Arg">gp</var> is constructed using <code class="file">GeneralisedPolygonByBlocks</code>, <code class="file">GeneralisedPolygonByElements</code> or <code class="file">GeneralisedPolygonByIncidenceMatrix</code>, 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 <var class="Arg">gp</var> has no collineation group computed. Therefore, this operation will return an error when <var class="Arg">gp</var> has no collineation group computed. As <code class="file">CollineationGroup</code> is an attribute for objects in <code class="code">IsGeneralisedPolygon</code>, 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 <var class="Arg">gp</var>, 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 <var class="Arg">gp</var>. 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.

<div class="example"><pre>
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

</pre></div>

<a id="X81F531BB7DEA127D" name="X81F531BB7DEA127D"></a>

<h5>12.3-4 IncidenceMatrixOfGeneralisedPolygon</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IncidenceMatrixOfGeneralisedPolygon</code>( <var class="Arg">gp</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
Returns: a matrix

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

<div class="example"><pre>
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 ] ]

</pre></div>

<a id="X83FF6FA0790D5747" name="X83FF6FA0790D5747"></a>

<h5>12.3-5 CollineationGroup</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CollineationGroup</code>( <var class="Arg">gp</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
Returns: a group

This attribute returns the full collineation group of the generalised polygon <var class="Arg">gp</var>. For some particular generalised polygons, a (subgroup) of the full collineation group can be computed efficiently without computing the incidence graph of <var class="Arg">gp</var>: 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 <code class="file">GeneralisedPolygonByBlocks</code>, <code class="file">GeneralisedPolygonByElements</code> or <code class="file">GeneralisedPolygonByIncidenceMatrix</code>, 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. <code class="file">GeneralisedPolygonByElements</code>.

The first example illustrates that <code class="file">CollineationGroup</code> is naturally applicable to all classical generalised Polygons.

<div class="example"><pre>
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

</pre></div>

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

<div class="example"><pre>
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)

</pre></div>

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 <code class="file">CollineationGroup</code> 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)\).

<div class="example"><pre>
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

</pre></div>

<a id="X8074EDB381D97984" name="X8074EDB381D97984"></a>

<h5>12.3-6 CollineationAction</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CollineationAction</code>( <var class="Arg">group</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
Returns: a function

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

<div class="example"><pre>
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 ]

</pre></div>

<a id="X7D75521986B958DA" name="X7D75521986B958DA"></a>

<h5>12.3-7 BlockDesignOfGeneralisedPolygon</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ BlockDesignOfGeneralisedPolygon</code>( <var class="Arg">gp</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
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 <var class="Arg">gp</var> 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 <var class="Arg">gp</var> 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.

<div class="example"><pre>
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 ],
--> --------------------

--> maximum size reached

--> --------------------

quality95%

¤ Dauer der Verarbeitung: 0.31 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.