dwww Home | Show directory contents | Find package

  
  5 Basic methods and functions for pcp-groups
  
  Pcp-groups are groups in the GAP sense and hence all generic GAP methods for
  groups  can  be  applied  for  pcp-groups.  However,  for  a number of group
  theoretic questions GAP does not provide generic methods that can be applied
  to  pcp-groups.  For some of these questions there are functions provided in
  Polycyclic.
  
  
  5.1 Elementary methods for pcp-groups
  
  In  this  chapter  we  describe  some  important  basic  functions which are
  available for pcp-groups. A number of higher level functions are outlined in
  later sections and chapters.
  
  Let U, V and N be subgroups of a pcp-group.
  
  5.1-1 \=
  
  \=( U, V )  method
  
  decides if U and V are equal as sets.
  
  5.1-2 Size
  
  Size( U )  method
  
  returns the size of U.
  
  5.1-3 Random
  
  Random( U )  method
  
  returns a random element of U.
  
  5.1-4 Index
  
  Index( U, V )  method
  
  returns  the  index of V in U if V is a subgroup of U. The function does not
  check  if  V  is  a  subgroup  of  U  and  if  it  is not, the result is not
  meaningful.
  
  5.1-5 \in
  
  \in( g, U )  method
  
  checks if g is an element of U.
  
  5.1-6 Elements
  
  Elements( U )  method
  
  returns  a  list  containing all elements of U if U is finite and it returns
  the list [fail] otherwise.
  
  5.1-7 ClosureGroup
  
  ClosureGroup( U, V )  method
  
  returns the group generated by U and V.
  
  5.1-8 NormalClosure
  
  NormalClosure( U, V )  method
  
  returns the normal closure of V under action of U.
  
  5.1-9 HirschLength
  
  HirschLength( U )  method
  
  returns the Hirsch length of U.
  
  5.1-10 CommutatorSubgroup
  
  CommutatorSubgroup( U, V )  method
  
  returns the group generated by all commutators [u,v] with u in U and v in V.
  
  5.1-11 PRump
  
  PRump( U, p )  method
  
  returns the subgroup U'U^p of U where p is a prime number.
  
  5.1-12 SmallGeneratingSet
  
  SmallGeneratingSet( U )  method
  
  returns a small generating set for U.
  
  
  5.2 Elementary properties of pcp-groups
  
  5.2-1 IsSubgroup
  
  IsSubgroup( U, V )  function
  
  tests if V is a subgroup of U.
  
  5.2-2 IsNormal
  
  IsNormal( U, V )  function
  
  tests if V is normal in U.
  
  5.2-3 IsNilpotentGroup
  
  IsNilpotentGroup( U )  method
  
  checks whether U is nilpotent.
  
  5.2-4 IsAbelian
  
  IsAbelian( U )  method
  
  checks whether U is abelian.
  
  5.2-5 IsElementaryAbelian
  
  IsElementaryAbelian( U )  method
  
  checks whether U is elementary abelian.
  
  5.2-6 IsFreeAbelian
  
  IsFreeAbelian( U )  property
  
  checks whether U is free abelian.
  
  
  5.3 Subgroups of pcp-groups
  
  A  subgroup  of  a  pcp-group  G  can  be  defined by a set of generators as
  described  in Section 4.3. However, many computations with a subgroup U need
  an  induced  generating  sequence  or  igs  of  U.  An  igs is a sequence of
  generators  of  U  whose  list  of  exponent  vectors form a matrix in upper
  triangular  form.  Note  that  there  may exist many igs of U. The first one
  calculated for U is stored as an attribute.
  
  An  induced  generating sequence of a subgroup of a pcp-group G is a list of
  elements  of  G.  An  igs  is  called normed, if each element in the list is
  normed.  Moreover,  it  is  canonical,  if  the exponent vector matrix is in
  Hermite  Normal Form. The following functions can be used to compute induced
  generating sequence for a given subgroup U of G.
  
  5.3-1 Igs
  
  Igs( U )  attribute
  Igs( gens )  function
  IgsParallel( gens, gens2 )  function
  
  returns  an induced generating sequence of the subgroup U of a pcp-group. In
  the  second  form the subgroup is given via a generating set gens. The third
  form  computes  an  igs  for  the  subgroup generated by gens carrying gens2
  through  as  shadows.  This means that each operation that is applied to the
  first list is also applied to the second list.
  
  5.3-2 Ngs
  
  Ngs( U )  attribute
  Ngs( igs )  function
  
  returns  a  normed  induced  generating  sequence  of  the  subgroup  U of a
  pcp-group. The second form takes an igs as input and norms it.
  
  5.3-3 Cgs
  
  Cgs( U )  attribute
  Cgs( igs )  function
  CgsParallel( gens, gens2 )  function
  
  returns a canonical generating sequence of the subgroup U of a pcp-group. In
  the  second  form the function takes an igs as input and returns a canonical
  generating sequence. The third version takes a generating set and computes a
  canonical  generating sequence carrying gens2 through as shadows. This means
  that each operation that is applied to the first list is also applied to the
  second list.
  
  For  a  large  number  of  methods  for  pcp-groups  U  we will first of all
  determine an igs for U. Hence it might speed up computations, if a known igs
  for  a group U is set a priori. The following functions can be used for this
  purpose.
  
  5.3-4 SubgroupByIgs
  
  SubgroupByIgs( G, igs )  function
  SubgroupByIgs( G, igs, gens )  function
  
  returns  the  subgroup  of  the pcp-group G generated by the elements of the
  induced generating sequence igs. Note that igs must be an induced generating
  sequence of the subgroup generated by the elements of the igs. In the second
  form  igs is a igs for a subgroup and gens are some generators. The function
  returns the subgroup generated by igs and gens.
  
  5.3-5 AddToIgs
  
  AddToIgs( igs, gens )  function
  AddToIgsParallel( igs, gens, igs2, gens2 )  function
  AddIgsToIgs( igs, igs2 )  function
  
  sifts  the  elements  in  the list gens into igs. The second version has the
  same  functionality and carries shadows. This means that each operation that
  is  applied  to  the  first list and the element gens is also applied to the
  second  list  and  the  element  gens2.  The  third version is available for
  efficiency  reasons  and  assumes  that  the  second list igs2 is not only a
  generating set, but an igs.
  
  
  5.4 Polycyclic presentation sequences for subfactors
  
  A  subfactor  of  a  pcp-group  G  is  again  a polycyclic group for which a
  polycyclic  presentation  can  be computed. However, to compute a polycyclic
  presentation for a given subfactor can be time-consuming. Hence we introduce
  polycyclic  presentation  sequences  or Pcp to compute more efficiently with
  subfactors.  (Note  that  a  subgroup  is  also  a subfactor and thus can be
  handled by a pcp)
  
  A  pcp for a pcp-group U or a subfactor U / N can be created with one of the
  following functions.
  
  5.4-1 Pcp
  
  Pcp( U[, flag] )  function
  Pcp( U, N[, flag] )  function
  
  returns  a  polycyclic  presentation  sequence  for  the  subgroup  U or the
  quotient  group  U modulo N. If the parameter flag is present and equals the
  string  snf,  the  function  can only be applied to an abelian subgroup U or
  abelian  subfactor  U/N. The pcp returned will correspond to a decomposition
  of the abelian group into a direct product of cyclic groups.
  
  A  pcp is a component object which behaves similar to a list representing an
  igs  of  the subfactor in question. The basic functions to obtain the stored
  values  of  this  component  object  are  as follows. Let pcp be a pcp for a
  subfactor U/N of the defining pcp-group G.
  
  5.4-2 GeneratorsOfPcp
  
  GeneratorsOfPcp( pcp )  function
  
  this returns a list of elements of U corresponding to an igs of U/N.
  
  5.4-3 \[\]
  
  \[\]( pcp, i )  method
  
  returns the i-th element of pcp.
  
  5.4-4 Length
  
  Length( pcp )  method
  
  returns the number of generators in pcp.
  
  5.4-5 RelativeOrdersOfPcp
  
  RelativeOrdersOfPcp( pcp )  function
  
  the relative orders of the igs in U/N.
  
  5.4-6 DenominatorOfPcp
  
  DenominatorOfPcp( pcp )  function
  
  returns an igs of N.
  
  5.4-7 NumeratorOfPcp
  
  NumeratorOfPcp( pcp )  function
  
  returns an igs of U.
  
  5.4-8 GroupOfPcp
  
  GroupOfPcp( pcp )  function
  
  returns U.
  
  5.4-9 OneOfPcp
  
  OneOfPcp( pcp )  function
  
  returns the identity element of G.
  
  The  main  feature  of a pcp are the possibility to compute exponent vectors
  without  having  to  determine  an  explicit  pcp-group corresponding to the
  subfactor  that  is  represented  by the pcp. Nonetheless, it is possible to
  determine this subfactor.
  
  5.4-10 ExponentsByPcp
  
  ExponentsByPcp( pcp, g )  function
  
  returns the exponent vector of g with respect to the generators of pcp. This
  is the exponent vector of gN with respect to the igs of U/N.
  
  5.4-11 PcpGroupByPcp
  
  PcpGroupByPcp( pcp )  function
  
  let  pcp  be  a  Pcp  of  a  subgroup or a factor group of a pcp-group. This
  function  computes  a  new pcp-group whose defining generators correspond to
  the generators in pcp.
  
    Example  
    gap>  G := DihedralPcpGroup(0);
    Pcp-group with orders [ 2, 0 ]
    gap>  pcp := Pcp(G);
    Pcp [ g1, g2 ] with orders [ 2, 0 ]
    gap>  pcp[1];
    g1
    gap>  Length(pcp);
    2
    gap>  RelativeOrdersOfPcp(pcp);
    [ 2, 0 ]
    gap>  DenominatorOfPcp(pcp);
    [  ]
    gap>  NumeratorOfPcp(pcp);
    [ g1, g2 ]
    gap>  GroupOfPcp(pcp);
    Pcp-group with orders [ 2, 0 ]
    gap> OneOfPcp(pcp);
    identity
  
  
    Example  
    gap> G := ExamplesOfSomePcpGroups(5);
    Pcp-group with orders [ 2, 0, 0, 0 ]
    gap> D := DerivedSubgroup( G );
    Pcp-group with orders [ 0, 0, 0 ]
    gap>  GeneratorsOfGroup( G );
    [ g1, g2, g3, g4 ]
    gap>  GeneratorsOfGroup( D );
    [ g2^-2, g3^-2, g4^2 ]
    
    # an ordinary pcp for G / D
    gap> pcp1 := Pcp( G, D );
    Pcp [ g1, g2, g3, g4 ] with orders [ 2, 2, 2, 2 ]
    
    # a pcp for G/D in independent generators
    gap>  pcp2 := Pcp( G, D, "snf" );
    Pcp [ g2, g3, g1 ] with orders [ 2, 2, 4 ]
    
    gap>  g := Random( G );
    g1*g2^-4*g3*g4^2
    
    # compute the exponent vector of g in G/D with respect to pcp1
    gap> ExponentsByPcp( pcp1, g );
    [ 1, 0, 1, 0 ]
    
    # compute the exponent vector of g in G/D with respect to pcp2
    gap>  ExponentsByPcp( pcp2, g );
    [ 0, 1, 1 ]
  
  
  
  5.5 Factor groups of pcp-groups
  
  Pcp's  for subfactors of pcp-groups have already been described above. These
  are  usually  used within algorithms to compute with pcp-groups. However, it
  is   also   possible   to  explicitly  construct  factor  groups  and  their
  corresponding natural homomorphisms.
  
  5.5-1 NaturalHomomorphismByNormalSubgroup
  
  NaturalHomomorphismByNormalSubgroup( G, N )  method
  
  returns  the  natural  homomorphism  G -> G/N. Its image is the factor group
  G/N.
  
  5.5-2 \/
  
  \/( G, N )  method
  FactorGroup( G, N )  method
  
  returns  the  desired  factor  as  pcp-group  without  giving  the  explicit
  homomorphism. This function is just a wrapper for PcpGroupByPcp( Pcp( G, N )
  ).
  
  
  5.6 Homomorphisms for pcp-groups
  
  Polycyclic  provides code for defining group homomorphisms by generators and
  images  where  either  the  source  or the range or both are pcp groups. All
  methods  provided  by  GAP  for  such  group homomorphisms are supported, in
  particular the following:
  
  5.6-1 GroupHomomorphismByImages
  
  GroupHomomorphismByImages( G, H, gens, imgs )  function
  
  returns  the homomorphism from the (pcp-) group G to the pcp-group H mapping
  the generators of G in the list gens to the corresponding images in the list
  imgs of elements of H.
  
  5.6-2 Kernel
  
  Kernel( hom )  function
  
  returns the kernel of the homomorphism hom from a pcp-group to a pcp-group.
  
  5.6-3 Image
  
  Image( hom )  operation
  Image( hom, U )  function
  Image( hom, g )  function
  
  returns the image of the whole group, of U and of g, respectively, under the
  homomorphism hom.
  
  5.6-4 PreImage
  
  PreImage( hom, U )  function
  
  returns  the complete preimage of the subgroup U under the homomorphism hom.
  If  the  domain  of  hom  is  not a pcp-group, then this function only works
  properly if hom is injective.
  
  5.6-5 PreImagesRepresentative
  
  PreImagesRepresentative( hom, g )  method
  
  returns a preimage of the element g under the homomorphism hom.
  
  5.6-6 IsInjective
  
  IsInjective( hom )  method
  
  checks if the homomorphism hom is injective.
  
  
  5.7 Changing the defining pc-presentation
  
  5.7-1 RefinedPcpGroup
  
  RefinedPcpGroup( G )  function
  
  returns   a   new  pcp-group  isomorphic  to  G  whose  defining  polycyclic
  presentation  is  refined;  that is, the corresponding polycyclic series has
  prime  or infinite factors only. If H is the new group, then H!.bijection is
  the isomorphism G -> H.
  
  5.7-2 PcpGroupBySeries
  
  PcpGroupBySeries( ser[, flag] )  function
  
  returns  a  new  pcp-group  isomorphic  to the first subgroup G of the given
  series  ser  such that its defining pcp refines the given series. The series
  must  be  subnormal  and  H!.bijection  is  the  isomorphism  G -> H. If the
  parameter  flag  is  present and equals the string snf, the series must have
  abelian   factors.   The   pcp  of  the  group  returned  corresponds  to  a
  decomposition of each abelian factor into a direct product of cyclic groups.
  
    Example  
    gap> G := DihedralPcpGroup(0);
    Pcp-group with orders [ 2, 0 ]
    gap>  U := Subgroup( G, [Pcp(G)[2]^1440]);
    Pcp-group with orders [ 0 ]
    gap>  F := G/U;
    Pcp-group with orders [ 2, 1440 ]
    gap> RefinedPcpGroup(F);
    Pcp-group with orders [ 2, 2, 2, 2, 2, 2, 3, 3, 5 ]
    
    gap> ser := [G, U, TrivialSubgroup(G)];
    [ Pcp-group with orders [ 2, 0 ],
      Pcp-group with orders [ 0 ],
      Pcp-group with orders [  ] ]
    gap>  PcpGroupBySeries(ser);
    Pcp-group with orders [ 2, 1440, 0 ]
  
  
  
  5.8 Printing a pc-presentation
  
  By  default,  a  pcp-group  is  printed  using its relative orders only. The
  following methods can be used to view the pcp presentation of the group.
  
  5.8-1 PrintPcpPresentation
  
  PrintPcpPresentation( G[, flag] )  function
  PrintPcpPresentation( pcp[, flag] )  function
  
  prints  the  pcp  presentation  defined  by  the igs of G or the pcp pcp. By
  default, the trivial conjugator relations are omitted from this presentation
  to  shorten  notation.  Also,  the  relations obtained from conjugating with
  inverse  generators  are  included  only  if  the  conjugating generator has
  infinite  order.  If  this  generator has finite order, then the conjugation
  relation  is a consequence of the remaining relations. If the parameter flag
  is  present  and equals the string all, all conjugate relations are printed,
  including  the  trivial  conjugate  relations  as  well  as  those involving
  conjugation with inverses.
  
  
  5.9 Converting to and from a presentation
  
  5.9-1 IsomorphismPcpGroup
  
  IsomorphismPcpGroup( G )  attribute
  
  returns  an isomorphism from G onto a pcp-group H. There are various methods
  installed  for  this  operation  and  some  of these methods are part of the
  Polycyclic package, while others may be part of other packages.
  
  For  example, Polycyclic contains methods for this function in the case that
  G is a finite pc-group or a finite solvable permutation group.
  
  Other  examples  for methods for IsomorphismPcpGroup are the methods for the
  case that G is a crystallographic group (see Cryst) or the case that G is an
  almost crystallographic group (see AClib). A method for the case that G is a
  rational polycyclic matrix group is included in the Polenta package.
  
  5.9-2 IsomorphismPcpGroupFromFpGroupWithPcPres
  
  IsomorphismPcpGroupFromFpGroupWithPcPres( G )  function
  
  This  function  can  convert  a  finitely  presented group with a polycyclic
  presentation into a pcp group.
  
  5.9-3 IsomorphismPcGroup
  
  IsomorphismPcGroup( G )  method
  
  pc-groups  are  a representation for finite polycyclic groups. This function
  can convert finite pcp-groups to pc-groups.
  
  5.9-4 IsomorphismFpGroup
  
  IsomorphismFpGroup( G )  method
  
  This function can convert pcp-groups to a finitely presented group.

Generated by dwww version 1.15 on Sun Jun 16 07:41:24 CEST 2024.