#############################################################################
##
#W orbits.xml
#Y Copyright (C) 2011-13 James D. Mitchell
##
## Licensing information can be found in the README file of this package.
##
#############################################################################
##
<#GAPDoc Label="EnumeratePosition">
<ManSection>
<Func Name = "EnumeratePosition" Arg = "o, val[, onlynew]"/>
<Returns>
A positive integer or <K>fail</K>.
</Returns>
<Description>
This function returns the position of the value <A>val</A> in the orbit
<A>o</A>. If <A>o</A> is closed, then this is equivalent to doing
<C>Position(<A>o</A>, <A>val</A>)</C>. However, if <A>o</A> is open, then
the orbit is enumerated until <A>val</A> is found, in which case the
position of <A>val</A> is returned, or the enumeration ends, in which
case <K>fail</K> is returned. <P/>
If the optional argument <A>onlynew</A> is present, it should be
<K>true</K> or <K>false</K>. If <A>onlynew</A> is <K>true</K>, then
<A>val</A> will only be checked against new points in <A>o</A>. Otherwise,
every point in the <A>o</A>, not only the new ones, is considered.
</Description>
</ManSection>
<#/GAPDoc>
<#GAPDoc Label="LookForInOrb">
<ManSection>
<Func Name = "LookForInOrb" Arg = "o, func, start"/>
<Returns>
<K>false</K> or a positive integer.
</Returns>
<Description>
The arguments of this function should be an orbit <A>o</A>, a function
<A>func</A> which gets the orbit object and a point in the orbit as
arguments, and a positive integer <A>start</A>. The function <A>func</A>
will be called for every point in <A>o</A> starting from <A>start</A>
(inclusive) and the orbit will be enumerated until <A>func</A> returns
<K>true</K> or the enumeration ends. In the former case, the position of
the first point in <A>o</A> for which <A>func</A> returns <K>true</K> is
returned, and in the latter <K>false</K> is returned.
<Example><![CDATA[
gap> o := Orb(SymmetricGroup(100), 1, OnPoints);
<open Int-orbit, 1 points>
gap> func := function(o, x) return x = 42; end;
function( o, x ) ... end
gap> LookForInOrb(o, func, 1);
42
gap> o;
<open Int-orbit, 42 points>]]></Example>
</Description>
</ManSection>
<#/GAPDoc>
<#GAPDoc Label="EvaluateWord">
<ManSection>
<Oper Name = "EvaluateWord" Arg = "gens, w"/>
<Returns>A semigroup element.</Returns>
<Description>
The argument <A>gens</A> should be a collection of generators of a
semigroup and the argument <A>w</A> should be a list of positive integers
less than or equal to the length of <A>gens</A>. This operation evaluates
the word <A>w</A> in the generators <A>gens</A>. More precisely,
<C>EvaluateWord(<A>gens</A>, <A>w</A>)</C> returns the equivalent of:
<Log>Product(List(w, i -> gens[i]));</Log>
see also <Ref Oper = "Factorization"/>.<P/>
<List>
<Mark>for elements of a semigroup</Mark>
<Item>
When <A>gens</A> is a list of elements of a semigroup and <A>w</A> is
a list of positive integers less than or equal to the length of
<A>gens</A>, this operation returns the product
<C>gens[w[1]] * gens[w[2]] * .. . * gens[w[n]]</C> when the length of
<A>w</A> is <C>n</C>.
</Item>
<Mark>for elements of an inverse semigroup</Mark>
<Item>
When <A>gens</A> is a list of elements with a semigroup inverse and
<A>w</A> is a list of non-zero integers whose absolute value does not
exceed the length of <A>gens</A>, this operation returns the product
<C>gens[AbsInt(w[1])] ^ SignInt(w[1]) * .. . * gens[AbsInt(w[n])] ^
SignInt(w[n])</C> where <C>n</C> is the length of <A>w</A>.
</Item>
</List>
<#GAPDoc Label="OrbSCC">
<ManSection>
<Func Name = "OrbSCC" Arg = "o"/>
<Returns>
The strongly connected components of an orbit.
</Returns>
<Description>
If <A>o</A> is an orbit created by the <Package>Orb</Package> package
with the option <C>orbitgraph=true</C>, then <C>OrbSCC</C> returns a set
of lists of positions in <A>o</A> corresponding to its strongly connected
components. <P/>
<#GAPDoc Label="OrbSCCLookup">
<ManSection>
<Func Name = "OrbSCCLookup" Arg = "o"/>
<Returns>
A lookup table for the strongly connected components of an orbit.
</Returns>
<Description>
If <A>o</A> is an orbit created by the <Package>Orb</Package> package
with the option <C>orbitgraph=true</C>, then <C>OrbSCCLookup</C> returns
a lookup table for its strongly connected components. More precisely,
<C>OrbSCCLookup(o)[i]</C> equals the index of the strongly connected
component containing <C>o[i]</C>. <P/>
<#GAPDoc Label="ReverseSchreierTreeOfSCC">
<ManSection>
<Func Name = "ReverseSchreierTreeOfSCC" Arg = "o, i"/>
<Returns>
The reverse Schreier tree corresponding to the <A>i</A>th strongly
connected component of an orbit.
</Returns>
<Description>
If <A>o</A> is an orbit created by the <Package>Orb</Package> package with
the option <C>orbitgraph = true</C> and action <C>act</C>, and <A>i</A> is a
positive integer, then <C>ReverseSchreierTreeOfSCC(<A>o</A>, <A>i</A>)</C>
returns a pair <C>[gen, pos]</C> of lists with <C>Length(o)</C> entries
such that <Log>act(o[j], o!.gens[gen[j]]) = o[pos[j]].</Log> The pair <C>[
gen, pos]</C> corresponds to a tree with root <C>OrbSCC(o)[i][1]</C> and a
path from every element of <C>OrbSCC(o)[i]</C> to the root. <P/>
<#GAPDoc Label="SchreierTreeOfSCC">
<ManSection>
<Func Name = "SchreierTreeOfSCC" Arg = "o, i"/>
<Returns>
The Schreier tree corresponding to the <A>i</A>th strongly
connected component of an orbit.
</Returns>
<Description>
If <A>o</A> is an orbit created by the <Package>Orb</Package> package with
the option <C>orbitgraph = true</C> and action <C>act</C>, and <A>i</A> is a
positive integer, then <C>SchreierTreeOfSCC(<A>o</A>, <A>i</A>)</C> returns
a pair <C>[gen, pos]</C> of lists with <C>Length(o)</C> entries such that
<Log>act(o[pos[j]], o!.gens[gen[j]]) = o[j].</Log> The pair <C>[gen, pos
]</C> corresponds to a tree with root <C>OrbSCC(o)[i][1]</C> and a path
from the root to every element of <C>OrbSCC(o)[i]</C>. <P/>
<#GAPDoc Label="TraceSchreierTreeOfSCCBack"/>
<ManSection>
<Oper Name = "TraceSchreierTreeOfSCCBack" Arg = "orb, m, nr"/>
<Returns>A word in the generators.</Returns>
<Description>
<A>orb</A> must be an orbit object with a Schreier tree and orbit
graph, that is, the options <C>schreier</C> and <C>orbitgraph</C> must have
been set to <K>true</K> during the creation of the orbit, <A>m</A> must be
the number of a strongly connected component of <A>orb</A>, and <C>nr</C>
must be the number of a point in the <A>m</A>th strongly connect
component of <A>orb</A>. <P/>
This operation traces the result of <Ref
Func = "ReverseSchreierTreeOfSCC"/> and with arguments <A>orb</A> and
<A>m</A> and returns a word in the generators that maps the point with
number <A>nr</A> to the first point in the <A>m</A>th strongly connected
component of <A>orb</A>. Here, a word is a list of integers, where
positive integers are numbers of generators.
<#GAPDoc Label="TraceSchreierTreeOfSCCForward"/>
<ManSection>
<Oper Name = "TraceSchreierTreeOfSCCForward" Arg = "orb, m, nr"/>
<Returns>
A word in the generators.
</Returns>
<Description>
<A>orb</A> must be an orbit object with a Schreier tree and orbit
graph, that is, the options <C>schreier</C> and <C>orbitgraph</C> must
have been set to <K>true</K> during the creation of the orbit, <A>m</A>
must be the number of a strongly connected component of <A>orb</A>, and
<C>nr</C> must be the number of a point in the <A>m</A>th strongly
connect component of <A>orb</A>. <P/>
This operation traces the result of <Ref Func = "SchreierTreeOfSCC"/> and
with arguments <A>orb</A> and <A>m</A> and returns a word in the
generators that maps the first point in the <A>m</A>th strongly connected
component of <A>orb</A> to the point with number <A>nr</A>. Here, a word
is a list of integers, where positive integers are numbers of generators.
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.
