39 Groups
  
  This  chapter  explains  how  to  create  groups  and defines operations for
  groups,  that  is  operations  whose  definition  does  not  depend  on  the
  representation used. However methods for these operations in most cases will
  make use of the representation.
  
  If not otherwise specified, in all examples in this chapter the group g will
  be the symmetric group S_4 acting on the letters { 1, ..., 4 }.
  
  
  39.1 Group Elements
  
  Groups  in GAP are written multiplicatively. The elements from which a group
  can  be  generated  must  permit multiplication and multiplicative inversion
  (see 31.14).
  
    Example  
    gap> a:=(1,2,3);;b:=(2,3,4);;
    gap> One(a);
    ()
    gap> Inverse(b);
    (2,4,3)
    gap> a*b;
    (1,3)(2,4)
    gap> Order(a*b);
    2
    gap> Order( [ [ 1, 1 ], [ 0, 1 ] ] );
    infinity
  
  
  The  next  example may run into an infinite loop because the given matrix in
  fact has infinite order.
  
    Example  
    gap> Order( [ [ 1, 1 ], [ 0, 1 ] ] * Indeterminate( Rationals ) );
    #I  Order: warning, order of <mat> might be infinite
  
  
  Since  groups are domains, the recommended command to compute the order of a
  group  is  Size (30.4-6). For convenience, group orders can also be computed
  with Order (31.10-10).
  
  The  operation  Comm  (31.12-3) can be used to compute the commutator of two
  elements,  the  operation LeftQuotient (31.12-2) computes the product x^{-1}
  y.
  
  
  39.2 Creating Groups
  
  When groups are created from generators, this means that the generators must
  be  elements  that  can  be  multiplied  and  inverted  (see also 31.3). For
  creating a free group on a set of symbols, see FreeGroup (37.2-1).
  
  
  39.2-1 Group
  
  Group( gen, ... )  function
  Group( gens[, id] )  function
  
  Group( gen, ... ) is the group generated by the arguments gen, ...
  
  If  the only argument gens is a list that is not a matrix then Group( gens )
  is the group generated by the elements of that list.
  
  If there are two arguments, a list gens and an element id, then Group( gens,
  id ) is the group generated by the elements of gens, with identity id.
  
  Note  that the value of the attribute GeneratorsOfGroup (39.2-4) need not be
  equal   to   the   list   gens   of  generators  entered  as  argument.  Use
  GroupWithGenerators  (39.2-3)  if you want to be sure that the argument gens
  is stored as value of GeneratorsOfGroup (39.2-4).
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2));
    Group([ (1,2,3,4), (1,2) ])
  
  
  39.2-2 GroupByGenerators
  
  GroupByGenerators( gens )  operation
  GroupByGenerators( gens, id )  operation
  
  GroupByGenerators  returns  the  group  G  generated  by the list gens. If a
  second argument id is present then this is stored as the identity element of
  the group.
  
  The value of the attribute GeneratorsOfGroup (39.2-4) of G need not be equal
  to  gens.  GroupByGenerators  is  the  underlying  operation called by Group
  (39.2-1).
  
  39.2-3 GroupWithGenerators
  
  GroupWithGenerators( gens[, id] )  operation
  
  GroupWithGenerators  returns  the  group  G generated by the list gens. If a
  second argument id is present then this is stored as the identity element of
  the  group.  The  value  of the attribute GeneratorsOfGroup (39.2-4) of G is
  equal to gens.
  
  39.2-4 GeneratorsOfGroup
  
  GeneratorsOfGroup( G )  attribute
  
  returns  a  list  of generators of the group G. If G has been created by the
  command  GroupWithGenerators  (39.2-3)  with  argument  gens,  then the list
  returned  by GeneratorsOfGroup will be equal to gens. For such a group, each
  generator  can also be accessed using the . operator (see GeneratorsOfDomain
  (31.9-2)):  for  a  positive  integer i, G.i returns the i-th element of the
  list returned by GeneratorsOfGroup. Moreover, if G is a free group, and name
  is the name of a generator of G then G.name also returns this generator.
  
    Example  
    gap> g:=GroupWithGenerators([(1,2,3,4),(1,2)]);
    Group([ (1,2,3,4), (1,2) ])
    gap> GeneratorsOfGroup(g);
    [ (1,2,3,4), (1,2) ]
  
  
  While  in  this example GAP displays the group via the generating set stored
  in  the  attribute GeneratorsOfGroup, the methods installed for View (6.3-3)
  will in general display only some information about the group which may even
  be just the fact that it is a group.
  
  39.2-5 AsGroup
  
  AsGroup( D )  attribute
  
  if  the  elements  of the collection D form a group the command returns this
  group, otherwise it returns fail.
  
    Example  
    gap> AsGroup([(1,2)]);
    fail
    gap> AsGroup([(),(1,2)]);
    Group([ (1,2) ])
  
  
  39.2-6 ConjugateGroup
  
  ConjugateGroup( G, obj )  operation
  
  returns  the  conjugate  group  of  G,  obtained by applying the conjugating
  element obj.
  
  To form a conjugate (group) by any object acting via ^, one can also use the
  infix operator ^.
  
    Example  
    gap> ConjugateGroup(g,(1,5));
    Group([ (2,3,4,5), (2,5) ])
  
  
  39.2-7 IsGroup
  
  IsGroup( obj )  Category
  
  A  group  is  a  magma-with-inverses  (see IsMagmaWithInverses (35.1-4)) and
  associative (see IsAssociative (35.4-7)) multiplication.
  
  IsGroup  tests whether the object obj fulfills these conditions, it does not
  test   whether   obj  is  a  set  of  elements  that  forms  a  group  under
  multiplication;  use  AsGroup  (39.2-5)  if you want to perform such a test.
  (See 13.3 for details about categories.)
  
    Example  
    gap> IsGroup(g);
    true
  
  
  39.2-8 InfoGroup
  
  InfoGroup  info class
  
  is the info class for the generic group theoretic functions (see 7.4).
  
  
  39.3 Subgroups
  
  For  the  general concept of parents and subdomains, see 31.7 and 31.8. More
  functions   that   construct   certain   subgroups   can  be  found  in  the
  sections 39.11, 39.12, 39.13, and 39.14.
  
  If  a  group  U  is  created as a subgroup of another group G, G becomes the
  parent  of U. There is no universal parent group, parent-child chains can be
  arbitrary long. GAP stores the result of some operations (such as Normalizer
  (39.11-1)) with the parent as an attribute.
  
  39.3-1 Subgroup
  
  Subgroup( G, gens )  function
  SubgroupNC( G, gens )  function
  Subgroup( G )  function
  
  creates  the subgroup U of G generated by gens. The Parent (31.7-1) value of
  U  will  be  G.  The NC version does not check, whether the elements in gens
  actually lie in G.
  
  The  unary version of Subgroup creates a (shell) subgroup that does not even
  know  generators  but  can be used to collect information about a particular
  subgroup over time.
  
    Example  
    gap> u:=Subgroup(g,[(1,2,3),(1,2)]);
    Group([ (1,2,3), (1,2) ])
  
  
  
  39.3-2 Index (GAP operation)
  
  Index( G, U )  operation
  IndexNC( G, U )  operation
  
  For  a  subgroup U of the group G, Index returns the index [G:U] = |G| / |U|
  of U in G. The NC version does not test whether U is contained in G.
  
    Example  
    gap> Index(g,u);
    4
  
  
  39.3-3 IndexInWholeGroup
  
  IndexInWholeGroup( G )  attribute
  
  If  the  family  of  elements  of  G  itself forms a group P, this attribute
  returns  the  index  of  G  in  P.  It  is used primarily for free groups or
  finitely presented groups.
  
    Example  
    gap> freegp:=FreeGroup(1);;
    gap> freesub:=Subgroup(freegp,[freegp.1^5]);;
    gap> IndexInWholeGroup(freesub);
    5
  
  
  39.3-4 AsSubgroup
  
  AsSubgroup( G, U )  operation
  
  creates a subgroup of G which contains the same elements as U
  
    Example  
    gap> v:=AsSubgroup(g,Group((1,2,3),(1,4)));
    Group([ (1,2,3), (1,4) ])
    gap> Parent(v);
    Group([ (1,2,3,4), (1,2) ])
  
  
  39.3-5 IsSubgroup
  
  IsSubgroup( G, U )  function
  
  IsSubgroup  returns  true  if U is a group that is a subset of the domain G.
  This  is actually checked by calling IsGroup( U ) and IsSubset( G, U ); note
  that  special  methods  for  IsSubset  (30.5-1) are available that test only
  generators of U if G is closed under the group operations. So in most cases,
  for  example  whenever  one knows already that U is a group, it is better to
  call only IsSubset (30.5-1).
  
    Example  
    gap> IsSubgroup(g,u);
    true
    gap> v:=Group((1,2,3),(1,2));
    Group([ (1,2,3), (1,2) ])
    gap> u=v;
    true
    gap> IsSubgroup(g,v);
    true
  
  
  39.3-6 IsNormal
  
  IsNormal( G, U )  operation
  
  returns true if the group G normalizes the group U and false otherwise.
  
  A  group G normalizes a group U if and only if for every g ∈ G and u ∈ U the
  element u^g is a member of U. Note that U need not be a subgroup of G.
  
    Example  
    gap> IsNormal(g,u);
    false
  
  
  39.3-7 IsCharacteristicSubgroup
  
  IsCharacteristicSubgroup( G, N )  operation
  
  tests whether N is invariant under all automorphisms of G.
  
    Example  
    gap> IsCharacteristicSubgroup(g,u);
    false
  
  
  39.3-8 ConjugateSubgroup
  
  ConjugateSubgroup( G, g )  operation
  
  For  a group G which has a parent group P (see Parent (31.7-1)), returns the
  subgroup of P, obtained by conjugating G using the conjugating element g.
  
  If  G  has  no parent group, it just delegates to the call to ConjugateGroup
  (39.2-6) with the same arguments.
  
  To  form a conjugate (subgroup) by any object acting via ^, one can also use
  the infix operator ^.
  
  39.3-9 ConjugateSubgroups
  
  ConjugateSubgroups( G, U )  operation
  
  returns a list of all images of the group U under conjugation action by G.
  
  39.3-10 IsSubnormal
  
  IsSubnormal( G, U )  operation
  
  A  subgroup  U of the group G is subnormal if it is contained in a subnormal
  series of G.
  
    Example  
    gap> IsSubnormal(g,Group((1,2,3)));
    false
    gap> IsSubnormal(g,Group((1,2)(3,4)));
    true
  
  
  39.3-11 SubgroupByProperty
  
  SubgroupByProperty( G, prop )  function
  
  creates  a subgroup of G consisting of those elements fulfilling prop (which
  is a tester function). No test is done whether the property actually defines
  a subgroup.
  
  Note  that currently very little functionality beyond an element test exists
  for groups created this way.
  
  39.3-12 SubgroupShell
  
  SubgroupShell( G )  function
  
  creates  a  subgroup  of  G which at this point is not yet specified further
  (but will be later, for example by assigning a generating set).
  
    Example  
    gap> u:=SubgroupByProperty(g,i->3^i=3);
    <subgrp of Group([ (1,2,3,4), (1,2) ]) by property>
    gap> (1,3) in u; (1,4) in u; (1,5) in u;
    false
    true
    false
    gap> GeneratorsOfGroup(u);
    [ (1,2), (1,4,2) ]
    gap> u:=SubgroupShell(g);
    <group>
  
  
  
  39.4 Closures of (Sub)groups
  
  39.4-1 ClosureGroup
  
  ClosureGroup( G, obj )  operation
  
  creates  the group generated by the elements of G and obj. obj can be either
  an element or a collection of elements, in particular another group.
  
    Example  
    gap> g:=SmallGroup(24,12);;u:=Subgroup(g,[g.3,g.4]);
    Group([ f3, f4 ])
    gap> ClosureGroup(u,g.2);
    Group([ f2, f3, f4 ])
    gap> ClosureGroup(u,[g.1,g.2]);
    Group([ f1, f2, f3, f4 ])
    gap> ClosureGroup(u,Group(g.2*g.1));
    Group([ f1*f2^2, f3, f4 ])
  
  
  39.4-2 ClosureGroupAddElm
  
  ClosureGroupAddElm( G, elm )  function
  ClosureGroupCompare( G, elm )  function
  ClosureGroupIntest( G, elm )  function
  
  These  three  functions together with ClosureGroupDefault (39.4-3) implement
  the main methods for ClosureGroup (39.4-1). In the ordering given, they just
  add elm to the generators, remove duplicates and identity elements, and test
  whether elm is already contained in G.
  
  39.4-3 ClosureGroupDefault
  
  ClosureGroupDefault( G, elm )  function
  
  This functions returns the closure of the group G with the element elm. If G
  has  the  attribute  AsSSortedList  (30.3-10)  then also the result has this
  attribute.  This  is  used  to  implement  the default method for Enumerator
  (30.3-2) and EnumeratorSorted (30.3-3).
  
  39.4-4 ClosureSubgroup
  
  ClosureSubgroup( G, obj )  function
  ClosureSubgroupNC( G, obj )  function
  
  For  a  group G that stores a parent group (see 31.7), ClosureSubgroup calls
  ClosureGroup  (39.4-1)  with the same arguments; if the result is a subgroup
  of  the  parent  of  G  then the parent of G is set as parent of the result,
  otherwise  an  error is raised. The check whether the result is contained in
  the  parent of G is omitted by the NC version. As a wrong parent might imply
  wrong properties this version should be used with care.
  
  
  39.5 Expressing Group Elements as Words in Generators
  
  Using  homomorphisms  (see  chapter 40)  it  is  possible  to  express group
  elements  as  words  in given generators: Create a free group (see FreeGroup
  (37.2-1)) on the correct number of generators and create a homomorphism from
  this  free group onto the group G in whose generators you want to factorize.
  Then  the preimage of an element of G is a word in the free generators, that
  will map on this element again.
  
  39.5-1 EpimorphismFromFreeGroup
  
  EpimorphismFromFreeGroup( G )  attribute
  
  For  a  group  G  with  a  known  generating  set,  this attribute returns a
  homomorphism  from  a free group that maps the free generators to the groups
  generators.
  
  The  option  names  can  be  used  to  prescribe a (print) name for the free
  generators.
  
  The  following  example  shows  how  to  decompose  elements  of  S_4 in the
  generators (1,2,3,4) and (1,2):
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2));
    Group([ (1,2,3,4), (1,2) ])
    gap> hom:=EpimorphismFromFreeGroup(g:names:=["x","y"]);
    [ x, y ] -> [ (1,2,3,4), (1,2) ]
    gap> PreImagesRepresentative(hom,(1,4));
    y^-1*x^-1*(x^-1*y^-1)^2*x
  
  
  The  following  example  stems  from  a  real  request  to the GAP Forum. In
  September  2000  a  GAP  user  working  with  puzzles  wanted to express the
  permutation (1,2) as a word as short as possible in particular generators of
  the symmetric group S_16.
  
    Example  
    gap> perms := [ (1,2,3,7,11,10,9,5), (2,3,4,8,12,11,10,6),
    >   (5,6,7,11,15,14,13,9), (6,7,8,12,16,15,14,10) ];;
    gap> puzzle := Group( perms );;Size( puzzle );
    20922789888000
    gap> hom:=EpimorphismFromFreeGroup(puzzle:names:=["a", "b", "c", "d"]);;
    gap> word := PreImagesRepresentative( hom, (1,2) );
    a^-1*c*b*c^-1*a*b^-1*a^-2*c^-1*a*b^-1*c*b
    gap> Length( word );
    13
  
  
  39.5-2 Factorization
  
  Factorization( G, elm )  operation
  
  returns  a  factorization  of  elm  as word in the generators of the group G
  given   in   the   attribute   GeneratorsOfGroup   (39.2-4).  The  attribute
  EpimorphismFromFreeGroup  (39.5-1)  of G will contain a map from the group G
  to   the   free  group  in  which  the  word  is  expressed.  The  attribute
  MappingGeneratorsImages (40.10-2) of this map gives a list of generators and
  corresponding letters.
  
  The algorithm used forms all elements of the group to ensure a short word is
  found.  Therefore this function should not be used when the group G has more
  than  a  few  million  elements.  Because  of this, one should not call this
  function within algorithms, but use homomorphisms instead.
  
    Example  
    gap> G:=SymmetricGroup( 6 );;
    gap> r:=(3,4);; s:=(1,2,3,4,5,6);;
    gap> # create subgroup to force the system to use the generators r and s:
    gap> H:= Subgroup(G, [ r, s ] );
    Group([ (3,4), (1,2,3,4,5,6) ])
    gap> Factorization( H, (1,2,3) );
    (x2*x1)^2*x2^-2
    gap> s*r*s*r*s^-2;
    (1,2,3)
    gap> MappingGeneratorsImages(EpimorphismFromFreeGroup(H));
    [ [ x1, x2 ], [ (3,4), (1,2,3,4,5,6) ] ]
  
  
  39.5-3 GrowthFunctionOfGroup
  
  GrowthFunctionOfGroup( G )  attribute
  GrowthFunctionOfGroup( G, radius )  operation
  
  For  a  group  G  with a generating set given in GeneratorsOfGroup (39.2-4),
  this function calculates the number of elements whose shortest expression as
  words  in the generating set is of a particular length. It returns a list L,
  whose i+1 entry counts the number of elements whose shortest word expression
  has  length  i. If a maximal length radius is given, only words up to length
  radius  are counted. Otherwise the group must be finite and all elements are
  enumerated.
  
    Example  
    gap> GrowthFunctionOfGroup(MathieuGroup(12));  
    [ 1, 5, 19, 70, 255, 903, 3134, 9870, 25511, 38532, 16358, 382 ]
    gap> GrowthFunctionOfGroup(MathieuGroup(12),2);
    [ 1, 5, 19 ]
    gap> GrowthFunctionOfGroup(MathieuGroup(12),99);
    [ 1, 5, 19, 70, 255, 903, 3134, 9870, 25511, 38532, 16358, 382 ]
    gap> free:=FreeGroup("a","b");
    <free group on the generators [ a, b ]>
    gap> product:=free/ParseRelators(free,"a2,b3");
    <fp group on the generators [ a, b ]>
    gap> SetIsFinite(product,false);
    gap> GrowthFunctionOfGroup(product,10);
    [ 1, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64 ]
  
  
  
  39.6 Structure Descriptions
  
  39.6-1 StructureDescription
  
  StructureDescription( G )  attribute
  
  The  method for StructureDescription exhibits a structure of the given group
  G to some extent, using the strategy outlined below. The idea is to return a
  possibly  short  string  which  gives  some  insight in the structure of the
  considered group. It is intended primarily for small groups (order less than
  100)  or  groups  with  few  normal subgroups, in other cases, in particular
  large  p-groups,  it can be very costly. Furthermore, the string returned is
  --  as  the  action  on chief factors is not described -- often not the most
  useful way to describe a group.
  
  The string returned by StructureDescription is not an isomorphism invariant:
  non-isomorphic  groups  can  have  the same string value, and two isomorphic
  groups in different representations can produce different strings. The value
  returned by StructureDescription is a string of the following form:
  
  
      StructureDescription(<G>) ::=
          1                                 ; trivial group 
        | C<size>                           ; finite cyclic group
        | Z                                 ; infinite cyclic group
        | A<degree>                         ; alternating group
        | S<degree>                         ; symmetric group
        | D<size>                           ; dihedral group
        | Q<size>                           ; quaternion group
        | QD<size>                          ; quasidihedral group
        | PSL(<n>,<q>)                      ; projective special linear group
        | SL(<n>,<q>)                       ; special linear group
        | GL(<n>,<q>)                       ; general linear group
        | PSU(<n>,<q>)                      ; proj. special unitary group
        | O(2<n>+1,<q>)                     ; orthogonal group, type B
        | O+(2<n>,<q>)                      ; orthogonal group, type D
        | O-(2<n>,<q>)                      ; orthogonal group, type 2D
        | PSp(2<n>,<q>)                     ; proj. special symplectic group
        | Sz(<q>)                           ; Suzuki group
        | Ree(<q>)                          ; Ree group (type 2F or 2G)
        | E(6,<q>) | E(7,<q>) | E(8,<q>)    ; Lie group of exceptional type
        | 2E(6,<q>) | F(4,<q>) | G(2,<q>)
        | 3D(4,<q>)                         ; Steinberg triality group
        | M11 | M12 | M22 | M23 | M24
        | J1 | J2 | J3 | J4 | Co1 | Co2
        | Co3 | Fi22 | Fi23 | Fi24' | Suz
        | HS | McL | He | HN | Th | B
        | M | ON | Ly | Ru                  ; sporadic simple group
        | 2F(4,2)'                          ; Tits group
        | PerfectGroup(<size>,<id>)         ; the indicated group from the
                                            ; library of perfect groups
        | A x B                             ; direct product
        | N : H                             ; semidirect product
        | C(G) . G/C(G) = G' . G/G'         ; non-split extension
                                            ; (equal alternatives and
                                            ; trivial extensions omitted)
        | Phi(G) . G/Phi(G)                 ; non-split extension:
                                            ; Frattini subgroup and
                                            ; Frattini factor group
  
  
  Note  that  the StructureDescription is only one possible way of building up
  the given group from smaller pieces.
  
  The  option  short  is  recognized  -  if this option is set, an abbreviated
  output format is used (e.g. "6x3" instead of "C6 x C3").
  
  If  the  Name  (12.8-2) attribute is not bound, but StructureDescription is,
  View  (6.3-3)  prints  the  value of the attribute StructureDescription. The
  Print  (6.3-4)ed  representation  of  a group is not affected by computing a
  StructureDescription.
  
  The strategy used to compute a StructureDescription is as follows:
  
  1.
        Lookup in a precomputed list, if the order of G is not larger than 100
        and not equal to 64 or 96.
  
  2.
        If  G  is abelian, then decompose it into cyclic factors in elementary
        divisors style. For example, "C2 x C3 x C3" is "C6 x C3". For infinite
        abelian groups, "Z" denotes the group of integers.
  
  3.
        Recognize  alternating  groups,  symmetric  groups,  dihedral  groups,
        quasidihedral  groups, quaternion groups, PSL's, SL's, GL's and simple
        groups not listed so far as basic building blocks.
  
  4.
        Decompose G into a direct product of irreducible factors.
  
  5.
        Recognize  semidirect products G=N:H, where N is normal. Select a pair
        N, H with the following preferences:
  
        1.
              if  G  is defined as a semidirect product of N, H then select N,
              H,
  
        2.
              if G is solvable, then select a solvable normal Hall subgroup N,
              if  exists,  and  consider the semidirect decomposition of N and
              G/N,
  
        3.
              find any nontrivial normal subgroup N which has a complement H.
  
        The  option  nice  is  recognized.  If  this  option  is set, then all
        semidirect  products  are  computed  in order to find a possibly nicer
        presentation.  Note, that this may take a very long time if G has many
        normal  subgroups, e.g. if G/G' has many cyclic factors. If the option
        nice  is  set,  then  GAP  would select a pair N, H with the following
        preferences:
  
        1.
              H is abelian
  
        2.
              N is abelian
  
        2a.
              N has many abelian invariants
  
        3.
              N is a direct product
  
        3a.
              N has many direct factors
  
        4.
              ϕ: H → Aut(N), h ↦ (n ↦ n^h) is injective.
  
  6.
        Fall back to non-splitting extensions: If the centre or the commutator
        factor  group  is  non-trivial,  write  G  as  Z(G).G/Z(G) or G'.G/G',
        respectively. Otherwise if the Frattini subgroup is non-trivial, write
        G as Φ(G).G/Φ(G).
  
  7.
        If  no  decomposition  is  found  (maybe  this is not the case for any
        finite  group),  try  to  identify G in the perfect groups library. If
        this fails also, then return a string describing this situation.
  
  Note  that  StructureDescription  is not intended to be a research tool, but
  rather an educational tool. The reasons for this are as follows:
  
  1.
        Most  groups do not have nice decompositions. This is in some contrast
        to  what  is often taught in elementary courses on group theory, where
        it is sometimes suggested that basically every group can be written as
        iterated  direct or semidirect product of cyclic groups and nonabelian
        simple groups.
  
  2.
        In   particular   many  p-groups  have  very  similar  structure,  and
        StructureDescription  can  only  exhibit a little of it. Changing this
        would  likely make the output not essentially easier to read than a pc
        presentation.
  
    Example  
    gap> l := AllSmallGroups(12);;
    gap> List(l,StructureDescription);; l;
    [ C3 : C4, C12, A4, D12, C6 x C2 ]
    gap> List(AllSmallGroups(40),G->StructureDescription(G:short));
    [ "5:8", "40", "5:8", "5:Q8", "4xD10", "D40", "2x(5:4)", "(10x2):2",
      "20x2", "5xD8", "5xQ8", "2x(5:4)", "2^2xD10", "10x2^2" ]
    gap> List(AllTransitiveGroups(DegreeAction,6),
    >         G->StructureDescription(G:short));
    [ "6", "S3", "D12", "A4", "3xS3", "2xA4", "S4", "S4", "S3xS3", 
      "(3^2):4", "2xS4", "A5", "(S3xS3):2", "S5", "A6", "S6" ]
    gap> StructureDescription(SmallGroup(504,7));
    "C7 : (C9 x Q8)"
    gap> StructureDescription(SmallGroup(504,7):nice);
    "(C7 : Q8) : C9"
    gap> StructureDescription(AbelianGroup([0,2,3]));
    "Z x C6"
    gap> StructureDescription(AbelianGroup([0,0,0,2,3,6]):short);
    "Z^3x6^2"
    gap> StructureDescription(PSL(4,2));
    "A8"
  
  
  
  39.7 Cosets
  
  39.7-1 RightCoset
  
  RightCoset( U, g )  operation
  
  returns  the right coset of U with representative g, which is the set of all
  elements  of  the  form  ug  for all u ∈ U. g must be an element of a larger
  group  G  which  contains U. For element operations such as in a right coset
  behaves like a set of group elements.
  
  Right  cosets  are  external  orbits  for  the  action  of  U which acts via
  OnLeftInverse  (41.2-3).  Of  course the action of a larger group G on right
  cosets is via OnRight (41.2-2).
  
    Example  
    gap> u:=Group((1,2,3), (1,2));;
    gap> c:=RightCoset(u,(2,3,4));
    RightCoset(Group( [ (1,2,3), (1,2) ] ),(2,3,4))
    gap> ActingDomain(c);
    Group([ (1,2,3), (1,2) ])
    gap> Representative(c);
    (2,3,4)
    gap> Size(c);
    6
    gap> AsList(c);
    [ (2,3,4), (1,4,2), (1,3,4,2), (1,3)(2,4), (2,4), (1,4,2,3) ]
    gap> IsBiCoset(c);
    false
  
  
  39.7-2 RightCosets
  
  RightCosets( G, U )  function
  RightCosetsNC( G, U )  operation
  
  computes  a  duplicate  free  list  of  right cosets U g for g ∈ G. A set of
  representatives for the elements in this list forms a right transversal of U
  in   G.   (By   inverting   the   representatives  one  obtains  a  list  of
  representatives  of  the  left  cosets  of U.) The NC version does not check
  whether U is a subgroup of G.
  
    Example  
    gap> RightCosets(g,u);
    [ RightCoset(Group( [ (1,2,3), (1,2) ] ),()), 
      RightCoset(Group( [ (1,2,3), (1,2) ] ),(1,3)(2,4)), 
      RightCoset(Group( [ (1,2,3), (1,2) ] ),(1,4)(2,3)), 
      RightCoset(Group( [ (1,2,3), (1,2) ] ),(1,2)(3,4)) ]
  
  
  39.7-3 CanonicalRightCosetElement
  
  CanonicalRightCosetElement( U, g )  operation
  
  returns  a  canonical  representative  of  the  right  coset  U  g  which is
  independent  of  the  given  representative  g.  This can be used to compare
  cosets by comparing their canonical representatives.
  
  The  representative  chosen  to  be  the  canonical  one  is  representation
  dependent and only guaranteed to remain the same within one GAP session.
  
    Example  
    gap> CanonicalRightCosetElement(u,(2,4,3));
    (3,4)
  
  
  39.7-4 IsRightCoset
  
  IsRightCoset( obj )  Category
  
  The category of right cosets.
  
  GAP  does  not  provide left cosets as a separate data type, but as the left
  coset gU consists of exactly the inverses of the elements of the right coset
  Ug^{-1}  calculations with left cosets can be emulated using right cosets by
  inverting the representatives.
  
  39.7-5 IsBiCoset
  
  IsBiCoset( C )  property
  
  A  (right)  coset  Ug  is  considered  a  bicoset  if  its  set  of elements
  simultaneously forms a left coset for the same subgroup. This is the case if
  and only if the coset representative g normalizes the subgroup U.
  
  39.7-6 CosetDecomposition
  
  CosetDecomposition( G, S )  function
  
  For  a finite group G and a subgroup S ≤ G this function returns a partition
  of  the  elements of G according to the (right) cosets of S. The result is a
  list of lists, each sublist corresponding to one coset. The first sublist is
  the elements list of the subgroup, the other lists are arranged accordingly.
  
    Example  
    gap> CosetDecomposition(SymmetricGroup(4),SymmetricGroup(3));          
    [ [ (), (2,3), (1,2), (1,2,3), (1,3,2), (1,3) ], 
      [ (1,4), (1,4)(2,3), (1,2,4), (1,2,3,4), (1,3,2,4), (1,3,4) ], 
      [ (1,4,2), (1,4,2,3), (2,4), (2,3,4), (1,3)(2,4), (1,3,4,2) ], 
      [ (1,4,3), (1,4,3,2), (1,2,4,3), (1,2)(3,4), (2,4,3), (3,4) ] ]
  
  
  
  39.8 Transversals
  
  39.8-1 RightTransversal
  
  RightTransversal( G, U )  operation
  
  A  right  transversal  t  is  a list of representatives for the set U ∖ G of
  right cosets (consisting of cosets Ug) of U in G.
  
  The  object  returned by RightTransversal is not a plain list, but an object
  that  behaves  like  an  immutable  list of length [G:U], except if U is the
  trivial  subgroup  of G in which case RightTransversal may return the sorted
  plain list of coset representatives.
  
  The operation PositionCanonical (21.16-3), called for a transversal t and an
  element  g  of  G,  will return the position of the representative in t that
  lies  in the same coset of U as the element g does. (In comparison, Position
  (21.16-1)   will   return   fail   if  the  element  is  not  equal  to  the
  representative.)  Functions  that  implement  group  actions  such as Action
  (41.7-2)  or  Permutation  (41.9-1)  (see  Chapter 41) use PositionCanonical
  (21.16-3),  therefore  it  is  possible  to  act  on  a right transversal to
  implement  the  action on the cosets. This is often much more efficient than
  acting on cosets.
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2));;
    gap> u:=Subgroup(g,[(1,2,3),(1,2)]);;
    gap> rt:=RightTransversal(g,u);
    RightTransversal(Group([ (1,2,3,4), (1,2) ]),Group([ (1,2,3), (1,2) ]))
    gap> Length(rt);
    4
    gap> Position(rt,(1,2,3));
    fail
  
  
  Note  that the elements of a right transversal are not necessarily canonical
  in  the  sense  of CanonicalRightCosetElement (39.7-3), but we may compute a
  list  of canonical coset representatives by calling that function. (See also
  PositionCanonical (21.16-3).)
  
    Example  
    gap> List(RightTransversal(g,u),i->CanonicalRightCosetElement(u,i));
    [ (), (2,3,4), (1,2,3,4), (3,4) ]
    gap> PositionCanonical(rt,(1,2,3));
    1
    gap> rt[1];
    ()
  
  
  
  39.9 Double Cosets
  
  39.9-1 DoubleCoset
  
  DoubleCoset( U, g, V )  operation
  
  The  groups U and V must be subgroups of a common supergroup G of which g is
  an  element. This command constructs the double coset U g V which is the set
  of all elements of the form ugv for any u ∈ U, v ∈ V. For element operations
  such  as in, a double coset behaves like a set of group elements. The double
  coset  stores  U  in  the  attribute  LeftActingGroup,  g  as Representative
  (30.4-7), and V as RightActingGroup.
  
  39.9-2 RepresentativesContainedRightCosets
  
  RepresentativesContainedRightCosets( D )  attribute
  
  A double coset D = U g V can be considered as a union of right cosets U h_i.
  (It is the union of the orbit of U g under right multiplication by V.) For a
  double  coset D this function returns a set of representatives h_i such that
  D  =  ⋃_{h_i}  U  h_i. The representatives returned are canonical for U (see
  CanonicalRightCosetElement (39.7-3)) and form a set.
  
    Example  
    gap> u:=Subgroup(g,[(1,2,3),(1,2)]);;v:=Subgroup(g,[(3,4)]);;
    gap> c:=DoubleCoset(u,(2,4),v);
    DoubleCoset(Group( [ (1,2,3), (1,2) ] ),(2,4),Group( [ (3,4) ] ))
    gap> (1,2,3) in c;
    false
    gap> (2,3,4) in c;
    true
    gap> LeftActingGroup(c);
    Group([ (1,2,3), (1,2) ])
    gap> RightActingGroup(c);
    Group([ (3,4) ])
    gap> RepresentativesContainedRightCosets(c);
    [ (2,3,4) ]
  
  
  39.9-3 DoubleCosets
  
  DoubleCosets( G, U, V )  function
  DoubleCosetsNC( G, U, V )  operation
  
  computes  a  duplicate  free  list of all double cosets U g V for g ∈ G. The
  groups  U  and  V  must be subgroups of the group G. The NC version does not
  check whether U and V are subgroups of G.
  
    Example  
    gap> dc:=DoubleCosets(g,u,v);
    [ DoubleCoset(Group( [ (1,2,3), (1,2) ] ),(),Group( [ (3,4) ] )), 
      DoubleCoset(Group( [ (1,2,3), (1,2) ] ),(1,3)(2,4),Group( 
        [ (3,4) ] )), DoubleCoset(Group( [ (1,2,3), (1,2) ] ),(1,4)
        (2,3),Group( [ (3,4) ] )) ]
    gap> List(dc,Representative);
    [ (), (1,3)(2,4), (1,4)(2,3) ]
  
  
  39.9-4 IsDoubleCoset
  
  IsDoubleCoset( obj )  Category
  
  The category of double cosets.
  
  39.9-5 DoubleCosetRepsAndSizes
  
  DoubleCosetRepsAndSizes( G, U, V )  operation
  
  returns  a list of double coset representatives and their sizes, the entries
  are  lists  of  the form [ r, n ] where r and n are an element of the double
  coset and the size of the coset, respectively. This operation is faster than
  DoubleCosetsNC (39.9-3) because no double coset objects have to be created.
  
    Example  
    gap> dc:=DoubleCosetRepsAndSizes(g,u,v);
    [ [ (), 12 ], [ (1,3)(2,4), 6 ], [ (1,4)(2,3), 6 ] ]
  
  
  39.9-6 InfoCoset
  
  InfoCoset  info class
  
  The information function for coset and double coset operations is InfoCoset.
  
  
  39.10 Conjugacy Classes
  
  39.10-1 ConjugacyClass
  
  ConjugacyClass( G, g )  operation
  
  creates  the  conjugacy  class  in G with representative g. This class is an
  external  set,  so  functions such as Representative (30.4-7) (which returns
  g),   ActingDomain  (41.12-3)  (which  returns  G),  StabilizerOfExternalSet
  (41.12-10) (which returns the centralizer of g) and AsList (30.3-8) work for
  it.
  
  A  conjugacy  class  is  an  external orbit (see ExternalOrbit (41.12-9)) of
  group  elements  with  the  group  acting by conjugation on it. Thus element
  tests   or   operation   representatives  can  be  computed.  The  attribute
  Centralizer  (35.4-4)  gives the centralizer of the representative (which is
  the  same  result  as StabilizerOfExternalSet (41.12-10)). (This is a slight
  abuse  of  notation: This is not the centralizer of the class as a set which
  would be the standard behaviour of Centralizer (35.4-4).)
  
  39.10-2 ConjugacyClasses
  
  ConjugacyClasses( G )  attribute
  
  returns the conjugacy classes of elements of G as a list of class objects of
  G  (see ConjugacyClass  (39.10-1)  for  details).  It is guaranteed that the
  class  of  the  identity  is  in the first position, the further arrangement
  depends  on  the  method  chosen  (and  might be different for equal but not
  identical groups).
  
  For  very  small  groups (of size up to 500) the classes will be computed by
  the   conjugation   action  of  G  on  itself  (see ConjugacyClassesByOrbits
  (39.10-4)).  This can be deliberately switched off using the noaction option
  shown below.
  
  For  solvable  groups,  the  default  method  to  compute  the classes is by
  homomorphic lift (see section 45.17).
  
  For other groups the method of [Hul00] is employed.
  
  ConjugacyClasses  supports  the following options that can be used to modify
  this strategy:
  
  random
        The     classes     are     computed    by    random    search.    See
        ConjugacyClassesByRandomSearch (39.10-3) below.
  
  action
        The   classes   are   computed   by   action   of  G  on  itself.  See
        ConjugacyClassesByOrbits (39.10-4) below.
  
  noaction
        Even  for  small groups ConjugacyClassesByOrbits (39.10-4) is not used
        as  a  default.  This can be useful if the elements of the group use a
        lot of memory.
  
    Example  
    gap> g:=SymmetricGroup(4);;
    gap> cl:=ConjugacyClasses(g);
    [ ()^G, (1,2)^G, (1,2)(3,4)^G, (1,2,3)^G, (1,2,3,4)^G ]
    gap> Representative(cl[3]);Centralizer(cl[3]);
    (1,2)(3,4)
    Group([ (1,2), (1,3)(2,4), (3,4) ])
    gap> Size(Centralizer(cl[5]));
    4
    gap> Size(cl[2]);
    6
  
  
  In  general,  you  will not need to have to influence the method, but simply
  call  ConjugacyClasses –GAP will try to select a suitable method on its own.
  The method specifications are provided here mainly for expert use.
  
  39.10-3 ConjugacyClassesByRandomSearch
  
  ConjugacyClassesByRandomSearch( G )  function
  
  computes  the  classes  of  the  group  G  by random search. This works very
  efficiently for almost simple groups.
  
  This  function  is  also  accessible  via  the option random to the function
  ConjugacyClass (39.10-1).
  
  39.10-4 ConjugacyClassesByOrbits
  
  ConjugacyClassesByOrbits( G )  function
  
  computes the classes of the group G as orbits of G on its elements. This can
  be  quick  but  unsurprisingly  may  also  take a lot of memory if G becomes
  larger.  All the classes will store their element list and thus a membership
  test will be quick as well.
  
  This  function  is  also  accessible  via  the option action to the function
  ConjugacyClass (39.10-1).
  
  Typically, for small groups (roughly of order up to 10^3) the computation of
  classes  as orbits under the action is fastest; memory restrictions (and the
  increasing  cost  of  eliminating  duplicates)  make this less efficient for
  larger groups.
  
  Calculation  by  random  search  has the smallest memory requirement, but in
  generally performs worse, the more classes are there.
  
  The  following  example shows the effect of this for a small group with many
  classes:
  
    Example  
    gap> h:=Group((4,5)(6,7,8),(1,2,3)(5,6,9));;ConjugacyClasses(h:noaction);;time;
    110
    gap> h:=Group((4,5)(6,7,8),(1,2,3)(5,6,9));;ConjugacyClasses(h:random);;time;
    300
    gap> h:=Group((4,5)(6,7,8),(1,2,3)(5,6,9));;ConjugacyClasses(h:action);;time;
    30
  
  
  39.10-5 NrConjugacyClasses
  
  NrConjugacyClasses( G )  attribute
  
  returns the number of conjugacy classes of G.
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2));;
    gap> NrConjugacyClasses(g);
    5
  
  
  39.10-6 RationalClass
  
  RationalClass( G, g )  operation
  
  creates  the  rational  class  in  G with representative g. A rational class
  consists  of  all  elements that are conjugate to g or to an i-th power of g
  where  i  is  coprime  to  the  order  of  g.  Thus  a rational class can be
  interpreted as a conjugacy class of cyclic subgroups. A rational class is an
  external  set  (IsExternalSet  (41.12-1))  of  group elements with the group
  acting by conjugation on it, but not an external orbit.
  
  39.10-7 RationalClasses
  
  RationalClasses( G )  attribute
  
  returns  a  list  of the rational classes of the group G. (See RationalClass
  (39.10-6).)
  
    Example  
    gap> RationalClasses(DerivedSubgroup(g));
    [ RationalClass( AlternatingGroup( [ 1 .. 4 ] ), () ), 
      RationalClass( AlternatingGroup( [ 1 .. 4 ] ), (1,2)(3,4) ), 
      RationalClass( AlternatingGroup( [ 1 .. 4 ] ), (1,2,3) ) ]
  
  
  39.10-8 GaloisGroup
  
  GaloisGroup( ratcl )  attribute
  
  Suppose  that  ratcl is a rational class of a group G with representative g.
  The  exponents  i for which g^i lies already in the ordinary conjugacy class
  of   g,  form  a  subgroup  of  the  prime  residue  class  group  P_n  (see
  PrimitiveRootMod  (15.3-3)),  the  so-called  Galois  group  of the rational
  class.  The  prime  residue  class  group  P_n  is obtained in GAP as Units(
  Integers  mod  n ), the unit group of a residue class ring. The Galois group
  of  a  rational  class  ratcl  is  stored  in the attribute GaloisGroup as a
  subgroup of this group.
  
  
  39.10-9 IsConjugate
  
  IsConjugate( G, x, y )  operation
  IsConjugate( G, U, V )  operation
  
  tests  whether  the  elements x and y or the subgroups U and V are conjugate
  under the action of G. (They do not need to be contained in G.) This command
  is only a shortcut to RepresentativeAction (41.6-1).
  
    Example  
    gap> IsConjugate(g,Group((1,2,3,4),(1,3)),Group((1,3,2,4),(1,2)));
    true
  
  
  RepresentativeAction (41.6-1) can be used to obtain conjugating elements.
  
    Example  
    gap> RepresentativeAction(g,(1,2),(3,4));
    (1,3)(2,4)
  
  
  39.10-10 NthRootsInGroup
  
  NthRootsInGroup( G, e, n )  function
  
  Let  e  be  an  element  in the group G. This function returns a list of all
  those elements in G whose n-th power is e.
  
    Example  
    gap> NthRootsInGroup(g,(1,2)(3,4),2);
    [ (1,3,2,4), (1,4,2,3) ]
  
  
  
  39.11 Normal Structure
  
  For the operations Centralizer (35.4-4) and Centre (35.4-5), see Chapter 35.
  
  
  39.11-1 Normalizer
  
  Normalizer( G, U )  operation
  Normalizer( G, g )  operation
  
  For two groups G, U, Normalizer computes the normalizer N_G(U), that is, the
  stabilizer of U under the conjugation action of G.
  
  For a group G and a group element g, Normalizer computes N_G(⟨ g ⟩).
  
    Example  
    gap> Normalizer(g,Subgroup(g,[(1,2,3)]));
    Group([ (1,2,3), (2,3) ])
  
  
  39.11-2 Core
  
  Core( S, U )  operation
  
  If S and U are groups of elements in the same family, this operation returns
  the core of U in S, that is the intersection of all S-conjugates of U.
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2));;
    gap> Core(g,Subgroup(g,[(1,2,3,4)]));
    Group(())
  
  
  39.11-3 PCore
  
  PCore( G, p )  operation
  
  The  p-core  of G is the largest normal p-subgroup of G. It is the core of a
  Sylow p-subgroup of G, see Core (39.11-2).
  
    Example  
    gap> g:=DicyclicGroup(12);;
    gap> PCore(g,2);
    Group([ y3 ])
    gap> PCore(g,2) = Core(g,SylowSubgroup(g,2));
    true
    gap> PCore(g,3);
    Group([ y*y3 ])
    gap> PCore(g,5);
    Group([  ])
    gap> g:=SymmetricGroup(4);;
    gap> PCore(g,2);
    Group([ (1,4)(2,3), (1,2)(3,4) ])
    gap> PCore(g,2) = Core(g,SylowSubgroup(g,2));
    true
  
  
  39.11-4 NormalClosure
  
  NormalClosure( G, U )  operation
  NormalClosure( G, list )  operation
  
  The  normal closure of U in G is the smallest normal subgroup of the closure
  of G and U which contains U.
  
  The  second argument may also be a list of group elements, in which case the
  normal closure of the group generated by these elements is computed.
  
    Example  
    gap> NormalClosure(g,Subgroup(g,[(1,2,3)])) = Group([ (1,2,3), (2,3,4) ]);
    true
    gap> NormalClosure(g,[(1,2,3)]) = Group([ (1,2,3), (2,3,4) ]);
    true
    gap> NormalClosure(g,Group((3,4,5))) = Group([ (3,4,5), (1,5,4), (1,2,5) ]);
    true
  
  
  39.11-5 NormalIntersection
  
  NormalIntersection( G, U )  operation
  
  computes  the  intersection  of G and U, assuming that G is normalized by U.
  This  works  faster than Intersection, but will not produce the intersection
  if G is not normalized by U.
  
    Example  
    gap> NormalIntersection(Group((1,2)(3,4),(1,3)(2,4)),Group((1,2,3,4)));
    Group([ (1,3)(2,4) ])
  
  
  39.11-6 ComplementClassesRepresentatives
  
  ComplementClassesRepresentatives( G, N )  operation
  
  Let   N  be  a  normal  subgroup  of  G.  This  command  returns  a  set  of
  representatives  for  the  conjugacy  classes  of  complements  of  N  in G.
  Complements are subgroups of G which intersect trivially with N and together
  with N generate G.
  
  At the moment only methods for a solvable N are available.
  
    Example  
    gap> ComplementClassesRepresentatives(g,Group((1,2)(3,4),(1,3)(2,4)));
    [ Group([ (3,4), (2,4,3) ]) ]
  
  
  39.11-7 InfoComplement
  
  InfoComplement  info class
  
  Info class for the complement routines.
  
  
  39.12 Specific and Parametrized Subgroups
  
  The  centre of a group (the subgroup of those elements that commute with all
  other  elements  of  the  group)  can  be  computed  by the operation Centre
  (35.4-5).
  
  39.12-1 TrivialSubgroup
  
  TrivialSubgroup( G )  attribute
  
    Example  
    gap> TrivialSubgroup(g);
    Group(())
  
  
  39.12-2 CommutatorSubgroup
  
  CommutatorSubgroup( G, H )  operation
  
  If  G  and  H  are two groups of elements in the same family, this operation
  returns  the group generated by all commutators [ g, h ] = g^{-1} h^{-1} g h
  (see Comm (31.12-3)) of elements g ∈ G and h ∈ H, that is the group ⟨ [ g, h
  ] ∣ g ∈ G, h ∈ H ⟩.
  
    Example  
    gap> CommutatorSubgroup(Group((1,2,3),(1,2)),Group((2,3,4),(3,4)));
    Group([ (1,4)(2,3), (1,3,4) ])
    gap> Size(last);
    12
  
  
  39.12-3 DerivedSubgroup
  
  DerivedSubgroup( G )  attribute
  
  The derived subgroup G' of G is the subgroup generated by all commutators of
  pairs  of  elements of G. It is normal in G and the factor group G/G' is the
  largest abelian factor group of G.
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2));;
    gap> DerivedSubgroup(g) = Group([ (1,3,2), (2,4,3) ]);
    true
  
  
  39.12-4 CommutatorLength
  
  CommutatorLength( G )  attribute
  
  returns  the minimal number n such that each element in the derived subgroup
  (see DerivedSubgroup  (39.12-3))  of the group G can be written as a product
  of (at most) n commutators of elements in G.
  
    Example  
    gap> CommutatorLength( g );
    1
  
  
  39.12-5 FittingSubgroup
  
  FittingSubgroup( G )  attribute
  
  The Fitting subgroup of a group G is its largest nilpotent normal subgroup.
  
    Example  
    gap> FittingSubgroup(g);
    Group([ (1,2)(3,4), (1,4)(2,3) ])
  
  
  39.12-6 FrattiniSubgroup
  
  FrattiniSubgroup( G )  attribute
  
  The  Frattini  subgroup  of  a  group  G  is the intersection of all maximal
  subgroups of G.
  
    Example  
    gap> FrattiniSubgroup(g);
    Group(())
  
  
  39.12-7 PrefrattiniSubgroup
  
  PrefrattiniSubgroup( G )  attribute
  
  returns a Prefrattini subgroup of the finite solvable group G.
  
  A  factor  M/N  of  G is called a Frattini factor if M/N is contained in the
  Frattini  subgroup  of G/N. A subgroup P is a Prefrattini subgroup of G if P
  covers  each Frattini chief factor of G, and if for each maximal subgroup of
  G  there  exists a conjugate maximal subgroup, which contains P. In a finite
  solvable  group  G the Prefrattini subgroups form a characteristic conjugacy
  class  of  subgroups  and  the  intersection  of  all these subgroups is the
  Frattini subgroup of G.
  
    Example  
    gap> G := SmallGroup( 60, 7 );
    <pc group of size 60 with 4 generators>
    gap> P := PrefrattiniSubgroup(G);
    Group([ f2 ])
    gap> Size(P);
    2
    gap> IsNilpotent(P);
    true
    gap> Core(G,P);
    Group([  ])
    gap> FrattiniSubgroup(G);
    Group([  ])
  
  
  39.12-8 PerfectResiduum
  
  PerfectResiduum( G )  attribute
  
  is the smallest normal subgroup of G that has a solvable factor group.
  
    Example  
    gap> PerfectResiduum(SymmetricGroup(5));
    Alt( [ 1 .. 5 ] )
  
  
  39.12-9 SolvableRadical
  
  SolvableRadical( G )  attribute
  
  is  the  solvable  radical of the group G, i.e., the largest solvable normal
  subgroup of G.
  
    Example  
    gap> rad:= SolvableRadical( SL(2,5) );
    <group of 2x2 matrices of size 2 over GF(5)>
    gap> Size( rad );
    2
  
  
  39.12-10 Socle
  
  Socle( G )  attribute
  
  The  socle  of  the  group G is the subgroup generated by all minimal normal
  subgroups.
  
    Example  
    gap> Socle(g);
    Group([ (1,4)(2,3), (1,2)(3,4) ])
  
  
  39.12-11 SupersolvableResiduum
  
  SupersolvableResiduum( G )  attribute
  
  is  the  supersolvable residuum of the group G, that is, its smallest normal
  subgroup N such that the factor group G / N is supersolvable.
  
    Example  
    gap> SupersolvableResiduum(g) = Group([ (1,3)(2,4), (1,4)(2,3) ]);
    true
  
  
  39.12-12 PRump
  
  PRump( G, p )  operation
  
  For  a  prime  p,  the p-rump of a group G is the subgroup G' G^p. Unless it
  equals G itself (which is the e.g. the case if G is perfect), it is equal to
  the second term of the p-central series of G, see PCentralSeries (39.17-13).
  
    Example  
    gap> g:=DicyclicGroup(12);;
    gap> PRump(g,2) = PCentralSeries(g,2)[2];
    true
    gap> g:=SymmetricGroup(4);;
    gap> PRump(g,2) = AlternatingGroup(4);
    true
  
  
  
  39.13 Sylow Subgroups and Hall Subgroups
  
  With respect to the following GAP functions, please note that by theorems of
  P. Hall,  a  group  G  is  solvable  if  and  only  if  one of the following
  conditions holds.
  
  1   For  each prime p dividing the order of G, there exists a p-complement
        (see SylowComplement (39.13-2)).
  
  2   For  each  set  P  of  primes  dividing the order of G, there exists a
        P-Hall subgroup (see HallSubgroup (39.13-3)).
  
  3   G has a Sylow system (see SylowSystem (39.13-4)).
  
  4   G has a complement system (see ComplementSystem (39.13-5)).
  
  39.13-1 SylowSubgroup
  
  SylowSubgroup( G, p )  operation
  
  returns  a Sylow p-subgroup of the finite group G. This is a p-subgroup of G
  whose index in G is coprime to p. SylowSubgroup computes Sylow subgroups via
  the operation SylowSubgroupOp.
  
    Example  
    gap> g:=SymmetricGroup(4);;
    gap> SylowSubgroup(g,2);
    Group([ (1,2), (3,4), (1,3)(2,4) ])
  
  
  39.13-2 SylowComplement
  
  SylowComplement( G, p )  operation
  
  returns  a Sylow p-complement of the finite group G. This is a subgroup U of
  order coprime to p such that the index [G:U] is a p-power.
  
  At  the  moment  methods  exist  only if G is solvable and GAP will issue an
  error if G is not solvable.
  
    Example  
    gap> SylowComplement(g,3);
    Group([ (1,2), (3,4), (1,3)(2,4) ])
  
  
  39.13-3 HallSubgroup
  
  HallSubgroup( G, P )  operation
  
  computes  a  P-Hall  subgroup  for a set P of primes. This is a subgroup the
  order  of  which is only divisible by primes in P and whose index is coprime
  to  all  primes  in  P.  Such  a  subgroup is unique up to conjugacy if G is
  solvable.   The   function   computes   Hall  subgroups  via  the  operation
  HallSubgroupOp.
  
  If  G  is  solvable  this  function  always  returns a subgroup. If G is not
  solvable  this  function  might  return  a  subgroup  (if it is unique up to
  conjugacy),  a list of subgroups (which are representatives of the conjugacy
  classes  in case there are several such classes) or fail if no such subgroup
  exists.
  
    Example  
    gap> h:=SmallGroup(60,10);;
    gap> u:=HallSubgroup(h,[2,3]);
    Group([ f1, f2, f3 ])
    gap> Size(u);
    12
    gap> h:=PSL(3,5);;
    gap> HallSubgroup(h,[2,3]);  
    [ <permutation group of size 96 with 6 generators>, 
      <permutation group of size 96 with 6 generators> ]
    gap> u := HallSubgroup(h,[3,31]);;
    gap> Size(u); StructureDescription(u);
    93
    "C31 : C3"
    gap> HallSubgroup(h,[5,31]);
    fail
  
  
  39.13-4 SylowSystem
  
  SylowSystem( G )  attribute
  
  A Sylow system of a group G is a set of Sylow subgroups of G such that every
  pair  of  subgroups from this set commutes as subgroups. Sylow systems exist
  only  for  solvable groups. The operation returns fail if the group G is not
  solvable.
  
    Example  
    gap> h:=SmallGroup(60,10);;
    gap> SylowSystem(h);
    [ Group([ f1, f2 ]), Group([ f3 ]), Group([ f4 ]) ]
    gap> List(last,Size);
    [ 4, 3, 5 ]
  
  
  39.13-5 ComplementSystem
  
  ComplementSystem( G )  attribute
  
  A  complement  system of a group G is a set of Hall p'-subgroups of G, where
  p'  runs  through  the subsets of prime factors of |G| that omit exactly one
  prime.  Every  pair  of  subgroups  from  this  set  commutes  as subgroups.
  Complement    systems    exist   only   for   solvable   groups,   therefore
  ComplementSystem returns fail if the group G is not solvable.
  
    Example  
    gap> ComplementSystem(h);
    [ Group([ f3, f4 ]), Group([ f1, f2, f4 ]), Group([ f1, f2, f3 ]) ]
    gap> List(last,Size);
    [ 15, 20, 12 ]
  
  
  39.13-6 HallSystem
  
  HallSystem( G )  attribute
  
  returns  a  list  containing  one  Hall  P-subgroup  for each set P of prime
  divisors of the order of G. Hall systems exist only for solvable groups. The
  operation returns fail if the group G is not solvable.
  
    Example  
    gap> HallSystem(h);
    [ Group([  ]), Group([ f1, f2 ]), Group([ f1, f2, f3 ]), 
      Group([ f1, f2, f3, f4 ]), Group([ f1, f2, f4 ]), Group([ f3 ]), 
      Group([ f3, f4 ]), Group([ f4 ]) ]
    gap> List(last,Size);
    [ 1, 4, 12, 60, 20, 3, 15, 5 ]
  
  
  
  39.14 Subgroups characterized by prime powers
  
  39.14-1 Omega
  
  Omega( G, p[, n] )  operation
  
  For  a  p-group G, one defines Ω_n(G) = { g ∈ G ∣ g^{p^n} = 1 }. The default
  value for n is 1.
  
    Example  
    gap> h:=SmallGroup(16,10);
    <pc group of size 16 with 4 generators>
    gap> Omega(h,2);
    Group([ f2, f3, f4 ])
  
  
  39.14-2 Agemo
  
  Agemo( G, p[, n] )  function
  
  For a p-group G, one defines ℧_n(G) = ⟨ g^{p^n} ∣ g ∈ G ⟩. The default value
  for n is 1.
  
    Example  
    gap> Agemo(h,2);Agemo(h,2,2);
    Group([ f4 ])
    Group([  ])
  
  
  
  39.15 Group Properties
  
  Some  properties  of  groups can be defined not only for groups but also for
  other  structures.  For  example, nilpotency and solvability make sense also
  for  algebras.  Note  that  these  names  refer to different definitions for
  groups   and   algebras,  contrary  to  the  situation  with  finiteness  or
  commutativity.  In  such  cases,  the  name of the function for groups got a
  suffix Group to distinguish different meanings for different structures.
  
  Some  functions, such as IsPSolvable (39.15-25) and IsPNilpotent (39.15-26),
  although  they  are mathematical properties, are not properties in the sense
  of GAP (see 13.5 and 13.7), as they depend on a parameter.
  
  39.15-1 IsCyclic
  
  IsCyclic( G )  property
  
  A group is cyclic if it can be generated by one element. For a cyclic group,
  one  can  compute  a  generating  set  consisting  of only one element using
  MinimalGeneratingSet (39.22-3).
  
  39.15-2 IsElementaryAbelian
  
  IsElementaryAbelian( G )  property
  
  A group G is elementary abelian if it is commutative and if there is a prime
  p such that the order of each element in G divides p.
  
  39.15-3 IsNilpotentGroup
  
  IsNilpotentGroup( G )  property
  
  A     group     is     nilpotent     if    the    lower    central    series
  (see LowerCentralSeriesOfGroup  (39.17-11)  for  a  definition)  reaches the
  trivial subgroup in a finite number of steps.
  
  39.15-4 NilpotencyClassOfGroup
  
  NilpotencyClassOfGroup( G )  attribute
  
  The  nilpotency  class  of a nilpotent group G is the number of steps in the
  lower central series of G (see LowerCentralSeriesOfGroup (39.17-11));
  
  If G is not nilpotent an error is issued.
  
  39.15-5 IsPerfectGroup
  
  IsPerfectGroup( G )  property
  
  A  group  is  perfect if it equals its derived subgroup (see DerivedSubgroup
  (39.12-3)).
  
  39.15-6 IsSolvableGroup
  
  IsSolvableGroup( G )  property
  
  A   group  is  solvable  if  the  derived  series  (see DerivedSeriesOfGroup
  (39.17-7)  for a definition) reaches the trivial subgroup in a finite number
  of steps.
  
  For    finite    groups    this    is   the   same   as   being   polycyclic
  (see IsPolycyclicGroup  (39.15-7)),  and  each polycyclic group is solvable,
  but there are infinite solvable groups that are not polycyclic.
  
  39.15-7 IsPolycyclicGroup
  
  IsPolycyclicGroup( G )  property
  
  A  group is polycyclic if it has a subnormal series with cyclic factors. For
  finite   groups   this   is   the   same   as   if  the  group  is  solvable
  (see IsSolvableGroup (39.15-6)).
  
  39.15-8 IsSupersolvableGroup
  
  IsSupersolvableGroup( G )  property
  
  A  finite  group  is  supersolvable  if  it  has a normal series with cyclic
  factors.
  
  39.15-9 IsMonomialGroup
  
  IsMonomialGroup( G )  property
  
  A finite group is monomial if every irreducible complex character is induced
  from a linear character of a subgroup.
  
  39.15-10 IsSimpleGroup
  
  IsSimpleGroup( G )  property
  IsNonabelianSimpleGroup( G )  property
  
  A  group  is  simple  if  it  is  nontrivial  and  has  no nontrivial normal
  subgroups. A nonabelian simple group is simple and not abelian.
  
  39.15-11 IsAlmostSimpleGroup
  
  IsAlmostSimpleGroup( G )  property
  
  A group G is almost simple if a nonabelian simple group S exists such that G
  is isomorphic to a subgroup of the automorphism group of S that contains all
  inner automorphisms of S.
  
  Equivalently,  G  is  almost  simple  if and only if it has a unique minimal
  normal subgroup N and if N is a nonabelian simple group.
  
  Note  that an almost simple group is not defined as an extension of a simple
  group  by outer automorphisms, since we want to exclude extensions of groups
  of  prime  order. In particular, a simple group is almost simple if and only
  if it is nonabelian.
  
    Example  
    gap> IsAlmostSimpleGroup( AlternatingGroup( 5 ) );
    true
    gap> IsAlmostSimpleGroup( SymmetricGroup( 5 ) );
    true
    gap> IsAlmostSimpleGroup( SymmetricGroup( 3 ) );
    false
    gap> IsAlmostSimpleGroup( SL( 2, 5 ) );
    false
  
  
  39.15-12 IsQuasisimpleGroup
  
  IsQuasisimpleGroup( G )  property
  
  A  group G is quasisimple if G is perfect (see IsPerfectGroup (39.15-5)) and
  if G/Z(G) is simple (see IsSimpleGroup (39.15-10)), where Z(G) is the centre
  of G (see Centre (35.4-5)).
  
    Example  
    gap> IsQuasisimpleGroup( AlternatingGroup( 5 ) );
    true
    gap> IsQuasisimpleGroup( SymmetricGroup( 5 ) );
    false
    gap> IsQuasisimpleGroup( SL( 2, 5 ) );
    true
  
  
  
  39.15-13 IsomorphismTypeInfoFiniteSimpleGroup
  
  IsomorphismTypeInfoFiniteSimpleGroup( G )  attribute
  IsomorphismTypeInfoFiniteSimpleGroup( n )  attribute
  
  For  a finite simple group G, IsomorphismTypeInfoFiniteSimpleGroup returns a
  record  with the components name, shortname, series, and possibly parameter,
  describing the isomorphism type of G.
  
  The  values  of the components name, shortname, and series are strings, name
  gives  name(s) for G, shortname gives one name for G that is compatible with
  the  naming scheme used in the GAP packages CTblLib and AtlasRep (and in the
  Atlas of Finite Groups [CCN+85]), and series describes the following series.
  
  (If  different  characterizations  of  G  are  possible only one is given by
  series and parameter, while name may give several names.)
  
  "A"
        Alternating groups, parameter gives the natural degree.
  
  "L"
        Linear  groups  (Chevalley  type A), parameter is a list [ n, q ] that
        indicates L(n,q).
  
  "2A"
        Twisted  Chevalley  type  ^2A,  parameter  is  a  list  [  n, q ] that
        indicates ^2A(n,q).
  
  "B"
        Chevalley type B, parameter is a list [n, q ] that indicates B(n,q).
  
  "2B"
        Twisted  Chevalley  type  ^2B,  parameter  is a value q that indicates
        ^2B(2,q).
  
  "C"
        Chevalley type C, parameter is a list [ n, q ] that indicates C(n,q).
  
  "D"
        Chevalley type D, parameter is a list [ n, q ] that indicates D(n,q).
  
  "2D"
        Twisted  Chevalley  type  ^2D,  parameter  is  a  list  [  n, q ] that
        indicates ^2D(n,q).
  
  "3D"
        Twisted  Chevalley  type  ^3D,  parameter  is a value q that indicates
        ^3D(4,q).
  
  "E"
        Exceptional  Chevalley  type  E,  parameter  is  a  list [ n, q ] that
        indicates E_n(q). The value of n is 6, 7, or 8.
  
  "2E"
        Twisted  exceptional  Chevalley  type E_6, parameter is a value q that
        indicates ^2E_6(q).
  
  "F"
        Exceptional  Chevalley  type  F, parameter is a value q that indicates
        F(4,q).
  
  "2F"
        Twisted  exceptional  Chevalley  type ^2F (Ree groups), parameter is a
        value q that indicates ^2F(4,q).
  
  "G"
        Exceptional  Chevalley  type  G, parameter is a value q that indicates
        G(2,q).
  
  "2G"
        Twisted  exceptional  Chevalley  type ^2G (Ree groups), parameter is a
        value q that indicates ^2G(2,q).
  
  "Spor"
        Sporadic simple groups, name gives the name.
  
  "Z"
        Cyclic groups of prime size, parameter gives the size.
  
  An  equal  sign  in  the  name denotes different naming schemes for the same
  group,  a  tilde  sign abstract isomorphisms between groups constructed in a
  different way.
  
    Example  
    gap> IsomorphismTypeInfoFiniteSimpleGroup(
    >                             Group((4,5)(6,7),(1,2,4)(3,5,6)));
    rec( 
      name := "A(1,7) = L(2,7) ~ B(1,7) = O(3,7) ~ C(1,7) = S(2,7) ~ 2A(1,\
    7) = U(2,7) ~ A(2,2) = L(3,2)", parameter := [ 2, 7 ], series := "L", 
      shortname := "L3(2)" )
  
  
  For  a positive integer n, IsomorphismTypeInfoFiniteSimpleGroup returns fail
  if  n  is  not the order of a finite simple group, and a record as described
  for  the case of a group G otherwise. If more than one simple group of order
  n  exists  then the result record contains only the name component, a string
  that  lists  the  two  possible  isomorphism  types of simple groups of this
  order.
  
    Example  
    gap> IsomorphismTypeInfoFiniteSimpleGroup( 5 );
    rec( name := "Z(5)", parameter := 5, series := "Z", shortname := "C5" 
     )
    gap> IsomorphismTypeInfoFiniteSimpleGroup( 6 );
    fail
    gap> IsomorphismTypeInfoFiniteSimpleGroup(Size(SymplecticGroup(6,3))/2);
    rec( 
      name := "cannot decide from size alone between B(3,3) = O(7,3) and C\
    (3,3) = S(6,3)", parameter := [ 3, 3 ] )
  
  
  39.15-14 SimpleGroup
  
  SimpleGroup( id[, param] )  function
  
  This  function will construct an instance of the specified nonabelian simple
  group.  Groups  are  specified  via their name in ATLAS style notation, with
  parameters  added if necessary. The intelligence applied to parsing the name
  is  limited,  and at the moment no proper extensions can be constructed. For
  groups  who  do  not  have  a permutation representation of small degree the
  ATLASREP package might need to be installed to construct theses groups.
  
    Example  
    gap> g:=SimpleGroup("M(23)");
    M23
    gap> Size(g);
    10200960
    gap> g:=SimpleGroup("PSL",3,5);
    PSL(3,5)
    gap> Size(g);
    372000
    gap> g:=SimpleGroup("PSp6",2);    
    PSp(6,2)
  
  
  39.15-15 SimpleGroupsIterator
  
  SimpleGroupsIterator( [start[, end]] )  function
  
  This  function  returns an iterator that will run over all nonabelian simple
  groups,  starting  at  order start if specified, up to order 10^27 (or -- if
  specified  --  order  end).  If  the  option NOPSL2 is given, groups of type
  PSL_2(q) are omitted.
  
    Example  
    gap> it:=SimpleGroupsIterator(20000);
    <iterator>
    gap> List([1..8],x->NextIterator(it)); 
    [ A8, PSL(3,4), PSL(2,37), PSp(4,3), Sz(8), PSL(2,32), PSL(2,41), 
      PSL(2,43) ]
    gap> it:=SimpleGroupsIterator(1,2000);;
    gap> l:=[];;for i in it do Add(l,i);od;l;
    [ A5, PSL(2,7), A6, PSL(2,8), PSL(2,11), PSL(2,13) ]
    gap> it:=SimpleGroupsIterator(20000,100000:NOPSL2);;
    gap> l:=[];;for i in it do Add(l,i);od;l;
    [ A8, PSL(3,4), PSp(4,3), Sz(8), PSU(3,4), M12 ]
  
  
  39.15-16 SmallSimpleGroup
  
  SmallSimpleGroup( order[, i] )  function
  Returns:  The ith simple group of order order in the stored list, given in a
            small-degree  permutation  representation,  or fail (20.2-1) if no
            such simple group exists.
  
  If  i  is not given, it defaults to 1. Currently, all simple groups of order
  less than 10^6 are available via this function.
  
    Example  
    gap> SmallSimpleGroup(60);
    A5
    gap> SmallSimpleGroup(20160,1);
    A8
    gap> SmallSimpleGroup(20160,2);
    PSL(3,4)
  
  
  39.15-17 AllSmallNonabelianSimpleGroups
  
  AllSmallNonabelianSimpleGroups( orders )  function
  Returns:  A  list  of  all  nonabelian simple groups whose order lies in the
            range orders.
  
  The  groups  are  given  in  small-degree  permutation  representations. The
  returned  list  is  sorted  by  ascending group order. Currently, all simple
  groups of order less than 10^6 are available via this function.
  
    Example  
    gap> List(AllSmallNonabelianSimpleGroups([1..1000000]),
    >         StructureDescription);
    [ "A5", "PSL(3,2)", "A6", "PSL(2,8)", "PSL(2,11)", "PSL(2,13)", 
      "PSL(2,17)", "A7", "PSL(2,19)", "PSL(2,16)", "PSL(3,3)", 
      "PSU(3,3)", "PSL(2,23)", "PSL(2,25)", "M11", "PSL(2,27)", 
      "PSL(2,29)", "PSL(2,31)", "A8", "PSL(3,4)", "PSL(2,37)", "O(5,3)", 
      "Sz(8)", "PSL(2,32)", "PSL(2,41)", "PSL(2,43)", "PSL(2,47)", 
      "PSL(2,49)", "PSU(3,4)", "PSL(2,53)", "M12", "PSL(2,59)", 
      "PSL(2,61)", "PSU(3,5)", "PSL(2,67)", "J1", "PSL(2,71)", "A9", 
      "PSL(2,73)", "PSL(2,79)", "PSL(2,64)", "PSL(2,81)", "PSL(2,83)", 
      "PSL(2,89)", "PSL(3,5)", "M22", "PSL(2,97)", "PSL(2,101)", 
      "PSL(2,103)", "HJ", "PSL(2,107)", "PSL(2,109)", "PSL(2,113)", 
      "PSL(2,121)", "PSL(2,125)", "O(5,4)" ]
  
  
  39.15-18 IsFinitelyGeneratedGroup
  
  IsFinitelyGeneratedGroup( G )  property
  
  tests whether the group G can be generated by a finite number of generators.
  (This property is mainly used to obtain finiteness conditions.)
  
  Note that this is a pure existence statement. Even if a group is known to be
  generated  by  a  finite  number  of  elements,  it can be very hard or even
  impossible to obtain such a generating set if it is not known.
  
  39.15-19 IsSubsetLocallyFiniteGroup
  
  IsSubsetLocallyFiniteGroup( U )  property
  
  A  group  is  called  locally finite if every finitely generated subgroup is
  finite.  This  property  checks whether the group U is a subset of a locally
  finite  group.  This  is  used to check whether finite generation will imply
  finiteness, as it does for example for permutation groups.
  
  39.15-20 IsPGroup
  
  IsPGroup( G )  property
  
  A  p-group  is  a  group  in which the order (see Order (31.10-10)) of every
  element  is  of the form p^n for a prime integer p and a nonnegative integer
  n. IsPGroup returns true if G is a p-group, and false otherwise.
  
  Finite  p-groups  are precisely those groups whose order (see Size (30.4-6))
  is a prime power, and are always nilpotent.
  
  Note  that  p-groups  can  also  be  infinite, and in that case, need not be
  nilpotent.
  
  39.15-21 IsPowerfulPGroup
  
  IsPowerfulPGroup( G )  property
  
  A  finite  p-group  G  is  said  to  be a powerful p-group if the commutator
  subgroup  [G,G]  is  contained  in G^p if the prime p is odd, or if [G,G] is
  contained  in  G^4  if  p  =  2.  The subgroup G^p is called the first Agemo
  subgroup,  (see Agemo  (39.14-2)).  IsPowerfulPGroup  returns true if G is a
  powerful p-group, and false otherwise. Note: This function returns true if G
  is the trivial group.
  
  39.15-22 PrimePGroup
  
  PrimePGroup( G )  attribute
  
  If  G is a nontrivial p-group (see IsPGroup (39.15-20)), PrimePGroup returns
  the  prime  integer  p;  if  G  is  trivial  then  PrimePGroup returns fail.
  Otherwise an error is issued.
  
  (One  should  avoid  a  common  error  of  writing  if  IsPGroup(g) then ...
  PrimePGroup(g)   ...  where  the  code  represented  by  dots  assumes  that
  PrimePGroup(g) is an integer.)
  
  39.15-23 PClassPGroup
  
  PClassPGroup( G )  attribute
  
  The  p-class  of  a p-group G (see IsPGroup (39.15-20)) is the length of the
  lower  p-central  series (see PCentralSeries (39.17-13)) of G. If G is not a
  p-group then an error is issued.
  
  39.15-24 RankPGroup
  
  RankPGroup( G )  attribute
  
  For a p-group G (see IsPGroup (39.15-20)), RankPGroup returns the rank of G,
  which  is  defined  as the minimal size of a generating system of G. If G is
  not a p-group then an error is issued.
  
    Example  
    gap> h:=Group((1,2,3,4),(1,3));;
    gap> PClassPGroup(h);
    2
    gap> RankPGroup(h);
    2
  
  
  39.15-25 IsPSolvable
  
  IsPSolvable( G, p )  operation
  
  A  finite  group  is  p-solvable  if every chief factor either has order not
  divisible by p, or is solvable.
  
  39.15-26 IsPNilpotent
  
  IsPNilpotent( G, p )  operation
  
  A group is p-nilpotent if it possesses a normal p-complement.
  
  
  39.16 Numerical Group Attributes
  
  This  section  gives only some examples of numerical group attributes, so it
  should  not  serve  as  a  collection of all numerical group attributes. The
  manual contains more such attributes documented in this manual, for example,
  NrConjugacyClasses (39.10-5), NilpotencyClassOfGroup (39.15-4) and others.
  
  Note  also  that  some  functions,  such  as EulerianFunction (39.16-3), are
  mathematical  attributes,  but  not  GAP  attributes  (see 13.5) as they are
  depending on a parameter.
  
  39.16-1 AbelianInvariants
  
  AbelianInvariants( G )  attribute
  
  returns the abelian invariants (also sometimes called primary decomposition)
  of  the commutator factor group of the group G. These are given as a list of
  prime-powers  or  zeroes  and  describe  the  structure  of G/G' as a direct
  product of cyclic groups of prime power (or infinite) order.
  
  (See   IndependentGeneratorsOfAbelianGroup   (39.22-5)   to   obtain  actual
  generators).
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2),(5,6));;
    gap> AbelianInvariants(g);
    [ 2, 2 ]
    gap> h:=FreeGroup(2);;h:=h/[h.1^3];;
    gap> AbelianInvariants(h);
    [ 0, 3 ]
  
  
  39.16-2 Exponent
  
  Exponent( G )  attribute
  
  The  exponent  e of a group G is the lcm of the orders of its elements, that
  is, e is the smallest integer such that g^e = 1 for all g ∈ G.
  
    Example  
    gap> Exponent(g);
    12
  
  
  39.16-3 EulerianFunction
  
  EulerianFunction( G, n )  operation
  
  returns the number of n-tuples (g_1, g_2, ..., g_n) of elements of the group
  G  that generate the whole group G. The elements of such an n-tuple need not
  be different.
  
  In  [Hal36],  the  notation  ϕ_n(G)  is  used  for  the  value  returned  by
  EulerianFunction,   and   the  quotient  of  ϕ_n(G)  by  the  order  of  the
  automorphism  group of G is called d_n(G). If G is a nonabelian simple group
  then  d_n(G)  is  the  greatest  number  d for which the direct product of d
  groups isomorphic with G can be generated by n elements.
  
  If  the  Library of Tables of Marks (see Chapter 70) covers the group G, you
  may also use EulerianFunctionByTom (70.9-9).
  
    Example  
    gap> EulerianFunction( g, 2 );
    432
  
  
  
  39.17 Subgroup Series
  
  In  group  theory  many  subgroup  series  are  considered, and GAP provides
  commands  to  compute  them.  In  the  following sections, there is always a
  series  G  =  U_1  > U_2 > ⋯ > U_m = ⟨ 1 ⟩ of subgroups considered. A series
  also may stop without reaching G or ⟨ 1 ⟩.
  
  A series is called subnormal if every U_{i+1} is normal in U_i.
  
  A series is called normal if every U_i is normal in G.
  
  A  series of normal subgroups is called central if U_i/U_{i+1} is central in
  G / U_{i+1}.
  
  We  call  a  series  refinable if intermediate subgroups can be added to the
  series without destroying the properties of the series.
  
  Unless  explicitly  declared  otherwise, all subgroup series are descending.
  That is they are stored in decreasing order.
  
  39.17-1 ChiefSeries
  
  ChiefSeries( G )  attribute
  
  is  a  series of normal subgroups of G which cannot be refined further. That
  is there is no normal subgroup N of G with U_i > N > U_{i+1}. This attribute
  returns one chief series (of potentially many possibilities).
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2));;
    gap> ChiefSeries(g);
    [ Group([ (1,2,3,4), (1,2) ]), 
      Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ]), 
      Group([ (1,4)(2,3), (1,3)(2,4) ]), Group(()) ]
  
  
  39.17-2 ChiefSeriesThrough
  
  ChiefSeriesThrough( G, l )  operation
  
  is  a  chief series of the group G going through the normal subgroups in the
  list  l,  which  must  be  a list of normal subgroups of G contained in each
  other,  sorted  by  descending size. This attribute returns one chief series
  (of potentially many possibilities).
  
  39.17-3 ChiefSeriesUnderAction
  
  ChiefSeriesUnderAction( H, G )  operation
  
  returns  a  series of normal subgroups of G which are invariant under H such
  that  the  series  cannot be refined any further. G must be a subgroup of H.
  This attribute returns one such series (of potentially many possibilities).
  
  39.17-4 SubnormalSeries
  
  SubnormalSeries( G, U )  operation
  
  If  U  is  a  subgroup  of  G this operation returns a subnormal series that
  descends from G to a subnormal subgroup V ≥U. If U is subnormal, V = U.
  
    Example  
    gap> s:=SubnormalSeries(g,Group((1,2)(3,4))) =
    > [ Group([ (1,2,3,4), (1,2) ]),
    >   Group([ (1,2)(3,4), (1,3)(2,4) ]),
    >   Group([ (1,2)(3,4) ]) ];
    true
  
  
  39.17-5 CompositionSeries
  
  CompositionSeries( G )  attribute
  CompositionSeriesThrough( G, normals )  operation
  
  A  composition  series  is  a subnormal series which cannot be refined. This
  attribute    returns   one   composition   series   (of   potentially   many
  possibilities).   The   variant  CompositionSeriesThrough  takes  as  second
  argument  a  list  normals  of  normal subgroups of the group, and returns a
  composition series that incorporates these normal subgroups.
  
  39.17-6 DisplayCompositionSeries
  
  DisplayCompositionSeries( G )  function
  
  Displays  a  composition  series  of G in a nice way, identifying the simple
  factors.
  
    Example  
    gap> CompositionSeries(g);
    [ Group([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]), 
      Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ]), 
      Group([ (1,4)(2,3), (1,3)(2,4) ]), Group([ (1,3)(2,4) ]), Group(()) 
     ]
    gap> DisplayCompositionSeries(Group((1,2,3,4,5,6,7),(1,2)));
    G (2 gens, size 5040)
     | C2
    S (5 gens, size 2520)
     | A7
    1 (0 gens, size 1)
  
  
  39.17-7 DerivedSeriesOfGroup
  
  DerivedSeriesOfGroup( G )  attribute
  
  The derived series of a group is obtained by U_{i+1} = U_i'. It stops if U_i
  is perfect.
  
  39.17-8 DerivedLength
  
  DerivedLength( G )  attribute
  
  The  derived length of a group is the number of steps in the derived series.
  (As there is always the group, it is the series length minus 1.)
  
    Example  
    gap> List(DerivedSeriesOfGroup(g),Size);
    [ 24, 12, 4, 1 ]
    gap> DerivedLength(g);
    3
  
  
  
  39.17-9 ElementaryAbelianSeries
  
  ElementaryAbelianSeries( G )  attribute
  ElementaryAbelianSeriesLargeSteps( G )  attribute
  ElementaryAbelianSeries( list )  attribute
  
  returns  a  series  of  normal  subgroups  of  G  such  that all factors are
  elementary  abelian.  If  the group is not solvable (and thus no such series
  exists) it returns fail.
  
  The  variant  ElementaryAbelianSeriesLargeSteps  tries  to make the steps in
  this  series  large (by eliminating intermediate subgroups if possible) at a
  small additional cost.
  
  In  the third variant, an elementary abelian series through the given series
  of normal subgroups in the list list is constructed.
  
    Example  
    gap> List(ElementaryAbelianSeries(g),Size);
    [ 24, 12, 4, 1 ]
  
  
  39.17-10 InvariantElementaryAbelianSeries
  
  InvariantElementaryAbelianSeries( G, morph[, N[, fine]] )  function
  
  For  a  (solvable)  group  G  and  a  list of automorphisms morph of G, this
  command finds a normal series of G with elementary abelian factors such that
  every group in this series is invariant under every automorphism in morph.
  
  If  a  normal  subgroup N of G which is invariant under morph is given, this
  series  is chosen to contain N. No tests are performed to check the validity
  of the arguments.
  
  The series obtained will be constructed to prefer large steps unless fine is
  given as true.
  
    Example  
    gap> g:=Group((1,2,3,4),(1,3));
    Group([ (1,2,3,4), (1,3) ])
    gap> hom:=GroupHomomorphismByImages(g,g,GeneratorsOfGroup(g),
    > [(1,4,3,2),(1,4)(2,3)]);
    [ (1,2,3,4), (1,3) ] -> [ (1,4,3,2), (1,4)(2,3) ]
    gap> InvariantElementaryAbelianSeries(g,[hom]);
    [ Group([ (1,2,3,4), (1,3) ]), Group([ (1,3)(2,4) ]), Group(()) ]
  
  
  39.17-11 LowerCentralSeriesOfGroup
  
  LowerCentralSeriesOfGroup( G )  attribute
  
  The  lower  central series of a group G is defined as U_{i+1}:= [G, U_i]. It
  is a central series of normal subgroups. The name derives from the fact that
  U_i is contained in the i-th step subgroup of any central series.
  
  39.17-12 UpperCentralSeriesOfGroup
  
  UpperCentralSeriesOfGroup( G )  attribute
  
  The  upper  central series of a group G is defined as an ending series U_i /
  U_{i+1}:= Z(G/U_{i+1}). It is a central series of normal subgroups. The name
  derives  from  the  fact  that  U_i  contains  every i-th step subgroup of a
  central series.
  
  39.17-13 PCentralSeries
  
  PCentralSeries( G, p )  operation
  
  The  p-central  series  of  G  is  defined  by  U_1:=  G, U_i:= [G, U_{i-1}]
  U_{i-1}^p.
  
    Example  
    gap> g:=DicyclicGroup(12);;
    gap> PCentralSeries(g,2);
    [ <pc group of size 12 with 3 generators>, Group([ y3, y*y3 ]), Group([ y*y3 ]) ]
    gap> g:=SymmetricGroup(4);;
    gap> List(PCentralSeries(g,2), StructureDescription);
    [ "S4", "A4" ]
  
  
  39.17-14 JenningsSeries
  
  JenningsSeries( G )  attribute
  
  For  a  p-group G, this function returns its Jennings series. This series is
  defined  by  setting G_1 = G and for i ≥ 0, G_{i+1} = [G_i,G] G_j^p, where j
  is the smallest integer > i/p.
  
  39.17-15 DimensionsLoewyFactors
  
  DimensionsLoewyFactors( G )  attribute
  
  This operation computes the dimensions of the factors of the Loewy series of
  G.  (See [HB82, p. 157] for the slightly complicated definition of the Loewy
  Series.)
  
  The  dimensions  are  computed  via  the  JenningsSeries  (39.17-14) without
  computing the Loewy series itself.
  
    Example  
    gap> G:= SmallGroup( 3^6, 100 );
    <pc group of size 729 with 6 generators>
    gap> JenningsSeries( G );
    [ <pc group of size 729 with 6 generators>, Group([ f3, f4, f5, f6 ]),
      Group([ f4, f5, f6 ]), Group([ f5, f6 ]), Group([ f5, f6 ]), 
      Group([ f5, f6 ]), Group([ f6 ]), Group([ f6 ]), Group([ f6 ]), 
      Group([ <identity> of ... ]) ]
    gap> DimensionsLoewyFactors(G);
    [ 1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20, 22, 23, 25, 26, 
      27, 27, 27, 27, 27, 27, 27, 27, 27, 26, 25, 23, 22, 20, 19, 17, 16, 
      14, 13, 11, 10, 8, 7, 5, 4, 2, 1 ]
  
  
  39.17-16 AscendingChain
  
  AscendingChain( G, U )  function
  
  This  function  computes  an  ascending chain of subgroups from U to G. This
  chain is given as a list whose first entry is U and the last entry is G. The
  function tries to make the links in this chain small.
  
  The  option refineIndex can be used to give a bound for refinements of steps
  to  avoid GAP trying to enforce too small steps. The option cheap (if set to
  true) will overall limit the amount of heuristic searches.
  
  39.17-17 IntermediateGroup
  
  IntermediateGroup( G, U )  function
  
  This  routine tries to find a subgroup E of G, such that G > E > U holds. If
  U  is  maximal  in  G,  the  function  returns fail. This is done by finding
  minimal blocks for the operation of G on the right cosets of U.
  
  39.17-18 IntermediateSubgroups
  
  IntermediateSubgroups( G, U )  operation
  
  returns  a  list  of all subgroups of G that properly contain U; that is all
  subgroups  between  G and U. It returns a record with a component subgroups,
  which is a list of these subgroups, as well as a component inclusions, which
  lists   all  maximality  inclusions  among  these  subgroups.  A  maximality
  inclusion is given as a list [i, j] indicating that the subgroup number i is
  a  maximal  subgroup  of  the  subgroup  number  j,  the  numbers  0 and 1 +
  Length(subgroups) are used to denote U and G, respectively.
  
  39.17-19 StructuralSeriesOfGroup
  
  StructuralSeriesOfGroup( G )  attribute
  
  The  structural  series  of  a  finite  group  G  is  a descending series of
  characteristic  subgroups  which  goes  throught  the  derived series of the
  solvable radical of $G$, refined into elementary abelian factors, as well as
  the  socle  and  the  Pker (kernel of the action on socle components) of the
  radical factor
  
    Example  
    gap> gp:=WreathProduct(SymmetricGroup(5),SymmetricGroup(3));;
    gap> gp:=WreathProduct(Group((1,2,3,4,5,6)),gp);;
    gap> List(StructuralSeriesOfGroup(gp),Size);
    [ 4874877920083968000, 812479653347328000, 101559956668416000, 470184984576, 32768, 1 ]
  
  
  
  39.18 Factor Groups
  
  39.18-1 NaturalHomomorphismByNormalSubgroup
  
  NaturalHomomorphismByNormalSubgroup( G, N )  function
  NaturalHomomorphismByNormalSubgroupNC( G, N )  function
  
  returns  a  homomorphism from G to another group whose kernel is N. GAP will
  try  to select the image group as to make computations in it as efficient as
  possible. As the factor group G/N can be identified with the image of G this
  permits  efficient  computations  in  the  factor  group.  The  homomorphism
  returned  is  not necessarily surjective, so ImagesSource (32.4-1) should be
  used  instead  of  Range  (32.3-7)  to  get a group isomorphic to the factor
  group. The NC variant does not check whether N is normal in G.
  
  39.18-2 FactorGroup
  
  FactorGroup( G, N )  function
  FactorGroupNC( G, N )  operation
  
  returns  the  image  of  the  NaturalHomomorphismByNormalSubgroup(G,N). This
  function  is provided for compatibility with older code, but if a connection
  between  group  and  factor is desired, users need to start by obtaining the
  NaturalHomomorphismByNormalSubgroup  in the first place. The NC version does
  not test whether N is normal in G.
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2));;n:=Subgroup(g,[(1,2)(3,4),(1,3)(2,4)]);;
    gap> hom:=NaturalHomomorphismByNormalSubgroup(g,n);
    [ (1,2,3,4), (1,2) ] -> [ f1*f2, f1 ]
    gap> Size(ImagesSource(hom));
    6
    gap> StructureDescription(Image(hom,g));
    "S3"
  
  
  39.18-3 CommutatorFactorGroup
  
  CommutatorFactorGroup( G )  attribute
  
  computes the commutator factor group G/G' of the group G.
  
    Example  
    gap> CommutatorFactorGroup(g);
    Group([ f1 ])
  
  
  39.18-4 MaximalAbelianQuotient
  
  MaximalAbelianQuotient( G )  attribute
  
  returns  an  epimorphism  from G onto the maximal abelian quotient of G. The
  kernel of this epimorphism is the derived subgroup of G, see DerivedSubgroup
  (39.12-3).
  
  39.18-5 HasAbelianFactorGroup
  
  HasAbelianFactorGroup( G, N )  function
  
  tests  whether  G / N is abelian (without explicitly constructing the factor
  group and without testing whether N is in fact a normal subgroup).
  
    Example  
    gap> HasAbelianFactorGroup(g,n);
    false
    gap> HasAbelianFactorGroup(DerivedSubgroup(g),n);
    true
  
  
  39.18-6 HasElementaryAbelianFactorGroup
  
  HasElementaryAbelianFactorGroup( G, N )  function
  
  tests  whether  G / N is elementary abelian (without explicitly constructing
  the  factor  group  and  without  testing  whether  N  is  in  fact a normal
  subgroup).
  
  39.18-7 CentralizerModulo
  
  CentralizerModulo( G, N, elm )  operation
  
  Computes the full preimage of the centralizer C_{G/N}(elm ⋅ N) in G (without
  necessarily constructing the factor group).
  
    Example  
    gap> CentralizerModulo(g,n,(1,2));
    Group([ (3,4), (1,3)(2,4), (1,4)(2,3) ])
  
  
  
  39.19 Sets of Subgroups
  
  39.19-1 ConjugacyClassSubgroups
  
  ConjugacyClassSubgroups( G, U )  operation
  
  generates  the conjugacy class of subgroups of G with representative U. This
  class  is  an  external  set,  so functions such as Representative (30.4-7),
  (which    returns    U),   ActingDomain   (41.12-3)   (which   returns   G),
  StabilizerOfExternalSet  (41.12-10) (which returns the normalizer of U), and
  AsList (30.3-8) work for it.
  
  (The use of the [] list access to select elements of the class is considered
  obsolescent  and will be removed in future versions. Use ClassElementLattice
  (39.20-2) instead.)
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2));;IsNaturalSymmetricGroup(g);;
    gap> cl:=ConjugacyClassSubgroups(g,Subgroup(g,[(1,2)]));
    Group( [ (1,2) ] )^G
    gap> Size(cl);
    6
    gap> ClassElementLattice(cl,4);
    Group([ (2,3) ])
  
  
  39.19-2 IsConjugacyClassSubgroupsRep
  
  IsConjugacyClassSubgroupsRep( obj )  Representation
  IsConjugacyClassSubgroupsByStabilizerRep( obj )  Representation
  
  Is the representation GAP uses for conjugacy classes of subgroups. It can be
  used  to  check  whether  an  object  is  a  class  of subgroups. The second
  representation  IsConjugacyClassSubgroupsByStabilizerRep  in  addition is an
  external orbit by stabilizer and will compute its elements via a transversal
  of the stabilizer.
  
  39.19-3 ConjugacyClassesSubgroups
  
  ConjugacyClassesSubgroups( G )  attribute
  
  This  attribute  returns a list of all conjugacy classes of subgroups of the
  group    G.    It   also   is   applicable   for   lattices   of   subgroups
  (see LatticeSubgroups  (39.20-1)). The order in which the classes are listed
  depends  on  the  method  chosen  by  GAP.  For  each  class of subgroups, a
  representative can be accessed using Representative (30.4-7).
  
    Example  
    gap> ConjugacyClassesSubgroups(g);
    [ Group( () )^G, Group( [ (1,3)(2,4) ] )^G, Group( [ (3,4) ] )^G, 
      Group( [ (2,4,3) ] )^G, Group( [ (1,4)(2,3), (1,3)(2,4) ] )^G, 
      Group( [ (3,4), (1,2)(3,4) ] )^G, 
      Group( [ (1,3,2,4), (1,2)(3,4) ] )^G, Group( [ (3,4), (2,4,3) ] )^G,
      Group( [ (1,4)(2,3), (1,3)(2,4), (3,4) ] )^G, 
      Group( [ (1,4)(2,3), (1,3)(2,4), (2,4,3) ] )^G, 
      Group( [ (1,4)(2,3), (1,3)(2,4), (2,4,3), (3,4) ] )^G ]
  
  
  39.19-4 ConjugacyClassesMaximalSubgroups
  
  ConjugacyClassesMaximalSubgroups( G )  attribute
  
  returns  the conjugacy classes of maximal subgroups of G. Representatives of
  the classes can be computed directly by MaximalSubgroupClassReps (39.19-5).
  
    Example  
    gap> ConjugacyClassesMaximalSubgroups(g);
    [ Group( [ (2,4,3), (1,4)(2,3), (1,3)(2,4) ] )^G,
      Group( [ (3,4), (1,4)(2,3), (1,3)(2,4) ] )^G,
      Group( [ (3,4), (2,4,3) ] )^G ]
  
  
  39.19-5 MaximalSubgroupClassReps
  
  MaximalSubgroupClassReps( G )  attribute
  
  returns a list of conjugacy representatives of the maximal subgroups of G.
  
    Example  
    gap> MaximalSubgroupClassReps(g);
    [ Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ]), Group([ (3,4), (1,4)
      (2,3), (1,3)(2,4) ]), Group([ (3,4), (2,4,3) ]) ]
  
  
  39.19-6 LowIndexSubgroups
  
  LowIndexSubgroups( G, index )  operation
  
  The  operation  LowIndexSubgroups  computes representatives of the conjugacy
  classes of subgroups of the group G that index less than or equal to index.
  
  For   finitely   presented   groups   this   operation  simply  defaults  to
  LowIndexSubgroupsFpGroup   (47.10-1).  In  other  cases,  it  uses  repeated
  calculation of maximal subgroups.
  
  The  function  LowLayerSubgroups  (39.20-6) works similar but does not bound
  the index, but instead considers up to layer-th maximal subgroups.
  
    Example  
    gap> g:=TransitiveGroup(18,950);;
    gap> l:=LowIndexSubgroups(g,20);;Collected(List(l,x->Index(g,x)));
    [ [ 1, 1 ], [ 2, 1 ], [ 5, 1 ], [ 6, 1 ], [ 10, 2 ], [ 12, 3 ], [ 15, 1 ], 
      [ 16, 2 ], [ 18, 1 ], [ 20, 9 ] ]
  
  
  39.19-7 AllSubgroups
  
  AllSubgroups( G )  function
  
  For  a  finite  group  G  AllSubgroups returns a list of all subgroups of G,
  intended  primarily  for  use  in  class  for small examples. This list will
  quickly  get  very  long  and  in  general  use of ConjugacyClassesSubgroups
  (39.19-3) is recommended.
  
    Example  
    gap> AllSubgroups(SymmetricGroup(3));
    [ Group(()), Group([ (2,3) ]), Group([ (1,2) ]), Group([ (1,3) ]), 
      Group([ (1,2,3) ]), Group([ (1,2,3), (2,3) ]) ]
  
  
  39.19-8 MaximalSubgroups
  
  MaximalSubgroups( G )  attribute
  
  returns  a  list of all maximal subgroups of G. This may take up much space,
  therefore    the    command    should    be   avoided   if   possible.   See
  ConjugacyClassesMaximalSubgroups (39.19-4).
  
    Example  
    gap> MaximalSubgroups(Group((1,2,3),(1,2)));
    [ Group([ (1,2,3) ]), Group([ (2,3) ]), Group([ (1,2) ]), 
      Group([ (1,3) ]) ]
  
  
  39.19-9 NormalSubgroups
  
  NormalSubgroups( G )  attribute
  
  returns a list of all normal subgroups of G.
  
    Example  
    gap> g:=SymmetricGroup(4);;
    gap> List( NormalSubgroups(g), StructureDescription );
    [ "S4", "A4", "C2 x C2", "1" ]
    gap> g:=AbelianGroup([2,2]);; NormalSubgroups(g);
    [ <pc group of size 4 with 2 generators>, Group([ f2 ]),
      Group([ f1*f2 ]), Group([ f1 ]), Group([  ]) ]
  
  
  The  algorithm  for  the  computation  of  normal  subgroups is described in
  [Hul98].
  
  39.19-10 MaximalNormalSubgroups
  
  MaximalNormalSubgroups( G )  attribute
  
  is  a  list containing those proper normal subgroups of the group G that are
  maximal  among the proper normal subgroups. Gives error if G/G' is infinite,
  yielding  infinitely  many  maximal normal subgroups. Note, that the maximal
  normal  subgroups  of  a  group  G  can  be computed more efficiently if the
  character  table  of  G  is known or if G is known to be abelian or solvable
  (even  if  infinite).  So  if the character table is needed, anyhow, or G is
  suspected  to  be  abelian or solvable, then these should be computed before
  computing the maximal normal subgroups.
  
    Example  
    gap> g:=SymmetricGroup(4);; MaximalNormalSubgroups( g );
    [ Alt( [ 1 .. 4 ] ) ]
    gap> f := FreeGroup("x", "y");; x := f.1;; y := f.2;;
    gap> List(MaximalNormalSubgroups(f/[x^2, y^2]), GeneratorsOfGroup);
    [ [ x, y*x*y^-1 ], [ y, x*y*x^-1 ], [ y*x^-1 ] ]
  
  
  39.19-11 MinimalNormalSubgroups
  
  MinimalNormalSubgroups( G )  attribute
  
  is  a  list containing those nontrivial normal subgroups of the group G that
  are minimal among the nontrivial normal subgroups.
  
    Example  
    gap> g:=SymmetricGroup(4);; MinimalNormalSubgroups( g );
    [ Group([ (1,4)(2,3), (1,3)(2,4) ]) ]
  
  
  39.19-12 CharacteristicSubgroups
  
  CharacteristicSubgroups( G )  attribute
  
  returns  a list of all characteristic subgroups of G, that is subgroups that
  are invariant under all automorphisms.
  
    Example  
    gap> g:=SymmetricGroup(4);;
    gap> List( CharacteristicSubgroups(g), StructureDescription );
    [ "S4", "A4", "C2 x C2", "1" ]
    gap> g:=AbelianGroup([2,2]);; CharacteristicSubgroups(g);
    [ <pc group of size 4 with 2 generators>, Group([  ]) ]
  
  
  
  39.20 Subgroup Lattice
  
  39.20-1 LatticeSubgroups
  
  LatticeSubgroups( G )  attribute
  
  computes  the  lattice  of  subgroups  of  the group G. This lattice has the
  conjugacy   classes  of  subgroups  as  attribute  ConjugacyClassesSubgroups
  (39.19-3) and permits one to test maximality/minimality relations.
  
    Example  
    gap> g:=SymmetricGroup(4);;
    gap> l:=LatticeSubgroups(g);
    <subgroup lattice of Sym( [ 1 .. 4 ] ), 11 classes, 30 subgroups>
    gap> ConjugacyClassesSubgroups(l);
    [ Group( () )^G, Group( [ (1,3)(2,4) ] )^G, Group( [ (3,4) ] )^G, 
      Group( [ (2,4,3) ] )^G, Group( [ (1,4)(2,3), (1,3)(2,4) ] )^G, 
      Group( [ (3,4), (1,2)(3,4) ] )^G, 
      Group( [ (1,3,2,4), (1,2)(3,4) ] )^G, Group( [ (3,4), (2,4,3) ] )^G,
      Group( [ (1,4)(2,3), (1,3)(2,4), (3,4) ] )^G, 
      Group( [ (1,4)(2,3), (1,3)(2,4), (2,4,3) ] )^G, 
      Group( [ (1,4)(2,3), (1,3)(2,4), (2,4,3), (3,4) ] )^G ]
  
  
  39.20-2 ClassElementLattice
  
  ClassElementLattice( C, n )  operation
  
  For  a  class  C  of  subgroups,  obtained  by  a  lattice computation, this
  operation returns the n-th conjugate subgroup in the class.
  
  Because  of other methods installed, calling AsList (30.3-8) with C can give
  a different arrangement of the class elements!
  
  The GAP package XGAP permits a graphical display of the lattice of subgroups
  in a nice way.
  
  39.20-3 DotFileLatticeSubgroups
  
  DotFileLatticeSubgroups( L, file )  function
  
  This  function produces a graphical representation of the subgroup lattice L
  in  file  file.  The  output is in .dot (also known as GraphViz format). For
  details  on  the  format,  and information about how to display or edit this
  format   see   https://www.graphviz.org.  (On  the  Macintosh,  the  program
  OmniGraffle is also able to read this format.)
  
  Subgroups are labelled in the form i-j where i is the number of the class of
  subgroups  and  j  the  number  within  this  class.  Normal  subgroups  are
  represented by a box.
  
    Example  
    gap> DotFileLatticeSubgroups(l,"s4lat.dot");
  
  
  39.20-4 MaximalSubgroupsLattice
  
  MaximalSubgroupsLattice( lat )  attribute
  
  For  a lattice lat of subgroups this attribute contains the maximal subgroup
  relations  among the subgroups of the lattice. It is a list corresponding to
  the  ConjugacyClassesSubgroups  (39.19-3)  value  of the lattice, each entry
  giving  a list of the maximal subgroups of the representative of this class.
  Every  maximal  subgroup  is  indicated by a list of the form [ c, n ] which
  means  that the n-th subgroup in class number c is a maximal subgroup of the
  representative.
  
  The number n corresponds to access via ClassElementLattice (39.20-2) and not
  necessarily     the     AsList     (30.3-8)     arrangement!     See    also
  MinimalSupergroupsLattice (39.20-5).
  
    Example  
    gap> MaximalSubgroupsLattice(l);
    [ [  ], [ [ 1, 1 ] ], [ [ 1, 1 ] ], [ [ 1, 1 ] ], 
      [ [ 2, 1 ], [ 2, 2 ], [ 2, 3 ] ], [ [ 3, 1 ], [ 3, 6 ], [ 2, 3 ] ], 
      [ [ 2, 3 ] ], [ [ 4, 1 ], [ 3, 1 ], [ 3, 2 ], [ 3, 3 ] ], 
      [ [ 7, 1 ], [ 6, 1 ], [ 5, 1 ] ], 
      [ [ 5, 1 ], [ 4, 1 ], [ 4, 2 ], [ 4, 3 ], [ 4, 4 ] ], 
      [ [ 10, 1 ], [ 9, 1 ], [ 9, 2 ], [ 9, 3 ], [ 8, 1 ], [ 8, 2 ], 
          [ 8, 3 ], [ 8, 4 ] ] ]
    gap> last[6];
    [ [ 3, 1 ], [ 3, 6 ], [ 2, 3 ] ]
    gap> u1:=Representative(ConjugacyClassesSubgroups(l)[6]);
    Group([ (3,4), (1,2)(3,4) ])
    gap> u2:=ClassElementLattice(ConjugacyClassesSubgroups(l)[3],1);;
    gap> u3:=ClassElementLattice(ConjugacyClassesSubgroups(l)[3],6);;
    gap> u4:=ClassElementLattice(ConjugacyClassesSubgroups(l)[2],3);;
    gap> IsSubgroup(u1,u2);IsSubgroup(u1,u3);IsSubgroup(u1,u4);
    true
    true
    true
  
  
  39.20-5 MinimalSupergroupsLattice
  
  MinimalSupergroupsLattice( lat )  attribute
  
  For  a  lattice  lat  of  subgroups  this  attribute  contains  the  minimal
  supergroup  relations  among  the  subgroups  of  the  lattice. It is a list
  corresponding  to  the  ConjugacyClassesSubgroups  (39.19-3)  value  of  the
  lattice,  each  entry  giving  a  list  of  the  minimal  supergroups of the
  representative  of  this  class.  Every minimal supergroup is indicated by a
  list  of  the  form  [  c,  n ], which means that the n-th subgroup in class
  number c is a minimal supergroup of the representative.
  
  The number n corresponds to access via ClassElementLattice (39.20-2) and not
  necessarily     the     AsList     (30.3-8)     arrangement!     See    also
  MaximalSubgroupsLattice (39.20-4).
  
    Example  
    gap> MinimalSupergroupsLattice(l);
    [ [ [ 2, 1 ], [ 2, 2 ], [ 2, 3 ], [ 3, 1 ], [ 3, 2 ], [ 3, 3 ], 
          [ 3, 4 ], [ 3, 5 ], [ 3, 6 ], [ 4, 1 ], [ 4, 2 ], [ 4, 3 ], 
          [ 4, 4 ] ], [ [ 5, 1 ], [ 6, 2 ], [ 7, 2 ] ], 
      [ [ 6, 1 ], [ 8, 1 ], [ 8, 3 ] ], [ [ 8, 1 ], [ 10, 1 ] ], 
      [ [ 9, 1 ], [ 9, 2 ], [ 9, 3 ], [ 10, 1 ] ], [ [ 9, 1 ] ], 
      [ [ 9, 1 ] ], [ [ 11, 1 ] ], [ [ 11, 1 ] ], [ [ 11, 1 ] ], [  ] ]
    gap> last[3];
    [ [ 6, 1 ], [ 8, 1 ], [ 8, 3 ] ]
    gap> u5:=ClassElementLattice(ConjugacyClassesSubgroups(l)[8],1);
    Group([ (3,4), (2,4,3) ])
    gap> u6:=ClassElementLattice(ConjugacyClassesSubgroups(l)[8],3);
    Group([ (1,3), (1,3,4) ])
    gap> IsSubgroup(u5,u2);
    true
    gap> IsSubgroup(u6,u2);
    true
  
  
  39.20-6 LowLayerSubgroups
  
  LowLayerSubgroups( [act, ]G, lim[, cond, dosub] )  function
  
  This function computes representatives of the conjugacy classes of subgroups
  of  the  finite  group G such that the subgroups can be obtained as lim-fold
  iterated  maximal subgroups. If a function cond is given, only subgroups for
  which this function returns true (also for their intermediate overgroups) is
  returned.  If  also  a  function  dosub is given, maximal subgroups are only
  attempted  if  this function returns true (this is separated for performance
  reasons).  In  the  example below, the result would be the same with leaving
  out  the fourth function, but calculation this way is slightly faster. If an
  inital  argument act is given, it must be a group containing and normalizing
  G,  and  representatives  for  classes  under  the  action of this group are
  chosen.
  
    Example  
    gap> g:=SymmetricGroup(12);;
    gap> l:=LowLayerSubgroups(g,2,x->Size(x)>100000,x->Size(x)>200000);;
    gap> Collected(List(l,Size));
    [ [ 100800, 1 ], [ 120960, 1 ], [ 161280, 1 ], [ 241920, 1 ], [ 302400, 3 ],
      [ 322560, 1 ], [ 483840, 3 ], [ 518400, 3 ], [ 604800, 1 ], [ 725760, 1 ],
      [ 967680, 1 ], [ 1036800, 1 ], [ 1088640, 3 ], [ 2177280, 1 ],
      [ 3628800, 3 ], [ 7257600, 1 ], [ 19958400, 1 ], [ 39916800, 1 ],
      [ 239500800, 1 ], [ 479001600, 1 ] ]
  
  
  39.20-7 ContainedConjugates
  
  ContainedConjugates( G, A, B[, onlyone] )  operation
  
  For  A,B  ≤  G  this  operation  returns  representatives of the A conjugacy
  classes of subgroups that are conjugate to B under G. The function returns a
  list  of  pairs  of subgroup and conjugating element. If the optional fourth
  argument  onlyone  is  given  as  true,  then only one pair (or fail if none
  exists) is returned.
  
    Example  
    gap> g:=SymmetricGroup(8);;
    gap> a:=TransitiveGroup(8,47);;b:=TransitiveGroup(8,9);;
    gap> ContainedConjugates(g,a,b);
    [ [ Group([ (1,8)(2,3)(4,5)(6,7), (1,3)(2,8)(4,6)(5,7), (1,5)(2,6)(3,7)(4,8),
            (4,5)(6,7) ]), () ],
      [ Group([ (1,8)(2,3)(4,5)(6,7), (1,5)(2,6)(3,7)(4,8), (1,3)(2,8)(4,6)(5,7),
            (2,3)(6,7) ]), (2,4)(3,5) ] ]
    gap> ContainedConjugates(g,a,b,true);
    [ Group([ (1,8)(2,3)(4,5)(6,7), (1,3)(2,8)(4,6)(5,7), (1,5)(2,6)(3,7)(4,8),
        (4,5)(6,7) ]), () ]
  
  
  39.20-8 ContainingConjugates
  
  ContainingConjugates( G, A, B )  operation
  
  For A,B ≤ G this operation returns all G conjugates of A that contain B. The
  function returns a list of pairs of subgroup and conjugating element.
  
    Example  
    gap> g:=SymmetricGroup(8);;
    gap> a:=TransitiveGroup(8,47);;b:=TransitiveGroup(8,7);;
    gap> ContainingConjugates(g,a,b);
    [ [ Group([ (1,3,5,7), (3,5), (1,4)(2,7)(3,6)(5,8) ]), (2,3,5,4)(7,8) ] ]
  
  
  39.20-9 MinimalFaithfulPermutationDegree
  
  MinimalFaithfulPermutationDegree( G )  operation
  MinimalFaithfulPermutationRepresentation( G )  operation
  
  For  a finite group G, MinimalFaithfulPermutationDegree calculates the least
  positive  integer  n=μ(G)  such  that  G  is isomorphic to a subgroup of the
  symmetric group of degree n. This can require calculating the whole subgroup
  lattice.  The  operation  MinimalFaithfulPermutationRepresentation returns a
  corresponding isomorphism.
  
    Example  
    gap> MinimalFaithfulPermutationDegree(SmallGroup(96,3));
    12
    gap> g:=TransitiveGroup(10,32);;
    gap> MinimalFaithfulPermutationDegree(g);
    6
    gap> map:=MinimalFaithfulPermutationRepresentation(g);;
    gap> Size(Image(map));
    720
  
  
  39.20-10 RepresentativesPerfectSubgroups
  
  RepresentativesPerfectSubgroups( G )  attribute
  RepresentativesSimpleSubgroups( G )  attribute
  
  returns a list of conjugacy representatives of perfect (respectively simple)
  subgroups  of  G.  This uses the library of perfect groups (see PerfectGroup
  (50.6-2)),  thus  it  will  issue an error if the library is insufficient to
  determine all perfect subgroups.
  
    Example  
    gap> m11:=TransitiveGroup(11,6);
    M(11)
    gap> r:=RepresentativesPerfectSubgroups(m11);;
    gap> List(r,Size);
    [ 60, 60, 360, 660, 7920, 1 ]
    gap> List(r,StructureDescription);
    [ "A5", "A5", "A6", "PSL(2,11)", "M11", "1" ]
  
  
  39.20-11 ConjugacyClassesPerfectSubgroups
  
  ConjugacyClassesPerfectSubgroups( G )  attribute
  
  returns  a  list  of  the  conjugacy classes of perfect subgroups of G. (see
  RepresentativesPerfectSubgroups (39.20-10).)
  
    Example  
    gap> r := ConjugacyClassesPerfectSubgroups(m11);;
    gap> List(r, x -> StructureDescription(Representative(x)));
    [ "A5", "A5", "A6", "PSL(2,11)", "M11", "1" ]
    gap> SortedList( List(r,Size) );
    [ 1, 1, 11, 12, 66, 132 ]
  
  
  39.20-12 Zuppos
  
  Zuppos( G )  attribute
  
  The  Zuppos  of  a group are the cyclic subgroups of prime power order. (The
  name  Zuppo  derives from the German abbreviation for zyklische Untergruppen
  von  Primzahlpotenzordnung.)  This  attribute  gives  generators of all such
  subgroups of a group G. That is all elements of G of prime power order up to
  the equivalence that they generate the same cyclic subgroup.
  
  39.20-13 InfoLattice
  
  InfoLattice  info class
  
  is  the  information class used by the cyclic extension methods for subgroup
  lattice calculations.
  
  
  39.21 Specific Methods for Subgroup Lattice Computations
  
  39.21-1 LatticeByCyclicExtension
  
  LatticeByCyclicExtension( G[, func[, noperf]] )  function
  
  computes  the  lattice  of  G  using  the cyclic extension algorithm. If the
  function  func  is  given,  the  algorithm  will  discard  all subgroups not
  fulfilling  func  (and  will  also  not  extend  them),  returning a partial
  lattice.  This  can  be  useful  to  compute  only  subgroups  with  certain
  properties.  Note however that this will not necessarily yield all subgroups
  that  fulfill  func,  but  the  subgroups  whose  subgroups are used for the
  construction  must  also fulfill func as well. (In fact the filter func will
  simply  discard  subgroups  in the cyclic extension algorithm. Therefore the
  trivial  subgroup  will  always  be  included.)  Also  note, that for such a
  partial   lattice   maximality/minimality   inclusion  relations  cannot  be
  computed.  (If  func  is  a  list  of  length  2,  its first entry is such a
  discarding function, the second a function for discarding zuppos.)
  
  The  cyclic extension algorithm requires the perfect subgroups of G. However
  GAP  cannot analyze the function func for its implication but can only apply
  it.  If  it  is  known that func implies solvability, the computation of the
  perfect  subgroups  can be avoided by giving a third parameter noperf set to
  true.
  
    Example  
    gap> g:=WreathProduct(Group((1,2,3),(1,2)),Group((1,2,3,4)));;
    gap> l:=LatticeByCyclicExtension(g,function(G)
    > return Size(G) in [1,2,3,6];end);
    <subgroup lattice of <permutation group of size 5184 with 
    9 generators>, 47 classes, 
    2628 subgroups, restricted under further condition l!.func>
  
  
  The total number of classes in this example is much bigger, as the following
  example shows:
  
    Example  
    gap> LatticeSubgroups(g);
    <subgroup lattice of <permutation group of size 5184 with 
    9 generators>, 566 classes, 27134 subgroups>
  
  
  ##
  
  39.21-2 InvariantSubgroupsElementaryAbelianGroup
  
  InvariantSubgroupsElementaryAbelianGroup( G, homs[, dims] )  function
  
  Let  G  be an elementary abelian group and homs be a set of automorphisms of
  G.  Then this function computes all subspaces of G which are invariant under
  all  automorphisms  in  homs. When considering G as a module for the algebra
  generated  by  homs, these are all submodules. If homs is empty, it computes
  all  subgroups.  If the optional parameter dims is given, only submodules of
  this dimension are computed.
  
    Example  
    gap> g:=Group((1,2,3),(4,5,6),(7,8,9));
    Group([ (1,2,3), (4,5,6), (7,8,9) ])
    gap> hom:=GroupHomomorphismByImages(g,g,[(1,2,3),(4,5,6),(7,8,9)],
    > [(7,8,9),(1,2,3),(4,5,6)]);
    [ (1,2,3), (4,5,6), (7,8,9) ] -> [ (7,8,9), (1,2,3), (4,5,6) ]
    gap> u:=InvariantSubgroupsElementaryAbelianGroup(g,[hom]);
    [ Group([ (7,8,9), (4,5,6), (1,2,3) ]),
      Group([ (1,3,2)(7,8,9), (1,3,2)(4,5,6) ]),
      Group([ (1,2,3)(4,5,6)(7,8,9) ]), Group(()) ]
  
  
  39.21-3 SubgroupsSolvableGroup
  
  SubgroupsSolvableGroup( G[, opt] )  function
  
  This  function  (implementing  the  algorithm published in [Hul99]) computes
  subgroups  of  a  solvable  group  G,  using  the homomorphism principle. It
  returns a list of representatives up to G-conjugacy.
  
  The  optional  argument  opt  is  a  record,  which  may  be used to suggest
  restrictions  on  the subgroups computed. The following record components of
  opt  are  recognized  and  have  the following effects. Note that all of the
  following restrictions to subgroups with particular properties are only used
  to  speed  up  the calculation, but the result might still contain subgroups
  (that had to be computed in any case) that do not satisfy the properties. If
  this  is  not  desired, the calculation must be followed by an explicit test
  for  the  desired properties (which is not done by default, as it would be a
  general  slowdown).  The  function  guarantees  that  representatives of all
  subgroups  that  satisfy  the  properties  are found, i.e. there can be only
  false positives.
  
  actions
        must  be a list of automorphisms of G. If given, only groups which are
        invariant  under  all  these automorphisms are computed. The algorithm
        must  know  the  normalizer  in  G  of  the group generated by actions
        (defined  formally  by  embedding  in the semidirect product of G with
        actions).  This  can  be  given  in the component funcnorm and will be
        computed if this component is not given.
  
  normal
        if  set  to  true  only normal subgroups are guaranteed to be returned
        (though some of the returned subgroups might still be not normal).
  
  consider
        a function to restrict the groups computed. This must be a function of
        five  parameters,  C, A, N, B, M, that are interpreted as follows: The
        arguments are subgroups of a factor F of G in the relation F ≥ C > A >
        N > B > M. N and M are normal subgroups. C is the full preimage of the
        normalizer  of  A/N  in  F/N.  When computing modulo M and looking for
        subgroups  U  such  that  U ∩ N = B and ⟨ U, N ⟩ = A, this function is
        called. If it returns false then all potential groups U (and therefore
        all  groups later arising from them) are disregarded. This can be used
        for example to compute only subgroups of certain sizes.
  
        (This is just a restriction to speed up computations. The function may
        still   return   (invariant)   subgroups   which  don't  fulfill  this
        condition!)  This  parameter  is  used  to permit calculations of some
        subgroups if the set of all subgroups would be too large to handle.
  
        The  actual groups C, A, N and B which are passed to this function are
        not  necessarily  subgroups  of  G  but might be subgroups of a proper
        factor  group  F = G/H. Therefore the consider function may not relate
        the parameter groups to G.
  
  retnorm
        if  set to true the function not only returns a list subs of subgroups
        but also a corresponding list norms of normalizers in the form [ subs,
        norms ].
  
  series
        is  an  elementary  abelian  series  of  G  which will be used for the
        computation.
  
  groups
        is  a  list of groups to seed the calculation. Only subgroups of these
        groups are constructed.
  
    Example  
    gap> g:=Group((1,2,3),(1,2),(4,5,6),(4,5),(7,8,9),(7,8));
    Group([ (1,2,3), (1,2), (4,5,6), (4,5), (7,8,9), (7,8) ])
    gap> hom:=GroupHomomorphismByImages(g,g,
    > [(1,2,3),(1,2),(4,5,6),(4,5),(7,8,9),(7,8)],
    > [(4,5,6),(4,5),(7,8,9),(7,8),(1,2,3),(1,2)]);
    [ (1,2,3), (1,2), (4,5,6), (4,5), (7,8,9), (7,8) ] -> 
    [ (4,5,6), (4,5), (7,8,9), (7,8), (1,2,3), (1,2) ]
    gap> l:=SubgroupsSolvableGroup(g,rec(actions:=[hom]));;
    gap> SortedList(List(l,Size));
    [ 1, 2, 3, 4, 6, 8, 9, 18, 27, 54, 108, 216 ]
    gap> Length(ConjugacyClassesSubgroups(g)); # to compare
    162
  
  
  39.21-4 SizeConsiderFunction
  
  SizeConsiderFunction( size )  function
  
  This function returns a function consider of five arguments that can be used
  in  SubgroupsSolvableGroup  (39.21-3)  for  the  option  consider to compute
  subgroups whose sizes are divisible by size.
  
    Example  
    gap> l:=SubgroupsSolvableGroup(g,rec(actions:=[hom],
    > consider:=SizeConsiderFunction(6)));;
    gap> SortedList(List(l,Size));
    [ 1, 3, 6, 9, 18, 27, 54, 108, 216 ]
  
  
  This  example shows that in general the consider function does not provide a
  perfect filter. It is guaranteed that all subgroups fulfilling the condition
  are  returned,  but  not  all  subgroups  returned  necessarily  fulfill the
  condition.
  
  39.21-5 ExactSizeConsiderFunction
  
  ExactSizeConsiderFunction( size )  function
  
  This function returns a function consider of five arguments that can be used
  in  SubgroupsSolvableGroup  (39.21-3)  for  the  option  consider to compute
  subgroups whose sizes are exactly size.
  
    Example  
    gap> l:=SubgroupsSolvableGroup(g,rec(actions:=[hom],
    > consider:=ExactSizeConsiderFunction(6)));;
    gap> SortedList(List(l,Size));
    [ 1, 3, 6, 9, 27, 54, 108, 216 ]
  
  
  Again,  the  consider  function  does  not  provide  a perfect filter. It is
  guaranteed that all subgroups fulfilling the condition are returned, but not
  all subgroups returned necessarily fulfill the condition.
  
  39.21-6 InfoPcSubgroup
  
  InfoPcSubgroup  info class
  
  Information function for the subgroup lattice functions using pcgs.
  
  
  39.22 Special Generating Sets
  
  39.22-1 GeneratorsSmallest
  
  GeneratorsSmallest( G )  attribute
  
  returns   a   smallest   generating  set  for  the  group  G.  This  is  the
  lexicographically  (using  GAPs  order of group elements) smallest list l of
  elements  of  G  such that G = ⟨ l ⟩ and l_i not ∈ ⟨ l_1, ..., l_{i-1} ⟩ (in
  particular  l_1 is not the identity element of the group). The comparison of
  two groups via lexicographic comparison of their sorted element lists yields
  the  same  relation as lexicographic comparison of their smallest generating
  sets.
  
    Example  
    gap> g:=SymmetricGroup(4);;
    gap> GeneratorsSmallest(g);
    [ (3,4), (2,3), (1,2) ]
  
  
  39.22-2 LargestElementGroup
  
  LargestElementGroup( G )  attribute
  
  returns  the  largest  element  of  G  with respect to the ordering < of the
  elements family.
  
  39.22-3 MinimalGeneratingSet
  
  MinimalGeneratingSet( G )  attribute
  
  returns a generating set of G of minimal possible length.
  
  Note  that  –apart  from  special  cases– currently there are only efficient
  methods  known  to compute minimal generating sets of finite solvable groups
  and  of finitely generated nilpotent groups. Hence so far these are the only
  cases  for  which  methods  are  available.  The former case is covered by a
  method  implemented  in  the GAP library, while the second case requires the
  package Polycyclic.
  
  If  you  do not really need a minimal generating set, but are satisfied with
  getting   a   reasonably   small   set   of   generators,   you  better  use
  SmallGeneratingSet (39.22-4).
  
  Information about the minimal generating sets of the finite simple groups of
  order less than 10^6 can be found in [MY79]. See also the package AtlasRep.
  
    Example  
    gap> MinimalGeneratingSet(g);
    [ (2,4,3), (1,4,2,3) ]
  
  
  39.22-4 SmallGeneratingSet
  
  SmallGeneratingSet( G )  attribute
  
  returns   a  generating  set  of  G  which  has  few  elements.  As  neither
  irredundancy,  nor  minimal  length  is  proven  it  runs  much  faster than
  MinimalGeneratingSet  (39.22-3).  It can be used whenever a short generating
  set is desired which not necessarily needs to be optimal.
  
    Example  
    gap> SmallGeneratingSet(g);
    [ (1,2,3,4), (1,2) ]
  
  
  39.22-5 IndependentGeneratorsOfAbelianGroup
  
  IndependentGeneratorsOfAbelianGroup( A )  attribute
  
  returns  a list of generators a_1, a_2, ... of prime power order or infinite
  order of the abelian group A such that A is the direct product of the cyclic
  groups  generated  by the a_i. The list of orders of the returned generators
  must  match  the  result of AbelianInvariants (39.16-1) (taking into account
  that zero and infinity (18.2-1) are identified).
  
    Example  
    gap> g:=AbelianGroup(IsPermGroup,[15,14,22,78]);;
    gap> List(IndependentGeneratorsOfAbelianGroup(g),Order);
    [ 2, 2, 2, 3, 3, 5, 7, 11, 13 ]
    gap> AbelianInvariants(g);
    [ 2, 2, 2, 3, 3, 5, 7, 11, 13 ]
  
  
  39.22-6 IndependentGeneratorExponents
  
  IndependentGeneratorExponents( G, g )  operation
  
  For  an  abelian group G, with IndependentGeneratorsOfAbelianGroup (39.22-5)
  value the list [ a_1, ..., a_n ], this operation returns the exponent vector
  [ e_1, ..., e_n ] to represent g = ∏_i a_i^{e_i}.
  
    Example  
    gap> g := AbelianGroup([16,9,625]);;
    gap> gens := IndependentGeneratorsOfAbelianGroup(g);;
    gap> List(gens, Order);
    [ 9, 16, 625 ]
    gap> AbelianInvariants(g);
    [ 9, 16, 625 ]
    gap> r:=gens[1]^4*gens[2]^12*gens[3]^128;;
    gap> IndependentGeneratorExponents(g,r);
    [ 4, 12, 128 ]
  
  
  
  39.23 1-Cohomology
  
  Let  G be a finite group and M an elementary abelian normal p-subgroup of G.
  Then the group of 1-cocycles Z^1( G/M, M ) is defined as
  
  
  Z^1(G/M, M) = { γ: G/M → M ∣ ∀ g_1, g_2 ∈ G : γ(g_1 M ⋅ g_2 M ) = γ(g_1 M)^{g_2} ⋅ γ(g_2 M) }
  
  and is a GF(p)-vector space.
  
  The group of 1-coboundaries B^1( G/M, M ) is defined as
  
  
  B^1(G/M, M) = { γ : G/M → M ∣ ∃ m ∈ M ∀ g ∈ G : γ(gM) = (m^{-1})^g ⋅ m }
  
  It also is a GF(p)-vector space.
  
  Let  α  be the isomorphism of M into a row vector space cal W and (g_1, ...,
  g_l)  representatives  for  a  generating  set  of  G/M. Then there exists a
  monomorphism β of Z^1( G/M, M ) in the l-fold direct sum of cal W, such that
  β( γ ) = ( α( γ(g_1 M) ),..., α( γ(g_l M) ) ) for every γ ∈ Z^1( G/M, M ).
  
  
  39.23-1 OneCocycles
  
  OneCocycles( G, M )  function
  OneCocycles( G, mpcgs )  function
  OneCocycles( gens, M )  function
  OneCocycles( gens, mpcgs )  function
  
  Computes  the  group  of 1-cocycles Z^1(G/M,M). The normal subgroup M may be
  given  by  a  (Modulo)Pcgs  mpcgs.  In  this  case  the whole calculation is
  performed      modulo      the      normal      subgroup      defined     by
  DenominatorOfModuloPcgs(mpcgs) (see 45.1). Similarly the group G may instead
  be  specified  by  a  set  of  elements  gens that are representatives for a
  generating  system  for the factor group G/M. If this is done the 1-cocycles
  are computed with respect to these generators (otherwise the routines try to
  select  suitable  generators  themselves).  The  current version of the code
  assumes that G is a permutation group or a pc group.
  
  39.23-2 OneCoboundaries
  
  OneCoboundaries( G, M )  function
  
  computes  the  group of 1-coboundaries. Syntax of input and output otherwise
  is  the same as with OneCocycles (39.23-1) except that entries that refer to
  cocycles are not computed.
  
  The  operations  OneCocycles  (39.23-1)  and OneCoboundaries return a record
  with (at least) the components:
  
  generators
        Is a list of representatives for a generating set of G/M. Cocycles are
        represented with respect to these generators.
  
  oneCocycles
        A  space  of row vectors over GF(p), representing Z^1. The vectors are
        represented in dimension a ⋅ b where a is the length of generators and
        p^b the size of M.
  
  oneCoboundaries
        A space of row vectors that represents B^1.
  
  cocycleToList
        is  a function to convert a cocycle (a row vector in oneCocycles) to a
        corresponding list of elements of M.
  
  listToCocycle
        is a function to convert a list of elements of M to a cocycle.
  
  isSplitExtension
        indicates  whether  G splits over M. The following components are only
        bound  if  the  extension  splits. Note that if M is given by a modulo
        pcgs  all  subgroups  are  given  as  subgroups  of  G  by  generators
        corresponding  to  generators and thus may not contain the denominator
        of  the  modulo  pcgs.  In  this  case  taking  the  closure with this
        denominator  will  give  the  full  preimage  of the complement in the
        factor group.
  
  complement
        One complement to M in G.
  
  cocycleToComplement( cyc )
        is  a  function  that takes a cocycle from oneCocycles and returns the
        corresponding  complement  to  M  in  G  (with  respect  to  the fixed
        complement complement).
  
  complementToCocycle(U)
        is  a  function  that takes a complement and returns the corresponding
        cocycle.
  
  If  the factor G/M is given by a (modulo) pcgs gens then special methods are
  used that compute a presentation for the factor implicitly from the pcgs.
  
  Note  that the groups of 1-cocycles and 1-coboundaries are not groups in the
  sense of Group (39.2-1) for GAP but vector spaces.
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2));;
    gap> n:=Group((1,2)(3,4),(1,3)(2,4));;
    gap> oc:=OneCocycles(g,n);
    rec( cocycleToComplement := function( c ) ... end, 
      cocycleToList := function( c ) ... end, 
      complement := Group([ (3,4), (2,4,3) ]), 
      complementGens := [ (3,4), (2,4,3) ], 
      complementToCocycle := function( K ) ... end, 
      factorGens := [ (3,4), (2,4,3) ], generators := [ (3,4), (2,4,3) ], 
      isSplitExtension := true, listToCocycle := function( L ) ... end, 
      oneCoboundaries := <vector space over GF(2), with 2 generators>, 
      oneCocycles := <vector space over GF(2), with 2 generators> )
    gap> oc.cocycleToList([ 0*Z(2), Z(2)^0, 0*Z(2), Z(2)^0 ]);
    [ (1,2)(3,4), (1,2)(3,4) ]
    gap> oc.listToCocycle([(),(1,3)(2,4)]) = Z(2) * [ 0, 0, 1, 0];
    true
    gap> oc.cocycleToComplement([ 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2) ]);
    Group([ (3,4), (1,3,4) ])
    gap> oc.complementToCocycle(Group((1,2,4),(1,4))) = Z(2) * [ 0, 1, 1, 1 ];
    true
  
  
  The factor group H^1(G/M, M) = Z^1(G/M, M) / B^1(G/M, M) is called the first
  cohomology  group.  Currently there is no function which explicitly computes
  this  group. The easiest way to represent it is as a vector space complement
  to B^1 in Z^1.
  
  If  the  only  purpose  of  the  calculation  of H^1 is the determination of
  complements it might be desirable to stop calculations once it is known that
  the  extension  cannot  split.  This  can be achieved via the more technical
  function OCOneCocycles (39.23-3).
  
  39.23-3 OCOneCocycles
  
  OCOneCocycles( ocr, onlySplit )  function
  
  is  the more technical function to compute 1-cocycles. It takes a record ocr
  as  first  argument which must contain at least the components group for the
  group  and  modulePcgs  for  a (modulo) pcgs of the module. This record will
  also  be  returned  with components as described under OneCocycles (39.23-1)
  (with  the exception of isSplitExtension which is indicated by the existence
  of  a  complement)  but  components  such  as  oneCoboundaries  will only be
  computed if not already present.
  
  If onlySplit is true, OCOneCocycles returns false as soon as possible if the
  extension does not split.
  
  39.23-4 ComplementClassesRepresentativesEA
  
  ComplementClassesRepresentativesEA( G, N )  function
  
  computes  complement  classes to an elementary abelian normal subgroup N via
  1-Cohomology.      Normally,      a     user     program     should     call
  ComplementClassesRepresentatives  (39.11-6)  instead, which also works for a
  solvable (not necessarily elementary abelian) N.
  
  39.23-5 InfoCoh
  
  InfoCoh  info class
  
  The info class for the cohomology calculations is InfoCoh.
  
  
  39.24 Schur Covers and Multipliers
  
  Additional  attributes  and  properties  of  a  group  can  be  derived from
  computing  its Schur cover. For example, if G is a finitely presented group,
  the  derived  subgroup  of a Schur cover of G is invariant and isomorphic to
  the NonabelianExteriorSquare (39.24-5) value of G, see [BJR87].
  
  39.24-1 EpimorphismSchurCover
  
  EpimorphismSchurCover( G[, pl] )  attribute
  
  returns  an  epimorphism  epi  from a group D onto G. The group D is one (of
  possibly  several)  Schur  covers  of  G. The group D can be obtained as the
  Source  (32.3-8)  value of epi. The kernel of epi is the Schur multiplier of
  G.  If  pl  is given as a list of primes, only the multiplier part for these
  primes  is realized. At the moment, D is represented as a finitely presented
  group.
  
  39.24-2 SchurCover
  
  SchurCover( G )  attribute
  
  returns one (of possibly several) Schur covers of the group G.
  
  At  the  moment  this cover is represented as a finitely presented group and
  IsomorphismPermGroup (43.3-1) would be needed to convert it to a permutation
  group.
  
  If  also the relation to G is needed, EpimorphismSchurCover (39.24-1) should
  be used.
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2));;
    gap> epi:=EpimorphismSchurCover(g);
    [ F1, F2, F3 ] -> [ (1,2), (2,3), (3,4) ]
    gap> Size(Source(epi));
    48
    gap> f:=FreeGroup("a","b");;
    gap> g:=f/ParseRelators(f,"a2,b3,(ab)5");;
    gap> epi:=EpimorphismSchurCover(g);
    [ a, b ] -> [ a, b ]
    gap> Size(Kernel(epi));
    2
  
  
  If   the  group  becomes  bigger,  Schur  Cover  calculations  might  become
  unfeasible.
  
  There  is  another  operation,  AbelianInvariantsMultiplier (39.24-3), which
  only  returns  the  structure of the Schur Multiplier, and which should work
  for larger groups as well.
  
  39.24-3 AbelianInvariantsMultiplier
  
  AbelianInvariantsMultiplier( G )  attribute
  
  returns a list of the abelian invariants of the Schur multiplier of G.
  
  At  the  moment,  this  operation will not give any information about how to
  extend the multiplier to a Schur Cover.
  
    Example  
    gap> AbelianInvariantsMultiplier(g);
    [ 2 ]
    gap> AbelianInvariantsMultiplier(AlternatingGroup(6));
    [ 2, 3 ]
    gap> AbelianInvariantsMultiplier(SL(2,3));
    [  ]
    gap> AbelianInvariantsMultiplier(SL(3,2));
    [ 2 ]
    gap> AbelianInvariantsMultiplier(PSU(4,2));
    [ 2 ]
  
  
  (Note that the last command from the example will take some time.)
  
  The  GAP 4.4.12  manual  contained  examples  for  larger  groups e.g. M_22.
  However, some issues that may very rarely (and not easily reproducibly) lead
  to  wrong  results  were  discovered  in the code capable of handling larger
  groups,  and  in GAP 4.5 it was replaced by a more reliable basic method. To
  deal   with   larger  groups,  one  can  use  the  function  SchurMultiplier
  (SchurMultiplier???) from the cohomolo package. Also, additional methods for
  AbelianInvariantsMultiplier  are  installed  in  the  Polycyclic package for
  pcp-groups.
  
  39.24-4 Epicentre
  
  Epicentre( G )  attribute
  ExteriorCentre( G )  attribute
  
  There  are  various ways of describing the epicentre of a group G. It is the
  smallest  normal  subgroup  N  of G such that G/N is a central quotient of a
  group. It is also equal to the Exterior Center of G, see [Ell98].
  
  39.24-5 NonabelianExteriorSquare
  
  NonabelianExteriorSquare( G )  operation
  
  Computes  the  nonabelian  exterior square G ∧ G of the group G, which for a
  finitely  presented  group  is  the derived subgroup of any Schur cover of G
  (see [BJR87]).
  
  39.24-6 EpimorphismNonabelianExteriorSquare
  
  EpimorphismNonabelianExteriorSquare( G )  operation
  
  Computes  the  mapping G ∧ G → G. The kernel of this mapping is equal to the
  Schur multiplier of G.
  
  39.24-7 IsCentralFactor
  
  IsCentralFactor( G )  property
  
  This function determines if there exists a group H such that G is isomorphic
  to  the  quotient H/Z(H). A group with this property is called in literature
  capable.  A  group  being  capable is equivalent to the epicentre of G being
  trivial, see [BFS79].
  
  
  39.24-8 Covering groups of symmetric groups
  
  The  covering  groups  of  symmetric  groups  were classified in [Sch11]; an
  inductive  procedure  to  construct faithful, irreducible representations of
  minimal  degree  over  all  fields  was  presented  in  [Maa10]. Methods for
  EpimorphismSchurCover  (39.24-1)  are  provided for natural symmetric groups
  which  use these representations. For alternating groups, the restriction of
  these  representations are provided, but they may not be irreducible. In the
  case  of degree 6 and 7, they are not the full covering groups and so matrix
  representations are just stored explicitly for the six-fold covers.
  
    Example  
    gap> EpimorphismSchurCover(SymmetricGroup(15));
    [ < immutable compressed matrix 64x64 over GF(9) >, 
      < immutable compressed matrix 64x64 over GF(9) > ] -> 
    [ (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15), (1,2) ]
    gap> EpimorphismSchurCover(AlternatingGroup(15));
    [ < immutable compressed matrix 64x64 over GF(9) >, 
      < immutable compressed matrix 64x64 over GF(9) > ] -> 
    [ (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15), (13,14,15) ]
    gap> SchurCoverOfSymmetricGroup(12);
    <matrix group of size 958003200 with 2 generators>
    gap> DoubleCoverOfAlternatingGroup(12);
    <matrix group of size 479001600 with 2 generators>
    gap> BasicSpinRepresentationOfSymmetricGroup( 10, 3, -1 );
    [ < immutable compressed matrix 16x16 over GF(9) >, 
      < immutable compressed matrix 16x16 over GF(9) >, 
      < immutable compressed matrix 16x16 over GF(9) >, 
      < immutable compressed matrix 16x16 over GF(9) >, 
      < immutable compressed matrix 16x16 over GF(9) >, 
      < immutable compressed matrix 16x16 over GF(9) >, 
      < immutable compressed matrix 16x16 over GF(9) >, 
      < immutable compressed matrix 16x16 over GF(9) >, 
      < immutable compressed matrix 16x16 over GF(9) > ]
  
  
  39.24-9 BasicSpinRepresentationOfSymmetricGroup
  
  BasicSpinRepresentationOfSymmetricGroup( n, p, sign )  function
  
  Constructs   the   image  of  the  Coxeter  generators  in  the  basic  spin
  (projective)  representation of the symmetric group of degree n over a field
  of  characteristic  p  ≥  0.  There  are  two  such representations and sign
  controls  which  is  returned:  +1  gives  a  group where the preimage of an
  adjacent  transposition  (i,i+1)  has  order  4,  -1 gives a group where the
  preimage  of  an  adjacent  transposition (i,i+1) has order 2. If no sign is
  specified,  +1  is  used  by  default.  If  no  p is specified, 3 is used by
  default.  (Note  that  the  convention  of  which cover is labelled as +1 is
  inconsistent in the literature.)
  
  39.24-10 SchurCoverOfSymmetricGroup
  
  SchurCoverOfSymmetricGroup( n, p, sign )  operation
  
  Constructs  a  Schur  cover  of SymmetricGroup(n) as a faithful, irreducible
  matrix  group  in  characteristic  p  (p ≠ 2). For n ≥ 4, there are two such
  covers,  and  sign  determines which is returned: +1 gives a group where the
  preimage  of an adjacent transposition (i,i+1) has order 4, -1 gives a group
  where  the  preimage of an adjacent transposition (i,i+1) has order 2. If no
  sign is specified, +1 is used by default. If no p is specified, 3 is used by
  default.  (Note  that  the  convention  of  which cover is labelled as +1 is
  inconsistent  in  the literature.) For n ≤ 3, the symmetric group is its own
  Schur  cover  and  sign  is  ignored.  For  p  =  2,  there  is no faithful,
  irreducible representation of the Schur cover unless n = 1 or n = 3, so fail
  is  returned  if  p  =  2.  For  p  =  3,  n  =  3,  the  representation  is
  indecomposable,  but  reducible.  The field of the matrix group is generally
  GF(p^2) if p > 0, and an abelian number field if p = 0.
  
  39.24-11 DoubleCoverOfAlternatingGroup
  
  DoubleCoverOfAlternatingGroup( n, p )  operation
  
  Constructs  a  double cover of AlternatingGroup(n) as a faithful, completely
  reducible matrix group in characteristic p (p ≠ 2) for n ≥ 4. For n ≤ 3, the
  alternating  group  is its own Schur cover, and fail is returned. For p = 2,
  there  is  no  faithful,  completely  reducible representation of the double
  cover,  so  fail  is  returned.  The  field of the matrix group is generally
  GF(p^2)  if  p>0,  and  an abelian number field if p=0. If p is omitted, the
  default is 3.
  
  
  39.25 2-Cohomology
  
  39.25-1 TwoCohomologyGeneric
  
  TwoCohomologyGeneric( G, M )  operation
  
  This  function  computes the second cohomology group for an arbitrary finite
  group G. The generators of the module M must correspond to the generators of
  G. It returns a record with components coboundaries, cocycles and cohomology
  which  are  lists  of  vectors  that  form  a basis of the respective group.
  cohomology  is  chosen  as  a vector space complement to coboundaries in the
  cocycles.  These  vectors  are  representing  tails in M with respect to the
  relators of the presentation presentation of G. (Note that this presentation
  is  on  a  generating  set  chosen  by  the  routine, this generating system
  corresponds  to  the components group and module of the record returned. The
  extension   corresponding   to   a   cocyle   c   can   be   constructed  as
  FpGroupCocycle(r,c) where r is the cohomology record. This is currently done
  as a finitely presented group.
  
    Example  
    gap> g:=Group((1,2,3,4,5),(1,2,3));;
    gap> mats:=[[[2,0,0,1],[1,2,1,0],[2,1,1,1],[2,1,1,0]],
    > [[0,2,0,0],[1,2,1,0],[0,0,1,0],[0,0,0,1]]]*Z(3)^0;;
    gap> mo:=GModuleByMats(mats,GF(3));;
    gap> coh:=TwoCohomologyGeneric(g,mo);;
    gap> coh.cocycles;
    < immutable compressed matrix 8x44 over GF(3) >
    gap> coh.coboundaries;
    [ < immutable compressed vector length 44 over GF(3) >,
      < immutable compressed vector length 44 over GF(3) >,
      < immutable compressed vector length 44 over GF(3) >,
      < immutable compressed vector length 44 over GF(3) >,
      < immutable compressed vector length 44 over GF(3) >,
      < immutable compressed vector length 44 over GF(3) >,
      < immutable compressed vector length 44 over GF(3) > ]
    gap> coh.cohomology;
    [ < immutable compressed vector length 44 over GF(3) > ]
    gap> g1:=FpGroupCocycle(coh,coh.zero,true);
    <fp group of size 4860 on the generators [ F1, F2, F3, m1, m2, m3, m4 ]>
    gap> g2:=FpGroupCocycle(coh,coh.cohomology[1],true);
    <fp group of size 4860 on the generators [ F1, F2, F3, m1, m2, m3, m4 ]>
    gap> g1:=Image(IsomorphismPermGroup(g1));
    <permutation group with 7 generators>
    gap> Length(ComplementClassesRepresentatives(g1,SolvableRadical(g1)));
    3
    gap> g2:=Image(IsomorphismPermGroup(g2));
    <permutation group with 7 generators>
    gap> Length(ComplementClassesRepresentatives(g2,SolvableRadical(g2)));
    0
  
  
  39.25-2 FpGroupCocycle
  
  FpGroupCocycle( r, c[, doperm] )  function
  
  For  a record r as returned by TwoCohomologyGeneric (39.25-1) and a vector c
  in  the  space  of two-cocycles, this operation returns a finitely presented
  group that is an extension corresponding to the cocycle c. If the underlying
  module  has dimension d, the last d generators generate the normal subgroup.
  If  the  optional  parameter doperm is given as true, a faithful permutation
  representation  is computed and stored in the attribute IsomorphismPermGroup
  (43.3-1)  of  the computed group. If the option normalform is given as true,
  arithmetic  in  the resulting finitely presented group will bring words into
  normal form.
  
    Example  
    gap> g:=Group((2,15,8,16)(3,17,14,21)(4,23,20,6)(5,9,22,11)(7,13,19,25),
    > (2,12,7,17)(3,18,13,23)(4,24,19,9)(5,10,25,15)(6,11,16,21));;
    gap> StructureDescription(g);
    "GL(2,5)"
    gap> mats:=[[[1,1,0,2],[2,0,0,0],[0,2,2,0],[0,1,0,0]],
    > [[0,0,0,1],[1,1,2,0],[1,0,2,1],[1,0,1,0]]]*Z(3)^0;;
    gap> mo:=GModuleByMats(mats,GF(3));;
    gap> coh:=TwoCohomologyGeneric(g,mo);;
    gap> coh.cohomology;
    [ < immutable compressed vector length 116 over GF(3) > ]
    gap> p:=FpGroupCocycle(coh,coh.zero,true);
    <fp group of size 38880 on the generators
    [ F1, F2, F3, F4, F5, F6, m1, m2, m3, m4 ]>
    gap> g1:=Image(IsomorphismPermGroup(p));
    <permutation group with 10 generators>
    gap> p:=FpGroupCocycle(coh,coh.cohomology[1],true);
    <fp group of size 38880 on the generators
    [ F1, F2, F3, F4, F5, F6, m1, m2, m3, m4 ]>
    gap> g2:=Image(IsomorphismPermGroup(p));
    <permutation group with 10 generators>
    gap> Collected(List(MaximalSubgroupClassReps(g1),Size));
    [ [ 480, 3 ], [ 3888, 1 ], [ 6480, 1 ], [ 7776, 1 ], [ 19440, 1 ] ]
    gap> Collected(List(MaximalSubgroupClassReps(g2),Size));
    [ [ 3888, 1 ], [ 6480, 1 ], [ 7776, 1 ], [ 19440, 1 ] ]
    gap> p:=FpGroupCocycle(coh,coh.cohomology[1],true:normalform);;
  
  
    Example  
    gap> p.7*p.1; # i.e. m1*F1, but in normal form
    F1*m4
  
  
  Also see Section 46.8 for operations and methods specific for Pc groups.
  
  
  39.26 Tests for the Availability of Methods
  
  The  following filters and operations indicate capabilities of GAP. They can
  be  used  in  the  method  selection  or  algorithms  to check whether it is
  feasible  to  compute certain operations for a given group. In general, they
  return true if good algorithms for the given arguments are available in GAP.
  An  answer  false indicates that no method for this group may exist, or that
  the existing methods might run into problems.
  
  Typical  examples  when this might happen is with finitely presented groups,
  for  which  many  of  the  methods  cannot  be  guaranteed to succeed in all
  situations.
  
  The  willingness  of GAP to perform certain operations may change, depending
  on  which  further  information  is known about the arguments. Therefore the
  filters  used  are  not  implemented  as  properties  but  as  other filters
  (see 13.7 and 13.8).
  
  39.26-1 CanEasilyTestMembership
  
  CanEasilyTestMembership( G )  filter
  
  This  filter  indicates  whether  GAP can test membership of elements in the
  group  G  (via the operation \in (30.6-1)) in reasonable time. It is used by
  the  method  selection  to  decide  whether  an  algorithm  that  relies  on
  membership tests may be used.
  
  39.26-2 CanEasilyComputeWithIndependentGensAbelianGroup
  
  CanEasilyComputeWithIndependentGensAbelianGroup( G )  filter
  
  This filter indicates whether GAP can in reasonable time compute independent
  abelian  generators  of the group G (via IndependentGeneratorsOfAbelianGroup
  (39.22-5))  and  then can decompose arbitrary group elements with respect to
  these  generators  using IndependentGeneratorExponents (39.22-6). It is used
  by  the method selection to decide whether an algorithm that relies on these
  two operations may be used.
  
  39.26-3 CanComputeSize
  
  CanComputeSize( dom )  filter
  
  This  filter  indicates  that we know that the size of the domain dom (which
  might  be  infinity  (18.2-1)) can be computed reasonably easily. It doesn't
  imply as quick a computation as HasSize would but its absence does not imply
  that the size cannot be computed.
  
  39.26-4 CanComputeSizeAnySubgroup
  
  CanComputeSizeAnySubgroup( G )  filter
  
  This  filter  indicates  whether  GAP  can  easily  compute  the size of any
  subgroup  of  the group G. (This is for example advantageous if one can test
  that  a  stabilizer  index equals the length of the orbit computed so far to
  stop early.)
  
  39.26-5 CanComputeIndex
  
  CanComputeIndex( G, H )  operation
  
  This  function  indicates  whether  the index [G:H] (which might be infinity
  (18.2-1))  can  be  computed.  It assumes that H ≤ G (see CanComputeIsSubset
  (39.26-6)).
  
  39.26-6 CanComputeIsSubset
  
  CanComputeIsSubset( A, B )  operation
  
  This filter indicates that GAP can test (via IsSubset (30.5-1)) whether B is
  a subset of A.
  
  39.26-7 KnowsHowToDecompose
  
  KnowsHowToDecompose( G[, gens] )  property
  
  Tests  whether the group G can decompose elements in the generators gens. If
  gens is not given it tests, whether it can decompose in the generators given
  in the GeneratorsOfGroup (39.2-4) value of G.
  
  This  property can be used for example to check whether a group homomorphism
  by images (see GroupHomomorphismByImages (40.1-1)) can be reasonably defined
  from this group.
  
  
  39.27 Specific functions for Normalizer calculation
  
  39.27-1 NormalizerViaRadical
  
  NormalizerViaRadical( G, S )  function
  
  This    function   implements   a   particular   approach,   following   the
  SolvableRadical  paradigm, for calculating the normalizer of a subgroup S in
  G.  It  is  at  the  moment provided only as a separate function, and not as
  method  for  the  operation Normalizer, as it can often be slower than other
  built-in   routines.   In  certain  hard  cases  (non-solvable  groups  with
  nontrivial  radical), however its performance is substantially superior. The
  function thus is provided as a non-automated tool for advanced users.
  
    Example  
    gap> g:=TransitiveGroup(30,2030);;
    gap> s:=SylowSubgroup(g,5);;
    gap> Size(NormalizerViaRadical(g,s));
    28800
  
  
  Note  that  this  example  only demonstrates usage, but that in this case in
  fact the ordinary Normalizer routine performs faster.