<?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>
<title>GAP (orb) - Chapter 3: Basic orbit enumeration</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" />
</head>
<body>
<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chap7.html">7</a> <a href="chap8.html">8</a> <a href="chap9.html">9</a> <a href="chap10.html">10</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
<div class="chlinkprevnexttop"> <a href="chap0.html">Top of Book</a> <a href="chap2.html">Previous Chapter</a> <a href="chap4.html">Next Chapter</a> </div>
<p><a id="X7D55DB437F5407E8" name="X7D55DB437F5407E8"></a></p>
<div class="ChapSects"><a href="chap3.html#X7D55DB437F5407E8">3 <span class="Heading">Basic orbit enumeration</span></a>
<div class="ContSect"><span class="nocss"> </span><a href="chap3.html#X87DF498E7F386786">3.1 <span class="Heading">Enumerating orbits</span></a>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X86A89A0881CE04F6">3.1-1 Orb</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X7BCD5342793C7A7E">3.1-2 Enumerate</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X81D5A4A97AA9D4B0">3.1-3 IsClosed</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X81BF5A087B9E1353">3.1-4 <span class="Heading">Options for orbits</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X7B11180F80A77D48">3.1-5 <span class="Heading">Output components of orbits</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X833670F47BD5632C">3.1-6 StabWords</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X84F62CB679D6B3CE">3.1-7 PositionOfFound</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X79A6D04C7CBABFC7">3.1-8 DepthOfSchreierTree</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X81C12D677CE815C7">3.1-9 ActionOnOrbit</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X7EA4E92180F142D3">3.1-10 OrbActionHomomorphism</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X7F927E787BA898BF">3.1-11 TraceSchreierTreeForward</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X80615B4D83620AA1">3.1-12 TraceSchreierTreeBack</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X7D892CE87E7EBEDB">3.1-13 ActWithWord</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X799D2F3C866B9AED">3.1-14 EvaluateWord</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X7D100BE4820039C1">3.1-15 AddGeneratorsToOrbit</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X823F7A9A83EACFD0">3.1-16 MakeSchreierTreeShallow</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X8566B13379E697F6">3.1-17 FindSuborbits</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X83015A9E823E1AB1">3.1-18 OrbitIntersectionMatrix</a></span>
</div>
</div>
<h3>3 <span class="Heading">Basic orbit enumeration</span></h3>
<p>This package contains a new implementation of the standard orbit enumeration algorithm. The design principles for this implementation have been:</p>
<ul>
<li><p>Allow partial orbit enumeration and later continuation.</p>
</li>
<li><p>Consequently use hashing techniques.</p>
</li>
<li><p>Implement stabiliser calculation and Schreier transversals on demand.</p>
</li>
<li><p>Allow for searching in orbits during orbit enumeration.</p>
</li>
</ul>
<p>Some of these design principles made it necessary to change the user interface in comparison to the standard <strong class="pkg">GAP</strong> one.</p>
<p><a id="X87DF498E7F386786" name="X87DF498E7F386786"></a></p>
<h4>3.1 <span class="Heading">Enumerating orbits</span></h4>
<p>The enumeration of an orbit works in at least two stages: First an orbit object is created with all the necessary information to describe the orbit. Then the actual enumeration is started. The latter stage can be repeated as many times as needed in the case that the orbit enumeration stopped for some reason before the orbit was enumerated completely. See below for conditions under which this happens.</p>
<p>For orbit object creation there is the following function:</p>
<p><a id="X86A89A0881CE04F6" name="X86A89A0881CE04F6"></a></p>
<h5>3.1-1 Orb</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> Orb</code>( <var class="Arg">gens, point, op[, opt]</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p><b>Returns: </b>An orbit object</p>
<p>The argument <var class="Arg">gens</var> is either a <strong class="pkg">GAP</strong> group object or a list of generators of the group acting, <var class="Arg">point</var> is a point in the orbit to be enumerated, <var class="Arg">op</var> is a <strong class="pkg">GAP</strong> function describing the action of the generators on points in the usual way, that is, <code class="code"><var class="Arg">op</var>(p,g)</code> returns the result of the action of the element <code class="code">g</code> on the point <code class="code">p</code>.</p>
<p>The optional argument <var class="Arg">opt</var> is a <strong class="pkg">GAP</strong> record which can contain quite a few options changing the orbit enumeration. For a list of possible options see Subsection <a href="chap3.html#X81BF5A087B9E1353"><b>3.1-4</b></a> at the end of this section.</p>
<p>The function returns an "orbit" object that can later be used to enumerate (a part of) the orbit of <var class="Arg">point</var> under the action of the group generated by <var class="Arg">gens</var>.</p>
<p>If <var class="Arg">gens</var> is a group object, then its generators are taken as the list of generators acting. If the group object knows its size, then this size is used to speed up orbit and in particular stabiliser computations.</p>
<p>The following operation actually starts the orbit enumeration:</p>
<p><a id="X7BCD5342793C7A7E" name="X7BCD5342793C7A7E"></a></p>
<h5>3.1-2 Enumerate</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> Enumerate</code>( <var class="Arg">orb[, limit]</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>The orbit object <var class="Arg">orb</var></p>
<p><var class="Arg">orb</var> must be an orbit object created by <code class="func">Orb</code> (<a href="chap3.html#X86A89A0881CE04F6"><b>3.1-1</b></a>). The optional argument <var class="Arg">limit</var> must be a positive integer meaning that the orbit enumeration should stop if <var class="Arg">limit</var> points have been found, regardless whether the orbit is complete or not. Note that the orbit enumeration can be continued by again calling the <code class="func">Enumerate</code> operation. If the argument <var class="Arg">limit</var> is omitted, the whole orbit is enumerated, unless other options lead to prior termination.</p>
<p>To see whether an orbit is closed you can use the following filter:</p>
<p><a id="X81D5A4A97AA9D4B0" name="X81D5A4A97AA9D4B0"></a></p>
<h5>3.1-3 IsClosed</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> IsClosed</code>( <var class="Arg">orb</var> )</td><td class="tdright">( filter )</td></tr></table></div>
<p><b>Returns: </b><code class="keyw">true</code> or <code class="keyw">false</code></p>
<p>The result indicates, whether the orbit <var class="Arg">orb</var> is already complete or not.</p>
<p>Here is an example of an orbit enumeration:</p>
<table class="example">
<tr><td><pre>gap> g := GeneratorsOfGroup(MathieuGroup(24));
[ (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23),
(3,17,10,7,9)(4,13,14,19,5)(8,18,11,12,23)(15,20,22,21,16),
(1,24)(2,23)(3,12)(4,16)(5,18)(6,10)(7,20)(8,14)(9,21)(11,17)
(13,22)(15,19)
]
gap> o := Orb(g,2,OnPoints);
<open Int-orbit, 1 points>
gap> Enumerate(o,20);
<open Int-orbit, 21 points>
gap> IsClosed(o);
false
gap> Enumerate(o);
<closed Int-orbit, 24 points>
gap> IsClosed(o);
true</pre></td></tr></table>
<p>The orbit object <code class="code">o</code> now behaves like an immutable dense list, the entries of which are the points in the orbit in the order as they were found during the orbit enumeration (note that this is not always true when one uses the function <code class="func">AddGeneratorsToOrbit</code> (<a href="chap3.html#X7D100BE4820039C1"><b>3.1-15</b></a>)). So you can ask the orbit for its length, access entries, and ask, whether a given point lies in the orbit or not. Due to the hashing techniques used such lookups are quite fast, they usually only use a constant time regardless of the length of the orbit!</p>
<table class="example">
<tr><td><pre>gap> Length(o);
24
gap> o[1];
2
gap> o[2];
3
gap> o{[3..5]};
[ 23, 4, 17 ]
gap> 17 in o;
true
gap> Position(o,17);
5</pre></td></tr></table>
<p><a id="X81BF5A087B9E1353" name="X81BF5A087B9E1353"></a></p>
<h5>3.1-4 <span class="Heading">Options for orbits</span></h5>
<p>The optional fourth argument <var class="Arg">opt</var> of the function <code class="func">Orb</code> (<a href="chap3.html#X86A89A0881CE04F6"><b>3.1-1</b></a>) is a <strong class="pkg">GAP</strong> record and its components change the behaviour of the orbit enumeration. In this subsection we explain the use of the components of this options record. All components are themselves optional. For every component we also describe the possible values in the following list:</p>
<dl>
<dt><strong class="Mark"><code class="code">eqfunc</code></strong></dt>
<dd><p>This component always has to be given together with the component <code class="code">hashfunc</code>. If both are given, they are used to set up a hash table to store the points in the orbit. You have to use this if the automatic mechanism to find a suitable hash function does not work for your starting point in the orbit.</p>
<p>Note that if you use this feature, the hash table cannot grow automatically any more, unless you also use the components <code class="code">hfbig</code> and <code class="code">hfdbig</code> as well. See the description of <code class="func">GrowHT</code> (<a href="chap4.html#X86E9DEC68728425C"><b>4.3-5</b></a>) for an explanation how to use this feature.</p>
</dd>
<dt><strong class="Mark"><code class="code">genstoapply</code></strong></dt>
<dd><p>This is only used internally and is intentionally not documented.</p>
</dd>
<dt><strong class="Mark"><code class="code">grpsizebound</code></strong></dt>
<dd><p>Possible values for this component are positive integers. By setting this value one can help the orbit enumeration to complete earlier. The given number must be an upper bound for the order of the group. If the exact group order is given and the stabiliser is calculated during the orbit enumeration (see component <code class="code">permgens</code>), then the orbit enumeration can stop as soon as the orbit is found completely and the stabiliser is complete, which is usually much earlier than after all generator are applied to all points in the orbit.</p>
</dd>
<dt><strong class="Mark"><code class="code">hashfunc</code></strong></dt>
<dd><p>See component <code class="code">eqfunc</code>.</p>
</dd>
<dt><strong class="Mark"><code class="code">hashlen</code></strong></dt>
<dd><p>Possible values are positive integers. This component determines the initial size of the hash used for the orbit enumeration. The default value is 10000. If the hash table turns out not to be large enough, it is automatically increased by a factor of two during the calculation. Although this process is quite fast it still improves performance to give a sensible hash size in advance.</p>
</dd>
<dt><strong class="Mark"><code class="code">hfbig</code> and <code class="code">hfdbig</code></strong></dt>
<dd><p>These components can only be used in connection with <code class="code">eqfunc</code> and <code class="code">hashfunc</code> and are otherwise ignored. There values are simply passed on to the hash table created. The idea is to still be able to grow the hash table if need be. See Section <a href="chap4.html#X8069137484662072"><b>4.4</b></a> for more details.</p>
</dd>
<dt><strong class="Mark"><code class="code">log</code></strong></dt>
<dd><p>If this component is set to <code class="keyw">true</code> then a log of the enumeration of the orbit is written into the components <code class="code">log</code>, <code class="code">logind</code> and <code class="code">logpos</code>. Every time a new point is found in the orbit enumeration, two numbers are appended to the log, first the number of the generator applied, then the index, under which the new point is stored in the orbit. For each point in the orbit, the start of the entries for that point in <code class="code">log</code> is stored in <code class="code">logind</code> and the end of those entries is marked by storing the number of the last generator producing a new point negated.</p>
<p>The purpose of a log is the following: With a log one can later add group generators to the orbit and thus get a different Schreier tree, such that the resulting orbit enumeration is still a breadth first enumeration using the new generating set! This is desirable to decrease the depth of the Schreier tree. The log helps to implement this in a way, such that the old generators do not again have to be applied to all the points in the orbit. See <code class="func">AddGeneratorsToOrbit</code> (<a href="chap3.html#X7D100BE4820039C1"><b>3.1-15</b></a>) for details.</p>
<p>A log needs roughly 3 machine words per point in the orbit as memory.</p>
</dd>
<dt><strong class="Mark"><code class="code">lookingfor</code></strong></dt>
<dd><p>This component is used to search for something in the orbit. The idea is that the orbit enumeration is stopped when some condition is met. This condition can be specified with a great flexibility. The first way is to store a list of points into <code class="code">orb.lookingfor</code>. In that case the orbit enumeration stops, when a point is found that is in that list. A second possiblity is to store a hash table object into <code class="code">orb.lookingfor</code>. Then every newly found point in the orbit is looked up in that hash table and the orbit enumeration stops as soon as a point is found that is also in the hash table. The third possibility is functional: You can store a <strong class="pkg">GAP</strong> function into <code class="code">opt.lookingfor</code> which is called for every newly found point in the orbit. It gets both the orbit object and the point as its two arguments. This function has to return <code class="keyw">false</code> or <code class="keyw">true</code> and in the latter case the orbit enumeration is stopped.</p>
<p>Whenever the orbit enumeration is stopped the component <code class="code">found</code> is set to the number of the found point in the orbit. Access this information using <code class="code">PositionOfFound(orb)</code>.</p>
</dd>
<dt><strong class="Mark"><code class="code">matgens</code></strong></dt>
<dd><p>This is not yet implemented. It will allow for stabiliser computations in matrix groups.</p>
</dd>
<dt><strong class="Mark"><code class="code">onlystab</code></strong></dt>
<dd><p>If this boolean flag is set to <code class="keyw">true</code> then the orbit enumeration stops once the stabiliser is completely determined. Note that this can only be known, if a bound for the group size is given in the <code class="code">opt.grpsizebound</code> option and when more than half of the orbit is already found, or when <code class="code">opt.stabsizebound</code> is given.</p>
</dd>
<dt><strong class="Mark"><code class="code">orbsizebound</code></strong></dt>
<dd><p>Possible values for this component are positive integers. The given number must be an upper bound for the orbit length. Giving this number helps the orbit enumeration to stop earlier, when the orbit is found completely.</p>
</dd>
<dt><strong class="Mark"><code class="code">permbase</code></strong></dt>
<dd><p>This component is used to tell the orbit enumerator that a certain list of points is a base of the permutation representation given in the <code class="code">opt.permgens</code> component. This information is often available beforehand and can drastically speed up the calculation of Schreier generators, especially for the common case that they are trivial. The value is just a list of integers.</p>
</dd>
<dt><strong class="Mark"><code class="code">permgens</code></strong></dt>
<dd><p>If this component is set, it must be set to a list of permutations, that represent the same group as the generators used to define the orbit. This permutation representation is then used to calculate the stabiliser of the starting point. After the orbit enumeration is complete, you can call <code class="code">Stabilizer(<var class="Arg">orb</var>)</code> with <var class="Arg">orb</var> being the orbit object and get the stabiliser as a permutation group. The stabiliser is also stored in the <code class="code">stab</code> component of the orbit object. Furthermore, the size of the stabiliser is stored in the <code class="code">stabsize</code> component of the orbit object and the component <code class="code">stabwords</code> contains the stabiliser generators as words in the original group generators. Access these words with <code class="code">StabWords(orb)</code>. Here, a word is a list of integers, where positive integers are numbers of generators and a negative integer i indicates the inverse of the generator with number -i. In this way, complete information about the stabiliser can be derived from the orbit object.</p>
</dd>
<dt><strong class="Mark"><code class="code">report</code></strong></dt>
<dd><p>Possible values are non-negative integers. This value asks for a status report whenever the orbit enumeration has applied all generators to <code class="code">opt.report</code> points. A value of 0, which is the default, switches off this report. In each report, the total number of points already found are given.</p>
</dd>
<dt><strong class="Mark"><code class="code">schreier</code></strong></dt>
<dd><p>This boolean flag decides, whether a Schreier tree is stored together with the orbit. A Schreier tree just stores for each point, which generator was applied to which other point in the orbit to get it. Thus, having the Schreier tree enables the usage of the operations <code class="func">TraceSchreierTreeForward</code> (<a href="chap3.html#X7F927E787BA898BF"><b>3.1-11</b></a>) and <code class="func">TraceSchreierTreeBack</code> (<a href="chap3.html#X80615B4D83620AA1"><b>3.1-12</b></a>). A Schreier tree needs two additional machine words of memory per point in the orbit. The <code class="code">opt.schreier</code> flag is automatically set when a stabiliser is computed during orbit enumeration (see components <code class="code">opt.permgens</code> and <code class="code">opt.matgens</code>).</p>
</dd>
<dt><strong class="Mark"><code class="code">schreiergenaction</code></strong></dt>
<dd><p>The value of this component must be a function with 4 arguments: the orbit object, an index <var class="Arg">i</var>, an integer <var class="Arg">j</var>, and an index <var class="Arg">pos</var>. It is called, whenever during the orbit enumeration generator number <var class="Arg">j</var> was applied to point number <var class="Arg">i</var> and the result was an already known point with number <var class="Arg">pos</var>. This is no longer done, once the component <code class="code">stabcomplete</code> is set to <code class="keyw">true</code>, which happens when there is evidence that the stabiliser is already completely determined.</p>
<p>This component is used internally when the <code class="code">permgens</code> component was set and the stabiliser is calculated.</p>
</dd>
<dt><strong class="Mark"><code class="code">stab</code></strong></dt>
<dd><p>This component is used to tell the orbit enumerator that a subgroup of the stabiliser of the starting point is already known. Store a subgroup of the group generated by the permutations in <code class="code">opt.permgens</code> stabilising the starting point into this component.</p>
</dd>
<dt><strong class="Mark"><code class="code">stabchainrandom</code></strong></dt>
<dd><p>This value can be a positive integer between 1 and 1000. If <code class="code">opt.permgens</code> is given, an integer value is used to set the <code class="code">random</code> option when calculating a stabiliser chain to compute the size of the group generated by the Schreier generators. Although this size computation can be speeded up considerably, the user should be aware that for values smaller than 1000 this triggers a Monte Carlo algorithm that can produce wrong results with a certain error probability. A verification of the obtained results is advisable. Note however, that such computations can only err in one direction, namely underestimating the size of the group.</p>
</dd>
<dt><strong class="Mark"><code class="code">stabsizebound</code></strong></dt>
<dd><p>Possible values for this component are positive integers. The given number must be an upper bound for the size of the stabiliser. Giving this number helps the orbit enumeration to stop earlier, when also <code class="code">opt.orbsizebound</code> or <code class="code">opt.grpsizebound</code> are given or when <code class="code">opt.onlystab</code> is set.</p>
</dd>
<dt><strong class="Mark"><code class="code">storenumbers</code></strong></dt>
<dd><p>This boolean flag decides, whether the positions of points in the orbit are stored in the hash. The memory requirement for this is one machine word (4 or 8 bytes depending on the architecture) per point in the orbit. If you just need the orbit itself this is not necessary. If you however want to find the position of a point in the orbit efficiently after enumeration, then you should switch this on. That is, the operation <code class="code">\in</code> is always fast, but <code class="code">Position(<var class="Arg">orb</var>, <var class="Arg">point</var>)</code> is only fast if <code class="code">opt.storenumbers</code> was set to <code class="keyw">true</code> or the orbit is "permutations acting on positive integers". In the latter case this flag is ignored.</p>
</dd>
</dl>
<p>For some examples using these options see Chapter <a href="chap10.html#X7A489A5D79DA9E5C"><b>10</b></a>.</p>
<p><a id="X7B11180F80A77D48" name="X7B11180F80A77D48"></a></p>
<h5>3.1-5 <span class="Heading">Output components of orbits</span></h5>
<p>The following components are bound in an orbit object. There might be some more, but those are implementation specific and not guaranteed to be there in future versions. Note that you have to access these components using the "<code class="code">.~</code>" dot exclamation mark notation and you should avoid using these if at all possible.</p>
<dl>
<dt><strong class="Mark"><code class="code">depth</code> and <code class="code">depthmarks</code></strong></dt>
<dd><p>If the orbit has either a Schreier tree or a log, then the component <code class="code">depth</code> holds its depth, that is the maximal number of generator applications needed to reach any point in the orbit. The corresponding component <code class="code">depthmarks</code> is a list of indices, at position i it holds the index of the first point in the orbit in depth i in the Schreier tree.</p>
</dd>
<dt><strong class="Mark"><code class="code">gens</code></strong></dt>
<dd><p>The list of group generators.</p>
</dd>
<dt><strong class="Mark"><code class="code">ht</code></strong></dt>
<dd><p>If the orbit uses a hash table it is stored in this component.</p>
</dd>
<dt><strong class="Mark"><code class="code">op</code></strong></dt>
<dd><p>The operation function.</p>
</dd>
<dt><strong class="Mark"><code class="code">orbind</code></strong></dt>
<dd><p>If generators have been added to the orbit later then the order in which the points are actually stored in the orbit might not correspond to a breadth first search. To cover this case, the component <code class="code">orbind</code> contains in position i the index under which the i-th point in the breadth-first search using the new generating set is actually stored in the orbit.</p>
</dd>
<dt><strong class="Mark"><code class="code">schreiergen</code> and <code class="code">schreierpos</code></strong></dt>
<dd><p>If a Schreier tree of the orbit was kept then both these components are lists containing integers. If point number i was found by applying generator number j to point number p then position i of <code class="code">schreiergen</code> is j and position i of <code class="code">schreierpos</code> is p. You can use the operations <code class="func">TraceSchreierTreeForward</code> (<a href="chap3.html#X7F927E787BA898BF"><b>3.1-11</b></a>) and <code class="func">TraceSchreierTreeBack</code> (<a href="chap3.html#X80615B4D83620AA1"><b>3.1-12</b></a>) to compute words in the generators using these two components.</p>
</dd>
<dt><strong class="Mark"><code class="code">tab</code></strong></dt>
<dd><p>For an orbit in which permutations act on positive integers this component is bound to a list containing in position i the index in the orbit, where the number i is stored.</p>
</dd>
</dl>
<p>The following operations help to ask additional information about orbit objects:</p>
<p><a id="X833670F47BD5632C" name="X833670F47BD5632C"></a></p>
<h5>3.1-6 StabWords</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> StabWords</code>( <var class="Arg">orb</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>A list of words</p>
<p>If the stabiliser was computed during the orbit enumeration, then this function returns the stabiliser generators found as words in the generators. A word is a sequence of integers, where positive integers stand for generators and negative numbers for their inverses.</p>
<p><a id="X84F62CB679D6B3CE" name="X84F62CB679D6B3CE"></a></p>
<h5>3.1-7 PositionOfFound</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> PositionOfFound</code>( <var class="Arg">orb</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>An integer</p>
<p>If during the orbit enumeration the option <code class="code">lookingfor</code> was used and the orbit enumerator looked for something, then this operation returns the index in the orbit, where the something was found most recently.</p>
<p><a id="X79A6D04C7CBABFC7" name="X79A6D04C7CBABFC7"></a></p>
<h5>3.1-8 DepthOfSchreierTree</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> DepthOfSchreierTree</code>( <var class="Arg">orb</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>An integer</p>
<p>If a Schreier tree or a log was stored during orbit enumeration, then this operation returns the depth of the Schreier tree.</p>
<p>We present a few more operations one can do with orbit objects. One can express the action of a given group element in the group generated by the generators given in the <code class="code">Orb</code> command on this orbit as a permutation:</p>
<p><a id="X81C12D677CE815C7" name="X81C12D677CE815C7"></a></p>
<h5>3.1-9 ActionOnOrbit</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> ActionOnOrbit</code>( <var class="Arg">orb, grpels</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>A permutation or <code class="keyw">fail</code></p>
<p><var class="Arg">orb</var> must be an orbit object and <var class="Arg">grpels</var> a list of group elements acting on the orbit. This operation calculates the action of <var class="Arg">grpels</var> on <var class="Arg">orb</var> as <strong class="pkg">GAP</strong> permutations, where the numbering of the points is in the same order as the points have been found in the orbit. Note that this operation is particularly fast if the orbit is an orbit of a permutation group acting on positive integers or if you used the option <code class="code">storenumbers</code> described in Subsection <a href="chap3.html#X81BF5A087B9E1353"><b>3.1-4</b></a>.</p>
<p><a id="X7EA4E92180F142D3" name="X7EA4E92180F142D3"></a></p>
<h5>3.1-10 OrbActionHomomorphism</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> OrbActionHomomorphism</code>( <var class="Arg">g, orb</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>An action homomorphism</p>
<p>The argument <var class="Arg">g</var> must be a group and <var class="Arg">orb</var> an orbit on which <var class="Arg">g</var> acts in the action of the orbit object. This operation returns a homomorphism into a permutation group acquired by taking the action of <var class="Arg">g</var> on the orbit.</p>
<p><a id="X7F927E787BA898BF" name="X7F927E787BA898BF"></a></p>
<h5>3.1-11 TraceSchreierTreeForward</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> TraceSchreierTreeForward</code>( <var class="Arg">orb, nr</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>A word in the generators</p>
<p><var class="Arg">orb</var> must be an orbit object with a Schreier tree, that is, the option <code class="code">schreier</code> must have been set during creation, and <var class="Arg">nr</var> must be the number of a point in the orbit. This operation traces the Schreier tree and returns a word in the generators that maps the starting point to the point with number <var class="Arg">nr</var>. Here, a word is a list of integers, where positive integers are numbers of generators and a negative integer i indicates the inverse of the generator with number -i.</p>
<p><a id="X80615B4D83620AA1" name="X80615B4D83620AA1"></a></p>
<h5>3.1-12 TraceSchreierTreeBack</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> TraceSchreierTreeBack</code>( <var class="Arg">orb, nr</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>A word in the generators</p>
<p><var class="Arg">orb</var> must be an orbit object with a Schreier tree, that is, the option <code class="code">schreier</code> must have been set during creation, and <var class="Arg">nr</var> must be the number of a point in the orbit. This operation traces the Schreier tree and returns a word in the generators that maps the point with number <var class="Arg">nr</var> to the starting point. As above, a word is here a list of integers, where positive integers are numbers of generators and a negative integer i indicates the inverse of the generator with number -i.</p>
<p><a id="X7D892CE87E7EBEDB" name="X7D892CE87E7EBEDB"></a></p>
<h5>3.1-13 ActWithWord</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> ActWithWord</code>( <var class="Arg">gens, w, op, p</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>A point</p>
<p><var class="Arg">gens</var> must be a list of group generators, <var class="Arg">w</var> a list of positive integers less than or equal to the length of <var class="Arg">gens</var>, <var class="Arg">op</var> an action function and <var class="Arg">p</var> a point. This operation computes the action of the word <var class="Arg">w</var> in the generators <var class="Arg">gens</var> on the point <var class="Arg">p</var> and returns the result.</p>
<p><a id="X799D2F3C866B9AED" name="X799D2F3C866B9AED"></a></p>
<h5>3.1-14 EvaluateWord</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> EvaluateWord</code>( <var class="Arg">gens, w</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>A group element</p>
<p><var class="Arg">gens</var> must be a list of group generators, <var class="Arg">w</var> a list of positive integers less than or equal to the length of <var class="Arg">gens</var>. This operation evaluates the word <var class="Arg">w</var> in the generators <var class="Arg">gens</var> and returns the result.</p>
<p><a id="X7D100BE4820039C1" name="X7D100BE4820039C1"></a></p>
<h5>3.1-15 AddGeneratorsToOrbit</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> AddGeneratorsToOrbit</code>( <var class="Arg">orb, l[, p]</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>The orbit object <var class="Arg">orb</var></p>
<p><var class="Arg">orb</var> must be an orbit object, <var class="Arg">l</var> a list of new generators and, if given, <var class="Arg">p</var> must be a list of permutations of equal length. <var class="Arg">p</var> must be given if and only if the component <code class="code">permgens</code> was specified upon creation of the orbit object. The new generators are appended to the old list of generators. The orbit object is changed such that it then shows the outcome of a breadth-first orbit enumeration with the <em>new</em> list of generators. Note that the order of the points already enumerated will <em>not</em> be changed. However, the Schreier tree changes, the component <code class="code">orbind</code> is changed to indicate the order in which the points were found in the breadth-first search with the new generators and the components <code class="code">depth</code> and <code class="code">depthmarks</code> are changed.</p>
<p>Note that all this is particularly efficient if the orbit has a log. If you add generators to an orbit with log, the old generators do not have to be applied again to all points!</p>
<p>Note that new generators can actually enlarge an orbit if they generate a larger group than the old ones alone. Note also that when adding generators, the orbit is automatically enumerated completely</p>
<p><a id="X823F7A9A83EACFD0" name="X823F7A9A83EACFD0"></a></p>
<h5>3.1-16 MakeSchreierTreeShallow</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> MakeSchreierTreeShallow</code>( <var class="Arg">orb[, d]</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>The orbit object <var class="Arg">orb</var></p>
<p>Uses <code class="func">AddGeneratorsToOrbit</code> (<a href="chap3.html#X7D100BE4820039C1"><b>3.1-15</b></a>) to add more generators to the orbit in order to make the Schreier tree shallower. If <var class="Arg">d</var> it is given, generators are added until the depth is less than or equal to <var class="Arg">d</var> or until three more generators did not reduce the depth any more. If <var class="Arg">d</var> is not given, then the logarithm to base 2 of the orbit length is taken as a default value.</p>
<p><a id="X8566B13379E697F6" name="X8566B13379E697F6"></a></p>
<h5>3.1-17 FindSuborbits</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> FindSuborbits</code>( <var class="Arg">orb, subgens[, nrsuborbits]</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>A record</p>
<p>The argument <var class="Arg">orb</var> must be a closed orbit object with a Schreier vector, <var class="Arg">subgens</var> a list of generators for a subgroup of the originally acting group. If given, <var class="Arg">nrsuborbits</var> must be a lower limit for the number of suborbits.</p>
<p>The returned record describes the suborbit structure of <var class="Arg">orb</var> with respect to the group generated by <var class="Arg">subgens</var> using the following components: <code class="code">issuborbitrecord</code> is bound to <code class="keyw">true</code>, <code class="code">o</code> is bound to <var class="Arg">orb</var>, <code class="code">nrsuborbits</code> is bound to the number of suborbits and <code class="code">reps</code> is a list of length <code class="code">nrsuborbits</code> containing the index in the orbit of a representative for each suborbit. Likewise, <code class="code">words</code> contains words in the original group generators of the orbit that map the starting point of the orbit to those representatives. <code class="code">lens</code> is a list containing the lengths of the suborbits. The component <code class="code">suborbs</code> is bound to a list of lists, one for each suborbit containing the indices of the points in the orbit. The component <code class="code">suborbnr</code> is a list with the same length as the orbit, containing in position i the number of the suborbit in which point i in the orbit is contained.</p>
<p>Finally, the component <code class="code">conjsuborbit</code> is bound to a list of length <code class="code">nrsuborbits</code>, containing for each suborbit the number the suborbit reached from the starting point by the inverse of the word used to reach the orbit representative. This latter information probably only makes sense when the subgroup generated by <var class="Arg">subgens</var> is contained in the point stabiliser of the starting point of the orbit, because then this is the so-called conjugate suborbit of a suborbit.</p>
<p><a id="X83015A9E823E1AB1" name="X83015A9E823E1AB1"></a></p>
<h5>3.1-18 OrbitIntersectionMatrix</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> OrbitIntersectionMatrix</code>( <var class="Arg">r, g</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p><b>Returns: </b>An integer matrix</p>
<p>The argument <var class="Arg">r</var> must be a suborbit record as returned by the operation <code class="func">FindSuborbits</code> (<a href="chap3.html#X8566B13379E697F6"><b>3.1-17</b></a>) above, describing the suborbit structure of an orbit with respect to a subgroup. <var class="Arg">g</var> must be an element of the acting group. If k is the number of suborbits and the suborbits are O_1, ..., O_k, then the matrix returned by this operation has the integer |O_i * <var class="Arg">g</var> cap O_j| in its (i,j)-entry.</p>
<div class="chlinkprevnextbot"> <a href="chap0.html">Top of Book</a> <a href="chap2.html">Previous Chapter</a> <a href="chap4.html">Next Chapter</a> </div>
<div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chap7.html">7</a> <a href="chap8.html">8</a> <a href="chap9.html">9</a> <a href="chap10.html">10</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
<hr />
<p class="foot">generated by <a href="http://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
</body>
</html>
distrib
>
Mandriva
>
2010.0
>
i586
>
media
>
contrib-release
>
by-pkgid
>
5e1854624d3bc613bdd0dd13d1ef9ac7
>
files
>
2532
