<!-- $Id: intro.xml,v 1.13 2007/10/04 22:02:12 gap Exp $ -->
<Chapter Label="ch:intro"><Heading>Introduction and Main Functions</Heading>
This chapter provides an overview of the background material, and provides
documentation for the main functions and data structures of the MapClass
package.
Let <M>G</M> be a finite group, let <M>C_1,\ldots, C_r</M> be a
collection of conjugacy classes in <M>G</M>. Let <M>\mathcal{E} =
\mathcal{E}(G,g,(C_1, \dots, C_r))</M> denote the set of all tuples
<M> \sigma = (\sigma_1,...,\sigma_{2g+r})\in G^{2g+r}</M> (for natural
numbers <M>g</M> and <M>r</M>) of elements in <M>G</M> satisfying the
relation
<Display> \prod_{i=1}^g [\sigma_i,
\sigma_{g+i}] \prod_{i=1}^r \sigma_{2g+i} = 1
</Display>
and such that <M>\sigma_{2g +k} \in C_k</M>. If the tuple also satisfies
<M>\langle \sigma_1, \ldots, \sigma_{2g+r}\rangle = G</M> it is said
to be <E>generating</E>.<P />
One may associate the
elements of the tuple <M>\sigma</M> with the standard generators of
the fundamental group of a compact connected surface <M>S</M> (genus
<M>g</M>, <M>r</M> punctures). The mapping class group of <M>S</M> is
naturally isomorphic to <M>Out(\pi_1(S))</M> and so gives rise to
an action on the fundamental group of <M>S</M> modulo inner automorphisms.
This action can be transferred to an action on the set <M>\mathcal{E}</M>
(up to conjugation in <M>G</M>). The <E>mapping class
orbits</E> are the orbits of <M>\mathcal{E}</M> under this action. <P />
The package can be used to compute the set <M>\mathcal{E}(G, g,
(C_1,\ldots,C_r))</M> and the corresponding partition into mapping
class orbits for a given group <M>G</M> and a set of conjugacy classes
<M>(C_1,...,C_r)</M> (although the programs expect a tuple of class
representatives). For an example application see Section <Ref
Sect="sec:application" />. We call the tuple <M>(g;C_1,...,C_r)</M>
the signature. The package is an extension of the <E>Braid</E> package
for &GAP;. <P/>
</Section>
<Section Label="mainfunction"><Heading>Overview of Main
Functions</Heading>
The following are the principal ways for calculating the mapping class
orbits for a given signature and group. We require our
groups to be permutation groups, and the tuple in question to have length
at least two.
<ManSection>
<Func Name="AllMCOrbits" Arg="group, genus, tuple"/>
<Description>
This function calculates the orbits for the given group, genus
and tuple. This function is a wrapper for the function <Ref
Filt="AllMCOrbitsCore" />, and so can make use of GAP's
<Keyword>OptionsStack</Keyword>. The options are described in
more detail in the documentation for
<Ref Filt="AllMCOrbitsCore" />. We draw attention to two useful
options: the <Code>OutputStyle</Code> and <Code>SaveOrbit</Code>
options. The <Code>SaveOrbit</Code> option takes values of
either <Keyword>false</Keyword> - in which case the orbit is
not saved to a file - or
it accepts a string that is the name of a directory
in which the routine saves the orbits. See
<Ref Filt="AllMCOrbitsCore" /> for more details on the
saving process.
The <Code> OutputStyle </Code> option controls the verbosity of
the output of the function. It accepts three possible
values:
<List>
<Item>
<Code>"silent"</Code> -- the routine prints no output
except in the case of an Error.
</Item>
<Item>
<Code>"single-line"</Code> -- the routine prints output
to a single line. An intermediate output style for those
who want some output but do not want to see all
diagnostic output.
</Item>
<Item>
<Code>"full"</Code> -- the routine provides full
diagnostic output.
</Item>
</List>
</Description>
</ManSection>
<ManSection>
<Func Name="AllMCOrbitsCore" Arg="group, genus, tuple,
partition, constant"/>
<Description>
This function calculates the orbits for the given group, genus
and tuple, with the <M>r</M> branch points partitioned as in
<A>partition</A>. It uses the given <A>constant</A> to determine how
many of the tuples it want to account for before exiting.
This function also make use of GAP's
<Keyword>OptionsStack</Keyword> if one desires to alter how the
algorithm runs. The following options and their defaults are
given below.
<Table Align="|r|c|">
<HorLine/>
<Row>
<Item>Option Name</Item><Item>Default Value</Item>
</Row>
<HorLine/>
<Row><Item><Code>MaximumWeight</Code></Item><Item>40
</Item></Row>
<Row><Item><Code>MinimumWeight</Code></Item><Item>20
</Item></Row>
<Row><Item><Code>InitialWeight</Code></Item><Item>20
</Item></Row>
<Row><Item><Code>BumpUp</Code></Item><Item>7</Item></Row>
<Row><Item><Code>KnockDown</Code></Item><Item>7</Item></Row>
<Row><Item><Code>InitialNumberOfRandomTuples
</Code></Item><Item>20</Item></Row>
<Row><Item><Code> SaveOrbit </Code></Item><Item>
<Keyword>false</Keyword>
</Item></Row>
<Row><Item><Code> OutputStyle </Code></Item><Item>
<Keyword>"full"</Keyword>
</Item></Row>
<HorLine/>
</Table>
When trying to search for orbits it can be the case that
the routine struggles to find a small orbit because of the low
probability of randomly choosing a tuple in the orbit. To combat
this problem the routine does not choose tuples entirely
randomly but uses a weighted random selection to increase the
probability of selecting tuples appearing in small tuples.
To small subgroups of our group we have an associated weight.
When a subgroup is generated by a tuple in our orbit
frequently then we reduce its weight. Subgroups which do not
appear often have their weight increased. The options
<Code>MaximumWeight</Code>,
<Code>MinimumWeight</Code>,
<Code>InitialWeight</Code>,<Code>BumpUp</Code>, and
<Code>KnockDown</Code>, control this subgroup weighting.
Each option takes positive integer values. They play the
following roles in the weighting process:
<List>
<Item><Code>MaximumWeight</Code> : The maximum weight that a
subgroup can be.
</Item>
<Item><Code>MinimumWeight</Code> : The minimum weight that a
subgroup can be.
</Item>
<Item><Code>InitialWeight</Code> : The weight that a new
subgroup receives when added to to the list of small
subgroups.
</Item>
<Item><Code>BumpUp</Code> : The amount we increase the
weight of a subgroup by when it does not appear
frequently.
</Item>
<Item><Code>KnockDown</Code> : The amount we decrease the
weight of a subgroup by when it appears too
frequently.
</Item>
</List>
The default options were chosen experimentally and so it may be
beneficial to tune these values for a specific case.<P />
The option <Code>InitialNumberOfRandomTuples</Code>
decides how many tuples the routine collects before trying to
see if they are in some pre-existing orbit.<P />
The option <Code>SaveOrbit</Code> which is by default
<Keyword>false</Keyword> can be set to the name of a directory
in which you want to save orbits. This option then saves the
orbits to files in the folder with "_name". So for
example if you wish to save your orbits into the file
<File>_example</File> then you would run
<Code>AllMCOrbits(group, genus, tuple:
SaveOrbit:="example");</Code>. The orbits are then saved in
orbits which are named numerically. Following on from the above
example then the first orbit will be saved as "_example/0".
The <Code> OutputStyle </Code> option controls the verbosity of
the output. It accepts three possible values:
<List>
<Item>
<Code>"silent"</Code> - the routine prints no output except in
the case of an Error.
</Item>
<Item>
<Code>"single-line"</Code> - the routine output to a single
line. An intermediate output style for those who
want some output but do not want to see all
diagnostic output.
</Item>
<Item>
<Code>"full"</Code> - the routine provides full diagnostic output.
</Item>
</List>
</Description>
</ManSection>
<ManSection>
<Func Name="GeneratingMCOrbits" Arg="group, genus, tuple" />
<Description>
This calculates the orbits for the given arguments.
Unlike the <Ref Filt="AllMCOrbits" /> function,
<Code>GeneratingMCOrbits</Code> calculates only those orbits
whose tuples generate the whole of our original group.
</Description>
</ManSection>
<ManSection>
<Func Name="GeneratingMCOrbitsCore" Arg="group, genus, tuple,
partition, constant" />
<Description>
This calculates the orbits for the given arguments. Unlike the
<Ref Filt="AllMCOrbits" /> function,
<Code>GeneratingMCOrbitsCore</Code> calculates only those orbits
whose tuples generate the whole of our original group. As with
<Ref Filt="AllMCOrbitsCore" />, the argument <A>partition</A>
must be a partition of the conjugacy classes represented in list
form. We also have access to the full value of the options stack
as in <Ref Filt="AllMCOrbitsCore" />.
</Description>
</ManSection>
<ManSection>
<Func Name="MappingClassOrbit" Arg="group, genus, principaltuple,
partition, tuple"
/>
<Returns> an orbit record for an orbit containing tuple or returns
<K>fail</K>
</Returns>
<Description>
Calculates the orbit of the <A>tuple</A> with respect
to the given <A>group</A>, <A>principaltuple</A> and
<A>genus</A>.
</Description>
</ManSection>
<ManSection>
<Func Name="PrepareMinTree" Arg="principaltuple,
group, ourR, genus" />
<Returns> a record with two keys <Code>MinimizationTree</Code> and
<Code>MinimumSet</Code>. If <Code>record</Code> is the returned
record then <Code>record.MinimizationTree</Code> is the list encoding the tree used to help minimize tuples. The list <Code>
record.MinimumSet</Code> is a list of minimal elements which
is also used to speed up tuple minimization. </Returns>
</ManSection>
<ManSection>
<Func Name="MinimizeTuple" Arg="tuple, minimizationTree, minimumSet,
numberOfGenerators"/>
<Returns> the minimal tuple in the same orbit of
<A>tuple</A>.</Returns>
<Description> Take the minimisation data provided by <Ref
Filt="PrepareMinTree" /> and minimizes the given
<A>tuple</A>.
</Description>
</ManSection>
<ManSection>
<Func Name="EasyMinimizeTuple" Arg="group, genus, tuple" />
<Returns> the minimal tuple in the same orbit as
<A>tuple</A>.</Returns>
</ManSection>
<ManSection>
<Func Name="IsInOrbit" Arg="orbit, tuple" />
<Returns><Keyword>True</Keyword> if the <A>tuple</A> lies in the
<A>orbit</A>.</Returns>
</ManSection>
<ManSection>
<Func Name="FindTupleInOrbit" Arg="orbit, tuple" />
<Returns> the index of <A>tuple</A> in <Code>orbit.TupleTable</Code> if in the
<A>orbit</A>. If the tuple is not in <A>orbit</A> returns
<Keyword>fail</Keyword>.
</Returns>
</ManSection>
<ManSection>
<Func Name="IsEqualOrbit" Arg="orbit1, orbit2" />
<Returns><Keyword>true</Keyword> if the two orbits are equal else
returns <Keyword>fail</Keyword>.
</Returns>
</ManSection>
<ManSection>
<Func Name="SelectTuple" Arg="orbit, index" />
<Returns> the tuple
<Code>orbit.TupleTable[index].tuple</Code>.
</Returns>
</ManSection>
<ManSection>
<Func Name="NumberGeneratingTuples" Arg="group, partition, tuple,
genus" />
<Returns> the total number of possible generating tuples for the
group and tuple.
</Returns>
</ManSection>
<ManSection>
<Func Name="TotalNumberTuples" Arg="group, tuple, genus"
/>
<Returns> the total number of tuples we have to account for.
</Returns>
</ManSection>
<ManSection>
<Func Name="CalculateTuplePartition" Arg="group, tuple" />
<Returns> A partition of <Math>{1,\ldots, r}</Math> where
<Math>r</Math> is the length of the tuple.
</Returns>
<Description>
The function returns a partition of <Math>{1,\ldots, r}</Math>
such that <M>i</M> and <M>j</M> lie in the same block if and only
if the elements <Code>tuple[i]</Code> and <Code>tuple[j]</Code>
are member of the same conjugacy class. The program currently
requires that the elements of the tuple be ordered such that if
<Code>tuple[i]</Code> and <Code>tuple[j]</Code> are in the same
conjugacy class with <M>i \le j</M> then so is<Code>tuple[k]</Code>
for all <M>i \le k \le j</M>.
</Description>
</ManSection>
<ManSection>
<Func Name="RestoreOrbitFromFile" Arg="n, name [, path]" />
<Returns> the n-th orbit record from the project with project
<Code>"name"</Code>
</Returns>
<Description> By default the function searches the current working
directory for the saved project folder and searches inside this
for the n-th orbit. If no such orbit exists it returns
<Keyword>fail</Keyword>. If an optional argument <A>path</A> is
provided then it searches this path for a folder with the name
specified (note that path expects a <Code>Directory</Code>
object). If an orbit exists then it is returned as a record as
outlined in the data structure section.
</Description>
</ManSection>
<ManSection>
<Func Name="SaveOrbitToFile" Arg=" orbit, n, name" />
<Description>
Saves the orbit to filename "n" in the directory
<Code>'_name'</Code>. The directory must already exist.
</Description>
</ManSection>
</Section>
<Section Label="datastructures"><Heading>Key Data Structures</Heading>
Many of the above functions require or return key data structures
which we aim to document.
<Subsection Label="orbitrecord"><Heading>The Orbit Record</Heading>
Many of the functions return or expect an orbit "object". This
object is in fact record with the following values:
<List>
<Item>
<Code>PrincipalFiniteGroup </Code>- the finite group
</Item>
<Item>
<Code>OurG </Code>- genus
</Item>
<Item>
<Code>OurR </Code>- length of our primary tuple
</Item>
<Item>
<Code>OurN </Code>- number of points on which our group
acts
</Item>
<Item>
<Code>NumberOfGenerators </Code>- 2 <Code>OurG</Code>+
<Code>OurR </Code>
</Item>
<Item>
<Code>OurFreeGroup </Code>- a free group on
<Code>NumberOfGenerators </Code>letters
</Item>
<Item>
<Code>AbsGens </Code>- generators for
<Code>OurFreeGroup</Code>
</Item>
<Item>
<Code>OurAlpha
</Code> - generators of
<Code>OurFreeGroup</Code>corresponding to the
<M>\alpha_i</M> type loops in the fundamental group ( the
first <M>g</M> elements of <Code>AbsGens</Code>)
</Item>
<Item>
<Code>OurBeta </Code>- elements of <Code>OurFreeGroup
</Code>corresponding to <M>\beta</M> type loops
</Item>
<Item>
<Code>OurGamma </Code>- generators of <Code>OurFreeGroup
</Code>corresponding to the loops around branch points
</Item>
<Item>
<Code>TupleTable </Code>- a table containing all the
tuples in the orbit
</Item>
<Item><Code>HashLength</Code></Item>
<Item><Code>Hash</Code></Item>
<Item><Code>PrimeCode</Code></Item>
<Item><Code>OurAction</Code></Item>
<Item><Code>ActionOnOrbit</Code></Item>
<Item><Code>MinimizationTree</Code>- minimization structure</Item>
<Item><Code>MinimumSet</Code>- minimizaton structure</Item>
</List>
</Subsection>
<Subsection Label="tupletable">
<Heading>The Tuple Table</Heading>
The tuple table is a list. Each element of the list is a record with
the names, tuple and next. If <Code>orbit</Code> is an orbit object
then <Code>orbit.TupleTable[n].tuple</Code> returns the tuple at
index <M>n</M> of the tuple table.
</Subsection>
</Section>
<Section><Heading>A Sample Session</Heading>
We demonstate how one might use the package.
<Log><![CDATA[
gap> group:=AlternatingGroup(5);
Alt( [ 1 .. 5 ] )
gap> tuple:=[ (1,2)(3,4), (1,2)(3,4), (1,2)(3,4) ];
[ (1,2)(3,4), (1,2)(3,4), (1,2)(3,4) ]
gap> orbits:=AllMCOrbits(group,1,tuple);;
Total Number of Tuples: 189120
Collecting 20 random tuples... done
Cleaning done; 20 random tuples remaining
Orbit 1:
Length=3072
Generating Tuple =[ (1,2,4,5,3), (1,4,5,2,3), (1,2)(4,5),
(1,4)(2,3), (2,5)(3,4) ]
Generated subgroup size=60
Centralizer size=1
4800 tuples remaining
Cleaning current orbit...
Cleaning a list of 20 tuples
Random Tuples Remaining: 0
Cleaning done; 0 random tuples remaining
Collecting 20 random tuples... done
Cleaning orbit 1
Cleaning a list of 20 tuples
Random Tuples Remaining: 0
Cleaning done; 0 random tuples remaining
Collecting 40 random tuples... done
Cleaning orbit 1
Cleaning a list of 40 tuples
Random Tuples Remaining: 3
Cleaning done; 3 random tuples remaining
Orbit 2:
Length=32
Generating Tuple =[ (1,4)(2,3), (1,2)(3,4), (1,4)(2,3), (1,2)(3,4),
(1,3)(2,4) ]
Generated subgroup size=4
Centralizer size=4
4320 tuples remaining
Cleaning current orbit...
Cleaning a list of 3 tuples
Random Tuples Remaining: 2
Cleaning done; 2 random tuples remaining
Orbit 3:
Length=72
Generating Tuple =[ (1,5,2), (1,3,2), (1,2)(3,5), (1,3)(2,5),
(1,3)(2,5) ]
Generated subgroup size=12
Centralizer size=1
0 tuples remaining
Cleaning current orbit...
Cleaning a list of 2 tuples
Random Tuples Remaining: 0
Cleaning done; 0 random tuples remaining
gap> # Check we have as many orbits as it says...
gap> Length(orbits);
3
gap> # Inspect the first orbit..
gap> orb1:=orbits[1];;
gap> # How long is orb1?
gap> Length(orb1.TupleTable);
3072
gap> # Select element 42 ...
gap> SelectTuple(orb1, 42);
[ (1,3,4), (1,5,3,2,4), (1,5)(2,4), (1,2)(3,5), (2,3)(4,5) ]
gap> # Save the orbit to a file...
gap> SaveOrbitToFile(orb1, 1, "test");
gap> #If the folder doesn't exist we get an error..
gap> SaveOrbitToFile(orb1, 1, "foo");
AppendTo: cannot open '_foo/1' for output at
CallFuncList( APPEND_TO, arg );
gap> #
gap> # Now we try find generating orbits
gap> group:=SymmetricGroup(5);
Sym( [ 1 .. 5 ] )
gap> # And we will save them using the `SaveOrbit` option
gap> GeneratingMCOrbits(group,1,tuple : SaveOrbit:="example");;
Total Number of Tuples: 607680
Collecting 20 generating tuples .. done
Cleaning done; 20 random tuples remaining
Orbit 1:
Length=5064
Generating Tuple =[ (1,3,2,5), (2,4,3), (1,4)(3,5), (1,3)(2,5),
(1,4)(3,5) ]
Generated subgroup size=120
Saving orbit to file _example/0
Centralizer size=1
0 tuples remaining
Cleaning current orbit...
Cleaning a list of 20 tuples
Random Tuples Remaining: 0
Cleaning done; 0 random tuples remaining
gap> generatingorbits:=last;;
gap> # How many generating orbits are there?
gap> Length(generatingorbits);
1
gap> # Is this orbit equal to the other one we found earlier
gap> IsEqualOrbit(orb1, generatingorbits[1]);
fail
gap> # We can reload the orbits...
gap> orb2:=RestoreOrbitFromFile(0, "example");;
gap> Length(orb2.TupleTable);
5064
]]></Log>
</Section>
<Section Label="sec:application"><Heading>An Application</Heading>
This section describes an application of the package. <P/>
Let <M>X</M> be a compact Riemann surface of genus <M>g</M> and <M>f: X
\rightarrow \mathbb{P}^1\mathbb{C}</M> be a meromorphic function of
degree <M>n</M>. Let <M>B</M> be the set of branch points for <M>f</M>
and fix a basepoint <M>b_0 \in \mathbb{P}^1\mathbb{C}- B</M>.
The fundamental group <M>\pi_1(\mathbb{P}^1 \mathbb{C} - B, b_0) </M>
acts transitively on the fibre <M>f^{-1}(b_0)</M> and this corresponds
to a representation
<Display>
f^* :\pi_1(\mathbb{P}^1 \mathbb{C} - B, b_0) \rightarrow S_n
</Display>
The image of <M>f^*</M> is called the <E>monodromy group</E> of <M>(X,
f)</M>. The fundamental group of the punctured Riemann sphere is
generated by the loops that wind around the points in <M>B</M>. Label the
branch points <M>b_1,...,b_r</M> and let <M>\tau_i </M>
be the image under <M>f^*</M> of the loop, <M>\gamma_i \in
\pi_1(\mathbb{P}^1\mathbb{C} - B)</M>, that winds
once around the point <M>b_i\in B</M>.
Therefore,
<Display>
\langle \tau_1, ..., \tau_r \rangle = G
</Display>
and
<Display>
\tau_1 \cdots \tau_r = 1
</Display>
Moreover by the Riemann-Hurwitz formula
<Display>
2(n+g-1) = \sum_1^r {ind}( \tau_i)
</Display>
where the <M>{ind}(\tau_i)</M> is the minimal number of factors to
express <M>\tau_i</M> as a product of transpositions.
A set <M>t_1, \ldots, t_r</M> of elements of <M>S_n</M> satisfying the
Riemann-Hurwitz formula, the product-one condition, and generating some
transitive subgroup <M>G</M> of <M>S_n</M> is called a <E>genus </E>
<M> g </M> <E>generating system </E> for <M>G</M>. Therefore to the
meromorphic function <M>(X, f)</M> there is an associated genus <M>g</M>
system. In fact the conjugacy classes of the elements <M>\tau_i</M> are
also determined by <M>f</M> -- the collection of conjugacy classes is
sometimes called the <E> ramification type</E> of <M>f</M>.
On the other hand for every genus <M> g</M> generating system, <M>t =
(\tau_1, \ldots, \tau_n)</M> for <M>G</M> there is Riemann surface
of genus <M>g</M> and a meromorphic function with associated generating
system <M>t</M> -- this result is known as <E> Riemann's Existence
Theorem</E>.<P />
The question we hope to use our package to answer is: For a given finite
group <M>G</M> how many meromorphic maps with monodromy group <M>G</M> are
there? It can be shown -- see <Cite Key="Volklein96" /> for example -- that determining whether
two genus <M>g</M> coverings are equivalent corresponds to determining
whether their associated genus <M>g</M> systems are in the same mapping
class orbit ( most literature would refer to mapping class orbits as
braid orbits in this case - this is because of the equivalence between
the mapping class group of a punctured disc and the braid groups <Cite
Key="Birman75" />). <P />
Thus for a finite group <M>G</M> we can answer the above principal
question using the following process:
<List>
<Item>
For a given finite group <M>G</M> the work of Breuer <Cite
Key="Breuer00" /> can be used to calculate all possible
ramification types.
</Item>
<Item>
Pick a tuple, <M>C = (c_1,...,c_r)</M>, of representative elements
of the conjugacy classes which correspond to a chosen ramification type as calculated in the previous step.
</Item>
<Item>
Use the function <Code>GeneratingMCOrbits(G, 0, [c1,...,cr])</Code>
to calculate the number of mapping class orbits. Note that the
genus argument is <M>0</M> because this is the genus of
<M>\mathbb{P}^1\mathbb{C}</M>.
</Item>
</List>
For more information on this process and the underlying theory see <Cite
Key="MSV" /> and <Cite Key="Volklein96" />.
</Section>
</Chapter>
¤ Dauer der Verarbeitung: 0.16 Sekunden
(vorverarbeitet)
¤
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.
