  
  [1X1 Introduction and Main Functions[0X
  
  This  chapter  provides an overview of the background material, and provides
  documentation  for  the  main  functions and data structures of the MapClass
  package.
  
  
  [1X1.1 Background Material[0X
  
  Let  G  be  a  finite  group,  let C_1,..., C_r be a collection of conjugacy
  classes  in  G. Let mathcalE = mathcalE(G,g,(C_1, dots, C_r)) denote the set
  of all tuples sigma = (sigma_1,...,sigma_2g+r)in G^2g+r (for natural numbers
  g and r) of elements in G satisfying the relation
  
  
       \prod_{i=1}^g [\sigma_i, \sigma_{g+i}] \prod_{i=1}^r \sigma_{2g+i}
       = 1
  
  
  and  such  that  sigma_2g  +k in C_k. If the tuple also satisfies < sigma_1,
  ..., sigma_2g+r> = G it is said to be [13Xgenerating[0m.
  
  One  may  associate  the  elements  of  the  tuple  sigma  with the standard
  generators  of the fundamental group of a compact connected surface S (genus
  g,  r  punctures).  The  mapping class group of S is naturally isomorphic to
  Out(pi_1(S))  and  so  gives rise to an action on the fundamental group of S
  modulo  inner  automorphisms. This action can be transferred to an action on
  the  set mathcalE (up to conjugation in G). The [13Xmapping class orbits[0m are the
  orbits of mathcalE under this action.
  
  The package can be used to compute the set mathcalE(G, g, (C_1,...,C_r)) and
  the  corresponding  partition  into mapping class orbits for a given group G
  and a set of conjugacy classes (C_1,...,C_r) (although the programs expect a
  tuple of class representatives). For an example application see Section [14X1.5[0m.
  We call the tuple (g;C_1,...,C_r) the signature. The package is an extension
  of the [13XBraid[0m package for [5XGAP[0m.
  
  
  [1X1.2 Overview of Main Functions[0X
  
  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.
  
  [1X1.2-1 AllMCOrbits[0m
  
  [2X> AllMCOrbits( [0X[3Xgroup, genus, tuple[0X[2X ) _______________________________[0Xfunction
  
  This  function  calculates  the orbits for the given group, genus and tuple.
  This  function is a wrapper for the function [2XAllMCOrbitsCore[0m ([14X1.2-2[0m), and so
  can make use of GAP's [9XOptionsStack[0m. The options are described in more detail
  in  the  documentation for [2XAllMCOrbitsCore[0m ([14X1.2-2[0m). We draw attention to two
  useful  options: the [10XOutputStyle[0m and [10XSaveOrbit[0m options. The [10XSaveOrbit[0m option
  takes  values  of  either  [9Xfalse[0m - 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 [2XAllMCOrbitsCore[0m ([14X1.2-2[0m) for more details on
  the  saving  process. The [10X OutputStyle [0m option controls the verbosity of the
  output of the function. It accepts three possible values:
  
  --    [10X"silent"[0m  --  the  routine  prints  no output except in the case of an
        Error.
  
  --    [10X"single-line"[0m  --  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.
  
  --    [10X"full"[0m -- the routine provides full diagnostic output.
  
  [1X1.2-2 AllMCOrbitsCore[0m
  
  [2X> AllMCOrbitsCore( [0X[3Xgroup, genus, tuple, partition, constant[0X[2X ) ______[0Xfunction
  
  This  function  calculates  the orbits for the given group, genus and tuple,
  with  the  r  branch  points  partitioned as in [3Xpartition[0m. It uses the given
  [3Xconstant[0m  to  determine how many of the tuples it want to account for before
  exiting. This function also make use of GAP's [9XOptionsStack[0m if one desires to
  alter  how  the algorithm runs. The following options and their defaults are
  given below.
  
      ------------------------------------------------
      |                  Option Name | Default Value | 
      ------------------------------------------------
      |                [10XMaximumWeight[0m |      40       | 
      |                [10XMinimumWeight[0m |      20       | 
      |                [10XInitialWeight[0m |      20       | 
      |                       [10XBumpUp[0m |       7       | 
      |                    [10XKnockDown[0m |       7       | 
      | [10XInitialNumberOfRandomTuples [0m |      20       | 
      |                  [10X SaveOrbit [0m |     [9Xfalse[0m     | 
      |                [10X OutputStyle [0m |    [9X"full"[0m     | 
      ------------------------------------------------
  
  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
  [10XMaximumWeight[0m,  [10XMinimumWeight[0m,  [10XInitialWeight[0m,[10XBumpUp[0m, and [10XKnockDown[0m, control
  this  subgroup  weighting.  Each  option takes positive integer values. They
  play the following roles in the weighting process:
  
  --    [10XMaximumWeight[0m : The maximum weight that a subgroup can be.
  
  --    [10XMinimumWeight[0m : The minimum weight that a subgroup can be.
  
  --    [10XInitialWeight[0m  : The weight that a new subgroup receives when added to
        to the list of small subgroups.
  
  --    [10XBumpUp[0m  :  The  amount we increase the weight of a subgroup by when it
        does not appear frequently.
  
  --    [10XKnockDown[0m : The amount we decrease the weight of a subgroup by when it
        appears too frequently.
  
  The  default  options were chosen experimentally and so it may be beneficial
  to tune these values for a specific case.
  
  The  option  [10XInitialNumberOfRandomTuples[0m decides how many tuples the routine
  collects before trying to see if they are in some pre-existing orbit.
  
  The  option  [10XSaveOrbit[0m which is by default [9Xfalse[0m 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 "[11X_name[0m". So for example if you wish to
  save   your   orbits   into   the   file   [11X_example[0m   then   you  would  run
  [10XAllMCOrbits(group, genus, tuple: SaveOrbit:="example");[0m. 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 [10X OutputStyle
  [0m  option  controls  the  verbosity  of the output. It accepts three possible
  values:
  
  --    [10X"silent"[0m  -  the  routine  prints  no  output except in the case of an
        Error.
  
  --    [10X"single-line"[0m  -  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.
  
  --    [10X"full"[0m - the routine provides full diagnostic output.
  
  [1X1.2-3 GeneratingMCOrbits[0m
  
  [2X> GeneratingMCOrbits( [0X[3Xgroup, genus, tuple[0X[2X ) ________________________[0Xfunction
  
  This  calculates  the orbits for the given arguments. Unlike the [2XAllMCOrbits[0m
  ([14X1.2-1[0m)  function,  [10XGeneratingMCOrbits[0m  calculates  only  those orbits whose
  tuples generate the whole of our original group.
  
  [1X1.2-4 GeneratingMCOrbitsCore[0m
  
  [2X> GeneratingMCOrbitsCore( [0X[3Xgroup, genus, tuple, partition, constant[0X[2X ) [0Xfunction
  
  This  calculates  the orbits for the given arguments. Unlike the [2XAllMCOrbits[0m
  ([14X1.2-1[0m)  function, [10XGeneratingMCOrbitsCore[0m calculates only those orbits whose
  tuples  generate  the  whole  of our original group. As with [2XAllMCOrbitsCore[0m
  ([14X1.2-2[0m), the argument [3Xpartition[0m 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 [2XAllMCOrbitsCore[0m ([14X1.2-2[0m).
  
  [1X1.2-5 MappingClassOrbit[0m
  
  [2X> MappingClassOrbit( [0X[3Xgroup, genus, principaltuple, partition, tuple[0X[2X ) [0Xfunction
  [6XReturns:[0X  an orbit record for an orbit containing tuple or returns [9Xfail[0m
  
  Calculates  the  orbit  of  the  [3Xtuple[0m  with  respect  to  the  given [3Xgroup[0m,
  [3Xprincipaltuple[0m and [3Xgenus[0m.
  
  [1X1.2-6 PrepareMinTree[0m
  
  [2X> PrepareMinTree( [0X[3Xprincipaltuple, group, ourR, genus[0X[2X ) _____________[0Xfunction
  [6XReturns:[0X  a  record with two keys [10XMinimizationTree[0m and [10XMinimumSet[0m. If [10Xrecord[0m
            is  the  returned  record then [10Xrecord.MinimizationTree[0m is the list
            encoding  the  tree  used  to  help  minimize  tuples.  The  list [10X
            record.MinimumSet[0m is a list of minimal elements which is also used
            to speed up tuple minimization.
  
  [1X1.2-7 MinimizeTuple[0m
  
  [2X> MinimizeTuple( [0X[3Xtuple, minimizationTree, minimumSet, numberOfGenerators[0X[2X ) [0Xfunction
  [6XReturns:[0X  the minimal tuple in the same orbit of [3Xtuple[0m.
  
  Take  the minimisation data provided by [2XPrepareMinTree[0m ([14X1.2-6[0m) and minimizes
  the given [3Xtuple[0m.
  
  [1X1.2-8 EasyMinimizeTuple[0m
  
  [2X> EasyMinimizeTuple( [0X[3Xgroup, genus, tuple[0X[2X ) _________________________[0Xfunction
  [6XReturns:[0X  the minimal tuple in the same orbit as [3Xtuple[0m.
  
  [1X1.2-9 IsInOrbit[0m
  
  [2X> IsInOrbit( [0X[3Xorbit, tuple[0X[2X ) ________________________________________[0Xfunction
  [6XReturns:[0X  [9XTrue[0m if the [3Xtuple[0m lies in the [3Xorbit[0m.
  
  [1X1.2-10 FindTupleInOrbit[0m
  
  [2X> FindTupleInOrbit( [0X[3Xorbit, tuple[0X[2X ) _________________________________[0Xfunction
  [6XReturns:[0X  the  index  of  [3Xtuple[0m  in [10Xorbit.TupleTable[0m if in the [3Xorbit[0m. If the
            tuple is not in [3Xorbit[0m returns [9Xfail[0m.
  
  [1X1.2-11 IsEqualOrbit[0m
  
  [2X> IsEqualOrbit( [0X[3Xorbit1, orbit2[0X[2X ) ___________________________________[0Xfunction
  [6XReturns:[0X  [9Xtrue[0m if the two orbits are equal else returns [9Xfail[0m.
  
  [1X1.2-12 SelectTuple[0m
  
  [2X> SelectTuple( [0X[3Xorbit, index[0X[2X ) ______________________________________[0Xfunction
  [6XReturns:[0X  the tuple [10Xorbit.TupleTable[index].tuple[0m.
  
  [1X1.2-13 NumberGeneratingTuples[0m
  
  [2X> NumberGeneratingTuples( [0X[3Xgroup, partition, tuple, genus[0X[2X ) _________[0Xfunction
  [6XReturns:[0X  the  total  number of possible generating tuples for the group and
            tuple.
  
  [1X1.2-14 TotalNumberTuples[0m
  
  [2X> TotalNumberTuples( [0X[3Xgroup, tuple, genus[0X[2X ) _________________________[0Xfunction
  [6XReturns:[0X  the total number of tuples we have to account for.
  
  [1X1.2-15 CalculateTuplePartition[0m
  
  [2X> CalculateTuplePartition( [0X[3Xgroup, tuple[0X[2X ) __________________________[0Xfunction
  [6XReturns:[0X  A  partition  of  ${1,\ldots,  r}$  where $r$ is the length of the
            tuple.
  
  The function returns a partition of ${1,\ldots, r}$ such that i and j lie in
  the  same block if and only if the elements [10Xtuple[i][0m and [10Xtuple[j][0m are member
  of  the  same  conjugacy  class.  The  program  currently  requires that the
  elements  of  the tuple be ordered such that if [10Xtuple[i][0m and [10Xtuple[j][0m are in
  the same conjugacy class with i le j then so is[10Xtuple[k][0m for all i le k le j.
  
  [1X1.2-16 RestoreOrbitFromFile[0m
  
  [2X> RestoreOrbitFromFile( [0X[3Xn, name[, path][0X[2X ) __________________________[0Xfunction
  [6XReturns:[0X  the n-th orbit record from the project with project [10X"name"[0m
  
  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  [9Xfail[0m.  If an optional argument [3Xpath[0m is provided then it
  searches  this  path  for  a  folder with the name specified (note that path
  expects  a  [10XDirectory[0m  object).  If an orbit exists then it is returned as a
  record as outlined in the data structure section.
  
  [1X1.2-17 SaveOrbitToFile[0m
  
  [2X> SaveOrbitToFile( [0X[3Xorbit, n, name[0X[2X ) ________________________________[0Xfunction
  
  Saves the orbit to filename "[3Xn[0m" in the directory [10X'_name'[0m. The directory must
  already exist.
  
  
  [1X1.3 Key Data Structures[0X
  
  Many  of  the above functions require or return key data structures which we
  aim to document.
  
  
  [1X1.3-1 The Orbit Record[0X
  
  Many  of the functions return or expect an orbit "object". This object is in
  fact record with the following values:
  
  --    [10XPrincipalFiniteGroup [0m- the finite group
  
  --    [10XOurG [0m- genus
  
  --    [10XOurR [0m- length of our primary tuple
  
  --    [10XOurN [0m- number of points on which our group acts
  
  --    [10XNumberOfGenerators [0m- 2 [10XOurG[0m+ [10XOurR [0m
  
  --    [10XOurFreeGroup [0m- a free group on [10XNumberOfGenerators [0mletters
  
  --    [10XAbsGens [0m- generators for [10XOurFreeGroup[0m
  
  --    [10XOurAlpha  [0m  -  generators  of [10XOurFreeGroup[0mcorresponding to the alpha_i
        type loops in the fundamental group ( the first g elements of [10XAbsGens[0m)
  
  --    [10XOurBeta [0m- elements of [10XOurFreeGroup [0mcorresponding to beta type loops
  
  --    [10XOurGamma  [0m-  generators  of  [10XOurFreeGroup  [0mcorresponding  to the loops
        around branch points
  
  --    [10XTupleTable [0m- a table containing all the tuples in the orbit
  
  --    [10XHashLength[0m
  
  --    [10XHash[0m
  
  --    [10XPrimeCode[0m
  
  --    [10XOurAction[0m
  
  --    [10XActionOnOrbit[0m
  
  --    [10XMinimizationTree[0m- minimization structure
  
  --    [10XMinimumSet[0m- minimizaton structure
  
  
  [1X1.3-2 The Tuple Table[0X
  
  The  tuple  table  is  a list. Each element of the list is a record with the
  names,    tuple   and   next.   If   [10Xorbit[0m   is   an   orbit   object   then
  [10Xorbit.TupleTable[n].tuple[0m returns the tuple at index n of the tuple table.
  
  
  [1X1.4 A Sample Session[0X
  
  We demonstate how one might use the package.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X            gap> group:=AlternatingGroup(5);[0X
    [4X            Alt( [ 1 .. 5 ] )[0X
    [4X            gap> tuple:=[ (1,2)(3,4), (1,2)(3,4), (1,2)(3,4) ][0X
    [4X            [ (1,2)(3,4), (1,2)(3,4), (1,2)(3,4) ][0X
    [4X            gap> orbits:=AllMCOrbits(group,1,tuple);;[0X
    [4X[0X
    [4X            Total Number of Tuples: 189120[0X
    [4X[0X
    [4X[0X
    [4X            Collecting 20 random tuples... done[0X
    [4X[0X
    [4X            Cleaning done; 20 random tuples remaining[0X
    [4X[0X
    [4X[0X
    [4X            Orbit 1:[0X
    [4X                                                                                  [0X
    [4X            Length=3072[0X
    [4X            Generating Tuple  =[ (1,2,4,5,3), (1,4,5,2,3), (1,2)(4,5),[0X
    [4X            (1,4)(2,3), (2,5)(3,4) ][0X
    [4X            Generated subgroup size=60[0X
    [4X            Centralizer size=1[0X
    [4X            4800 tuples remaining[0X
    [4X            Cleaning current orbit...[0X
    [4X            Cleaning a list of 20 tuples[0X
    [4X            Random Tuples Remaining: 0[0X
    [4X            Cleaning done; 0 random tuples remaining[0X
    [4X[0X
    [4X[0X
    [4X            Collecting 20 random tuples... done[0X
    [4X[0X
    [4X            Cleaning orbit 1[0X
    [4X            Cleaning a list of 20 tuples[0X
    [4X            Random Tuples Remaining: 0[0X
    [4X[0X
    [4X            Cleaning done; 0 random tuples remaining[0X
    [4X[0X
    [4X[0X
    [4X            Collecting 40 random tuples... done[0X
    [4X[0X
    [4X            Cleaning orbit 1[0X
    [4X            Cleaning a list of 40 tuples[0X
    [4X            Random Tuples Remaining: 3[0X
    [4X[0X
    [4X            Cleaning done; 3 random tuples remaining[0X
    [4X[0X
    [4X[0X
    [4X            Orbit 2:[0X
    [4X                                                                                  [0X
    [4X            Length=32[0X
    [4X            Generating Tuple  =[ (1,4)(2,3), (1,2)(3,4), (1,4)(2,3), (1,2)(3,4),[0X
    [4X            (1,3)(2,4) ][0X
    [4X            Generated subgroup size=4[0X
    [4X            Centralizer size=4[0X
    [4X            4320 tuples remaining[0X
    [4X            Cleaning current orbit...[0X
    [4X            Cleaning a list of 3 tuples[0X
    [4X            Random Tuples Remaining: 2[0X
    [4X            Cleaning done; 2 random tuples remaining[0X
    [4X[0X
    [4X[0X
    [4X            Orbit 3:[0X
    [4X                                                                                  [0X
    [4X            Length=72[0X
    [4X            Generating Tuple  =[ (1,5,2), (1,3,2), (1,2)(3,5), (1,3)(2,5),[0X
    [4X            (1,3)(2,5) ][0X
    [4X            Generated subgroup size=12[0X
    [4X            Centralizer size=1[0X
    [4X            0 tuples remaining[0X
    [4X            Cleaning current orbit...[0X
    [4X            Cleaning a list of 2 tuples[0X
    [4X            Random Tuples Remaining: 0[0X
    [4X            Cleaning done; 0 random tuples remaining[0X
    [4X[0X
    [4X            gap> # Check we have as many orbits as it says...[0X
    [4X            gap> Length(orbits);[0X
    [4X            3[0X
    [4X            gap> # Inspect the first orbit..[0X
    [4X            gap> orb1:=orbits[1];;[0X
    [4X            gap> # How long is orb1?[0X
    [4X            gap> Length(orb1.TupleTable);[0X
    [4X            3072[0X
    [4X            gap> # Select element 42 ...[0X
    [4X            gap> SelectTuple(orb1, 42);[0X
    [4X            [ (1,3,4), (1,5,3,2,4), (1,5)(2,4), (1,2)(3,5), (2,3)(4,5) ][0X
    [4X            gap> # Save the orbit to a file...[0X
    [4X            gap> SaveOrbitToFile(orb1, 1, "test");[0X
    [4X            gap> #If the folder doesn't exist we get an error..[0X
    [4X            gap> SaveOrbitToFile(orb1, 1, "foo");[0X
    [4X            AppendTo: cannot open '_foo/1' for output at[0X
    [4X            CallFuncList( APPEND_TO, arg );[0X
    [4X            gap> #[0X
    [4X            gap> # Now we try find generating orbits [0X
    [4X            gap> group:=SymmetricGroup(5);[0X
    [4X            Sym( [ 1 .. 5 ] )[0X
    [4X            gap> # And we will save them using the `SaveOrbit` option[0X
    [4X            gap> GeneratingMCOrbits(group,1,tuple : SaveOrbit:="example");;[0X
    [4X[0X
    [4X            Total Number of Tuples: 607680[0X
    [4X[0X
    [4X[0X
    [4X[0X
    [4X            Collecting 20 generating tuples .. done[0X
    [4X[0X
    [4X            Cleaning done; 20 random tuples remaining[0X
    [4X[0X
    [4X[0X
    [4X            Orbit 1:                    [0X
    [4X            Length=5064[0X
    [4X            Generating Tuple  =[ (1,3,2,5), (2,4,3), (1,4)(3,5), (1,3)(2,5),[0X
    [4X            (1,4)(3,5) ][0X
    [4X            Generated subgroup size=120[0X
    [4X            Saving orbit to file _example/0[0X
    [4X            Centralizer size=1[0X
    [4X            0 tuples remaining[0X
    [4X            Cleaning current orbit...[0X
    [4X            Cleaning a list of 20 tuples[0X
    [4X            Random Tuples Remaining: 0[0X
    [4X            Cleaning done; 0 random tuples remaining[0X
    [4X[0X
    [4X            gap> generatingorbits:=last;;[0X
    [4X            gap> # How many generating orbits are there?[0X
    [4X            gap> Length(generatingorbits);[0X
    [4X            1[0X
    [4X            gap> # Is this orbit equal to the other one we found earlier[0X
    [4X            gap> IsEqualOrbit(orb1, generatingorbits[1]);[0X
    [4X            fail[0X
    [4X            gap> # We can reload the orbits...[0X
    [4X            gap> orb2:=RestoreOrbitFromFile(0, "example");;[0X
    [4X            gap> Length(orb2.TupleTable);[0X
    [4X            5064[0X
    [4X        [0X
  [4X------------------------------------------------------------------[0X
  
  
  [1X1.5 An Application[0X
  
  This section describes an application of the package.
  
  Let  X  be  a  compact  Riemann  surface  of  genus  g and f: X -> P^1C be a
  meromorphic  function  of  degree n. Let B be the set of branch points for f
  and  fix  a  basepoint b_0 in P^1C- B. The fundamental group pi_1(P^1 C - B,
  b_0)  acts  transitively  on  the  fibre f^-1(b_0) and this corresponds to a
  representation
  
  
       f^* :\pi_1(\mathbb{P}^1 \mathbb{C} - B, b_0) \rightarrow S_n
  
  
  The  image  of  f^* is called the [13Xmonodromy group[0m of (X, f). The fundamental
  group  of  the  punctured Riemann sphere is generated by the loops that wind
  around the points in B. Label the branch points b_1,...,b_r and let tau_i be
  the  image under f^* of the loop, gamma_i in pi_1(P^1C - B), that winds once
  around the point b_iin B. Therefore,
  
  
       \langle \tau_1, ..., \tau_r \rangle = G
  
  
  and
  
  
       \tau_1 \cdots \tau_r = 1
  
  
  Moreover by the Riemann-Hurwitz formula
  
  
       2(n+g-1) = \sum_1^r {ind}( \tau_i)
  
  
  where  the ind(tau_i) is the minimal number of factors to express tau_i as a
  product of transpositions. A set t_1, ..., t_r of elements of S_n satisfying
  the  Riemann-Hurwitz formula, the product-one condition, and generating some
  transitive  subgroup G of S_n is called a [13Xgenus [0m g [13Xgenerating system [0m for G.
  Therefore  to the meromorphic function (X, f) there is an associated genus g
  system.  In  fact  the  conjugacy  classes  of  the  elements tau_i are also
  determined  by  f -- the collection of conjugacy classes is sometimes called
  the  [13X ramification type[0m of f. On the other hand for every genus g generating
  system,  t  =  (tau_1, ..., tau_n) for G there is Riemann surface of genus g
  and  a  meromorphic  function  with  associated  generating system t -- this
  result is known as [13X Riemann's Existence Theorem[0m.
  
  The  question  we  hope  to use our package to answer is: For a given finite
  group  G  how many meromorphic maps with monodromy group G are there? It can
  be  shown -- see [V{\96] for example -- that determining whether two genus g
  coverings are equivalent corresponds to determining whether their associated
  genus  g 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 [Bir75]).
  
  Thus  for  a finite group G we can answer the above principal question using
  the following process:
  
  --    For  a  given finite group G the work of Breuer [Bre00] can be used to
        calculate all possible ramification types.
  
  --    Pick  a  tuple,  C  = (c_1,...,c_r), of representative elements of the
        conjugacy  classes  which  correspond to a chosen ramification type as
        calculated in the previous step.
  
  --    Use  the  function  [10XGeneratingMCOrbits(G, 0, [c1,...,cr])[0m to calculate
        the  number of mapping class orbits. Note that the genus argument is 0
        because this is the genus of P^1C.
  
  For  more information on this process and the underlying theory see [MSSV02]
  and [V{\96].
  
