Welcome To Our Shell

Mister Spy & Souheyl Bypass Shell

  
  46 Pc Groups
  
  Pc  groups  are  polycyclic  groups that use the polycyclic presentation for
  element  arithmetic.  This  presentation  gives  them  a  natural  pcgs, the
  FamilyPcgs  (46.1-1)  with  respect to which pcgs operations as described in
  chapter 45 are particularly efficient.
  
  Let  G be a polycyclic group with pcgs P = (g_1, ..., g_n) and corresponding
  relative  orders  (r_1, ..., r_n). Recall that the r_i are positive integers
  or  infinity  and let I be the set of indices i with r_i a positive integer.
  Then  G  has  a  finite  presentation  on  the generators g_1, ..., g_n with
  relations of the following form.
  
        g_i^{r_i}          =   g_{i+1}^a(i,i,i+1) ⋯ g_n^a(i,i,n)   
                               for 1 ≤ i ≤ n and i ∈ I             
        g_i^{-1} g_j g_i   =   g_{i+1}^a(i,j,i+1) ⋯ g_n^a(i,j,n)   
                               for 1 ≤ i < j ≤ n                   
  
  For infinite groups we need additionally
  
        g_i^{-1} g_j^{-1} g_i   =   g_{i+1}^b(i,j,i+1) ⋯ g_n^b(i,j,n)     
                                    for 1 ≤ i < j ≤ n and j not ∈ I       
        g_i g_j g_i^{-1}        =   g_{i+1}^c(i,j,i+1) ⋯ g_n^c(i,j,n)     
                                    for 1 ≤ i < j ≤ n and i not ∈ I       
        g_i g_j^{-1} g_i^{-1}   =   g_{i+1}^d(i,j,i+1) ⋯ g_n^d(i,j,n)     
                                    for 1 ≤ i < j ≤ n and i, j, not ∈ I   
  
  Here  the  right hand sides are assumed to be words in normal form; that is,
  for  k  ∈  I  we  have  for  all exponents 0 ≤ a(i,j,k), b(i,j,k), c(i,j,k),
  d(i,j,k) < r_k.
  
  A  finite presentation of this type is called a power-conjugate presentation
  and  a  pc  group  is  a  polycyclic  group  defined  by  a  power-conjugate
  presentation.  Instead  of  conjugates  we  could  just  as  well  work with
  commutators  and  then  the  presentation would be called a power-commutator
  presentation. Both types of presentation are abbreviated as pc presentation.
  Note that a pc presentation is a rewriting system.
  
  Clearly, whenever a group G with pcgs P is given, then we can write down the
  corresponding  pc presentation. On the other hand, one may just write down a
  presentation  on  n  abstract generators g_1, ..., g_n with relations of the
  above  form  and  define  a group H by this. Then the subgroups C_i = ⟨ g_i,
  ..., g_n ⟩ of H form a subnormal series whose factors are cyclic or trivial.
  In  the  case  that  all  factors  are  non-trivial,  we  say  that  the  pc
  presentation of H is confluent. Note that GAP 4 can only work correctly with
  pc groups defined by a confluent pc presentation.
  
  At  the current state of implementations the GAP library contains methods to
  compute  with  finite polycyclic groups, while the GAP package Polycyclic by
  Bettina  Eick  and  Werner  Nickel  allows  also  computations with infinite
  polycyclic groups which are given by a pc-presentation.
  
  Algorithms  for pc groups use the methods for polycyclic groups described in
  chapter 45.
  
  
  46.1 The family pcgs
  
  Clearly,  the  generators  of a power-conjugate presentation of a pc group G
  form a pcgs of the pc group. This pcgs is called the family pcgs.
  
  46.1-1 FamilyPcgs
  
  FamilyPcgs( grp )  attribute
  
  returns  a  natural  pcgs  of  a  pc  group  grp (with respect to which pcgs
  operations as described in Chapter 45 are particularly efficient).
  
  46.1-2 IsFamilyPcgs
  
  IsFamilyPcgs( pcgs )  property
  
  specifies whether the pcgs is a FamilyPcgs (46.1-1) of a pc group.
  
  46.1-3 InducedPcgsWrtFamilyPcgs
  
  InducedPcgsWrtFamilyPcgs( grp )  attribute
  
  returns  the  pcgs  which  induced  with  respect  to  a  family  pcgs  (see
  IsParentPcgsFamilyPcgs (46.1-4) for further details).
  
  46.1-4 IsParentPcgsFamilyPcgs
  
  IsParentPcgsFamilyPcgs( pcgs )  property
  
  This  property  indicates  that  the  pcgs pcgs is induced with respect to a
  family pcgs.
  
  This  property  is  needed  to  distinguish  between  different  independent
  polycyclic  generating  sequences  which  a  pc  group  may  have, since the
  elementary  operations  for a non-family pcgs may not be as efficient as the
  elementary operations for the family pcgs.
  
  This  can  have a significant influence on the performance of algorithms for
  polycyclic  groups.  Many  algorithms  require a pcgs that corresponds to an
  elementary  abelian  series  (see PcgsElementaryAbelianSeries  (45.11-2)) or
  even  a  special  pcgs  (see 45.13).  If  the  family  pcgs has the required
  properties,  it will be used for these purposes, if not GAP has to work with
  respect to a new pcgs which is not the family pcgs and thus takes longer for
  elementary calculations like ExponentsOfPcElement (45.5-3).
  
  Therefore,  if the family pcgs chosen for arithmetic is not of importance it
  might  be  worth to change to another, nicer, pcgs to speed up calculations.
  This  can be achieved, for example, by using the Range (32.3-7) value of the
  isomorphism obtained by IsomorphismSpecialPcGroup (46.5-3).
  
  
  46.2 Elements of pc groups
  
  
  46.2-1 Comparison of elements of pc groups
  
  \=( pcword1, pcword2 )  method
  \<( pcword1, pcword2 )  method
  
  The  elements of a pc group G are always represented as words in normal form
  with  respect to the family pcgs of G. Thus it is straightforward to compare
  elements  of  a  pc  group,  since  this  boils down to a mere comparison of
  exponent  vectors  with  respect to the family pcgs. In particular, the word
  problem is efficiently solvable in pc groups.
  
  
  46.2-2 Arithmetic operations for elements of pc groups
  
  \*( pcword1, pcword2 )  method
  Inverse( pcword )  attribute
  
  However,  multiplication  and  inversion  of elements in pc groups is not as
  straightforward  as  in  arbitrary  finitely presented groups where a simple
  concatenation or reversion of the corresponding words is sufficient (but one
  cannot solve the word problem).
  
  To   multiply  two  elements  in  a  pc  group,  we  first  concatenate  the
  corresponding words and then use an algorithm called collection to transform
  the new word into a word in normal form.
  
    Example  
    gap> g := FamilyPcgs( SmallGroup( 24, 12 ) );
    Pcgs([ f1, f2, f3, f4 ])
    gap> g[4] * g[1];
    f1*f3
    gap> (g[2] * g[3])^-1;
    f2^2*f3*f4
  
  
  
  46.3 Pc groups versus fp groups
  
  In  theory  pc  groups  are  finitely  presented  groups.  In  practice  the
  arithmetic  in pc groups is different from the arithmetic in fp groups. Thus
  for  technical reasons the pc groups in GAP do not form a subcategory of the
  fp groups and hence the methods for fp groups cannot be applied to pc groups
  in general.
  
  46.3-1 IsPcGroup
  
  IsPcGroup( G )  Category
  
  tests whether G is a pc group.
  
    Example  
    gap> G := SmallGroup( 24, 12 );
    <pc group of size 24 with 4 generators>
    gap> IsPcGroup( G );
    true
    gap> IsFpGroup( G );
    false
  
  
  46.3-2 IsomorphismFpGroupByPcgs
  
  IsomorphismFpGroupByPcgs( pcgs, str )  function
  
  It  is  possible  to  convert  a pc group to a fp group in GAP. The function
  IsomorphismFpGroupByPcgs  computes the power-commutator presentation defined
  by  pcgs. The string str can be used to give a name to the generators of the
  fp group.
  
    Example  
    gap> p := FamilyPcgs( SmallGroup( 24, 12 ) );
    Pcgs([ f1, f2, f3, f4 ])
    gap> iso := IsomorphismFpGroupByPcgs( p, "g" );
    [ f1, f2, f3, f4 ] -> [ g1, g2, g3, g4 ]
    gap> F := Image( iso );
    <fp group of size 24 on the generators [ g1, g2, g3, g4 ]>
    gap> RelatorsOfFpGroup( F );
    [ g1^2, g2^-1*g1^-1*g2*g1*g2^-1, g3^-1*g1^-1*g3*g1*g4^-1*g3^-1, 
      g4^-1*g1^-1*g4*g1*g4^-1*g3^-1, g2^3, g3^-1*g2^-1*g3*g2*g4^-1*g3^-1, 
      g4^-1*g2^-1*g4*g2*g3^-1, g3^2, g4^-1*g3^-1*g4*g3, g4^2 ]
  
  
  
  46.4 Constructing Pc Groups
  
  If  necessary,  you can supply GAP with a pc presentation by hand. (Although
  this  is  the  most  tedious  way  to  input  a  pc group.) Note that the pc
  presentation has to be confluent in order to work with the pc group in GAP.
  
  (If  you  have  already  a  suitable  pcgs  in  another  representation, use
  PcGroupWithPcgs (46.5-1), see below.)
  
  One  way  is  to define a finitely presented group with a pc presentation in
  GAP  and  then convert this presentation into a pc group, see PcGroupFpGroup
  (46.4-1).  Note  that  this  does  not  work  for arbitrary presentations of
  polycyclic groups, see Chapter 47.14 for further information.
  
  Another  way  is  to create and manipulate a collector of a pc group by hand
  and  to  use  it to define a pc group. GAP provides different collectors for
  different  collecting strategies; at the moment, there are two collectors to
  choose  from: the single collector for finite pc groups (see SingleCollector
  (46.4-2))  and  the combinatorial collector for finite p-groups. See [Sim94]
  for further information on collecting strategies.
  
  A  collector  is  initialized with an underlying free group and the relative
  orders of the pc series. Then one adds the right hand sides of the power and
  the commutator or conjugate relations one by one. Note that omitted relators
  are assumed to be trivial.
  
  For   performance   reasons   it   is   beneficial  to  enforce  a  syllable
  representation in the free group (see 37.6).
  
  Note  that  in  the  end,  the collector has to be converted to a group, see
  GroupByRws (46.4-6).
  
  With  these  methods  a  pc  group  with  arbitrary  defining  pcgs  can  be
  constructed. However, for almost all applications within GAP we need to have
  a   pc   group   whose   defining   pcgs   is   a   prime  order  pcgs,  see
  IsomorphismRefinedPcGroup (46.4-8) and RefinedPcGroup (46.4-9).
  
  46.4-1 PcGroupFpGroup
  
  PcGroupFpGroup( G )  function
  
  creates  a pc group P from an fp group (see Chapter 47) G whose presentation
  is  polycyclic.  The  resulting  group P has generators corresponding to the
  generators  of  G.  They are printed in the same way as generators of G, but
  they  lie  in  a  different  family.  If  the  pc  presentation  of G is not
  confluent, an error message occurs.
  
    Example  
    gap> F := FreeGroup(IsSyllableWordsFamily,"a","b","c","d");;
    gap> a := F.1;; b := F.2;; c := F.3;; d := F.4;;
    gap> rels := [a^2, b^3, c^2, d^2, Comm(b,a)/b, Comm(c,a)/d, Comm(d,a),
    >             Comm(c,b)/(c*d), Comm(d,b)/c, Comm(d,c)];
    [ a^2, b^3, c^2, d^2, b^-1*a^-1*b*a*b^-1, c^-1*a^-1*c*a*d^-1, 
      d^-1*a^-1*d*a, c^-1*b^-1*c*b*d^-1*c^-1, d^-1*b^-1*d*b*c^-1, 
      d^-1*c^-1*d*c ]
    gap> G := F / rels;
    <fp group on the generators [ a, b, c, d ]>
    gap> H := PcGroupFpGroup( G );
    <pc group of size 24 with 4 generators>
  
  
  46.4-2 SingleCollector
  
  SingleCollector( fgrp, relorders )  operation
  CombinatorialCollector( fgrp, relorders )  operation
  
  initializes a single collector or a combinatorial collector, where fgrp must
  be  a  free group and relorders must be a list of the relative orders of the
  pc series.
  
  A combinatorial collector can only be set up for a finite p-group. Here, the
  relative orders relorders must all be equal and a prime.
  
  46.4-3 SetConjugate
  
  SetConjugate( coll, j, i, w )  operation
  
  Let  f_1,  ...,  f_n  be  the generators of the underlying free group of the
  collector coll.
  
  For  i  <  j, SetConjugate sets the conjugate f_j^{f_i} to equal w, which is
  assumed to be a word in f_{i+1}, ..., f_n.
  
  46.4-4 SetCommutator
  
  SetCommutator( coll, j, i, w )  operation
  
  Let  f_1,  ...,  f_n  be  the generators of the underlying free group of the
  collector coll.
  
  For  i  <  j,  SetCommutator  sets the commutator of f_j and f_i to equal w,
  which is assumed to be a word in f_{i+1}, ..., f_n.
  
  46.4-5 SetPower
  
  SetPower( coll, i, w )  operation
  
  Let  f_1,  ...,  f_n  be  the generators of the underlying free group of the
  collector coll, and let r_i be the corresponding relative orders.
  
  SetPower  sets the power f_i^{r_i} to equal w, which is assumed to be a word
  in f_{i+1}, ..., f_n.
  
  46.4-6 GroupByRws
  
  GroupByRws( coll )  operation
  GroupByRwsNC( coll )  operation
  
  creates  a group from a rewriting system. In the first version it is checked
  whether  the  rewriting  system  is confluent, in the second version this is
  assumed to be true.
  
  46.4-7 IsConfluent
  
  IsConfluent( G )  property
  
  checks  whether  the  pc  group  G  has  been  built from a collector with a
  confluent power-commutator presentation.
  
    Example  
    gap> F := FreeGroup(IsSyllableWordsFamily, 2 );;
    gap> coll1 := SingleCollector( F, [2,3] );
    <<single collector, 8 Bits>>
    gap> SetConjugate( coll1, 2, 1, F.2 );
    gap> SetPower( coll1, 1, F.2 );
    gap> G1 := GroupByRws( coll1 );
    <pc group of size 6 with 2 generators>
    gap> IsConfluent(G1);
    true
    gap> IsAbelian(G1);
    true
    gap> coll2 := SingleCollector( F, [2,3] );
    <<single collector, 8 Bits>>
    gap> SetConjugate( coll2, 2, 1, F.2^2 );
    gap> G2 := GroupByRws( coll2 );
    <pc group of size 6 with 2 generators>
    gap> IsAbelian(G2);
    false
  
  
  46.4-8 IsomorphismRefinedPcGroup
  
  IsomorphismRefinedPcGroup( G )  attribute
  
  returns  an isomorphism from G onto an isomorphic pc group whose family pcgs
  is a prime order pcgs.
  
  46.4-9 RefinedPcGroup
  
  RefinedPcGroup( G )  attribute
  
  returns the range of the IsomorphismRefinedPcGroup (46.4-8) value of G.
  
  
  46.5 Computing Pc Groups
  
  Another  possibility  to  get  a  pc group in GAP is to convert a polycyclic
  group  given  by  some  other  representation  to  a  pc group. For finitely
  presented groups there are various quotient methods available. For all other
  types of groups one can use the following functions.
  
  46.5-1 PcGroupWithPcgs
  
  PcGroupWithPcgs( mpcgs )  attribute
  
  creates  a  new  pc  group G whose family pcgs is isomorphic to the (modulo)
  pcgs mpcgs.
  
    Example  
    gap> G := Group( (1,2,3), (3,4,1) );;
    gap> PcGroupWithPcgs( Pcgs(G) );
    <pc group of size 12 with 3 generators>
  
  
  If  a pcgs is only given by a list of pc elements, PcgsByPcSequence (45.3-1)
  can be used:
  
    Example  
    gap> G:=Group((1,2,3,4),(1,2));;
    gap> p:=PcgsByPcSequence(FamilyObj(One(G)),
    > [ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]);
    Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ])
    gap> PcGroupWithPcgs(p);
    <pc group of size 24 with 4 generators>
    gap> G := SymmetricGroup( 5 );
    Sym( [ 1 .. 5 ] )
    gap> H := Subgroup( G, [(1,2,3,4,5), (3,4,5)] );
    Group([ (1,2,3,4,5), (3,4,5) ])
    gap> modu := ModuloPcgs( G, H );
    Pcgs([ (4,5) ])
    gap> PcGroupWithPcgs(modu);
    <pc group of size 2 with 1 generators>
  
  
  46.5-2 IsomorphismPcGroup
  
  IsomorphismPcGroup( G )  attribute
  
  returns an isomorphism from G onto an isomorphic pc group. The series chosen
  for  this  pc  representation  depends  on  the  method  chosen. G must be a
  polycyclic group of any kind, for example a solvable permutation group.
  
    Example  
    gap> G := Group( (1,2,3), (3,4,1) );;
    gap> iso := IsomorphismPcGroup( G );
    Pcgs([ (2,4,3), (1,2)(3,4), (1,3)(2,4) ]) -> [ f1, f2, f3 ]
    gap> H := Image( iso );
    Group([ f1, f2, f3 ])
  
  
  46.5-3 IsomorphismSpecialPcGroup
  
  IsomorphismSpecialPcGroup( G )  attribute
  
  returns  an isomorphism from G onto an isomorphic pc group whose family pcgs
  is  a special pcgs. (This can be beneficial to the runtime of calculations.)
  G  may be a polycyclic group of any kind, for example a solvable permutation
  group.
  
  
  46.6 Saving a Pc Group
  
  As printing a polycyclic group does not display the presentation, one cannot
  simply  print  a pc group to a file to save it. For this purpose we need the
  following function.
  
  46.6-1 GapInputPcGroup
  
  GapInputPcGroup( grp, string )  function
  
    Example  
    gap> G := SmallGroup( 24, 12 );
    <pc group of size 24 with 4 generators>
    gap> PrintTo( "save", GapInputPcGroup( G, "H" ) );
    gap> Read( "save" );
    #I A group of order 24 has been defined.
    #I It is called H
    gap> H = G;
    false
    gap> IdSmallGroup( H ) = IdSmallGroup( G );
    true
    gap> RemoveFile( "save" );;
  
  
  
  46.7 Operations for Pc Groups
  
  All  the  operations  described  in  Chapters 39 and 45 apply to a pc group.
  Nearly  all  methods  for  pc  groups  are  methods  for groups with pcgs as
  described  in Chapter 45. The only method with is special for pc groups is a
  method  to compute intersections of subgroups, since here a pcgs of a parent
  group is needed and this can only by guaranteed within pc groups.
  
  
  46.8 2-Cohomology and Extensions
  
  One  of the most interesting applications of pc groups is the possibility to
  compute  with  extensions of these groups by elementary abelian groups; that
  is,  H  is  an extension of G by M, if there exists a normal subgroup N in H
  which is isomorphic to M such that H/N is isomorphic to G.
  
  Pc   groups  are  particularly  suited  for  such  applications,  since  the
  2-cohomology  can  be  computed  efficiently  for such groups and, moreover,
  extensions  of  pc groups by elementary abelian groups can be represented as
  pc groups again.
  
  To  define  the elementary abelian group M together with an action of G on M
  we   consider   M   as   a   MeatAxe  module  for  G  over  a  finite  field
  (section IrreducibleModules  (71.15-1)  describes functions that can be used
  to  obtain  certain modules). For further information on meataxe modules see
  Chapter  69.  Note  that the matrices defining the module must correspond to
  the pcgs of the group G.
  
  There  exists  an  action  of  the  subgroup of compatible pairs in Aut(G) ×
  Aut(M)  which  acts  on  the  second  cohomology  group, see CompatiblePairs
  (46.8-8).  2-cocycles  which  lie in the same orbit under this action define
  isomorphic extensions of G. However, there may be isomorphic extensions of G
  corresponding to cocycles in different orbits.
  
  See  also  the  GAP  package GrpConst by Hans Ulrich Besche and Bettina Eick
  that  contains  methods to construct up to isomorphism the groups of a given
  order.
  
  Finally  we  note  that  for  the  computation of split extensions it is not
  necessary  that M must correspond to an elementary abelian group. Here it is
  possible   to  construct  split  extensions  of  arbitrary  pc  groups,  see
  SplitExtension (46.8-6).
  
  46.8-1 TwoCoboundaries
  
  TwoCoboundaries( G, M )  operation
  
  returns  the  group of 2-coboundaries of a pc group G by the G-module M. The
  generators  of  M must correspond to the Pcgs (45.2-1) value of G. The group
  of coboundaries is given as vector space over the field underlying M.
  
  46.8-2 TwoCocycles
  
  TwoCocycles( G, M )  operation
  
  returns  the 2-cocycles of a pc group G by the G-module M. The generators of
  M  must  correspond to the Pcgs (45.2-1) value of G. The operation returns a
  list of vectors over the field underlying M and the additive group generated
  by these vectors is the group of 2-cocyles.
  
  46.8-3 TwoCohomology
  
  TwoCohomology( G, M )  operation
  
  returns a record defining the second cohomology group as factor space of the
  space of cocycles by the space of coboundaries. G must be a pc group and the
  generators of M must correspond to the pcgs of G.
  
    Example  
    gap> G := SmallGroup( 4, 2 );
    <pc group of size 4 with 2 generators>
    gap> mats := List( Pcgs( G ), x -> IdentityMat( 1, GF(2) ) );
    [ [ <a GF2 vector of length 1> ], [ <a GF2 vector of length 1> ] ]
    gap> M := GModuleByMats( mats, GF(2) );
    rec( IsOverFiniteField := true, dimension := 1, field := GF(2), 
      generators := [ <an immutable 1x1 matrix over GF2>, 
          <an immutable 1x1 matrix over GF2> ], isMTXModule := true )
    gap> TwoCoboundaries( G, M );
    [  ]
    gap> TwoCocycles( G, M );
    [ [ Z(2)^0, 0*Z(2), 0*Z(2) ], [ 0*Z(2), Z(2)^0, 0*Z(2) ], 
      [ 0*Z(2), 0*Z(2), Z(2)^0 ] ]
    gap> cc := TwoCohomology( G, M );;
    gap> cc.cohom;
    <linear mapping by matrix, <vector space of dimension 3 over GF(
    2)> -> ( GF(2)^3 )>
  
  
  46.8-4 Extensions
  
  Extensions( G, M )  operation
  
  returns  all  extensions  of  G  by  the  G-module M up to equivalence as pc
  groups.
  
  46.8-5 Extension
  
  Extension( G, M, c )  operation
  ExtensionNC( G, M, c )  operation
  
  returns the extension of G by the G-module M via the cocycle c as pc groups.
  The NC version does not check the resulting group for consistence.
  
  46.8-6 SplitExtension
  
  SplitExtension( G, M )  operation
  
  returns  the split extension of G by the G-module M. See also SplitExtension
  (46.8-10) for its 3-argument version.
  
  46.8-7 ModuleOfExtension
  
  ModuleOfExtension( E )  attribute
  
  returns  the module of an extension E of G by M. This is the normal subgroup
  of E which corresponds to M.
  
    Example  
    gap> G := SmallGroup( 4, 2 );;
    gap> mats := List( Pcgs( G ), x -> IdentityMat( 1, GF(2) ) );;
    gap> M := GModuleByMats( mats, GF(2) );;
    gap> co := TwoCocycles( G, M );;
    gap> Extension( G, M, co[2] );
    <pc group of size 8 with 3 generators>
    gap> SplitExtension( G, M );
    <pc group of size 8 with 3 generators>
    gap> Extensions( G, M );
    [ <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators> ]
    gap> List(last, IdSmallGroup);
    [ [ 8, 5 ], [ 8, 2 ], [ 8, 3 ], [ 8, 3 ], [ 8, 2 ], [ 8, 2 ], 
      [ 8, 3 ], [ 8, 4 ] ]
  
  
  Note  that the extensions returned by Extensions (46.8-4) are computed up to
  equivalence, but not up to isomorphism.
  
  46.8-8 CompatiblePairs
  
  CompatiblePairs( G, M[, D] )  function
  
  returns  the group of compatible pairs of the group G with the G-module M as
  subgroup of the direct product Aut(G) × Aut(M). Here Aut(M) is considered as
  subgroup  of  a  general  linear  group. The optional argument D should be a
  subgroup  of Aut(G) × Aut(M). If it is given, then only the compatible pairs
  in D are computed.
  
  46.8-9 ExtensionRepresentatives
  
  ExtensionRepresentatives( G, M, P )  operation
  
  returns all extensions of G by the G-module M up to equivalence under action
  of P where P has to be a subgroup of the group of compatible pairs of G with
  M.
  
    Example  
    gap> G := SmallGroup( 4, 2 );;
    gap> mats := List( Pcgs( G ), x -> IdentityMat( 1, GF(2) ) );;
    gap> M := GModuleByMats( mats, GF(2) );;
    gap> A := AutomorphismGroup( G );;
    gap> B := GL( 1, 2 );;
    gap> D := DirectProduct( A, B );; Size(D);
    6
    gap> P := CompatiblePairs( G, M, D );
    <group of size 6 with 2 generators>
    gap> ExtensionRepresentatives( G, M, P );
    [ <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators> ]
    gap> Extensions( G, M );
    [ <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators>, 
      <pc group of size 8 with 3 generators> ]
  
  
  46.8-10 SplitExtension
  
  SplitExtension( G, aut, N )  operation
  
  returns the split extensions of the pc group G by the pc group N. aut should
  be a homomorphism from G into Aut(N).
  
  In  the  following  example  we  construct  the  holomorph  of  Q_8 as split
  extension of Q_8 by S_4.
  
    Example  
    gap> N := SmallGroup( 8, 4 );
    <pc group of size 8 with 3 generators>
    gap> IsAbelian( N );
    false
    gap> A := AutomorphismGroup( N );
    <group of size 24 with 4 generators>
    gap> iso := IsomorphismPcGroup( A );
    CompositionMapping( Pcgs([ (2,6,5,3), (1,3,5)(2,4,6), (2,5)(3,6), 
      (1,4)(3,6) ]) -> [ f1, f2, f3, f4 ], <action isomorphism> )
    gap> H := Image( iso );
    Group([ f1, f2, f3, f4 ])
    gap> G := Subgroup( H, Pcgs(H){[1,2]} );
    Group([ f1, f2 ])
    gap> inv := InverseGeneralMapping( iso );
    [ f1*f2, f2^2*f3, f4, f3 ] -> 
    [ Pcgs([ f1, f2, f3 ]) -> [ f1*f2, f2, f3 ], 
      Pcgs([ f1, f2, f3 ]) -> [ f2, f1*f2, f3 ], 
      Pcgs([ f1, f2, f3 ]) -> [ f1*f3, f2, f3 ], 
      Pcgs([ f1, f2, f3 ]) -> [ f1, f2*f3, f3 ] ]
    gap> K := SplitExtension( G, inv, N );
    <pc group of size 192 with 7 generators>
  
  
  
  46.9 Coding a Pc Presentation
  
  If  one wants to store a large number of pc groups, then it can be useful to
  store  them  in  a  compressed  format,  since pc presentations can be space
  consuming. Here we introduce a method to code and decode pc presentations by
  integers.  To  decode  a  given  code the size of the underlying pc group is
  needed  as  well.  For  the  full  definition  and  the  coding and decoding
  procedures  see  [BE99].  This  method is used with the small groups library
  (see 'smallgrp: The Small Groups Library'.
  
  46.9-1 CodePcgs
  
  CodePcgs( pcgs )  function
  
  returns the code corresponding to pcgs.
  
    Example  
    gap> G := CyclicGroup(512);;
    gap> p := Pcgs( G );;
    gap> CodePcgs( p );  
    162895587718739690298008513020159
  
  
  46.9-2 CodePcGroup
  
  CodePcGroup( G )  function
  
  returns the code for a pcgs of G.
  
    Example  
    gap> G := DihedralGroup(512);;
    gap> CodePcGroup( G );       
    2940208627577393070560341803949986912431725641726
  
  
  46.9-3 PcGroupCode
  
  PcGroupCode( code, size )  function
  
  returns  a  pc  group  of size size corresponding to code. The argument code
  must  be a valid code for a pcgs, otherwise anything may happen. Valid codes
  are   usually  obtained  by  one  of  the  functions  CodePcgs  (46.9-1)  or
  CodePcGroup (46.9-2).
  
    Example  
    gap> G := SmallGroup( 24, 12 );;
    gap> p := Pcgs( G );;
    gap> code := CodePcgs( p );
    5790338948
    gap> H := PcGroupCode( code, 24 );
    <pc group of size 24 with 4 generators>
    gap> map := GroupHomomorphismByImages( G, H, p, FamilyPcgs(H) );
    Pcgs([ f1, f2, f3, f4 ]) -> Pcgs([ f1, f2, f3, f4 ])
    gap> IsBijective(map);
    true
  
  
  
  46.10 Random Isomorphism Testing
  
  The generic isomorphism test for groups may be applied to pc groups as well.
  However,  this  test is often quite time consuming. Here we describe another
  method to test isomorphism by a probabilistic approach.
  
  46.10-1 RandomIsomorphismTest
  
  RandomIsomorphismTest( coderecs, n )  function
  
  The  first argument is a list coderecs containing records describing groups,
  and the second argument is a non-negative integer n.
  
  The  test  returns a sublist of coderecs where isomorphic copies detected by
  the probabilistic test have been removed.
  
  The  list  coderecs  should  contain  records  with two components, code and
  order,  describing  a  group via PcGroupCode( code, order ) (see PcGroupCode
  (46.9-3)).
  
  The  integer  n  gives  a  certain amount of control over the probability to
  detect  all  isomorphisms. If it is 0, then nothing will be done at all. The
  larger  n  is,  the  larger  is the probability of finding all isomorphisms.
  However,  due  to  the  underlying  method  we  can  not  guarantee that the
  algorithm finds all isomorphisms, no matter how large n is.