Welcome To Our Shell

Mister Spy & Souheyl Bypass Shell

  
  50 Group Libraries
  
  When you start GAP, it already knows several groups. Currently GAP initially
  knows the following groups:
  
      some   basic  groups,  such  as  cyclic  groups  or  symmetric  groups
        (see 50.1),
  
      Classical matrix groups (see 50.2),
  
      the  transitive  permutation  groups of degree at most 30, provided by
        the TransGrp package (see 'transgrp: Transitive Permutation Groups'),
  
      a  library  of  groups of small order (see 'smallgrp: The Small Groups
        Library'),
  
      the  finite  perfect  groups of size at most 10^6 (excluding 11 sizes)
        (see 50.6).
  
      the  primitive  permutation  groups  of degree < 4096, provided by the
        PrimGrp package (see 'primgrp: Primitive Permutation Groups'),
  
      the  irreducible  solvable subgroups of GL(n,p) for n>1 and p^n < 256,
        provided  by  the  PrimGrp package (see 'primgrp: Irreducible Solvable
        Matrix Groups'),
  
      the  irreducible maximal finite integral matrix groups of dimension at
        most 31 (see 50.7),
  
      the crystallographic groups of dimension at most 4
  
  There  is  usually no relation between the groups in the different libraries
  and a group may occur in different libraries in different incarnations.
  
  Note  that  a system administrator may choose to install all, or only a few,
  or  even none of the libraries. So some of the libraries mentioned below may
  not be available on your installation.
  
  GAP  might  use  data libraries that are available to speed up calculations,
  for  example  in  using  a  classification  to determine that groups must be
  isomorphic,  based  on  agreement  of  properties;  or  to determine maximal
  subgroups  or subgroup maximality. This will be indicated by an info message
  of  level  2  in the info class InfoPerformance. If the calculation is to be
  independent  of  such  data library use, for example if it is used to verify
  the data library, functions can be called with the option NoPrecomputedData,
  to  turn  these  features  off.  Doing  so  might cause significantly longer
  calculations, or even failure of certain calculations.
  
  
  50.1 Basic Groups
  
  There  are  several  infinite  families  of groups which are parametrized by
  numbers.  GAP  provides  various  functions  to  construct these groups. The
  functions  always  permit  (but  do  not  require)  one to indicate a filter
  (see 13.2),  for  example  IsPermGroup  (43.1-1),  IsMatrixGroup (44.1-1) or
  IsPcGroup (46.3-1), in which the group shall be constructed. There always is
  a  default  filter  corresponding  to a natural way to describe the group in
  question.  Note  that  not  every  group can be constructed in every filter,
  there  may  be  theoretical  restrictions (IsPcGroup (46.3-1) only works for
  solvable groups) or methods may be available only for a few filters.
  
  Certain  filters may admit additional hints. For example, groups constructed
  in  IsMatrixGroup  (44.1-1) may be constructed over a specified field, which
  can  be  given as second argument of the function that constructs the group;
  The default field is Rationals (17.1-1).
  
  50.1-1 TrivialGroup
  
  TrivialGroup( [filter] )  function
  
  constructs  a  trivial  group in the category given by the filter filter. If
  filter  is not given it defaults to IsPcGroup (46.3-1). For more information
  on possible values of filt see section (50.1).
  
    Example  
    gap> TrivialGroup();
    <pc group of size 1 with 0 generators>
    gap> TrivialGroup( IsPermGroup );
    Group(())
  
  
  50.1-2 CyclicGroup
  
  CyclicGroup( [filt, ]n )  function
  
  constructs  the  cyclic  group of size n in the category given by the filter
  filt.  If  filt  is  not  given  it defaults to IsPcGroup (46.3-1), unless n
  equals  infinity  (18.2-1),  in which case the default filter is switched to
  IsFpGroup  (47.1-2).  For  more  information  on possible values of filt see
  section (50.1).
  
    Example  
    gap> CyclicGroup(12);
    <pc group of size 12 with 3 generators>
    gap> CyclicGroup(infinity);
    <free group on the generators [ a ]>
    gap> CyclicGroup(IsPermGroup,12);
    Group([ (1,2,3,4,5,6,7,8,9,10,11,12) ])
    gap> matgrp1:= CyclicGroup( IsMatrixGroup, 12 );
    <matrix group of size 12 with 1 generators>
    gap> FieldOfMatrixGroup( matgrp1 );
    Rationals
    gap> matgrp2:= CyclicGroup( IsMatrixGroup, GF(2), 12 );
    <matrix group of size 12 with 1 generators>
    gap> FieldOfMatrixGroup( matgrp2 );
    GF(2)
  
  
  50.1-3 AbelianGroup
  
  AbelianGroup( [filt, ]ints )  function
  
  constructs  an  abelian group in the category given by the filter filt which
  is  of isomorphism type C_{ints[1]} × C_{ints[2]} × ... × C_{ints[n]}, where
  ints  must  be a list of non-negative integers or infinity (18.2-1); for the
  latter  value  or  0,  C_{ints[i]}  is  taken  as  an infinite cyclic group,
  otherwise  as  a  cyclic  group  of  order  ints[i]. If filt is not given it
  defaults  to  IsPcGroup  (46.3-1),  unless any 0 or infinity is contained in
  ints,  in  which  the  default filter is switched to IsFpGroup (47.1-2). The
  generators  of  the  group  returned  are  the elements corresponding to the
  factors  C_{ints[i]} and hence the integers in ints. For more information on
  possible values of filt see section (50.1).
  
    Example  
    gap> AbelianGroup([1,2,3]);
    <pc group of size 6 with 3 generators>
    gap> G:=AbelianGroup([0,3]);
    <fp group of size infinity on the generators [ f1, f2 ]>
    gap> AbelianInvariants(G);
    [ 0, 3 ]
  
  
  50.1-4 ElementaryAbelianGroup
  
  ElementaryAbelianGroup( [filt, ]n )  function
  
  constructs  the  elementary abelian group of size n in the category given by
  the filter filt. If filt is not given it defaults to IsPcGroup (46.3-1). For
  more information on possible values of filt see section (50.1).
  
    Example  
    gap> ElementaryAbelianGroup(8192);
    <pc group of size 8192 with 13 generators>
  
  
  50.1-5 FreeAbelianGroup
  
  FreeAbelianGroup( [filt, ]rank )  function
  
  constructs  the  free  abelian  group of rank n in the category given by the
  filter  filt.  If  filt  is not given it defaults to IsFpGroup (47.1-2). For
  more information on possible values of filt see section (50.1).
  
    Example  
    gap> FreeAbelianGroup(4);
    <fp group of size infinity on the generators [ f1, f2, f3, f4 ]>
  
  
  50.1-6 DihedralGroup
  
  DihedralGroup( [filt, ]n )  function
  
  constructs  the dihedral group of size n in the category given by the filter
  filt.  If  filt  is  not  given  it defaults to IsPcGroup (46.3-1), unless n
  equals  infinity  (18.2-1),  in which case the default filter is switched to
  IsFpGroup  (47.1-2).  For  more  information  on possible values of filt see
  section (50.1).
  
    Example  
    gap> DihedralGroup(8);
    <pc group of size 8 with 3 generators>
    gap> DihedralGroup( IsPermGroup, 8 );
    Group([ (1,2,3,4), (2,4) ])
    gap> DihedralGroup(infinity);
    <fp group of size infinity on the generators [ r, s ]>
  
  
  50.1-7 QuaternionGroup
  
  QuaternionGroup( [filt, ]n )  function
  DicyclicGroup( [filt, ]n )  function
  
  constructs the generalized quaternion group (or dicyclic group) of size n in
  the  category  given by the filter filt. Here, n is a multiple of 4. If filt
  is  not  given  it  defaults  to IsPcGroup (46.3-1). For more information on
  possible  values  of filt see section (50.1). Methods are also available for
  permutation  and  matrix  groups (of minimal degree and minimal dimension in
  coprime characteristic).
  
    Example  
    gap> QuaternionGroup(32);
    <pc group of size 32 with 5 generators>
    gap> g:=QuaternionGroup(IsMatrixGroup,CF(16),32);
    Group([ [ [ 0, 1 ], [ -1, 0 ] ], [ [ E(16), 0 ], [ 0, -E(16)^7 ] ] ])
  
  
  50.1-8 ExtraspecialGroup
  
  ExtraspecialGroup( [filt, ]order, exp )  function
  
  Let  order  be  of  the  form p^{2n+1}, for a prime integer p and a positive
  integer  n.  ExtraspecialGroup returns the extraspecial group of order order
  that is determined by exp, in the category given by the filter filt.
  
  If  p  is  odd  then  admissible values of exp are the exponent of the group
  (either  p  or  p^2) or one of '+', "+", '-', "-". For p = 2, only the above
  plus or minus signs are admissible.
  
  If filt is not given it defaults to IsPcGroup (46.3-1). For more information
  on possible values of filt see section (50.1).
  
    Example  
    gap> ExtraspecialGroup( 27, 3 );
    <pc group of size 27 with 3 generators>
    gap> ExtraspecialGroup( 27, '+' );
    <pc group of size 27 with 3 generators>
    gap> ExtraspecialGroup( 8, "-" );
    <pc group of size 8 with 3 generators>
  
  
  
  50.1-9 AlternatingGroup
  
  AlternatingGroup( [filt, ]deg )  function
  AlternatingGroup( [filt, ]dom )  function
  
  constructs  the alternating group of degree deg in the category given by the
  filter  filt.  If filt is not given it defaults to IsPermGroup (43.1-1). For
  more  information  on  possible  values  of  filt see section (50.1). In the
  second  version, the function constructs the alternating group on the points
  given in the set dom which must be a set of positive integers.
  
    Example  
    gap> AlternatingGroup(5);
    Alt( [ 1 .. 5 ] )
  
  
  
  50.1-10 SymmetricGroup
  
  SymmetricGroup( [filt, ]deg )  function
  SymmetricGroup( [filt, ]dom )  function
  
  constructs  the  symmetric  group of degree deg in the category given by the
  filter  filt.  If filt is not given it defaults to IsPermGroup (43.1-1). For
  more  information  on  possible  values  of  filt see section (50.1). In the
  second  version,  the  function constructs the symmetric group on the points
  given in the set dom which must be a set of positive integers.
  
    Example  
    gap> SymmetricGroup(10);
    Sym( [ 1 .. 10 ] )
  
  
  Note  that  permutation  groups  provide  special treatment of symmetric and
  alternating groups, see 43.4.
  
  50.1-11 MathieuGroup
  
  MathieuGroup( [filt, ]degree )  function
  
  constructs  the  Mathieu group of degree degree in the category given by the
  filter filt, where degree must be in the set { 9, 10, 11, 12, 21, 22, 23, 24
  }.  If  filt  is  not  given  it  defaults to IsPermGroup (43.1-1). For more
  information on possible values of filt see section (50.1).
  
    Example  
    gap> MathieuGroup( 11 );
    Group([ (1,2,3,4,5,6,7,8,9,10,11), (3,7,11,8)(4,10,5,6) ])
  
  
  50.1-12 SuzukiGroup
  
  SuzukiGroup( [filt, ]q )  function
  Sz( [filt, ]q )  function
  
  Constructs  a  group  isomorphic  to the Suzuki group Sz( q ) over the field
  with q elements, where q is a non-square power of 2.
  
  If filt is not given it defaults to IsMatrixGroup (44.1-1), and the returned
  group is the Suzuki group itself. For more information on possible values of
  filt see section (50.1).
  
    Example  
    gap> SuzukiGroup( 32 );
    Sz(32)
  
  
  50.1-13 ReeGroup
  
  ReeGroup( [filt, ]q )  function
  Ree( [filt, ]q )  function
  
  Constructs  a  group isomorphic to the Ree group ^2G_2(q) where q = 3^{1+2m}
  for m a non-negative integer.
  
  If  filt  is  not  given  it  defaults  to  IsMatrixGroup  (44.1-1)  and the
  generating  matrices  are  based  on [KLM01].  (No  particular  choice  of a
  generating  set  is  guaranteed.) For more information on possible values of
  filt see section (50.1).
  
    Example  
    gap> ReeGroup( 27 );
    Ree(27)
  
  
  
  50.2 Classical Groups
  
  The following functions return classical groups.
  
  For  the  linear, symplectic, and unitary groups (the latter in dimension at
  least  3),  the generators are taken from [Tay87]. For the unitary groups in
  dimension  2,  the  isomorphism  of  SU(2,q)  and  SL(2,q)  is used, see for
  example [Hup67].
  
  The  generators  of  the  general  and  special  orthogonal groups are taken
  from [IE94]  and  [KL90],  except  that  the generators of the groups in odd
  dimension  in  even  characteristic are constructed via the isomorphism to a
  symplectic group, see for example [Car72].
  
  The generators of the groups Ω^ϵ(d, q) are taken from [RT98], except that in
  odd  dimension and even characteristic, the generators of SO(d, q) are taken
  for Ω(d, q). Note that the generators claimed in [RT98, Section 4.5 and 4.6]
  do  not  describe  orthogonal  groups,  one  would  have  to transpose these
  matrices  in  order  to  get  groups  that  respect  the required forms. The
  matrices  from [RT98] generate groups of the right isomorphism types but not
  orthogonal  groups,  except  in  the  case (d,q) = (5,2), where the matrices
  from [RT98] generate the simple group S_4(2)' and not the group S_4(2).
  
  The generators for the semilinear groups are constructed from the generators
  of  the  corresponding  linear  groups  plus  one  additional generator that
  describes the action of the group of field automorphisms; for prime integers
  p  and positive integers f, this yields the matrix groups GammaL(d, p^f) and
  SigmaL(d,  p^f)  as  groups  of  d  f  ×  df  matrices over the field with p
  elements.
  
  For  symplectic  and  orthogonal  matrix  groups  returned  by the functions
  described  below,  the invariant bilinear form is stored as the value of the
  attribute   InvariantBilinearForm   (44.5-1).   Analogously,  the  invariant
  sesquilinear  form defining the unitary groups is stored as the value of the
  attribute  InvariantSesquilinearForm  (44.5-3)). The defining quadratic form
  of   orthogonal   groups   is   stored   as   the  value  of  the  attribute
  InvariantQuadraticForm (44.5-5).
  
  Note  that  due  to  the different sources for the generators, the invariant
  forms  for  the  groups Ω(e,d,q) are in general different from the forms for
  SO(e,d,q) and GO(e,d,q).
  
  
  50.2-1 GeneralLinearGroup
  
  GeneralLinearGroup( [filt, ]d, R )  function
  GL( [filt, ]d, R )  function
  GeneralLinearGroup( [filt, ]d, q )  function
  GL( [filt, ]d, q )  function
  
  The first two forms construct a group isomorphic to the general linear group
  GL( d, R ) of all d × d matrices that are invertible over the ring R, in the
  category given by the filter filt.
  
  The  third  and  the fourth form construct the general linear group over the
  finite field with q elements.
  
  If filt is not given it defaults to IsMatrixGroup (44.1-1), and the returned
  group  is  the  general linear group as a matrix group in its natural action
  (see also IsNaturalGL (44.4-2), IsNaturalGLnZ (44.6-4)).
  
  Currently  supported  rings R are finite fields, the ring Integers (14), and
  residue class rings Integers mod m, see 14.5.
  
    Example  
    gap> GL(4,3);
    GL(4,3)
    gap> GL(2,Integers);
    GL(2,Integers)
    gap> GL(3,Integers mod 12);
    GL(3,Z/12Z)
  
  
  Using  the  OnLines  (41.2-12)  operation  it  is  possible  to  obtain  the
  corresponding projective groups in a permutation action:
  
    Example  
    gap> g:=GL(4,3);;Size(g);
    24261120
    gap> pgl:=Action(g,Orbit(g,Z(3)^0*[1,0,0,0],OnLines),OnLines);;
    gap> Size(pgl);
    12130560
  
  
  If  you  are  interested only in the projective group as a permutation group
  and not in the correspondence between its moved points and the points in the
  projective space, you can also use PGL (50.2-11).
  
  
  50.2-2 SpecialLinearGroup
  
  SpecialLinearGroup( [filt, ]d, R )  function
  SL( [filt, ]d, R )  function
  SpecialLinearGroup( [filt, ]d, q )  function
  SL( [filt, ]d, q )  function
  
  The first two forms construct a group isomorphic to the special linear group
  SL(  d, R ) of all those d × d matrices over the ring R whose determinant is
  the identity of R, in the category given by the filter filt.
  
  The  third  and  the fourth form construct the special linear group over the
  finite field with q elements.
  
  If filt is not given it defaults to IsMatrixGroup (44.1-1), and the returned
  group  is  the  special linear group as a matrix group in its natural action
  (see also IsNaturalSL (44.4-4), IsNaturalSLnZ (44.6-5)).
  
  Currently  supported  rings R are finite fields, the ring Integers (14), and
  residue class rings Integers mod m, see 14.5.
  
    Example  
    gap> SpecialLinearGroup(2,2);
    SL(2,2)
    gap> SL(3,Integers);
    SL(3,Integers)
    gap> SL(4,Integers mod 4);
    SL(4,Z/4Z)
  
  
  50.2-3 GeneralUnitaryGroup
  
  GeneralUnitaryGroup( [filt, ]d, q )  function
  GU( [filt, ]d, q )  function
  
  constructs  a  group  isomorphic  to the general unitary group GU( d, q ) of
  those  d  × d matrices over the field with q^2 elements that respect a fixed
  nondegenerate sesquilinear form, in the category given by the filter filt.
  
  If filt is not given it defaults to IsMatrixGroup (44.1-1), and the returned
  group is the general unitary group itself.
  
    Example  
    gap> GeneralUnitaryGroup( 3, 5 );
    GU(3,5)
  
  
  50.2-4 SpecialUnitaryGroup
  
  SpecialUnitaryGroup( [filt, ]d, q )  function
  SU( [filt, ]d, q )  function
  
  constructs a group isomorphic to the special unitary group GU(d, q) of those
  d  ×  d  matrices  over the field with q^2 elements whose determinant is the
  identity  of  the  field and that respect a fixed nondegenerate sesquilinear
  form, in the category given by the filter filt.
  
  If filt is not given it defaults to IsMatrixGroup (44.1-1), and the returned
  group is the special unitary group itself.
  
    Example  
    gap> SpecialUnitaryGroup( 3, 5 );
    SU(3,5)
  
  
  
  50.2-5 SymplecticGroup
  
  SymplecticGroup( [filt, ]d, q )  function
  SymplecticGroup( [filt, ]d, ring )  function
  Sp( [filt, ]d, q )  function
  Sp( [filt, ]d, ring )  function
  SP( [filt, ]d, q )  function
  SP( [filt, ]d, ring )  function
  
  constructs  a group isomorphic to the symplectic group Sp( d, q ) of those d
  ×  d  matrices  over  the field with q elements (respectively the ring ring)
  that respect a fixed nondegenerate symplectic form, in the category given by
  the filter filt.
  
  If filt is not given it defaults to IsMatrixGroup (44.1-1), and the returned
  group is the symplectic group itself.
  
  At the moment finite fields or residue class rings Integers mod q, with q an
  odd prime power are supported.
  
    Example  
    gap> SymplecticGroup( 4, 2 );
    Sp(4,2)
    gap> g:=SymplecticGroup(6,Integers mod 9);
    Sp(6,Z/9Z)
    gap> Size(g);
    95928796265538862080
  
  
  50.2-6 GeneralOrthogonalGroup
  
  GeneralOrthogonalGroup( [filt, ][e, ]d, q )  function
  GO( [filt, ][e, ]d, q )  function
  
  constructs  a group isomorphic to the general orthogonal group GO( e, d, q )
  of  those  d  ×  d  matrices  over  the field with q elements that respect a
  non-singular  quadratic form (see InvariantQuadraticForm (44.5-5)) specified
  by e, in the category given by the filter filt.
  
  The  value  of  e must be 0 for odd d (and can optionally be omitted in this
  case),  respectively  one  of  1  or  -1 for even d. If filt is not given it
  defaults  to  IsMatrixGroup  (44.1-1), and the returned group is the general
  orthogonal group itself.
  
  Note  that  in [KL90],  GO  is  defined  as the stabilizer ∆(V, F, κ) of the
  quadratic form, up to scalars, whereas our GO is called I(V, F, κ) there.
  
  50.2-7 SpecialOrthogonalGroup
  
  SpecialOrthogonalGroup( [filt, ][e, ]d, q )  function
  SO( [filt, ][e, ]d, q )  function
  
  SpecialOrthogonalGroup  returns a group isomorphic to the special orthogonal
  group  SO(  e,  d,  q  ), which is the subgroup of all those matrices in the
  general  orthogonal  group  (see GeneralOrthogonalGroup  (50.2-6)) that have
  determinant one, in the category given by the filter filt. (The index of SO(
  e,  d,  q  )  in  GO(  e, d, q ) is 2 if q is odd, and 1 if q is even.) Also
  interesting  is  the  group  Omega(  e, d, q ), see Omega (50.2-8), which is
  always of index 2 in SO( e, d, q ).
  
  If filt is not given it defaults to IsMatrixGroup (44.1-1), and the returned
  group is the special orthogonal group itself.
  
    Example  
    gap> GeneralOrthogonalGroup( 3, 7 );
    GO(0,3,7)
    gap> GeneralOrthogonalGroup( -1, 4, 3 );
    GO(-1,4,3)
    gap> SpecialOrthogonalGroup( 1, 4, 4 );
    GO(+1,4,4)
  
  
  50.2-8 Omega
  
  Omega( [filt, ][e, ]d, q )  operation
  
  constructs  a  group  isomorphic  to  the  group Ω( e, d, q ) of those d × d
  matrices  over  the  field  with  q  elements  that  respect  a non-singular
  quadratic  form  (see InvariantQuadraticForm  (44.5-5))  specified by e, and
  that have square spinor norm in odd characteristic or Dickson invariant 0 in
  even characteristic, respectively, in the category given by the filter filt.
  For  odd  q,  this  group  has always index two in the corresponding special
  orthogonal  group,  which will be conjugate in GL(d,q) to the group returned
  by  SO(  e,  d,  q  ),  see  SpecialOrthogonalGroup  (50.2-7), but may fix a
  different form (see 50.2).
  
  The  value  of  e must be 0 for odd d (and can optionally be omitted in this
  case),  respectively  one  of  1  or  -1 for even d. If filt is not given it
  defaults  to  IsMatrixGroup (44.1-1), and the returned group is the group Ω(
  e, d, q ) itself.
  
    Example  
    gap> g:= Omega( 3, 5 );  StructureDescription( g );
    Omega(0,3,5)
    "A5"
    gap> g:= Omega( 1, 4, 4 );  StructureDescription( g );
    Omega(+1,4,4)
    "A5 x A5"
    gap> g:= Omega( -1, 4, 3 );  StructureDescription( g );
    Omega(-1,4,3)
    "A6"
  
  
  50.2-9 GeneralSemilinearGroup
  
  GeneralSemilinearGroup( [filt, ]d, q )  function
  GammaL( [filt, ]d, q )  function
  
  GeneralSemilinearGroup  returns a group isomorphic to the general semilinear
  group ΓL( d, q ) of semilinear mappings of the vector space GF( q )^d.
  
  If filt is not given it defaults to IsMatrixGroup (44.1-1), and the returned
  group  consists of matrices of dimension d f over the field with p elements,
  where q = p^f, for a prime integer p.
  
  50.2-10 SpecialSemilinearGroup
  
  SpecialSemilinearGroup( [filt, ]d, q )  function
  SigmaL( [filt, ]d, q )  function
  
  SpecialSemilinearGroup  returns a group isomorphic to the special semilinear
  group  ΣL( d, q ) of those semilinear mappings of the vector space GF( q )^d
  (see GeneralSemilinearGroup (50.2-9)) whose linear part has determinant one.
  
  If filt is not given it defaults to IsMatrixGroup (44.1-1), and the returned
  group  consists of matrices of dimension d f over the field with p elements,
  where q = p^f, for a prime integer p.
  
  50.2-11 ProjectiveGeneralLinearGroup
  
  ProjectiveGeneralLinearGroup( [filt, ]d, q )  function
  PGL( [filt, ]d, q )  function
  
  constructs a group isomorphic to the projective general linear group PGL( d,
  q  )  of  those  d  ×  d matrices over the field with q elements, modulo the
  centre, in the category given by the filter filt.
  
  If  filt  is not given it defaults to IsPermGroup (43.1-1), and the returned
  group is the action on lines of the underlying vector space.
  
  50.2-12 ProjectiveSpecialLinearGroup
  
  ProjectiveSpecialLinearGroup( [filt, ]d, q )  function
  PSL( [filt, ]d, q )  function
  
  constructs a group isomorphic to the projective special linear group PSL( d,
  q ) of those d × d matrices over the field with q elements whose determinant
  is  the  identity  of the field, modulo the centre, in the category given by
  the filter filt.
  
  If  filt  is not given it defaults to IsPermGroup (43.1-1), and the returned
  group is the action on lines of the underlying vector space.
  
  50.2-13 ProjectiveGeneralUnitaryGroup
  
  ProjectiveGeneralUnitaryGroup( [filt, ]d, q )  function
  PGU( [filt, ]d, q )  function
  
  constructs  a  group isomorphic to the projective general unitary group PGU(
  d, q ) of those d × d matrices over the field with q^2 elements that respect
  a  fixed nondegenerate sesquilinear form, modulo the centre, in the category
  given by the filter filt.
  
  If  filt  is not given it defaults to IsPermGroup (43.1-1), and the returned
  group is the action on lines of the underlying vector space.
  
  50.2-14 ProjectiveSpecialUnitaryGroup
  
  ProjectiveSpecialUnitaryGroup( [filt, ]d, q )  function
  PSU( [filt, ]d, q )  function
  
  constructs  a  group isomorphic to the projective special unitary group PSU(
  d, q ) of those d × d matrices over the field with q^2 elements that respect
  a  fixed  nondegenerate sesquilinear form and have determinant 1, modulo the
  centre, in the category given by the filter filt.
  
  If  filt  is not given it defaults to IsPermGroup (43.1-1), and the returned
  group is the action on lines of the underlying vector space.
  
  50.2-15 ProjectiveSymplecticGroup
  
  ProjectiveSymplecticGroup( [filt, ]d, q )  function
  PSP( [filt, ]d, q )  function
  PSp( [filt, ]d, q )  function
  
  constructs a group isomorphic to the projective symplectic group PSp(d,q) of
  those  d  ×  d  matrices over the field with q elements that respect a fixed
  nondegenerate  symplectic  form, modulo the centre, in the category given by
  the filter filt.
  
  If  filt  is not given it defaults to IsPermGroup (43.1-1), and the returned
  group is the action on lines of the underlying vector space.
  
  50.2-16 ProjectiveOmega
  
  ProjectiveOmega( [filt, ][e, ]d, q )  function
  POmega( [filt, ][e, ]d, q )  function
  
  constructs a group isomorphic to the projective group PΩ( e, d, q ) of Ω( e,
  d, q ), modulo the centre (see Omega (50.2-8)), in the category given by the
  filter filt.
  
  If  filt  is not given it defaults to IsPermGroup (43.1-1), and the returned
  group is the action on lines of the underlying vector space.
  
  
  50.3 Conjugacy Classes in Classical Groups
  
  For  general  and  special  linear  groups  (see GeneralLinearGroup (50.2-1)
  and SpecialLinearGroup  (50.2-2))  GAP  has  an efficient method to generate
  representatives  of  the  conjugacy  classes.  This uses results from linear
  algebra  on  normal  forms of matrices. If you know how to do this for other
  types of classical groups, please, tell us.
  
    Example  
    gap> g := SL(4,9);
    SL(4,9)
    gap> NrConjugacyClasses(g);
    861
    gap> cl := ConjugacyClasses(g);;
    gap> Length(cl);
    861
  
  
  50.3-1 NrConjugacyClassesGL
  
  NrConjugacyClassesGL( n, q )  function
  NrConjugacyClassesGU( n, q )  function
  NrConjugacyClassesSL( n, q )  function
  NrConjugacyClassesSU( n, q )  function
  NrConjugacyClassesPGL( n, q )  function
  NrConjugacyClassesPGU( n, q )  function
  NrConjugacyClassesPSL( n, q )  function
  NrConjugacyClassesPSU( n, q )  function
  NrConjugacyClassesSLIsogeneous( n, q, f )  function
  NrConjugacyClassesSUIsogeneous( n, q, f )  function
  
  The  first of these functions compute for given positive integer n and prime
  power  q the number of conjugacy classes in the classical groups GL( n, q ),
  GU(  n,  q ), SL( n, q ), SU( n, q ), PGL( n, q ), PGU( n, q ), PSL( n, q ),
  PSL(  n,  q  ),  respectively.  (See  also  ConjugacyClasses  (39.10-2)  and
  Section 50.2.)
  
  For  each divisor f of n there is a group of Lie type with the same order as
  SL(  n,  q ), such that its derived subgroup modulo its center is isomorphic
  to  PSL(  n,  q  ).  The  various  such groups with fixed n and q are called
  isogeneous.  (Depending on congruence conditions on q and n several of these
  groups      may      actually      be      isomorphic.)     The     function
  NrConjugacyClassesSLIsogeneous  computes  the number of conjugacy classes in
  this  group. The extreme cases f = 1 and f = n lead to the groups SL( n, q )
  and PGL( n, q ), respectively.
  
  The  function  NrConjugacyClassesSUIsogeneous  is  the analogous one for the
  corresponding unitary groups.
  
  The formulae for the number of conjugacy classes are taken from [Mac81].
  
    Example  
    gap> NrConjugacyClassesGL(24,27);
    22528399544939174406067288580609952
    gap> NrConjugacyClassesPSU(19,17);
    15052300411163848367708
    gap> NrConjugacyClasses(SL(16,16));
    1229782938228219920
  
  
  
  50.4 Constructors for Basic Groups
  
  All functions described in the previous sections call constructor operations
  to do the work. The names of the constructors are obtained from the names of
  the functions by appending "Cons", so for example CyclicGroup (50.1-2) calls
  the constructor
  
  CyclicGroupCons( cat, n )
  
  The  first  argument  cat  for  each  method of this constructor must be the
  category  for  which  the  method  is  installed. For example the method for
  constructing   a   cyclic   permutation   group   is  installed  as  follows
  (see InstallMethod (78.2-1) for the meaning of the arguments.
  
    Example  
    InstallMethod( CyclicGroupCons,
        "regular perm group",
        true,
        [ IsPermGroup and IsRegularProp and IsFinite, IsInt and IsPosRat ], 0,
        function( filter, n )
    
        ...
    
        end );
  
  
  
  50.5 Selection Functions
  
  AllLibraryGroups( fun1, val1, ... )
  
  For  a  number  of the group libraries two selection functions are provided.
  Each  AllLibraryGroups  selection  function permits one to select all groups
  from the library Library that have a given set of properties. Currently, the
  library  selection  functions  provided,  of  this  type, are AllSmallGroups
  (smallgrp:     AllSmallGroups),    AllIrreducibleSolvableGroups    (primgrp:
  AllIrreducibleSolvableGroups),         AllTransitiveGroups        (transgrp:
  AllTransitiveGroups),  and AllPrimitiveGroups (primgrp: AllPrimitiveGroups).
  Corresponding  to  each  of  these  there is a OneLibraryGroup function (see
  below) which returns at most one group.
  
  These functions take an arbitrary number of pairs (but at least one pair) of
  arguments.  The  first  argument  in  such  a pair is a function that can be
  applied  to  the  groups in the library, and the second argument is either a
  single  value  that  this  function  must return in order to have this group
  included  in  the  selection,  or  a  list  of such values. For the function
  AllSmallGroups  (smallgrp:  AllSmallGroups)  the first such function must be
  Size  (30.4-6),  and,  unlike  the  other  library  selection  functions, it
  supports   an   alternative   syntax   where   Size   (30.4-6)   is  omitted
  (see AllSmallGroups      (smallgrp:      AllSmallGroups)).     Also,     see
  AllIrreducibleSolvableGroups  (primgrp:  AllIrreducibleSolvableGroups),  for
  details pertaining to this function.
  
  For  an  example,  let us consider the selection function for the library of
  transitive  groups (also see 'transgrp: Transitive Permutation Groups'). The
  command
  
    Example  
    gap> AllTransitiveGroups(NrMovedPoints,[10..15],
    >                        Size,         [1..100],
    >                        IsAbelian,    false    );
  
  
  returns  a  list  of all transitive groups with degree between 10 and 15 and
  size less than 100 that are not abelian.
  
  Thus  AllTransitiveGroups  behaves  as  if  it was implemented by a function
  similar  to  the  one defined below, where TransitiveGroupsList is a list of
  all  transitive  groups.  (Note  that  in the definition below we assume for
  simplicity  that  AllTransitiveGroups  accepts exactly 4 arguments. It is of
  course  obvious  how  to  change  this definition so that the function would
  accept a variable number of arguments.)
  
    Example  
    AllTransitiveGroups := function( fun1, val1, fun2, val2 )
    local    groups, g, i;
      groups := [];
      for i  in [ 1 .. Length( TransitiveGroupsList ) ] do
        g := TransitiveGroupsList[i];
        if      fun1(g) = val1  or IsList(val1) and fun1(g) in val1
            and fun2(g) = val2  or IsList(val2) and fun2(g) in val2
         then
          Add( groups, g );
        fi;
      od;
      return groups;
    end;
  
  
  Note  that  the real selection functions are considerably more difficult, to
  improve  the  efficiency.  Most  important, each recognizes a certain set of
  properties  which  are precomputed for the library without having to compute
  them  anew  for  each  group. This will substantially speed up the selection
  process. In the description of each library we will list the properties that
  are stored for this library.
  
  OneLibraryGroup( fun1, val1, ... )
  
  For  each  AllLibraryGroups  function  (see  above) there is a corresponding
  function  OneLibraryGroup  on  exactly  the  same arguments, i.e., there are
  OneSmallGroup    (smallgrp:    OneSmallGroup),   OneIrreducibleSolvableGroup
  (primgrp:    OneIrreducibleSolvableGroup),   OneTransitiveGroup   (transgrp:
  OneTransitiveGroup),  and  OnePrimitiveGroup  (primgrp:  OnePrimitiveGroup).
  Each  function  simply  returns  one  group  in  the  library  that  has the
  prescribed  properties,  instead  of  all such groups. It returns fail if no
  such group exists in the library.
  
  
  50.6 Finite Perfect Groups
  
  The GAP library of finite perfect groups provides, up to isomorphism, a list
  of all perfect groups whose sizes are less than 10^6 excluding the following
  sizes:
  
      For  n  =  61440,  122880,  172032, 245760, 344064, 491520, 688128, or
        983040,  the  perfect  groups  of  size  n  have  not  completely been
        determined  yet.  The  library  neither  provides  the number of these
        groups nor the groups themselves.
  
      For n = 86016, 368640, or 737280, the library does not yet contain the
        perfect groups of size n, it only provides their numbers which are 52,
        46, and 54, respectively.
  
  Except for these eleven sizes, the list of altogether 1097 perfect groups in
  the  library  is complete. It relies on results of Derek F. Holt and Wilhelm
  Plesken  which  are published in their book Perfect Groups [HP89]. Moreover,
  they have supplied us with files with presentations of 488 of the groups. In
  terms  of  these,  the remaining 607 nontrivial groups in the library can be
  described  as  276  direct products, 107 central products, and 224 subdirect
  products. They are computed automatically by suitable GAP functions whenever
  they  are needed. Two additional groups omitted from the book Perfect Groups
  have also been included.
  
  We  are  grateful  to Derek Holt and Wilhelm Plesken for making their groups
  available  to  the  GAP  community by contributing their files. It should be
  noted  that their book contains a lot of further information for many of the
  library  groups.  So  we  would  like to recommend it to any GAP user who is
  interested in the groups.
  
  The library has been brought into GAP format by Volkmar Felsch.
  
  As  all  groups are stored by presentations, a permutation representation is
  obtained  by  coset enumeration. Note that some of the library groups do not
  have  a faithful permutation representation of small degree. Computations in
  these groups may be rather time consuming.
  
  50.6-1 SizesPerfectGroups
  
  SizesPerfectGroups(  )  function
  
  This  is  the  ordered list of all numbers up to 10^6 that occur as sizes of
  perfect groups. One can iterate over the perfect groups library with:
  
    Example  
    gap> for n in SizesPerfectGroups() do
    >      for k in [1..NrPerfectLibraryGroups(n)] do
    >        pg := PerfectGroup(n,k);
    >      od;
    >    od;
  
  
  
  50.6-2 PerfectGroup
  
  PerfectGroup( [filt, ]size[, n] )  function
  PerfectGroup( [filt, ]sizenumberpair )  function
  
  returns  a  group  which is isomorphic to the library group specified by the
  size  number  [  size,  n  ]  or  by  the two separate arguments size and n,
  assuming  a  default  value of n = 1. The optional argument filt defines the
  filter  in  which  the  group  is  returned.  Possible  filters  so  far are
  IsPermGroup (43.1-1) and IsSubgroupFpGroup (47.1-1). In the latter case, the
  generators  and  relators  used  coincide  with  those  given in [HP89]. The
  default filter is IsSubgroupFpGroup (47.1-1).
  
    Example  
    gap> G := PerfectGroup(IsPermGroup,6048,1);
    U3(3)
    gap> G:=PerfectGroup(IsPermGroup,823080,2);
    A5 2^1 19^2 C 19^1
    gap> NrMovedPoints(G);
    6859
  
  
  50.6-3 PerfectIdentification
  
  PerfectIdentification( G )  attribute
  
  This  attribute  is  set  for  all  groups  obtained from the perfect groups
  library  and  has  the  value  [size,nr] if the group is obtained with these
  parameters from the library.
  
  50.6-4 NumberPerfectGroups
  
  NumberPerfectGroups( size )  function
  
  returns  the  number  of non-isomorphic perfect groups of size size for each
  positive  integer  size  up to 10^6 except for the eight sizes listed at the
  beginning  of  this section for which the number is not yet known. For these
  values as well as for any argument out of range it returns fail.
  
  50.6-5 NumberPerfectLibraryGroups
  
  NumberPerfectLibraryGroups( size )  function
  
  returns the number of perfect groups of size size which are available in the
  library of finite perfect groups. (The purpose of the function is to provide
  a simple way to formulate a loop over all library groups of a given size.)
  
  50.6-6 SizeNumbersPerfectGroups
  
  SizeNumbersPerfectGroups( factor1, factor2, ... )  function
  
  SizeNumbersPerfectGroups returns a list of pairs, each entry consisting of a
  group  order and the number of those groups in the library of perfect groups
  that  contain  the  specified  factors  factor1,  factor2,  ...  among their
  composition factors.
  
  Each  argument must either be the name of a simple group or an integer which
  stands for the product of the sizes of one or more cyclic factors. (In fact,
  the function replaces all integers among the arguments by their product.)
  
  The following text strings are accepted as simple group names.
  
      An  or  A(n) for the alternating groups A_n, 5 ≤ n ≤ 9, for example A5
        or A(6).
  
      Ln(q)  or L(n,q) for PSL(n,q), where n ∈ { 2, 3 } and q a prime power,
        ranging
  
            for n = 2 from 4 to 125
  
            for n = 3 from 2 to 5
  
      Un(q)  or U(n,q) for PSU(n,q), where n ∈ { 3, 4 } and q a prime power,
        ranging
  
            for n = 3 from 3 to 5
  
            for n = 4 from 2 to 2
  
      Sp4(4) or S(4,4) for the symplectic group Sp(4,4),
  
      Sz(8) for the Suzuki group Sz(8),
  
      Mn or M(n) for the Mathieu groups M_11, M_12, and M_22, and
  
      Jn or J(n) for the Janko groups J_1 and J_2.
  
  Note  that,  for most of the groups, the preceding list offers two different
  names  in order to be consistent with the notation used in [HP89] as well as
  with  the notation used in the DisplayCompositionSeries (39.17-6) command of
  GAP.  However, as the names are compared as text strings, you are restricted
  to the above choice. Even expressions like L2(2^5) are not accepted.
  
  As  the use of the term PSU(n,q) is not unique in the literature, we mention
  that  in  this library it denotes the factor group of SU(n,q) by its centre,
  where  SU(n,q)  is  the  group of all n × n unitary matrices with entries in
  GF(q^2) and determinant 1.
  
  The  purpose  of the function is to provide a simple way to formulate a loop
  over all library groups which contain certain composition factors.
  
  
  50.6-7 DisplayInformationPerfectGroups
  
  DisplayInformationPerfectGroups( size[, n] )  function
  DisplayInformationPerfectGroups( sizenumberpair )  function
  
  DisplayInformationPerfectGroups  displays  some invariants of the n-th group
  of order size from the perfect groups library.
  
  If  no  value  of n has been specified, the invariants will be displayed for
  all groups of size size available in the library.
  
  Alternatively,  also  a  list  of  length  two  may  be  entered as the only
  argument, with entries size and n.
  
  The information provided for G includes the following items:
  
      a  headline  containing  the  size number [ size, n ] of G in the form
        size.n  (the  suffix .n will be suppressed if, up to isomorphism, G is
        the only perfect group of order size),
  
      a  message if G is simple or quasisimple, i.e., if the factor group of
        G by its centre is simple,
  
      the  description  of  the  structure  of  G as it is given by Holt and
        Plesken in [HP89] (see below),
  
      the size of the centre of G (suppressed, if G is simple),
  
      the prime decomposition of the size of G,
  
      orbit  sizes  for  a faithful permutation representation of G which is
        provided by the library (see below),
  
      a  reference  to  each occurrence of G in the tables of section 5.3 of
        [HP89].  Each  of  these  references consists of a class number and an
        internal  number (i,j) under which G is listed in that class. For some
        groups,  there  is more than one reference because these groups belong
        to more than one of the classes in the book.
  
    Example  
    gap> DisplayInformationPerfectGroups( 30720, 3 );
    #I Perfect group 30720:  A5 ( 2^4 E N 2^1 E 2^4 ) A
    #I   size = 2^11*3*5  orbit size = 240
    #I   Holt-Plesken class 1 (9,3)
    gap> DisplayInformationPerfectGroups( 30720, 6 );
    #I Perfect group 30720:  A5 ( 2^4 x 2^4 ) C N 2^1
    #I   centre = 2  size = 2^11*3*5  orbit size = 384
    #I   Holt-Plesken class 1 (9,6)
    gap> DisplayInformationPerfectGroups( Factorial( 8 ) / 2 );
    #I Perfect group 20160.1:  A5 x L3(2) 2^1
    #I   centre = 2  size = 2^6*3^2*5*7  orbit sizes = 5 + 16
    #I   Holt-Plesken class 31 (1,1) (occurs also in class 32)
    #I Perfect group 20160.2:  A5 2^1 x L3(2)
    #I   centre = 2  size = 2^6*3^2*5*7  orbit sizes = 7 + 24
    #I   Holt-Plesken class 31 (1,2) (occurs also in class 32)
    #I Perfect group 20160.3:  ( A5 x L3(2) ) 2^1
    #I   centre = 2  size = 2^6*3^2*5*7  orbit size = 192
    #I   Holt-Plesken class 31 (1,3)
    #I Perfect group 20160.4:  simple group  A8
    #I   size = 2^6*3^2*5*7  orbit size = 8
    #I   Holt-Plesken class 26 (0,1)
    #I Perfect group 20160.5:  simple group  L3(4)
    #I   size = 2^6*3^2*5*7  orbit size = 21
    #I   Holt-Plesken class 27 (0,1)
  
  
  
  50.6-8 More about the Perfect Groups Library
  
  For  any  library  group  G,  the  library  files  do  not  only  provide  a
  presentation,  but,  in  addition, a list of one or more subgroups S_1, ...,
  S_r  of  G  such that there is a faithful permutation representation of G of
  degree  ∑_{i  =  1}^r [G:S_i] on the set { S_i g ∣ 1 ≤ i ≤ r, g ∈ G } of the
  cosets  of  the  S_i. This allows one to construct the groups as permutation
  groups.  The function DisplayInformationPerfectGroups (50.6-7) displays only
  the available degree. The message
  
    Example  
    orbit size = 8
  
  
  in  the above example means that the available permutation representation is
  transitive and of degree 8, whereas the message
  
    Example  
    orbit sizes = 5 + 16
  
  
  means  that  a  nontransitive  permutation representation is available which
  acts on two orbits of size 5 and 16 respectively.
  
  The   notation   used  in  the  description  of  a  group  is  explained  in
  section 5.1.2 of [HP89]. We quote the respective page from there:
  
  Within  a  class  Q#p,  an  isomorphism type of groups will be denoted by an
  ordered  pair  of integers (r,n), where r ≥ 0 and n > 0. More precisely, the
  isomorphism types in Q # p of order p^r |Q| will be denoted by (r,1), (r,2),
  (r,3), .... Thus Q will always get the size number (0,1).
  
  In addition to the symbol (r,n), the groups in Q#p will also be given a more
  descriptive name. The purpose of this is to provide a very rough idea of the
  structure of the group. The names are derived in the following manner. First
  of all, the isomorphism classes of irreducible F_pQ-modules M with |Q|.|M| ≤
  10^6,  where  F_p  is the field of order p, are assigned symbols. These will
  either  be  simply p^x, where x is the dimension of the module, or, if there
  is  more  than  one isomorphism class of irreducible modules having the same
  dimension,  they  will  be  denoted  byp^x, p^{x'}, etc. The one-dimensional
  module with trivial Q-action will therefore be denoted by p^1. These symbols
  will  be  listed  under  the  description  of  Q.  The  group  name consists
  essentially of a list of the composition factors working from the top of the
  group  downwards;  hence  it  always starts with the name of Q itself. (This
  convention  is  the most convenient in our context, but it is different from
  that  adopted  in the ATLAS [CCN+85], for example, where composition factors
  are  listed  in the reverse order. For example, we denote a group isomorphic
  to SL(2,5) by A_5 2^1 rather than 2.A_5.)
  
  Some  other  symbols are used in the name, in order to give some idea of the
  relationship between these composition factors, and splitting properties. We
  shall now list these additional symbols.
  
  ×
        between  two  factors  denotes  a  direct  product  of F_pQ-modules or
        groups.
  
  C
        (for commutator) between two factors means that the second lies in the
        commutator  subgroup  of  the  first. Similarly, a segment of the form
        (f_1  ×  f_2)  C  f_3  would mean that the factors f_1 and f_2 commute
        modulo f_3 and f_3 lies in [f_1,f_2].
  
  A
        (for  abelian) between two factors indicates that the second is in the
        pth  power  (but not the commutator subgroup) of the first. A may also
        follow the factors, if bracketed.
  
  E
        (for  elementary  abelian) between two factors indicates that together
        they generate an elementary abelian group (modulo subsequent factors),
        but that the resulting F_p Q-module extension does not split.
  
  N
        (for  nonsplit)  before  a  factor  indicates  that Q (or possibly its
        covering  group)  splits  down  as far at this factor but not over the
        factor  itself.  So Q f_1 N f_2 means that the normal subgroup f_1 f_2
        of  the  group  has  no  complement  but, modulo f_2, f_1, does have a
        complement.
  
  Brackets have their obvious meaning. Summarizing, we have:
  
  ×
        = direct product;
  
  C
        = commutator subgroup;
  
  A
        = abelian;
  
  E
        = elementary abelian; and
  
  N
        = nonsplit.
  
  Here are some examples.
  
  (i)
        A_5  (2^4  E 2^1 E 2^4) A means that the pairs 2^4 E 2^1 and 2^1 E 2^4
        are both elementary abelian of exponent 4.
  
  (ii)
        A_5  (2^4  E  2^1  A)  C  2^1  means that O_2(G) is of symplectic type
        2^{1+5}, with Frattini factor group of type 2^4 E 2^1. The A after the
        2^1  indicates that G has a central cyclic subgroup 2^1 A 2^1 of order
        4.
  
  (iii)
        L_3(2)  ((2^1 E) × ( N 2^3 E 2^{3'} A) C) 2^{3'} means that the 2^{3'}
        factor at the bottom lies in the commutator subgroup of the pair 2^3 E
        2^{3'} in the middle, but the lower pair 2^{3'} A 2^{3'} is abelian of
        exponent  4.  There is also a submodule 2^1 E 2^{3'}, and the covering
        group  L_3(2) 2^1 of L_3(2) does not split over the 2^3 factor. (Since
        G  is  perfect,  it  goes without saying that the extension L_3(2) 2^1
        cannot split itself.)
  
  We  must  stress that this notation does not always succeed in being precise
  or even unambiguous, and the reader is free to ignore it if it does not seem
  helpful.
  
  If  such a group description has been given in the book for G (and, in fact,
  this  is  the  case  for  most  of  the  library groups), it is displayed by
  DisplayInformationPerfectGroups  (50.6-7). Otherwise the function provides a
  less  explicit description of the (in these cases unique) Holt-Plesken class
  to  which  G  belongs, together with a serial number if this is necessary to
  make it unique.
  
  
  50.7 Irreducible Maximal Finite Integral Matrix Groups
  
  A  library  of irreducible maximal finite integral matrix groups is provided
  with  GAP.  It  contains  ℚ-class representatives for all of these groups of
  dimension  at most 31, and ℤ-class representatives for those of dimension at
  most 11 or of dimension 13, 17, 19, or 23.
  
  The groups provided in this library have been determined by Wilhelm Plesken,
  partially  as  joint work with Michael Pohst, or by members of his institute
  (Lehrstuhl  B  für Mathematik, RWTH Aachen). In particular, the data for the
  groups  of  dimensions  2  to  9 have been taken from the output of computer
  calculations  which they performed in 1979 (see [PP77], [PP80]). The ℤ-class
  representatives  of  the  groups  of  dimension  10 have been determined and
  computed  by Bernd Souvignier ([Sou94]), and those of dimensions 11, 13, and
  17  have  been  recomputed for this library from the circulant Gram matrices
  given  in  [Ple85],  using  the  stand-alone programs for the computation of
  short  vectors  and  Bravais  groups  which have been developed in Plesken's
  institute. The ℤ-class representatives of the groups of dimensions 19 and 23
  had  already  been  determined in [Ple85]. Gabriele Nebe has recomputed them
  for  us.  Her  main  contribution  to this library, however, is that she has
  determined  and  computed  the  ℚ-class  representatives  of  the  groups of
  non-prime dimensions between 12 and 24 and the groups of dimensions 25 to 31
  (see [PN95], [NP95b], [Neb95], [Neb96]).
  
  The  library  has  been  brought  into  GAP format by Volkmar Felsch. He has
  applied  several  GAP  routines  to  check  certain consistency of the data.
  However,  the  credit  and  responsibility  for  the  lists  remain with the
  authors.  We  are  grateful  to  Wilhelm  Plesken,  Gabriele Nebe, and Bernd
  Souvignier for supplying their results to GAP.
  
  In  the  preceding acknowledgement, we used some notations that will also be
  needed in the sequel. We first define these.
  
  Any  integral matrix group G of dimension n is a subgroup of GL_n(ℤ) as well
  as  of  GL_n(ℚ)  and  hence  lies in some conjugacy class of integral matrix
  groups  under  GL_n(ℤ)  and  also in some conjugacy class of rational matrix
  groups  under  GL_n(ℚ).  As usual, we call these classes the ℤ-class and the
  ℚ-class  of  G,  respectively. Note that any conjugacy class of subgroups of
  GL_n(ℚ)  contains at least one ℤ-class of subgroups of GL_n(ℤ) and hence can
  be considered as the ℚ-class of some integral matrix group.
  
  In  the  context  of  this  library we are only concerned with ℤ-classes and
  ℚ-classes  of  subgroups of GL_n(ℤ) which are irreducible and maximal finite
  in  GL_n(ℤ)  (we  will  call  them  i.m.f. subgroups  of  GL_n(ℤ)).  We  can
  distinguish two types of these groups:
  
  First,  there  are  those i.m.f. subgroups of GL_n(ℤ) which are also maximal
  finite  subgroups  of  GL_n(ℚ).  Let us denote the set of their ℚ-classes by
  Q_1(n).  It  is clear from the above remark that Q_1(n) just consists of the
  ℚ-classes of i.m.f. subgroups of GL_n(ℚ).
  
  Secondly,  there  is  the  set  Q_2(n)  of  the  ℚ-classes  of the remaining
  i.m.f. subgroups  of  GL_n(ℤ),  i.e.,  of those which are not maximal finite
  subgroups of GL_n(ℚ). For any such group G, say, there is at least one class
  C  ∈  Q_1(n)  such  that G is conjugate under ℚ to a proper subgroup of some
  group  H  ∈  C.  In fact, the class C is uniquely determined for any group G
  occurring  in the library (though there seems to be no reason to assume that
  this  property  should  hold  in  general). Hence we may call C the rational
  i.m.f. class  of  G. Finally, we will denote the number of classes in Q_1(n)
  and Q_2(n) by q_1(n) and q_2(n), respectively.
  
  As  an  example,  let  us  consider the case n = 4. There are 6 ℤ-classes of
  i.m.f. subgroups  of  GL_4(ℤ) with representative subgroups G_1, ..., G_6 of
  isomorphism types G_1 ≅ W(F_4), G_2 ≅ D_12 ≀ C_2, G_3 ≅ G_4 ≅ C_2 × S_5, G_5
  ≅  W(B_4),  and  G_6  ≅ (D_12YD_12) : C_2. The corresponding ℚ-classes, R_1,
  ...,  R_6,  say,  are pairwise different except that R_3 coincides with R_4.
  The  groups  G_1,  G_2, and G_3 are i.m.f. subgroups of GL_4(ℚ), but G_5 and
  G_6  are not because they are conjugate under GL_4(ℚ) to proper subgroups of
  G_1 and G_2, respectively. So we have Q_1(4) = { R_1, R_2, R_3 }, Q_2(4) = {
  R_5, R_6 }, q_1(4) = 3, and q_2(4) = 2.
  
  The q_1(n) ℚ-classes of i.m.f. subgroups of GL_n(ℚ) have been determined for
  each   dimension   n  ≤  31.  The  current  GAP  library  provides  integral
  representative  groups  for  all  these  classes. Moreover, all ℤ-classes of
  i.m.f. subgroups  of GL_n(ℤ) are known for n ≤ 11 and for n ∈ {13,17,19,23}.
  For  these dimensions, the library offers integral representative groups for
  all  ℚ-classes  in  Q_1(n)  and  Q_2(n)  as  well  as  for  all ℤ-classes of
  i.m.f. subgroups of GL_n(ℤ).
  
  Any  group  G  of  dimension  n  given  in the library is represented as the
  automorphism  group G = Aut(F,L) = { g ∈ GL_n(ℤ) ∣ Lg = L, g F g^tr = F } of
  a positive definite symmetric n × n matrix F ∈ ℤ^{n × n} on an n-dimensional
  lattice  L  ≅  ℤ^{1 × n} (for details see e.g. [PN95]). GAP provides for G a
  list of matrix generators and the Gram matrix F.
  
  The  positive  definite  quadratic form defined by F defines a norm v F v^tr
  for  each vector v ∈ L, and there is only a finite set of vectors of minimal
  norm.  These  vectors  are  often simply called the short vectors. Their set
  splits  into orbits under G, and G being irreducible acts faithfully on each
  of  these  orbits by multiplication from the right. GAP provides for each of
  these orbits the orbit size and a representative vector.
  
  Like  most of the other GAP libraries, the library of i.m.f. integral matrix
  groups  supplies  an  extraction  function,  ImfMatrixGroup. However, as the
  library involves only 525 different groups, there is no need for a selection
  or  an  example  function.  Instead,  there are two functions, ImfInvariants
  (50.7-3)  and  DisplayImfInvariants  (50.7-2),  which  provide  some ℤ-class
  invariants   that  can  be  extracted  from  the  library  without  actually
  constructing  the  representative  groups themselves. The difference between
  these  two  functions  is that the latter one displays the resulting data in
  some  easily  readable  format, whereas the first one returns them as record
  components so that you can properly access them.
  
  We  shall  give  an individual description of each of the library functions,
  but first we would like to insert a short remark concerning their names: Any
  self-explaining  name  of  a  function  handling  irreducible maximal finite
  integral  matrix  groups  would have to include this term in full length and
  hence  would  grow  extremely  long.  Therefore  we  have decided to use the
  abbreviation  Imf  instead in order to restrict the names to some reasonable
  length.
  
  The first three functions can be used to formulate loops over the classes.
  
  50.7-1 ImfNumberQQClasses
  
  ImfNumberQQClasses( dim )  function
  ImfNumberQClasses( dim )  function
  ImfNumberZClasses( dim, q )  function
  
  ImfNumberQQClasses   returns   the   number   q_1(dim)   of   ℚ-classes   of
  i.m.f. rational  matrix groups of dimension dim. Valid values of dim are all
  positive integers up to 31.
  
  Note:  In  order  to  enable  you to loop just over the classes belonging to
  Q_1(dim),  we  have  arranged the list of ℚ-classes of dimension dim for any
  dimension dim in the library such that, whenever the classes of Q_2(dim) are
  known,  too, i.e., in the cases dim ≤ 11 or dim ∈ {13,17,19,23}, the classes
  of  Q_1(dim)  precede  those  of  Q_2(dim)  and hence are numbered from 1 to
  q_1(dim).
  
  ImfNumberQClasses returns the number of ℚ-classes of groups of dimension dim
  which are available in the library. If dim ≤ 11 or dim ∈ {13,17,19,23}, this
  is  the  number  q_1(dim)  +  q_2(dim)  of  ℚ-classes of i.m.f. subgroups of
  GL_dim(ℤ).  Otherwise,  it  is  just  the  number  q_1(dim)  of ℚ-classes of
  i.m.f. subgroups of GL_dim(ℚ). Valid values of dim are all positive integers
  up to 31.
  
  ImfNumberZClasses  returns  the  number  of ℤ-classes in the q-th ℚ-class of
  i.m.f. integral  matrix groups of dimension dim. Valid values of dim are all
  positive integers up to 11 and all primes up to 23.
  
  50.7-2 DisplayImfInvariants
  
  DisplayImfInvariants( dim, q[, z] )  function
  
  DisplayImfInvariants displays the following ℤ-class invariants of the groups
  in  the z-th ℤ-class in the q-th ℚ-class of i.m.f. integral matrix groups of
  dimension dim:
  
      its  ℤ-class  number  in  the  form dim.q.z, if dim is at most 11 or a
        prime at most 23, or its ℚ-class number in the form dim.q, else,
  
      a message if the group is solvable,
  
      the size of the group,
  
      the isomorphism type of the group,
  
      the elementary divisors of the associated quadratic form,
  
      the  sizes of the orbits of short vectors (these sizes are the degrees
        of  the  faithful  permutation representations which you may construct
        using     the     functions     IsomorphismPermGroup    (50.7-5)    or
        IsomorphismPermGroupImfGroup (50.7-6) below),
  
      the norm of the associated short vectors,
  
      only  in  case  that  the  group is not an i.m.f. group in GL_n(ℚ): an
        appropriate message, including the ℚ-class number of the corresponding
        rational i.m.f. class.
  
  If  you  specify  the  value  0  for any of the parameters dim, q, or z, the
  command  will  loop  over  all  available  dimensions,  ℚ-classes  of  given
  dimension,  or  ℤ-classes within the given ℚ-class, respectively. Otherwise,
  the  values  of  the  arguments  must be in range. A value z ≠ 1 must not be
  specified  if  the ℤ-classes are not known for the given dimension, i.e., if
  dim > 11 and dim not ∈ { 13, 17, 19, 23 }. The default value of z is 1. This
  value  of  z  will  be accepted even if the ℤ-classes are not known. Then it
  specifies  the  only  representative  group  which is available for the q-th
  ℚ-class. The greatest legal value of dim is 31.
  
    Example  
    gap> DisplayImfInvariants( 3, 1, 0 );
    #I Z-class 3.1.1:  Solvable, size = 2^4*3
    #I   isomorphism type = C2 wr S3 = C2 x S4 = W(B3)
    #I   elementary divisors = 1^3
    #I   orbit size = 6, minimal norm = 1
    #I Z-class 3.1.2:  Solvable, size = 2^4*3
    #I   isomorphism type = C2 wr S3 = C2 x S4 = C2 x W(A3)
    #I   elementary divisors = 1*4^2
    #I   orbit size = 8, minimal norm = 3
    #I Z-class 3.1.3:  Solvable, size = 2^4*3
    #I   isomorphism type = C2 wr S3 = C2 x S4 = C2 x W(A3)
    #I   elementary divisors = 1^2*4
    #I   orbit size = 12, minimal norm = 2
    gap> DisplayImfInvariants( 8, 15, 1 );
    #I Z-class 8.15.1:  Solvable, size = 2^5*3^4
    #I   isomorphism type = C2 x (S3 wr S3)
    #I   elementary divisors = 1*3^3*9^3*27
    #I   orbit size = 54, minimal norm = 8
    #I   not maximal finite in GL(8,Q), rational imf class is 8.5
    gap> DisplayImfInvariants( 20, 23 );
    #I Q-class 20.23:  Size = 2^5*3^2*5*11
    #I   isomorphism type = (PSL(2,11) x D12).C2
    #I   elementary divisors = 1^18*11^2
    #I   orbit size = 3*660 + 2*1980 + 2640 + 3960, minimal norm = 4
  
  
  Note  that  the  function  DisplayImfInvariants  uses a kind of shorthand to
  display  the  elementary divisors. E. g., the expression 1*3^3*9^3*27 in the
  preceding  example stands for the elementary divisors 1,3,3,3,9,9,9,27. (See
  also  the  next example which shows that the function ImfInvariants (50.7-3)
  provides the elementary divisors in form of an ordinary GAP list.)
  
  In  the  description  of  the  isomorphism types the following notations are
  used:
  
  A x B 
        denotes a direct product of a group A by a group B,
  
  A subd B 
        denotes a subdirect product of A by B,
  
  A Y B 
        denotes a central product of A by B,
  
  A wr B 
        denotes a wreath product of A by B,
  
  A:B 
        denotes a split extension of A by B,
  
  A.B 
        denotes just an extension of A by B (split or nonsplit).
  
  The groups involved are
  
      the cyclic groups C_n, dihedral groups D_n, and generalized quaternion
        groups Q_n of order n, denoted by Cn, Dn, and Qn, respectively,
  
      the  alternating  groups  A_n  and  symmetric  groups S_n of degree n,
        denoted by An and Sn, respectively,
  
      the linear groups GL_n(q), PGL_n(q), SL_n(q), and PSL_n(q), denoted by
        GL(n,q), PGL(n,q), SL(n,q), and PSL(n,q), respectively,
  
      the  unitary  groups  SU_n(q)  and  PSU_n(q),  denoted  by SU(n,q) and
        PSU(n,q), respectively,
  
      the  symplectic  groups  Sp(n,q)  and PSp(n,q), denoted by Sp(n,q) and
        PSp(n,q), respectively,
  
      the  orthogonal  groups O_8^+(2) and PO_8^+(2), denoted by O+(8,2) and
        PO+(8,2), respectively,
  
      the   extraspecial   groups   2_+^{1+8},   3_+^{1+2},  3_+^{1+4},  and
        5_+^{1+2},  denoted  by  2+^(1+8),  3+^(1+2),  3+^(1+4), and 5+^(1+2),
        respectively,
  
      the Chevalley group G_2(3), denoted by G2(3),
  
      the twisted Chevalley group ^3D_4(2), denoted by 3D4(2),
  
      the Suzuki group Sz(8), denoted by Sz(8),
  
      the Weyl groups W(A_n), W(B_n), W(D_n), W(E_n), and W(F_4), denoted by
        W(An), W(Bn), W(Dn), W(En), and W(F4), respectively,
  
      the  sporadic  simple  groups  Co_1,  Co_2, Co_3, HS, J_2, M_12, M_22,
        M_23,  M_24,  and Mc, denoted by Co1, Co2, Co3, HS, J2, M12, M22, M23,
        M24, and Mc, respectively,
  
      a point stabilizer of index 11 in M_11, denoted by M10.
  
  As  mentioned above, the data assembled by the function DisplayImfInvariants
  are cheap data in the sense that they can be provided by the library without
  loading any of its large matrix files or performing any matrix calculations.
  The  following  function allows you to get proper access to these cheap data
  instead of just displaying them.
  
  50.7-3 ImfInvariants
  
  ImfInvariants( dim, q[, z] )  function
  
  ImfInvariants returns a record which provides some ℤ-class invariants of the
  groups  in  the  z-th  ℤ-class in the q-th ℚ-class of i.m.f. integral matrix
  groups  of  dimension  dim.  A  value  z  ≠  1  must not be specified if the
  ℤ-classes  are  not known for the given dimension, i.e., if dim > 11 and dim
  not  ∈ { 13, 17, 19, 23 }. The default value of z is 1. This value of z will
  be  accepted even if the ℤ-classes are not known. Then it specifies the only
  representative  group  which is available for the q-th ℚ-class. The greatest
  legal value of dim is 31.
  
  The resulting record contains six or seven components:
  
  size 
        the size of any representative group G,
  
  isSolvable 
        is true if G is solvable,
  
  isomorphismType 
        a  text  string  describing  the  isomorphism  type  of G (in the same
        notation as used by the function DisplayImfInvariants above),
  
  elementaryDivisors 
        the  elementary  divisors of the associated Gram matrix F (in the same
        format as the result of the function ElementaryDivisorsMat (24.9-1),
  
  minimalNorm 
        the norm of the associated short vectors,
  
  sizesOrbitsShortVectors 
        the sizes of the orbits of short vectors under F,
  
  maximalQClass 
        the  ℚ-class number of an i.m.f. group in GL_n(ℚ) that contains G as a
        subgroup  (only  in  case  that  not G itself is an i.m.f. subgroup of
        GL_n(ℚ)).
  
  Note  that  four  of these data, namely the group size, the solvability, the
  isomorphism  type, and the corresponding rational i.m.f. class, are not only
  ℤ-class invariants, but also ℚ-class invariants.
  
  Note  further  that, though the isomorphism type is a ℚ-class invariant, you
  will  sometimes  get  different  descriptions for different ℤ-classes of the
  same  ℚ-class (as, e.g., for the classes 3.1.1 and 3.1.2 in the last example
  above).  The  purpose  of this behaviour is to provide some more information
  about the underlying lattices.
  
    Example  
    gap> ImfInvariants( 8, 15, 1 );
    rec( elementaryDivisors := [ 1, 3, 3, 3, 9, 9, 9, 27 ], 
      isSolvable := true, isomorphismType := "C2 x (S3 wr S3)", 
      maximalQClass := 5, minimalNorm := 8, size := 2592, 
      sizesOrbitsShortVectors := [ 54 ] )
    gap> ImfInvariants( 24, 1 ).size;
    10409396852733332453861621760000
    gap> ImfInvariants( 23, 5, 2 ).sizesOrbitsShortVectors;
    [ 552, 53130 ]
    gap> for i in [ 1 .. ImfNumberQClasses( 22 ) ] do
    >    Print( ImfInvariants( 22, i ).isomorphismType, "\n" ); od;
    C2 wr S22 = W(B22)
    (C2 x PSU(6,2)).S3
    (C2 x S3) wr S11 = (C2 x W(A2)) wr S11
    (C2 x S12) wr C2 = (C2 x W(A11)) wr C2
    C2 x S3 x S12 = C2 x W(A2) x W(A11)
    (C2 x HS).C2
    (C2 x Mc).C2
    C2 x S23 = C2 x W(A22)
    C2 x PSL(2,23)
    C2 x PSL(2,23)
    C2 x PGL(2,23)
    C2 x PGL(2,23)
  
  
  50.7-4 ImfMatrixGroup
  
  ImfMatrixGroup( dim, q[, z] )  function
  
  ImfMatrixGroup  is  the  essential extraction function of this library (note
  that  its  name has been changed from ImfMatGroup in GAP 3 to ImfMatrixGroup
  in  GAP 4). It returns a representative group, G say, of the z-th ℤ-class in
  the  q-th ℚ-class of i.m.f. integral matrix groups of dimension dim. A value
  z≠  1  must  not  be  specified if the ℤ-classes are not known for the given
  dimension,  i.e.,  if dim > 11 and dim not ∈ { 13, 17, 19, 23 }. The default
  value  of z is 1. This value of z will be accepted even if the ℤ-classes are
  not  known.  Then  it  specifies  the  only  representative  group  which is
  available for the q-th ℚ-class. The greatest legal value of dim is 31.
  
    Example  
    gap> G := ImfMatrixGroup( 5, 1, 3 );
    ImfMatrixGroup(5,1,3)
    gap> for m in GeneratorsOfGroup( G ) do PrintArray( m ); od;
    [ [  -1,   0,   0,   0,   0 ],
      [   0,   1,   0,   0,   0 ],
      [   0,   0,   0,   1,   0 ],
      [  -1,  -1,  -1,  -1,   2 ],
      [  -1,   0,   0,   0,   1 ] ]
    [ [  0,  1,  0,  0,  0 ],
      [  0,  0,  1,  0,  0 ],
      [  0,  0,  0,  1,  0 ],
      [  1,  0,  0,  0,  0 ],
      [  0,  0,  0,  0,  1 ] ]
  
  
  The  attributes  Size  (30.4-6)  and  IsSolvable will be properly set in the
  resulting   matrix   group   G.   In   addition,   it   has  two  attributes
  IsImfMatrixGroup  and  ImfRecord  where the first one is just a logical flag
  set  to  true  and the latter one is a record. Except for the group size and
  the  solvability  flag,  this  record  contains  the  same components as the
  resulting  record  of  the  function ImfInvariants (50.7-3) described above,
  namely  the components isomorphismType, elementaryDivisors, minimalNorm, and
  sizesOrbitsShortVectors   and,   if   G  is  not  a  rational  i.m.f. group,
  maximalQClass. Moreover, it has the two components
  
  form
        the associated Gram matrix F, and
  
  repsOrbitsShortVectors
        representatives of the orbits of short vectors under F.
  
  The  last  one  of  these  components  will  be  required  by  the  function
  IsomorphismPermGroup (50.7-5) below.
  
    Example  
    gap> Size( G );
    3840
    gap> imf := ImfRecord( G );;
    gap> imf.isomorphismType;
    "C2 wr S5 = C2 x W(D5)"
    gap> PrintArray( imf.form );
    [ [  4,  0,  0,  0,  2 ],
      [  0,  4,  0,  0,  2 ],
      [  0,  0,  4,  0,  2 ],
      [  0,  0,  0,  4,  2 ],
      [  2,  2,  2,  2,  5 ] ]
    gap> imf.elementaryDivisors;
    [ 1, 4, 4, 4, 4 ]
    gap> imf.minimalNorm;
    4
  
  
  If  you  want to perform calculations in such a matrix group G you should be
  aware  of  the fact that the permutation group routines of GAP are much more
  efficient  than  the  matrix  group routines. Hence we recommend that you do
  your  computations,  whenever  possible, in the isomorphic permutation group
  which  is  induced by the action of G on one of the orbits of the associated
  short   vectors.   You   may   call   one   of   the   following   functions
  IsomorphismPermGroup  (50.7-5)  or  IsomorphismPermGroupImfGroup (50.7-6) to
  get  an  isomorphism  to  such  a  permutation  group (note that these GAP 4
  functions    have    replaced    the    GAP 3    functions   PermGroup   and
  PermGroupImfGroup).
  
  50.7-5 IsomorphismPermGroup
  
  IsomorphismPermGroup( G )  method
  
  returns an isomorphism, φ say, from the given i.m.f. integral matrix group G
  to  a permutation group P := φ(G) acting on a minimal orbit, S say, of short
  vectors  of  G  such  that  each  matrix  m ∈ G is mapped to the permutation
  induced by its action on S.
  
  Note  that  in  case of a large orbit the construction of φ may be space and
  time consuming. Fortunately, there are only six ℚ-classes in the library for
  which the smallest orbit of short vectors is of size greater than 20000, the
  worst case being the orbit of size 196560 for the Leech lattice (dim = 24, q
  = 3).
  
  The  inverse  isomorphism φ^{-1} from P to G is constructed by determining a
  ℚ-base  B  ⊂  S  of  ℚ^{1  × dim} in S and, in addition, the associated base
  change  matrix  M  which transforms B into the standard base of ℤ^{1 × dim}.
  This   allows  a  simple  computation  of  the  preimage  φ^{-1}(p)  of  any
  permutation  p  ∈  P,  as  follows. If, for 1 ≤ i ≤ dim, b_i is the position
  number  in S of the i-th base vector in B, it suffices to look up the vector
  whose  position number in S is the image of b_i under p and to multiply this
  vector by M to get the i-th row of φ^{-1}(p).
  
  You  may  use  the  functions Image (32.4-6) and PreImage (32.5-6) to switch
  from G to P and back from P to G.
  
  As  an  example,  let  us  continue  the  preceding  example and compute the
  solvable residuum of the group G.
  
    Example  
    gap> # Perform the computations in an isomorphic permutation group.
    gap> phi := IsomorphismPermGroup( G );;
    gap> P := Image( phi );
    Group([ (1,7,6)(2,9)(4,5,10), (2,3,4,5)(6,9,8,7) ])
    gap> D := DerivedSubgroup( P );;
    gap> Size( D );
    960
    gap> IsPerfectGroup( D );
    true
    gap> # We have found the solvable residuum of P,
    gap> # now move the results back to the matrix group G.
    gap> R := PreImage( phi, D );;
    gap> StructureDescription(R);
    "(C2 x C2 x C2 x C2) : A5"
    gap> IdGroup(D)=IdGroup(R);
    true
  
  
  50.7-6 IsomorphismPermGroupImfGroup
  
  IsomorphismPermGroupImfGroup( G, n )  function
  
  IsomorphismPermGroupImfGroup  returns  an isomorphism, φ say, from the given
  i.m.f. integral  matrix  group G to a permutation group P acting on the n-th
  orbit, S say, of short vectors of G such that each matrix m ∈ G is mapped to
  the permutation induced by its action on S.
  
  The  only  difference to the above function IsomorphismPermGroup (50.7-5) is
  that  you  can specify the orbit to be used. In fact, as the orbits of short
  vectors are sorted by increasing sizes, the function IsomorphismPermGroup( G
  )    has    been    implemented    such    that    it   is   equivalent   to
  IsomorphismPermGroupImfGroup( G, 1 ).
  
    Example  
    gap> ImfInvariants( 12, 9 ).sizesOrbitsShortVectors;
    [ 120, 300 ]
    gap> G := ImfMatrixGroup( 12, 9 );
    ImfMatrixGroup(12,9)
    gap> phi1 := IsomorphismPermGroupImfGroup( G, 1 );;
    gap> P1 := Image( phi1 );
    <permutation group of size 2400 with 2 generators>
    gap> LargestMovedPoint( P1 );
    120
    gap> phi2 := IsomorphismPermGroupImfGroup( G, 2 );;
    gap> P2 := Image( phi2 );
    <permutation group of size 2400 with 2 generators>
    gap> LargestMovedPoint( P2 );
    300