Welcome To Our Shell

Mister Spy & Souheyl Bypass Shell

  
  43 Permutation Groups
  
  
  43.1 IsPermGroup (Filter)
  
  43.1-1 IsPermGroup
  
  IsPermGroup( obj )  Category
  
  A permutation group is a group of permutations on a finite set Ω of positive
  integers.  GAP  does  not require the user to specify the operation domain Ω
  when a permutation group is defined.
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2));
    Group([ (1,2,3,4), (1,2) ])
  
  
  Permutation  groups  are groups and therefore all operations for groups (see
  Chapter 39)  can  be  applied  to  them.  In  many cases special methods are
  installed for permutation groups that make computations more effective.
  
  
  43.2 The Natural Action
  
  The     functions     MovedPoints    (42.3-3),    NrMovedPoints    (42.3-4),
  LargestMovedPoint  (42.3-2), and SmallestMovedPoint (42.3-1) are defined for
  arbitrary  collections of permutations (see 42.3), in particular they can be
  applied to permutation groups.
  
    Example  
    gap> g:= Group( (2,3,5,6), (2,3) );;
    gap> MovedPoints( g );  NrMovedPoints( g );
    [ 2, 3, 5, 6 ]
    4
    gap> LargestMovedPoint( g );  SmallestMovedPoint( g );
    6
    2
  
  
  The action of a permutation group on the positive integers is a group action
  (via  the acting function OnPoints (41.2-1)). Therefore all action functions
  can  be applied (see the Chapter 41), for example Orbit (41.4-1), Stabilizer
  (41.5-2), Blocks (41.11-1), IsTransitive (41.10-1), IsPrimitive (41.10-7).
  
  If  one has a list of group generators and is interested in the moved points
  (see  above)  or orbits, it may be useful to avoid the explicit construction
  of  the  group for efficiency reasons. For the special case of the action of
  permutations  on  positive integers via ^, the functions OrbitPerms (43.2-1)
  and OrbitsPerms (43.2-2) are provided for this purpose.
  
  Similarly,  several  functions  concerning the natural action of permutation
  groups  address  stabilizer chains (see 43.6) rather than permutation groups
  themselves, for example BaseStabChain (43.10-1).
  
  43.2-1 OrbitPerms
  
  OrbitPerms( perms, pnt )  function
  
  returns  the  orbit of the positive integer pnt under the group generated by
  the permutations in the list perms.
  
  43.2-2 OrbitsPerms
  
  OrbitsPerms( perms, D )  function
  
  returns  the list of orbits of the positive integers in the list D under the
  group generated by the permutations in the list perms.
  
    Example  
    gap> OrbitPerms( [ (1,2,3)(4,5), (3,6) ], 1 );
    [ 1, 2, 3, 6 ]
    gap> OrbitsPerms( [ (1,2,3)(4,5), (3,6) ], [ 1 .. 6 ] );
    [ [ 1, 2, 3, 6 ], [ 4, 5 ] ]
  
  
  
  43.3 Computing a Permutation Representation
  
  43.3-1 IsomorphismPermGroup
  
  IsomorphismPermGroup( G )  attribute
  
  returns  an  isomorphism  from the group G onto a permutation group which is
  isomorphic   to   G.   The   method   will  select  a  suitable  permutation
  representation.
  
    Example  
    gap> g:=SmallGroup(24,12);
    <pc group of size 24 with 4 generators>
    gap> iso:=IsomorphismPermGroup(g);
    <action isomorphism>
    gap> Image(iso,g.3*g.4);
    (1,12)(2,16)(3,19)(4,5)(6,22)(7,8)(9,23)(10,11)(13,24)(14,15)(17,
    18)(20,21)
  
  
  In    many    cases    the   permutation   representation   constructed   by
  IsomorphismPermGroup is regular.
  
  43.3-2 SmallerDegreePermutationRepresentation
  
  SmallerDegreePermutationRepresentation( G )  function
  
  Let  G  be  a  permutation group that acts transitively on its moved points.
  SmallerDegreePermutationRepresentation  tries to find a faithful permutation
  representation  of smaller degree. The result is a group homomorphism onto a
  permutation group, in the worst case this is the identity mapping on G.
  
  If the cheap option is given, the function only tries to reduce to orbits or
  actions  on blocks, otherwise also actions on cosets of random subgroups are
  tried.
  
  Note  that  the  result  is  not  guaranteed  to  be  a faithful permutation
  representation   of  smallest  degree,  or  of  smallest  degree  among  the
  transitive  permutation  representations  of G. Using GAP interactively, one
  might  be  able  to  choose  subgroups  of  small  index for which the cores
  intersect  trivially;  in  this  case,  the  actions  on the cosets of these
  subgroups give rise to an intransitive permutation representation the degree
  of which may be smaller than the original degree.
  
  The  methods  used  might  involve  the  use  of  random  elements  and  the
  permutation representation (or even the degree of the representation) is not
  guaranteed     to     be     the     same    for    different    calls    of
  SmallerDegreePermutationRepresentation.
  
  If  the  option  cheap  is given less work is spent on trying to get a small
  degree  representation,  if  the  value  of this option is set to the string
  "skip"  the  identity  mapping  is  returned.  (This is useful if a function
  called internally might try a degree reduction.)
  
    Example  
    gap> image:= Image( iso );;  NrMovedPoints( image );
    24
    gap> small:= SmallerDegreePermutationRepresentation( image );;
    gap> Image( small );
    Group([ (2,3), (2,3,4), (1,2)(3,4), (1,3)(2,4) ])
  
  
    Example  
    gap> p:=Group((1,2,3,4,5,6),(1,2));;p:=Action(p,AsList(p),OnRight);;
    gap> Length(MovedPoints(p));
    720
    gap> q:=SmallerDegreePermutationRepresentation(p);;
    gap> NrMovedPoints(Image(q));
    6
  
  
  
  43.4 Symmetric and Alternating Groups
  
  The  commands  SymmetricGroup  (50.1-10)  and AlternatingGroup (50.1-9) (see
  Section 50.1)  construct  symmetric  and alternating permutation groups. GAP
  can  also  detect  whether  a  given  permutation  group  is  a symmetric or
  alternating  group  on  the set of its moved points; if so then the group is
  called a natural symmetric or alternating group, respectively.
  
  The  functions IsSymmetricGroup (43.4-2) and IsAlternatingGroup (43.4-3) can
  be used to check whether a given group (not necessarily a permutation group)
  is isomorphic to a symmetric or alternating group.
  
  43.4-1 IsNaturalSymmetricGroup
  
  IsNaturalSymmetricGroup( group )  property
  IsNaturalAlternatingGroup( group )  property
  
  A  group  is a natural symmetric or alternating group if it is a permutation
  group  acting  as symmetric or alternating group, respectively, on its moved
  points.
  
  For  groups  that  are  known to be natural symmetric or natural alternating
  groups,  very efficient methods for computing membership, conjugacy classes,
  Sylow subgroups etc. are used.
  
    Example  
    gap> g:=Group((1,5,7,8,99),(1,99,13,72));;
    gap> IsNaturalSymmetricGroup(g);
    true
    gap> g;
    Sym( [ 1, 5, 7, 8, 13, 72, 99 ] )
    gap> IsNaturalSymmetricGroup( Group( (1,2)(4,5), (1,2,3)(4,5,6) ) );
    false
  
  
  43.4-2 IsSymmetricGroup
  
  IsSymmetricGroup( group )  property
  
  is true if the group group is isomorphic to a symmetric group.
  
  43.4-3 IsAlternatingGroup
  
  IsAlternatingGroup( group )  property
  
  is true if the group group is isomorphic to a alternating group.
  
  43.4-4 SymmetricParentGroup
  
  SymmetricParentGroup( grp )  attribute
  
  For  a  permutation group grp this function returns the symmetric group that
  moves the same points as grp does.
  
    Example  
    gap> SymmetricParentGroup( Group( (1,2), (4,5), (7,8,9) ) );
    Sym( [ 1, 2, 4, 5, 7, 8, 9 ] )
  
  
  
  43.5 Primitive Groups
  
  43.5-1 ONanScottType
  
  ONanScottType( G )  attribute
  
  returns  the  type  of  a  primitive  permutation  group G, according to the
  O'Nan-Scott  classification.  The  labelling  of  the different types is not
  consistent  in  the  literature,  we  use the following identifications. The
  two-letter code given is the name of the type as used by Praeger.
  
  1
        Affine. (HA)
  
  2
        Almost simple. (AS)
  
  3a
        Diagonal, Socle consists of two normal subgroups. (HS)
  
  3b
        Diagonal, Socle is minimal normal. (SD)
  
  4a
        Product action with the first factor primitive of type 3a. (HC)
  
  4b
        Product action with the first factor primitive of type 3b. (CD)
  
  4c
        Product action with the first factor primitive of type 2. (PA)
  
  5
        Twisted wreath product (TW)
  
  See [EH01] for correspondence to other labellings used in the literature. As
  it can contain letters, the type is returned as a string.
  
  If  G  is  not a permutation group or does not act primitively on the points
  moved by it, the result is undefined.
  
  43.5-2 SocleTypePrimitiveGroup
  
  SocleTypePrimitiveGroup( G )  attribute
  
  returns  the socle type of the primitive permutation group G. The socle of a
  primitive group is the direct product of isomorphic simple groups, therefore
  the type is indicated by a record with components series, parameter (both as
  described  under IsomorphismTypeInfoFiniteSimpleGroup (39.15-12)), and width
  for the number of direct factors.
  
  If G does not have a faithful primitive action, the result is undefined.
  
    Example  
    gap> g:=AlternatingGroup(5);;
    gap> h:=DirectProduct(g,g);;
    gap> p:=List([1,2],i->Projection(h,i));;
    gap> ac:=Action(h,AsList(g),
    > function(g,h) return Image(p[1],h)^-1*g*Image(p[2],h);end);;
    gap> Size(ac);NrMovedPoints(ac);IsPrimitive(ac,[1..60]);
    3600
    60
    true
    gap> ONanScottType(ac);
    "3a"
    gap> SocleTypePrimitiveGroup(ac);
    rec( 
      name := "A(5) ~ A(1,4) = L(2,4) ~ B(1,4) = O(3,4) ~ C(1,4) = S(2,4) \
    ~ 2A(1,4) = U(2,4) ~ A(1,5) = L(2,5) ~ B(1,5) = O(3,5) ~ C(1,5) = S(2,\
    5) ~ 2A(1,5) = U(2,5)", parameter := 5, series := "A", width := 2 )
  
  
  
  43.6 Stabilizer Chains
  
  Many  of the algorithms for permutation groups use a stabilizer chain of the
  group.  The concepts of stabilizer chains, bases, and strong generating sets
  were  introduced  by  Charles Sims in [Sim70]. An extensive account of basic
  algorithms  together  with  asymptotic  runtime  analysis  can  be  found in
  reference [Ser03,  Chapter  4]. A further discussion of base change is given
  in section 87.1.
  
  Let  B  =  [  b_1, ..., b_n ] be a list of points, G^(1) = G and G^{(i+1)} =
  Stab_{G^(i)}(b_i), such that G^(n+1) = { () }. Then the list [ b_1, ..., b_n
  ]  is  called a base of G, the points b_i are called base points. A set S of
  generators for G satisfying the condition ⟨ S ∩ G^(i) ⟩ = G^(i) for each 1 ≤
  i  ≤  n,  is  called  a strong generating set (SGS) of G. (More precisely we
  ought  to  say  that it is a SGS of G relative to B). The chain of subgroups
  G^(i) of G itself is called the stabilizer chain of G relative to B.
  
  Since  [  b_1,  ..., b_n ], where n is the degree of G and b_i are the moved
  points  of  G,  certainly  is  a  base  for  G  there exists a base for each
  permutation  group.  The  number of points in a base is called the length of
  the  base. A base B is called reduced if there exists no i such that G^(i) =
  G^(i+1).  (This  however does not imply that no subset of B could also serve
  as  a  base.)  Note that different reduced bases for one permutation group G
  may  have  different  lengths.  For  example,  the  irreducible  degree  416
  permutation  representation  of the Chevalley Group G_2(4) possesses reduced
  bases of lengths 5 and 7.
  
  Let  R^(i)  be  a right transversal of G^(i+1) in G^(i), i.e. a set of right
  coset representatives of the cosets of G^(i+1) in G^(i). Then each element g
  of  G  has  a unique representation as a product of the form g = r_n ... r_1
  with  r_i  ∈  R^(i).  The  cosets  of  G^(i+1)  in  G^(i)  are  in bijective
  correspondence  with  the  points  in  O^(i)  :=  b_i^{G^(i)}.  So  we could
  represent  a  transversal  as a list T such that T[p] is a representative of
  the  coset  corresponding  to the point p ∈ O^(i), i.e., an element of G^(i)
  that  takes  b_i  to  p.  (Note  that such a list has holes in all positions
  corresponding to points not contained in O^(i).)
  
  This  approach  however  will  store  many  different  permutations as coset
  representatives which can be a problem if the degree n gets bigger. Our goal
  therefore is to store as few different permutations as possible such that we
  can  still  reconstruct  each  representative  in  R^(i),  and from them the
  elements  in G. A factorized inverse transversal T is a list where T[p] is a
  generator  of G^(i) such that p^{T[p]} is a point that lies earlier in O^(i)
  than  p  (note that we consider O^(i) as a list, not as a set). If we assume
  inductively  that  we  know an element r ∈ G^(i) that takes b_i to p^{T[p]},
  then  r  T[p]^{-1} is an element in G^(i) that takes b_i to p. GAP uses such
  factorized inverse transversals.
  
  Another  name  for  a factorized inverse transversal is a Schreier tree. The
  vertices  of  the  tree are the points in O^(i), and the root of the tree is
  b_i. The edges are defined as the ordered pairs (p, p^{T[p]}), for p ∈ O^(i)
  ∖  {  b_i }. The edge (p, p^{T[p]}) is labelled with the generator T[p], and
  the  product  of  edge  labels  along  the  unique path from p to b_i is the
  inverse of the transversal element carrying b_i to p.
  
  Before we describe the construction of stabilizer chains in 43.8, we explain
  in 43.7  the  idea  of using non-deterministic algorithms; this is necessary
  for  understanding  the options available for the construction of stabilizer
  chains. After that, in 43.9 it is explained how a stabilizer chain is stored
  in  GAP,  43.10  lists operations for stabilizer chains, and 43.11 lists low
  level routines for manipulating stabilizer chains.
  
  
  43.7 Randomized Methods for Permutation Groups
  
  For  most  computations  with permutation groups, it is crucial to construct
  stabilizer  chains  efficiently.  Sims's original construction in [Sim70] is
  deterministic,  and  is  called  the  Schreier-Sims algorithm, because it is
  based on Schreier's Lemma ([HJ59, p. 96]): given K = ⟨ S ⟩ and a transversal
  T for K mod L, one can obtain |S||T| generators for L. This lemma is applied
  recursively,  with  consecutive  point stabilizers G^(i) and G^(i+1) playing
  the role of K and L.
  
  In  permutation groups of large degree, the number of Schreier generators to
  be   processed  becomes  too  large,  and  the  deterministic  Schreier-Sims
  algorithm  becomes  impractical.  Therefore, GAP uses randomized algorithms.
  The method selection process, which is quite different from Version 3, works
  the following way.
  
  If  a  group  acts  on  not  more  than  a  hundred  points, Sims's original
  deterministic  algorithm  is  applied.  In  groups  of  degree  greater than
  hundred,  a  heuristic  algorithm  based  on  ideas in [BCFS91] constructs a
  stabilizer chain. This construction is complemented by a verify-routine that
  either  proves  the  correctness  of  the  stabilizer  chain  or  causes the
  extension  of  the  chain  to  a  correct  one.  The  user can influence the
  verification  process  by  setting  the value of the record component random
  (cf. 43.8).
  
  If  the  random  value equals 1000 then a slight extension of an unpublished
  method  of  Sims is used. The outcome of this verification process is always
  correct. The user also can prescribe any integer x, 1 ≤ x ≤ 999 as the value
  of  random. In this case, a randomized verification process from [BCFS91] is
  applied,  and  the result of the stabilizer chain construction is guaranteed
  to be correct with probability at least x/1000. The practical performance of
  the algorithm is much better than the theoretical guarantee.
  
  If  the  stabilizer chain is not correct then the elements in the product of
  transversals R^(m) R^(m-1) ⋯ R^(1) constitute a proper subset of the group G
  in  question.  This  means that a membership test with this stabilizer chain
  returns  false  for  all  elements that are not in G, but it may also return
  false  for  some  elements  of  G;  in  other  words,  the  result true of a
  membership  test  is  always  correct,  whereas  the  result  false  may  be
  incorrect.
  
  The  construction  and  verification  phases are separated because there are
  situations  where  the  verification  step can be omitted; if one happens to
  know  the  order of the group in advance then the randomized construction of
  the  stabilizer  chain  stops  as  soon as the product of the lengths of the
  basic  orbits  of  the  chain  equals the group order, and the chain will be
  correct (see the size option of the StabChain (43.8-1) command).
  
  Although  the  worst  case  running  time  is  roughly  quadratic for Sims's
  verification and roughly linear for the randomized one, in most examples the
  running  time  of  the  stabilizer chain construction with random value 1000
  (i.e.,  guaranteed  correct output) is about the same as the running time of
  randomized  verification  with guarantee of at least 90 percent correctness.
  Therefore,  we suggest to use the default value random = 1000. Possible uses
  of  random  values  less  than  1000 are when one has to run through a large
  collection of subgroups, and a low value of random is used to choose quickly
  a  candidate  for  more  thorough  examination; another use is when the user
  suspects   that   the   quadratic   bottleneck  of  the  guaranteed  correct
  verification is hit.
  
  We will give two examples to illustrate these ideas.
  
    Example  
    gap> h:= SL(4,7);;
    gap> o:= Orbit( h, [1,0,0,0]*Z(7)^0, OnLines );;
    gap> op:= Action( h, o, OnLines );;
    gap> NrMovedPoints( op );
    400
  
  
  We  created a permutation group on 400 points. First we compute a guaranteed
  correct stabilizer chain (see StabChain (43.8-1)).
  
    Example  
    gap> h:= Group( GeneratorsOfGroup( op ) );;
    gap> StabChain( h );;  time;
    1120
    gap> Size( h );
    2317591180800
  
  
  Now  randomized  verification  will  be  used. We require that the result is
  guaranteed  correct with probability 90 percent. This means that if we would
  do  this  calculation  many times over, GAP would guarantee that in least 90
  percent  of  all calculations the result is correct. In fact the results are
  much  better than the guarantee, but we cannot promise that this will really
  happen.  (For  the meaning of the random component in the second argument of
  StabChain (43.8-1).)
  
  First the group is created anew.
  
    Example  
    gap> h:= Group( GeneratorsOfGroup( op ) );;
    gap> StabChain( h, rec( random:= 900 ) );;  time;
    1410
    gap> Size( h );
    2317591180800
  
  
  The  result  is  still  correct,  and  the running time is actually somewhat
  slower.  If  you  give  the  algorithm additional information so that it can
  check  its  results, things become faster and the result is guaranteed to be
  correct.
  
    Example  
    gap> h:=Group( GeneratorsOfGroup( op ) );;
    gap> SetSize( h, 2317591180800 );
    gap> StabChain( h );;  time;
    170
  
  
  The  second  example gives a typical group when the verification with random
  value  1000 is slow. The problem is that the group has a stabilizer subgroup
  G^(i)  such  that  the fundamental orbit O^(i) is split into a lot of orbits
  when we stabilize b_i and one additional point of O^(i).
  
    Example  
    gap> p1:=PermList(Concatenation([401],[1..400]));;
    gap> p2:=PermList(List([1..400],i->(i*20 mod 401)));;
    gap> d:=DirectProduct(Group(p1,p2),SymmetricGroup(5));;
    gap> h:=Group(GeneratorsOfGroup(d));;
    gap> StabChain(h);;time;Size(h);
    1030
    192480
    gap> h:=Group(GeneratorsOfGroup(d));;
    gap> StabChain(h,rec(random:=900));;time;Size(h);
    570
    192480
  
  
  When  stabilizer chains of a group G are created with random value less than
  1000,  this  is  noted  in  the  group G, by setting of the record component
  random  in  the  value  of the attribute StabChainOptions (43.8-2) for G. As
  errors  induced  by  the  random  methods  might  propagate,  any  group  or
  homomorphism   created   from   G   inherits   a  random  component  in  its
  StabChainOptions (43.8-2) value from the corresponding component for G.
  
  A  lot of algorithms dealing with permutation groups use randomized methods;
  however,  if  the  initial  stabilizer  chain  construction  for  a group is
  correct, these further methods will provide guaranteed correct output.
  
  
  43.8 Construction of Stabilizer Chains
  
  43.8-1 StabChain
  
  StabChain( G[, options] )  function
  StabChain( G, base )  function
  StabChainOp( G, options )  operation
  StabChainMutable( G )  attribute
  StabChainMutable( permhomom )  attribute
  StabChainImmutable( G )  attribute
  
  These  commands  compute  a  stabilizer  chain  for the permutation group G;
  additionally,   StabChainMutable   is   also  an  attribute  for  the  group
  homomorphism permhomom whose source is a permutation group.
  
  (The  mathematical background of stabilizer chains is sketched in 43.6, more
  information  about  the objects representing stabilizer chains in GAP can be
  found in 43.9.)
  
  StabChainOp  is  an  operation  with two arguments G and options, the latter
  being  a  record  which  controls  some  aspects  of  the  computation  of a
  stabilizer  chain  (see  below);  StabChainOp  returns  a mutable stabilizer
  chain.  StabChainMutable is a mutable attribute for groups or homomorphisms,
  its  default  method  for  groups  is to call StabChainOp with empty options
  record.  StabChainImmutable  is  an  attribute  with  immutable  values; its
  default method dispatches to StabChainMutable.
  
  StabChain  is  a  function  with  first  argument a permutation group G, and
  optionally   a   record   options  as  second  argument.  If  the  value  of
  StabChainImmutable  for  G  is  already  known  and if this stabilizer chain
  matches  the  requirements  of options, StabChain simply returns this stored
  stabilizer  chain.  Otherwise  StabChain  calls  StabChainOp  and returns an
  immutable  copy  of  the  result;  additionally,  this  chain  is  stored as
  StabChainImmutable  value  for  G.  If  no  options  argument  is given, its
  components  default to the global variable DefaultStabChainOptions (43.8-3).
  If  base  is  a  list of positive integers, the version StabChain( G, base )
  defaults to StabChain( G, rec( base:= base ) ).
  
  If  given,  options  is  a record whose components specify properties of the
  desired stabilizer chain or which may help the algorithm. Default values for
  all  of  them  can  be  given in the global variable DefaultStabChainOptions
  (43.8-3). The following options are supported.
  
  base (default an empty list)
        A  list  of points, through which the resulting stabilizer chain shall
        run. For the base B of the resulting stabilizer chain S this means the
        following.  If  the  reduced  component  of options is true then those
        points  of  base with nontrivial basic orbits form the initial segment
        of  B,  if  the  reduced  component  is  false then base itself is the
        initial  segment  of  B.  Repeated  occurrences  of points in base are
        ignored.  If  a  stabilizer  chain  for  G  is  already known then the
        stabilizer chain is computed via a base change.
  
  knownBase (no default value)
        A  list  of  points  which is known to be a base for the group. Such a
        known  base  makes  it easier to test whether a permutation given as a
        word  in  terms  of  a  set  of  generators  is the identity, since it
        suffices  to map the known base with each factor consecutively, rather
        than multiplying the whole permutations (which would mean to map every
        point).  This speeds up the Schreier-Sims algorithm which is used when
        a  new  stabilizer  chain  is  constructed;  it will not affect a base
        change, however. The component knownBase bears no relation to the base
        component,  you  may specify a known base knownBase and a desired base
        base independently.
  
  reduced (default true)
        If this is true the resulting stabilizer chain S is reduced, i.e., the
        case  G^(i)  =  G^(i+1) does not occur. Setting reduced to false makes
        sense only if the component base (see above) is also set; in this case
        all  points  of  base will occur in the base B of S, even if they have
        trivial  basic orbits. Note that if base is just an initial segment of
        B, the basic orbits of the points in B ∖base are always nontrivial.
  
  tryPcgs (default true)
        If  this  is true and either the degree is at most 100 or the group is
        known  to  be  solvable,  GAP  will first try to construct a pcgs (see
        Chapter 45)  for  G  which  will  succeed  and  implicitly construct a
        stabilizer chain if G is solvable. If G turns out non-solvable, one of
        the   other   methods   will   be  used.  This  solvability  check  is
        comparatively fast, even if it fails, and it can save a lot of time if
        G is solvable.
  
  random (default 1000)
        If  the  value  is less than 1000, the resulting chain is correct with
        probability  at  least random/ 1000. The random option is explained in
        more detail in 43.7.
  
  size (default Size(G) if this is known, i.e., if HasSize(G) is true)
        If  this component is present, its value is assumed to be the order of
        the   group   G.  This  information  can  be  used  to  prove  that  a
        non-deterministically constructed stabilizer chain is correct. In this
        case,  GAP  does  a  non-deterministic  construction until the size is
        correct.
  
  limit (default Size(Parent(G)) or StabChainOptions(Parent(G)).limit if it is present)
        If  this component is present, it must be greater than or equal to the
        order  of  G. The stabilizer chain construction stops if size limit is
        reached.
  
  43.8-2 StabChainOptions
  
  StabChainOptions( G )  attribute
  
  is  a  record that stores the options with which the stabilizer chain stored
  in StabChainImmutable (43.8-1) has been computed (see StabChain (43.8-1) for
  the options that are supported).
  
  43.8-3 DefaultStabChainOptions
  
  DefaultStabChainOptions global variable
  
  are the options for StabChain (43.8-1) which are set as default.
  
  43.8-4 StabChainBaseStrongGenerators
  
  StabChainBaseStrongGenerators( base, sgs, one )  function
  
  Let  base  be  a  base  for  a  permutation group G, and let sgs be a strong
  generating  set  for  G  with  respect  to base; one must be the appropriate
  identity  element  of  G (see One (31.10-2), in most cases this will be ()).
  This  function  constructs  a  stabilizer  chain  without  the  need to find
  Schreier generators; so this is much faster than the other algorithms.
  
  43.8-5 MinimalStabChain
  
  MinimalStabChain( G )  attribute
  
  returns the reduced stabilizer chain corresponding to the base [ 1, 2, 3, 4,
  ... ].
  
  
  43.9 Stabilizer Chain Records
  
  If a permutation group has a stabilizer chain, this is stored as a recursive
  structure. This structure is itself a record S and it has
  
  (1)
        components  that  provide  information  about  one  level G^(i) of the
        stabilizer chain (which we call the current stabilizer) and
  
  (2)
        a  component  stabilizer  that  holds  another such record, namely the
        stabilizer chain of the next stabilizer G^(i+1).
  
  This gives a recursive structure where the outermost record representing the
  topmost  stabilizer is bound to the group record component stabChain and has
  the  components  explained  below.  Note:  Since the structure is recursive,
  never  print  a stabilizer chain! (Unless you want to exercise the scrolling
  capabilities of your terminal.)
  
  identity 
        the identity element of the current stabilizer.
  
  labels 
        a  list of permutations which contains labels for the Schreier tree of
        the  current stabilizer, i.e., it contains elements for the factorized
        inverse  transversal.  The  first  entry  in  this  list is always the
        identity.  Note  that  GAP  tries to arrange things so that the labels
        components  are  identical  (i.e.,  the  same  GAP  object)  in  every
        stabilizer  of  the  chain;  thus  the  labels  of a stabilizer do not
        necessarily all lie in the this stabilizer (but see genlabels below).
  
  genlabels 
        a  list  of  integers  indexing some of the permutations in the labels
        component.  The labels addressed in this way form a generating set for
        the  current stabilizer. If the genlabels component is empty, the rest
        of  the  stabilizer  chain represents the trivial subgroup, and can be
        ignored, e.g., when calculating the size.
  
  generators 
        a  list  of  generators  for  the  current  stabilizer. Usually, it is
        labels{ genlabels }.
  
  orbit 
        the  vertices  of  the  Schreier  tree,  which  form  the  basic orbit
        b_i^{G^(i)},  ordered  in such a way that the base point b_i is in the
        first position in the orbit.
  
  transversal
        The  factorized  inverse transversal found during the orbit algorithm.
        The  element  g stored at transversal[i] will map i to another point j
        that  in  the  Schreier  tree is closer to the base point. By iterated
        application  (transversal[j]  and  so on) eventually the base point is
        reached and an element that maps i to the base point found as product.
  
  translabels
        An  index  list  such  that transversal[j] = labels[ translabels[j] ].
        This list takes up comparatively little memory and is used to speed up
        base changes.
  
  stabilizer 
        If the current stabilizer is not yet the trivial group, the stabilizer
        chain  continues  with the stabilizer of the current base point, which
        is  again  represented  as  a record with components labels, identity,
        genlabels,  generators,  orbit,  translabels, transversal (and perhaps
        stabilizer).  This  record is bound to the stabilizer component of the
        current   stabilizer.  The  last  member  of  a  stabilizer  chain  is
        recognized by the fact that it has no stabilizer component bound.
  
  It is possible that different stabilizer chains share the same record as one
  of their iterated stabilizer components.
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2));;
    gap> StabChain(g);
    <stabilizer chain record, Base [ 1, 2, 3 ], Orbit length 4, Size: 24>
    gap> BaseOfGroup(g);
    [ 1, 2, 3 ]
    gap> StabChainOptions(g);
    rec( random := 1000 )
    gap> DefaultStabChainOptions;
    rec( random := 1000, reduced := true, tryPcgs := true )
  
  
  
  43.10 Operations for Stabilizer Chains
  
  43.10-1 BaseStabChain
  
  BaseStabChain( S )  function
  
  returns the base belonging to the stabilizer chain S.
  
  43.10-2 BaseOfGroup
  
  BaseOfGroup( G )  attribute
  
  returns  a  base  of  the  permutation group G. There is no guarantee that a
  stabilizer chain stored in G corresponds to this base!
  
  43.10-3 SizeStabChain
  
  SizeStabChain( S )  function
  
  returns the product of the orbit lengths in the stabilizer chain S, that is,
  the order of the group described by S.
  
  43.10-4 StrongGeneratorsStabChain
  
  StrongGeneratorsStabChain( S )  function
  
  returns a strong generating set corresponding to the stabilizer chain S.
  
  43.10-5 GroupStabChain
  
  GroupStabChain( [G, ]S )  function
  
  constructs  a  permutation group with stabilizer chain S, i.e., a group with
  generators Generators( S ) to which S is assigned as component stabChain. If
  the optional argument G is given, the result will have the parent G.
  
  43.10-6 OrbitStabChain
  
  OrbitStabChain( S, pnt )  function
  
  returns  the  orbit of pnt under the group described by the stabilizer chain
  S.
  
  43.10-7 IndicesStabChain
  
  IndicesStabChain( S )  function
  
  returns a list of the indices of the stabilizers in the stabilizer chain S.
  
  43.10-8 ListStabChain
  
  ListStabChain( S )  function
  
  returns  a  list that contains at position i the stabilizer of the first i-1
  base points in the stabilizer chain S.
  
  43.10-9 ElementsStabChain
  
  ElementsStabChain( S )  function
  
  returns  a  list  of  all  elements of the group described by the stabilizer
  chain S.
  
  43.10-10 IteratorStabChain
  
  IteratorStabChain( S )  function
  
  returns an iterator for the elments of the group described by the stabilizer
  chain  S.  The elements of the group G are produced by iterating through all
  base  images  in  turn,  and  in  the ordering induced by the base. For more
  details see 43.6
  
  43.10-11 InverseRepresentative
  
  InverseRepresentative( S, pnt )  function
  
  calculates  the transversal element which maps pnt back to the base point of
  S.  It  just  runs  back  through the Schreier tree from pnt to the root and
  multiplies the labels along the way.
  
  43.10-12 SiftedPermutation
  
  SiftedPermutation( S, g )  function
  
  sifts  the  permutation  g  through  the  stabilizer chain S and returns the
  result after the last step.
  
  The   element   g   is   sifted   as   follows:   g   is  replaced  by  g  *
  InverseRepresentative( S, S.orbit[1]^g ), then S is replaced by S.stabilizer
  and  this  process  is repeated until S is trivial or S.orbit[1]^g is not in
  the  basic  orbit  S.orbit.  The remainder g is returned, it is the identity
  permutation if and only if the original g is in the group G described by the
  original S.
  
  43.10-13 MinimalElementCosetStabChain
  
  MinimalElementCosetStabChain( S, g )  function
  
  Let  G  be  the  group  described  by  the stabilizer chain S. This function
  returns  a  permutation  h such that G g = G h (that is, g / h ∈ G) and with
  the  additional  property  that  the  list  of  images  under  h of the base
  belonging to S is minimal w.r.t. lexicographical ordering.
  
  43.10-14 LargestElementStabChain
  
  LargestElementStabChain( S, id )  function
  
  Let  G  be  the  group  described  by  the stabilizer chain S. This function
  returns  the element h ∈ G with the property that the list of images under h
  of  the  base belonging to S is maximal w.r.t. lexicographical ordering. The
  second argument must be an identity element (used to start the recursion).
  
  43.10-15 ApproximateSuborbitsStabilizerPermGroup
  
  ApproximateSuborbitsStabilizerPermGroup( G, pnt )  function
  
  returns an approximation of the orbits of Stabilizer( G, pnt ) on all points
  of  the  orbit Orbit( G, pnt ), without computing the full point stabilizer;
  As not all Schreier generators are used, the result may represent the orbits
  of only a subgroup of the point stabilizer.
  
  
  43.11 Low Level Routines to Modify and Create Stabilizer Chains
  
  These  operations  modify  a  stabilizer  chain  or  obtain  new chains with
  specific  properties.  They  are rather technical and should only be used if
  such  low-level  routines  are  deliberately required. (For all functions in
  this section the parameter S is a stabilizer chain.)
  
  43.11-1 CopyStabChain
  
  CopyStabChain( S )  function
  
  This  function  returns a mutable copy of the stabilizer chain S that has no
  mutable  object  (list or record) in common with S. The labels components of
  the result are possibly shared by several levels, but superfluous labels are
  removed.  (An  entry in labels is superfluous if it does not occur among the
  genlabels  or  translabels  on  any  of  the  levels which share that labels
  component.)
  
  This  is  useful  for  stabiliser  sub-chains that have been obtained as the
  (iterated) stabilizer component of a bigger chain.
  
  43.11-2 CopyOptionsDefaults
  
  CopyOptionsDefaults( G, options )  function
  
  sets  components  in  a stabilizer chain options record options according to
  what is known about the group G. This can be used to obtain a new stabilizer
  chain for G quickly.
  
  43.11-3 ChangeStabChain
  
  ChangeStabChain( S, base[, reduced] )  function
  
  changes  or reduces a stabilizer chain S to be adapted to the base base. The
  optional argument reduced is interpreted as follows.
  
  reduced = false : 
        change the stabilizer chain, do not reduce it,
  
  reduced = true : 
        change the stabilizer chain, reduce it.
  
  43.11-4 ExtendStabChain
  
  ExtendStabChain( S, base )  function
  
  extends  the  stabilizer  chain  S  so that it corresponds to base base. The
  original base of S must be a subset of base.
  
  43.11-5 ReduceStabChain
  
  ReduceStabChain( S )  function
  
  changes  the stabilizer chain S to a reduced stabilizer chain by eliminating
  trivial steps.
  
  43.11-6 RemoveStabChain
  
  RemoveStabChain( S )  function
  
  S  must be a stabilizer record in a stabilizer chain. This chain then is cut
  off  at  S by changing the entries in S. This can be used to remove trailing
  trivial steps.
  
  43.11-7 EmptyStabChain
  
  EmptyStabChain( labels, id[, pnt] )  function
  
  constructs  a  stabilizer  chain  for  the trivial group with identity value
  equal  toid  and  labels = { id } ∪ labels (but of course with genlabels and
  generators  values  an  empty  list).  If the optional third argument pnt is
  present,  the only stabilizer of the chain is initialized with the one-point
  basic orbit [ pnt ] and with translabels and transversal components.
  
  43.11-8 InsertTrivialStabilizer
  
  InsertTrivialStabilizer( S, pnt )  function
  
  InsertTrivialStabilizer  initializes  the  current  stabilizer  with  pnt as
  EmptyStabChain  (43.11-7)  did,  but  assigns  the  original  S  to  the new
  S.stabilizer  component, such that a new level with trivial basic orbit (but
  identical  labels  and  ShallowCopyed genlabels and generators) is inserted.
  This  function  should be used only if pnt really is fixed by the generators
  of S, because then new generators can be added and the orbit and transversal
  at the same time extended with AddGeneratorsExtendSchreierTree (43.11-10).
  
  43.11-9 IsFixedStabilizer
  
  IsFixedStabilizer( S, pnt )  function
  
  returns true if pnt is fixed by all generators of S and false otherwise.
  
  43.11-10 AddGeneratorsExtendSchreierTree
  
  AddGeneratorsExtendSchreierTree( S, new )  function
  
  adds the elements in new to the list of generators of S and at the same time
  extends  the  orbit  and transversal. This is the only legal way to extend a
  Schreier   tree   (because  this  involves  careful  handling  of  the  tree
  components).
  
  
  43.12 Backtrack
  
  A  main use for stabilizer chains is in backtrack algorithms for permutation
  groups.  GAP  implements  a  partition-backtrack  algorithm  as described in
  [Leo91] and refined in [The97].
  
  43.12-1 SubgroupProperty
  
  SubgroupProperty( G, Pr[, L] )  function
  
  Pr  must  be a one-argument function that returns true or false for elements
  of  the  group  G, and the subset of elements of G that fulfill Pr must be a
  subgroup.  (If  the  latter  is  not  true  the  result of this operation is
  unpredictable!) This command computes this subgroup. The optional argument L
  must  be a subgroup of the set of all elements in G fulfilling Pr and can be
  given if known in order to speed up the calculation.
  
  43.12-2 ElementProperty
  
  ElementProperty( G, Pr[, L[, R]] )  function
  
  ElementProperty  returns  an  element π of the permutation group G such that
  the  one-argument function Pr returns true for π. It returns fail if no such
  element  exists in G. The optional arguments L and R are subgroups of G such
  that  the  property Pr has the same value for all elements in the cosets L g
  and g R, respectively, with g ∈ G.
  
  A  typical  example of using the optional subgroups L and R is the conjugacy
  test for elements a and b for which one can set L:= C_G(a) and R:= C_G(b).
  
    Example  
    gap> propfun:= el -> (1,2,3)^el in [ (1,2,3), (1,3,2) ];;
    gap> SubgroupProperty( g, propfun, Subgroup( g, [ (1,2,3) ] ) );
    Group([ (1,2,3), (2,3) ])
    gap> ElementProperty( g, el -> Order( el ) = 2 );
    (2,4)
  
  
  Chapter 42  describes  special  operations  to construct permutations in the
  symmetric group without using backtrack constructions.
  
  Backtrack  routines  are  also  called by the methods for permutation groups
  that  compute centralizers, normalizers, intersections, conjugating elements
  as  well  as  stabilizers  for  the  operations  of  a permutation group via
  OnPoints   (41.2-1),  OnSets  (41.2-4),  OnTuples  (41.2-5)  and  OnSetsSets
  (41.2-7).   Some  of  these  methods  use  more  specific  refinements  than
  SubgroupProperty   (43.12-1)  or  ElementProperty.  For  the  definition  of
  refinements, and how one can define refinements, see Section 87.2.
  
  43.12-3 TwoClosure
  
  TwoClosure( G )  attribute
  
  The 2-closure of a transitive permutation group G on n points is the largest
  subgroup  of  the  symmetric  group S_n which has the same orbits on sets of
  ordered  pairs  of  points as the group G has. It also can be interpreted as
  the stabilizer of the orbital graphs of G.
  
    Example  
    gap> TwoClosure(Group((1,2,3),(2,3,4)));
    Sym( [ 1 .. 4 ] )
  
  
  43.12-4 InfoBckt
  
  InfoBckt info class
  
  is the info class for the partition backtrack routines.
  
  
  43.13 Working with large degree permutation groups
  
  Permutation groups of large degree (usually at least a few 10000) can pose a
  challenge  to  the heuristics used in the algorithms for permutation groups.
  This  section  lists a few useful tricks that may speed up calculations with
  such large groups enormously.
  
  The  first aspect concerns solvable groups: A lot of calculations (including
  an  initial  stabilizer  chain  computation  thanks  to  the  algorithm from
  [Sim90])  are  faster if a permutation group is known to be solvable. On the
  other  hand,  proving  nonsolvability  can  be expensive for higher degrees.
  Therefore  GAP  will automatically test a permutation group for solvability,
  only  if the degree is not exceeding 100. (See also the tryPcgs component of
  StabChainOptions  (43.8-2).)  It  is therefore beneficial to tell a group of
  larger   degree,   which  is  known  to  be  solvable,  that  it  is,  using
  SetIsSolvableGroup(G,true).
  
  The  second  aspect  concerns memory usage. A permutation on more than 65536
  points  requires  4  bytes  per point for storing. So permutations on 256000
  points  require  roughly  1MB  of  storage per permutation. Just storing the
  permutations  required  for  a  stabilizer chain might already go beyond the
  available  memory,  in  particular  if the base is not very short. In such a
  situation  it  can  be  useful, to replace the permutations by straight line
  program elements (see 37.9).
  
  The  following  code  gives an example of usage: We create a group of degree
  231000.  Using  straight line program elements, one can compute a stabilizer
  chain in about 200 MB of memory.
  
    Example  
    gap> Read("largeperms"); # read generators from file
    gap> gens:=StraightLineProgGens(permutationlist);;
    gap> g:=Group(gens);
    <permutation group with 5 generators>
    gap> # use random algorithm (faster, but result is monte carlo)
    gap> StabChainOptions(g).random:=1;;
    gap> Size(g); # enforce computation of a stabilizer chain
    3529698298145066075557232833758234188056080273649172207877011796336000
  
  
  Without  straight  line  program  elements,  the  same calculation runs into
  memory problems after a while even with 512MB of workspace:
  
    Example  
    gap> h:=Group(permutationlist);
    <permutation group with 5 generators>
    gap> StabChainOptions(h).random:=1;;
    gap> Size(h);
    exceeded the permitted memory (`-o' command line option) at
    mlimit := 1; called from
    SCRMakeStabStrong( S.stabilizer, [ g ], param, orbits, where, basesize,
     base, correct, missing, false ); called from
     SCRMakeStabStrong( S.stabilizer, [ g ], param, orbits, where, basesize,
    ...
  
  
  The advantage in memory usage however is paid for in runtime: Comparisons of
  elements  become  much  more  expensive.  One  can avoid some of the related
  problems by registering a known base with the straight line program elements
  (see StraightLineProgGens  (37.9-3)).  In  this case element comparison will
  only  compare  the images of the given base points. If we are planning to do
  extensive  calculations  with the group, it can even be worth to recreate it
  with straight line program elements knowing a previously computed base:
  
    Example  
    gap> # get the base we computed already
    gap> bas:=BaseStabChain(StabChainMutable(g));
    [ 1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52, 55,
    ...
      2530, 2533, 2554, 2563, 2569 ]
    gap> gens:=StraightLineProgGens(permutationlist,bas);;
    gap> g:=Group(gens);;
    gap> SetSize(g,
    > 3529698298145066075557232833758234188056080273649172207877011796336000);
    gap> Random(g);; # enforce computation of a stabilizer chain
  
  
  As  we  know already base and size, this second stabilizer chain calculation
  is much faster than the first one and takes less memory.