  
  [1X2. The User Interface of the [5XAtlasRep[0X[1X Package[0X
  
  The  [13Xuser  interface[0X  is  the  part  of the [5XGAP[0X interface that allows one to
  display information about the current contents of the database and to access
  individual  data  (perhaps  from  a  remote  server, see Section [14X1.7-1[0X). The
  corresponding  functions  are described in this chapter. See Section [14X2.6[0X for
  some small examples how to use the functions of the interface.
  
  Extensions  of  the [5XAtlasRep[0X package are regarded as another part of the [5XGAP[0X
  interface,  they are described in Chapter [14X3.[0X. Finally, the low level part of
  the interface are described in Chapter [14X5.[0X.
  
  As  stated  in  Section [14X1.2[0X,  the  user interface is preliminary. It will be
  extended  when  the  [5XGAP[0X  version  of  the [5XATLAS[0X of Group Representations is
  connected  to  other [5XGAP[0X databases such as the libraries of character tables
  and tables of marks.
  
  For  some  of the examples in this chapter, the [5XGAP[0X packages [5XCTblLib[0X [Bre04]
  and [5XTomLib[0X are needed.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> LoadPackage( "ctbllib" );[0X
    [4Xtrue[0X
    [4Xgap> LoadPackage( "tomlib" );[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  
  [1X2.1 Accessing vs. Constructing Representations[0X
  
  Note  that  [13Xaccessing[0X the data means in particular that it is [13Xnot[0X the aim of
  this  package  to [13Xconstruct[0X representations from known ones. For example, if
  at  least  one  permutation  representation  for  a group G is stored but no
  matrix   representation   in   a   positive   characteristic  p,  say,  then
  [2XOneAtlasGeneratingSetInfo[0X  ([14X2.5-4[0X)  returns  [9Xfail[0X  when  it  is  asked for a
  description of an available set of matrix generators for G in characteristic
  p,  although  such a representation can be obtained by reduction modulo p of
  an integral matrix representation, which in turn can be constructed from any
  permutation representation.
  
  
  [1X2.2 Group Names Used in the [5XAtlasRep[0X[1X Package[0X
  
  The [5XAtlasRep[0X package refers to data of the [5XATLAS[0X of group representations by
  the  [13Xname[0X  of  the group in question plus additional information. Thus it is
  essential  to  know  this name, which is called [13Xthe [5XGAP[0X name[0X of the group in
  the following.
  
  For  an  almost  simple  group,  the  [5XGAP[0X  name  is  equal to the [2XIdentifier[0X
  ([14XReference: Identifier!for character tables[0X) value of the character table of
  this  group  in  the  [5XGAP[0X  library  (see [2XAccess  to Library Character Tables[0X
  ([14XCTblLib:  Access  to  Library Character Tables[0X)); this name is usually very
  similar  to  the  name  used  in  the  [5XATLAS[0X of Finite Groups [CCNPW85]. For
  example,   [10X"M22"[0X   is   the   [5XGAP[0X  name  of  the  Mathieu  group  M_22,  and
  [10X"12_1.U4(3).2_1"[0X is the [5XGAP[0X name of 12_1.U_4(3).2_1.
  
  Internally,  for example as part of filenames (see Section [14X5.6[0X), the package
  uses  names  that  may  differ  from  the  [5XGAP[0X names; these names are called
  [13X[5XATLAS[0X-file  names[0X.  For  example,  [10XA5[0X, [10XTE62[0X, and [10XF24[0X are possible values for
  [3Xgroupname[0X.  Of these, only [10XA5[0X is also a [5XGAP[0X name, but the other two are not;
  the corresponding [5XGAP[0X names are [10X2E6(2)[0X and [10XFi24'[0X, respectively.
  
  
  [1X2.3 Standard Generators Used in the [5XAtlasRep[0X[1X Package[0X
  
  For   the  general  definition  of  [13Xstandard  generators[0X  of  a  group,  see
  Section [14X'Reference:  Standard  Generators  of  Groups'[0X; details can be found
  in [Wil96].
  
  Several  [13Xdifferent[0X  standard  generators  may  be  defined  for a group, the
  definitions can be found at
  
  [7Xhttp://brauer.maths.qmul.ac.uk/Atlas[0X
  
  When  one specifies the standardization, the i-th set of standard generators
  is  denoted  by  the  number i. Note that when more than one set of standard
  generators  is  defined  for  a group, one must be careful to use [13Xcompatible
  standardization[0X.  For  example,  the  straight  line programs, straight line
  decisions  and  black  box  programs  in  the  database  refer to a specific
  standardization  of  their  inputs.  That  is,  a  straight line program for
  computing  generators of a certain subgroup of a group G is defined only for
  a  specific  set  of  standard  generators of G, and applying the program to
  matrix or permutation generators of G but w.r.t. a different standardization
  may  yield  unpredictable  results.  Therefore  the  results returned by the
  functions   described   in   this  chapter  contain  information  about  the
  standardizations they refer to.
  
  
  [1X2.4 Class Names Used in the [5XAtlasRep[0X[1X Package[0X
  
  For  each  straight  line program (see [2XAtlasProgram[0X ([14X2.5-3[0X)) that is used to
  compute  lists  of  class  representatives,  it is essential to describe the
  classes  in  which these elements lie. Therefore, in these cases the records
  returned  by  the  function [2XAtlasProgram[0X ([14X2.5-3[0X) contain a component [10Xoutputs[0X
  with value a list of [13Xclass names[0X.
  
  Currently we define these class names only for simple groups and automorphic
  extensions  and  central extensions of simple groups, see Section [14X2.4-1[0X. The
  function  [2XAtlasClassNames[0X  ([14X2.4-2[0X)  can be used to compute the list of class
  names from the character table in the [5XGAP[0X Library.
  
  
  [1X2.4-1 Definition of [5XATLAS[0X[1X Class Names[0X
  
  For  the definition of class names of an almost simple group, we assume that
  the  ordinary  character tables of all nontrivial normal subgroups are shown
  in the [5XATLAS[0X of Finite Groups [CCNPW85].
  
  Each  class name is a string consisting of the element order of the class in
  question  followed  by  a  combination  of  capital letters, digits, and the
  characters  [10X'[0X and [10X-[0X (starting with a capital letter). For example, [10X1A[0X, [10X12A1[0X,
  and  [10X3B'[0X  denote  the  class  that contains the identity element, a class of
  element order 12, and a class of element order 3, respectively.
  
  (1)   For  the  table  of  a  [13Xsimple[0X  group, the class names are the same as
        returned  by  the  two argument version of the [5XGAP[0X function [2XClassNames[0X
        ([14XReference:  ClassNames[0X),  cf. [CCNPW85,  Chapter  7,  Section 5]: The
        classes  are  arranged  w.r.t. increasing  element  order and for each
        element  order  w.r.t. decreasing  centralizer  order,  the  conjugacy
        classes  that  contain  elements of order n are named n[10XA[0X, n[10XB[0X, n[10XC[0X, ...;
        the  alphabet  used  here  is potentially infinite, and reads [10XA[0X, [10XB[0X, [10XC[0X,
        ..., [10XZ[0X, [10XA1[0X, [10XB1[0X, ..., [10XA2[0X, [10XB2[0X, ....
  
        For  example,  the classes of the alternating group A_5 have the names
        [10X1A[0X, [10X2A[0X, [10X3A[0X, [10X5A[0X, and [10X5B[0X.
  
  (2)   Next we consider the case of an [13Xupward extension[0X G.A of a simple group
        G by a [13Xcyclic[0X group of order A. The [5XATLAS[0X defines class names for each
        element  g of G.A only w.r.t. the group G.a, say, that is generated by
        G  and  g; namely, there is a power of g (with the exponent coprime to
        the order of g) for which the class has a name of the same form as the
        class  names  for  simple  groups,  and  the  name  of  the class of g
        w.r.t. G.a  is  then  obtained  from this name by appending a suitable
        number  of  dashes [10X'[0X.  So  dashed  class  names refer exactly to those
        classes that are not printed in the [5XATLAS[0X.
  
        For  example, those classes of the symmetric group S_5 that do not lie
        in  A_5  have the names [10X2B[0X, [10X4A[0X, and [10X6A[0X. The outer classes of the group
        L_2(8).3  have  the  names  [10X3B[0X,  [10X6A[0X,  [10X9D[0X, and [10X3B'[0X, [10X6A'[0X, [10X9D'[0X. The outer
        elements  of  order  5  in  the group Sz(32).5 lie in the classes with
        names [10X5B[0X, [10X5B'[0X, [10X5B''[0X, and [10X5B'''[0X.
  
        In the group G.A, the class of g may fuse with other classes. The name
        of  the  class  of g in G.A is obtained from the names of the involved
        classes of G.a by concatenating their names after removing the element
        order part from all of them except the first one.
  
        For  example,  the  elements  of  order  9  in the group L_2(27).6 are
        contained  in the subgroup L_2(27).3 but not in L_2(27). In L_2(27).3,
        they  lie  in  the  classes  [10X9A[0X, [10X9A'[0X, [10X9B[0X, and [10X9B'[0X; in L_2(27).6, these
        classes fuse to [10X9AB[0X and [10X9A'B'[0X.
  
  (3)   Now  we  define  class  names  for  [13Xgeneral upward extensions[0X G.A of a
        simple  group  G.  Each  element  g  of such a group lies in an upward
        extension  G.a  by  a cyclic group, and the class names w.r.t. G.a are
        already  defined.  The  name  of  the class of g in G.A is obtained by
        concatenating  the  names  of  the  classes in the orbit of G.A on the
        classes  of  cyclic  upward  extensions of G, after ordering the names
        lexicographically and removing the element order part from all of them
        except  the  first one. An [13Xexception[0X is the situation where dashed and
        non-dashed  class  names  appear in an orbit; in this case, the dashed
        names are omitted.
  
        For  example,  the  classes  [10X21A[0X and [10X21B[0X of the group U_3(5).3 fuse in
        U_3(5).S_3  to the class [10X21AB[0X, and the class [10X2B[0X of U_3(5).2 fuses with
        the  involution  classes  [10X2B'[0X,  [10X2B''[0X  in the groups U_3(5).2^prime and
        U_3(5).2^primeprime to the class [10X2B[0X of U_3(5).S_3.
  
        It  may  happen  that  some names in the [10Xoutputs[0X component of a record
        returned by [2XAtlasProgram[0X ([14X2.5-3[0X) do not uniquely determine the classes
        of   the  corresponding  elements.  For  example,  the  (algebraically
        conjugate)  classes  [10X39A[0X  and  [10X39B[0X  of  the  group  Co_1 have not been
        distinguished  yet. In such cases, the names used contain a minus sign
        [10X-[0X,  and  mean  "one  of the classes in the range described by the name
        before  and  the name after the minus sign"; the element order part of
        the  name  does not appear after the minus sign. So the name [10X39A-B[0X for
        the  group  Co_1 means [10X39A[0X or [10X39B[0X, and the name [10X20A-B'''[0X for the group
        Sz(32).5  means  one  of the classes of element order 20 in this group
        (these classes lie outside the simple group Sz).
  
  (4)   For  a  central [13Xdownward extension[0X m.G of a simple group G by a cyclic
        group  of order m, let pi denote the natural epimorphism from m.G onto
        G.  Each  class  name of m.G has the form [10XnX_0[0X, [10XnX_1[0X etc., where [10XnX[0X is
        the  class  name  of the image under pi, and the indices [10X0[0X, [10X1[0X etc. are
        chosen  according  to  the  position of the class in the lifting order
        rows  for  G,  see [CCNPW85,  Chapter 7, Section 7, and the example in
        Section 8]).
  
        For example, if m = 6 then [10X1A_1[0X and [10X1A_5[0X denote the classes containing
        the generators of the kernel of pi, that is, central elements of order
        6.
  
  [1X2.4-2 AtlasClassNames[0X
  
  [2X> AtlasClassNames( [0X[3Xtbl[0X[2X ) ___________________________________________[0Xfunction
  [6XReturns:[0X  a list of class names.
  
  Let  [3Xtbl[0X  be  the ordinary character table of a group G that is simple or an
  automorphic or a central extension of a simple group and such that [3Xtbl[0X is an
  [5XATLAS[0X  table from the [5XGAP[0X Character Table Library, according to its [2XInfoText[0X
  ([14XReference:  InfoText[0X) value. Then [2XAtlasClassNames[0X returns the list of class
  names for G, as defined in Section [14X2.4-1[0X. The ordering of class names is the
  same as the ordering of the columns of [3Xtbl[0X.
  
  (The  function may work also for character tables that are not [5XATLAS[0X tables,
  but then clearly the class names returned are somewhat arbitrary.)
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> AtlasClassNames( CharacterTable( "L3(4).3" ) );[0X
    [4X[ "1A", "2A", "3A", "4ABC", "5A", "5B", "7A", "7B", "3B", "3B'", "3C", "3C'", [0X
    [4X  "6B", "6B'", "15A", "15A'", "15B", "15B'", "21A", "21A'", "21B", "21B'" ][0X
    [4Xgap> AtlasClassNames( CharacterTable( "U3(5).2" ) );[0X
    [4X[ "1A", "2A", "3A", "4A", "5A", "5B", "5CD", "6A", "7AB", "8AB", "10A", "2B", [0X
    [4X  "4B", "6D", "8C", "10B", "12B", "20A", "20B" ][0X
    [4Xgap> AtlasClassNames( CharacterTable( "L2(27).6" ) );[0X
    [4X[ "1A", "2A", "3AB", "7ABC", "13ABC", "13DEF", "14ABC", "2B", "4A", "26ABC", [0X
    [4X  "26DEF", "28ABC", "28DEF", "3C", "3C'", "6A", "6A'", "9AB", "9A'B'", "6B", [0X
    [4X  "6B'", "12A", "12A'" ][0X
    [4Xgap> AtlasClassNames( CharacterTable( "L3(4).3.2_2" ) );[0X
    [4X[ "1A", "2A", "3A", "4ABC", "5AB", "7A", "7B", "3B", "3C", "6B", "15A", [0X
    [4X  "15B", "21A", "21B", "2C", "4E", "6E", "8D", "14A", "14B" ][0X
    [4Xgap> AtlasClassNames( CharacterTable( "3.A6" ) );[0X
    [4X[ "1A_0", "1A_1", "1A_2", "2A_0", "2A_1", "2A_2", "3A_0", "3B_0", "4A_0", [0X
    [4X  "4A_1", "4A_2", "5A_0", "5A_1", "5A_2", "5B_0", "5B_1", "5B_2" ][0X
  [4X------------------------------------------------------------------[0X
  
  
  [1X2.5 Accessing Data of the [5XAtlasRep[0X[1X Package[0X
  
  (Note  that  the  output of the examples in this section refers to a perhaps
  outdated  table of contents; the current version of the database may contain
  more information than is shown here.)
  
  [1X2.5-1 DisplayAtlasInfo[0X
  
  [2X> DisplayAtlasInfo( [0X[3X[0X[2X ) _____________________________________________[0Xfunction
  [2X> DisplayAtlasInfo( [0X[3Xlistofnames[0X[2X ) __________________________________[0Xfunction
  [2X> DisplayAtlasInfo( [0X[3Xgapname[, std][, ...][0X[2X ) ________________________[0Xfunction
  
  This  function lists the information available via the [5XAtlasRep[0X package, for
  the  given input. Depending on whether remote access to data is enabled (see
  Section  [14X1.7-1[0X), all the data provided by the [5XATLAS[0X of Group Representations
  or only those in the local installation are considered.
  
  (An   interactive   alternative   to   [2XDisplayAtlasInfo[0X   is   the  function
  [2XBrowseAtlasInfo[0X   ([14XBrowse:   BrowseAtlasInfo[0X),  see  [BL07];  this  function
  provides also the functionality of [2XAtlasGenerators[0X ([14X2.5-2[0X).)
  
  Called   without   arguments,   [2XDisplayAtlasInfo[0X  prints  an  overview  what
  information the [5XATLAS[0X of Group Representations provides. One line is printed
  for each group G, with the following columns.
  
  [8X[10Xgroup[0X[0X
        the [5XGAP[0X name of G (see Section [14X2.2[0X),
  
  [8X[10X#[0X[0X
        the number of representations stored for G,
  
  [8X[10Xmaxes[0X[0X
        the  available  straight  line  programs  for  computing generators of
        maximal subgroups of G,
  
  [8X[10Xcl[0X[0X
        a  [10X+[0X  sign  if  at  least one program for computing representatives of
        conjugacy classes of elements of G is stored, and a [10X-[0X sign otherwise,
  
  [8X[10Xcyc[0X[0X
        a  [10X+[0X  sign  if  at  least one program for computing representatives of
        classes  of  maximally  cyclic  subgroups of G is stored, and a [10X-[0X sign
        otherwise,
  
  [8X[10Xout[0X[0X
        descriptions  of  outer  automorphisms  of  G  for  which at least one
        program is stored,
  
  [8X[10Xcheck[0X[0X
        a  [10X+[0X  sign if at least one program is available for checking whether a
        set  of  generators  is  a  set  of  standard generators, and a [10X-[0X sign
        otherwise,
  
  [8X[10Xpres[0X[0X
        a  [10X+[0X  sign  if  at  least  one  program  is  available  that encodes a
        presentation, and a [10X-[0X sign otherwise,
  
  [8X[10Xfind[0X[0X
        a  [10X+[0X  sign  if  at least one program is available for finding standard
        generators, and a [10X-[0X sign otherwise,
  
  Called  with  a  list  [3Xlistofnames[0X of strings that are [5XGAP[0X names for a group
  from  the  [5XATLAS[0X  of  Group  Representations,  [2XDisplayAtlasInfo[0X  prints  the
  overview described above but restricted to the groups in this list.
  
  Called  with  a string [3Xgapname[0X that is a [5XGAP[0X name for a group from the [5XATLAS[0X
  of  Group  Representations,  [2XDisplayAtlasInfo[0X  prints  an  overview  of  the
  information  that  is available for this group. One line is printed for each
  representation, showing the number of this representation (which can be used
  in  calls  of [2XAtlasGenerators[0X ([14X2.5-2[0X)), and a string of one of the following
  forms; in both cases, [3Xid[0X is a (possibly empty) string.
  
  [8X[10XG <= Sym([3Xn[0X[3Xid[0X)[0X[0X
        denotes  a  permutation  representation  of degree [3Xn[0X, for example [10XG <=
        Sym(40a)[0X  and [10XG <= Sym(40b)[0X denote two (nonequivalent) representations
        of degree 40.
  
  [8X[10XG <= GL([3Xn[0X[3Xid[0X,[3Xdescr[0X)[0X[0X
        denotes a matrix representation of dimension [3Xn[0X over a coefficient ring
        described  by  [3Xdescr[0X, which can be a prime power, [10XZ[0X (denoting the ring
        of  integers),  a  description  of  an  algebraic  extension  field, [10XC[0X
        (denoting  an  unspecified  algebraic extension field), or [10XZ/[3Xm[0XZ[0X for an
        integer  [3Xm[0X  (denoting  the  ring of residues mod [3Xm[0X); for example, [10XG <=
        GL(2a,4)[0X  and [10XG <= GL(2b,4)[0X denote two (nonequivalent) representations
        of dimension 2 over the field with four elements.
  
  After the representations, the programs available for [3Xgapname[0X are listed.
  
  If  the first argument is a string [3Xgapname[0X, the following optional arguments
  can be used to restrict the overview.
  
  [8X[3Xstd[0X[0X
        must  be  a  positive integer or a list of positive integers; if it is
        given then only those representations are considered that refer to the
        [3Xstd[0X-th  set  of  standard  generators  or  the  i-th  set  of standard
        generators, for i in [3Xstd[0X (see Section [14X2.3[0X),
  
  [8X[10XIsPermGroup[0X and [9Xtrue[0X[0X
        restrict to permutation representations,
  
  [8X[10XNrMovedPoints[0X and [3Xn[0X[0X
        for  a positive integer, a list of positive integers, or a property [3Xn[0X,
        restrict  to  permutation  representations of degree equal to [3Xn[0X, or in
        the list [3Xn[0X, or satisfying the function [3Xn[0X,
  
  [8X[10XNrMovedPoints[0X and the string [10X"minimal"[0X[0X
        restrict to faithful permutation representations of minimal degree (if
        this information is available),
  
  [8X[10XIsMatrixGroup[0X and [9Xtrue[0X[0X
        restrict to matrix representations,
  
  [8X[10XCharacteristic[0X and [3Xp[0X[0X
        for  a  prime  integer,  a  list  of  prime integers, or a property [3Xp[0X,
        restrict to matrix representations over fields of characteristic equal
        to  [3Xp[0X, or in the list [3Xp[0X, or satisfying the function [3Xp[0X (representations
        over  residue  class  rings  that  are  not fields can be addressed by
        entering [9Xfail[0X as the value of [3Xp[0X),
  
  [8X[10XDimension[0X and [3Xn[0X[0X
        for  a positive integer, a list of positive integers, or a property [3Xn[0X,
        restrict  to matrix representations of dimension equal to [3Xn[0X, or in the
        list [3Xn[0X, or satisfying the function [3Xn[0X,
  
  [8X[10XCharacteristic[0X, [3Xp[0X, [10XDimension[0X,
        and the string [10X"minimal"[0X[0X
        for  a  prime  integer  [3Xp[0X, restrict to faithful matrix representations
        over  fields  of characteristic [3Xp[0X that have minimal dimension (if this
        information is available),
  
  [8X[10XRing[0X and [3XR[0X[0X
        for  a  ring  or a property [3XR[0X, restrict to matrix representations over
        this  ring  or  satisfying this function (note that the representation
        might be defined over a proper subring of [3XR[0X), and
  
  [8X[10XRing[0X, [3XR[0X, [10XDimension[0X,
        and the string [10X"minimal"[0X[0X
        for  a  ring  [3XR[0X, restrict to faithful matrix representations over this
        ring that have minimal dimension (if this information is available),
  
  [8X[10XIsStraightLineProgram[0X[0X
        restricts  to  straight  line  programs,  straight line decisions (see
        Section [14X4.1[0X), and black box programs (see Section [14X4.2[0X).
  
  If  "minimality"  information  is  requested and no available representation
  matches this condition then either no minimal representation is available or
  the     information     about     the    minimality    is    missing.    See
  [2XMinimalRepresentationInfo[0X   ([14X4.3-1[0X)  for  checking  whether  the  minimality
  information  is  available for the group in question. Note that in the cases
  where  the string [10X"minimal"[0X occurs as an argument, [2XMinimalRepresentationInfo[0X
  ([14X4.3-1[0X)  is  called with third argument [10X"lookup"[0X; this is because the stored
  information  was  computed  just  for  the  groups  in  the  [5XATLAS[0X  of Group
  Representations,  so  trying  to  compute  non-stored minimality information
  (using other available databases) will hardly be successful.
  
  The representations are ordered as follows. Permutation representations come
  first   (ordered   according   to   their   degrees),   followed  by  matrix
  representations  over  finite  fields  (ordered first according to the field
  size and second according to the dimension), matrix representations over the
  integers,  and  then  matrix representations over algebraic extension fields
  (both  kinds  ordered  according to the dimension), the last representations
  are matrix representations over residue class rings (ordered first according
  to the modulus and second according to the dimension).
  
  The  maximal  subgroups are ordered according to decreasing group order. For
  an extension G.p of a simple group G by an outer automorphism of prime order
  p,  this  means  that  G  is  the  first  maximal subgroup and then come the
  extensions  of  the  maximal  subgroups  of G and the novelties; so the n-th
  maximal  subgroup  of  G and the n-th maximal subgroup of G.p are in general
  not related. (This coincides with the numbering used for the [2XMaxes[0X ([14XCTblLib:
  Maxes[0X) attribute for character tables.)
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> DisplayAtlasInfo( [ "M11", "A5" ] );[0X
    [4Xgroup     #  maxes  cl  cyc  out  find  check  pres[0X
    [4X---------------------------------------------------[0X
    [4XM11      42      5   +    +          +      +     +[0X
    [4XA5       18      3   -    -          -      +     +[0X
  [4X------------------------------------------------------------------[0X
  
  The  above  output means that the [5XATLAS[0X of Group Representations contains 42
  representations  of  the  Mathieu  group  M_11,  straight  line programs for
  computing  generators  of  representatives  of  all  five classes of maximal
  subgroups,  for  computing  representatives  of  the  conjugacy  classes  of
  elements  and  of  generators  of  maximally  cyclic  subgroups, contains no
  straight  line  program for applying outer automorphisms (well, in fact M_11
  admits  no  nontrivial  outer  automorphism),  and  contains a straight line
  decision  that checks generators for being standard generators. Analogously,
  18 representations of the alternating group A_5 are available, straight line
  programs for computing generators of representatives of all three classes of
  maximal   subgroups,   and   no   straight   line   programs  for  computing
  representatives  of  the  conjugacy  classes  of  elements, of generators of
  maximally  cyclic  subgroups,  and  no  for  computing  images  under  outer
  automorphisms;  a straight line decision for checking the standardization of
  generators is contained.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> DisplayAtlasInfo( "A5", IsPermGroup, true );[0X
    [4XRepresentations for G = A5:    (all refer to std. generators 1)[0X
    [4X---------------------------[0X
    [4X1: G <= Sym(5)[0X
    [4X2: G <= Sym(6)[0X
    [4X3: G <= Sym(10)[0X
    [4Xgap> DisplayAtlasInfo( "A5", NrMovedPoints, [ 4 .. 9 ] );[0X
    [4XRepresentations for G = A5:    (all refer to std. generators 1)[0X
    [4X---------------------------[0X
    [4X1: G <= Sym(5)[0X
    [4X2: G <= Sym(6)[0X
  [4X------------------------------------------------------------------[0X
  
  The  first  three  representations  stored  for  A_5 are (in fact primitive)
  permutation representations.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> DisplayAtlasInfo( "A5", Dimension, [ 1 .. 3 ] );[0X
    [4XRepresentations for G = A5:    (all refer to std. generators 1)[0X
    [4X---------------------------[0X
    [4X 8: G <= GL(2a,4)[0X
    [4X 9: G <= GL(2b,4)[0X
    [4X10: G <= GL(3,5)[0X
    [4X12: G <= GL(3a,9)[0X
    [4X13: G <= GL(3b,9)[0X
    [4X17: G <= GL(3a,Field([Sqrt(5)]))[0X
    [4X18: G <= GL(3b,Field([Sqrt(5)]))[0X
    [4Xgap> DisplayAtlasInfo( "A5", Characteristic, 0 );[0X
    [4XRepresentations for G = A5:    (all refer to std. generators 1)[0X
    [4X---------------------------[0X
    [4X14: G <= GL(4,Z)[0X
    [4X15: G <= GL(5,Z)[0X
    [4X16: G <= GL(6,Z)[0X
    [4X17: G <= GL(3a,Field([Sqrt(5)]))[0X
    [4X18: G <= GL(3b,Field([Sqrt(5)]))[0X
  [4X------------------------------------------------------------------[0X
  
  The  representations  with number between 4 and 13 are (in fact irreducible)
  matrix  representations over various finite fields, those with numbers 14 to
  16  are  integral  matrix  representations,  and  the  last  two  are matrix
  representations  over  the field generated by sqrt5 over the rational number
  field.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> DisplayAtlasInfo( "A5", NrMovedPoints, IsPrimeInt );[0X
    [4XRepresentations for G = A5:    (all refer to std. generators 1)[0X
    [4X---------------------------[0X
    [4X1: G <= Sym(5)[0X
    [4Xgap> DisplayAtlasInfo( "A5", Characteristic, IsOddInt ); [0X
    [4XRepresentations for G = A5:    (all refer to std. generators 1)[0X
    [4X---------------------------[0X
    [4X 6: G <= GL(4,3)[0X
    [4X 7: G <= GL(6,3)[0X
    [4X10: G <= GL(3,5)[0X
    [4X11: G <= GL(5,5)[0X
    [4X12: G <= GL(3a,9)[0X
    [4X13: G <= GL(3b,9)[0X
    [4Xgap> DisplayAtlasInfo( "A5", Dimension, IsPrimeInt );     [0X
    [4XRepresentations for G = A5:    (all refer to std. generators 1)[0X
    [4X---------------------------[0X
    [4X 8: G <= GL(2a,4)[0X
    [4X 9: G <= GL(2b,4)[0X
    [4X10: G <= GL(3,5)[0X
    [4X11: G <= GL(5,5)[0X
    [4X12: G <= GL(3a,9)[0X
    [4X13: G <= GL(3b,9)[0X
    [4X15: G <= GL(5,Z)[0X
    [4X17: G <= GL(3a,Field([Sqrt(5)]))[0X
    [4X18: G <= GL(3b,Field([Sqrt(5)]))[0X
    [4Xgap> DisplayAtlasInfo( "A5", Ring, IsFinite and IsPrimeField );[0X
    [4XRepresentations for G = A5:    (all refer to std. generators 1)[0X
    [4X---------------------------[0X
    [4X 4: G <= GL(4a,2)[0X
    [4X 5: G <= GL(4b,2)[0X
    [4X 6: G <= GL(4,3)[0X
    [4X 7: G <= GL(6,3)[0X
    [4X10: G <= GL(3,5)[0X
    [4X11: G <= GL(5,5)[0X
  [4X------------------------------------------------------------------[0X
  
  The above examples show how the output can be restricted using a property (a
  unary   function   that   returns   either   [9Xtrue[0X  or  [9Xfalse[0X)  that  follows
  [10XNrMovedPoints[0X,  [10XCharacteristic[0X,  [10XDimension[0X,  or [10XRing[0X in the argument list of
  [2XDisplayAtlasInfo[0X.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> DisplayAtlasInfo( "A5", IsStraightLineProgram, true );[0X
    [4XPrograms for G = A5:    (all refer to std. generators 1)[0X
    [4X--------------------[0X
    [4Xavailable maxes of G:  [ 1 .. 3 ][0X
    [4Xstandard generators checker available[0X
    [4Xpresentation available[0X
  [4X------------------------------------------------------------------[0X
  
  Straight   line   programs   are   available  for  computing  generators  of
  representatives  of  the  three  classes  of maximal subgroups of A_5, and a
  straight  line  decision  for  checking whether given generators are in fact
  standard  generators  ia  available  as  well  as a presentation in terms of
  standard generators, see [2XAtlasProgram[0X ([14X2.5-3[0X).
  
  [1X2.5-2 AtlasGenerators[0X
  
  [2X> AtlasGenerators( [0X[3Xgapname, repnr[, maxnr][0X[2X ) _______________________[0Xfunction
  [2X> AtlasGenerators( [0X[3Xidentifier[0X[2X ) ____________________________________[0Xfunction
  [6XReturns:[0X  a record containing generators for a representation, or [9Xfail[0X.
  
  In  the  first  form,  [3Xgapname[0X  must  be  a  string denoting a [5XGAP[0X name (see
  Section [14X2.2[0X) of a group, and [3Xrepnr[0X a positive integer. If the [5XATLAS[0X of Group
  Representations  contains  at least [3Xrepnr[0X representations for the group with
  [5XGAP[0X  name  [3Xgapname[0X then [10XAtlasGenerators[0X, when called with [3Xgapname[0X and [3Xrepnr[0X,
  returns   an   immutable  record  describing  the  [3Xrepnr[0X-th  representation;
  otherwise  [9Xfail[0X  is returned. If a third argument [3Xmaxnr[0X, a positive integer,
  is given then an immutable record describing the restriction of the [3Xrepnr[0X-th
  representation to the [3Xmaxnr[0X-th maximal subgroup is returned.
  
  The result record has the following components.
  
  [8X[10Xgroupname[0X[0X
        the [5XGAP[0X name of the group (see Section [14X2.2[0X),
  
  [8X[10Xgenerators[0X[0X
        a list of generators for the group,
  
  [8X[10Xstandardization[0X[0X
        the positive integer denoting the underlying standard generators,
  
  [8X[10Xsize[0X (only if known)[0X
        the order of the group,
  
  [8X[10Xidentifier[0X[0X
        a  [5XGAP[0X  object  (a list of filenames plus additional information) that
        uniquely  determines  the  representation;  the  value  can be used as
        [3Xidentifier[0X argument of [10XAtlasGenerators[0X (see below).
  
  [8X[10Xrepnr[0X[0X
        the  number of the representation in the current session, equal to the
        argument [3Xrepnr[0X if this is given.
  
  Additionally,  there are describing components dependent on the data type of
  the  representation:  For  permutation  representations, these are [10Xp[0X for the
  number of moved points and [10Xid[0X for the distinguishing string as described for
  [2XDisplayAtlasInfo[0X  ([14X2.5-1[0X); for matrix representations, these are [10Xdim[0X for the
  dimension  of  the  matrices,  [10Xring[0X (if known) for the ring generated by the
  matrix entries, and [10Xid[0X for the distinguishing string.
  
  It  should  be  noted  that  the  number [3Xrepnr[0X refers to the number shown by
  [2XDisplayAtlasInfo[0X  ([14X2.5-1[0X)  [13Xin  the current session[0X; it may be that after the
  addition of new representations, [3Xrepnr[0X refers to another representation.
  
  The  alternative form of [10XAtlasGenerators[0X, with only argument [3Xidentifier[0X, can
  be  used  to  fetch  the  result  record  with  [10Xidentifier[0X  value  equal  to
  [3Xidentifier[0X. The purpose of this variant is to access the [13Xsame[0X representation
  also in [13Xdifferent[0X [5XGAP[0X sessions.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> gens1:= AtlasGenerators( "A5", 1 );[0X
    [4Xrec( generators := [ (1,2)(3,4), (1,3,5) ], groupname := "A5",[0X
    [4X  standardization := 1, repnr := 1, [0X
    [4X  identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], p := 5, [0X
    [4X  id := "", size := 60 )[0X
    [4Xgap> gens8:= AtlasGenerators( "A5", 8 );[0X
    [4Xrec( [0X
    [4X  generators := [ [ [ Z(2)^0, 0*Z(2) ], [ Z(2^2), Z(2)^0 ] ], [ [ 0*Z(2), Z(2[0X
    [4X                 )^0 ], [ Z(2)^0, Z(2)^0 ] ] ], groupname := "A5",[0X
    [4X  standardization := 1, repnr := 8, [0X
    [4X  identifier := [ "A5", [ "A5G1-f4r2aB0.m1", "A5G1-f4r2aB0.m2" ], 1, 4 ], [0X
    [4X  dim := 2, id := "a", ring := GF(2^2), size := 60 )[0X
    [4Xgap> gens17:= AtlasGenerators( "A5", 17 );[0X
    [4Xrec( [0X
    [4X  generators := [ [ [ -1, 0, 0 ], [ 0, -1, 0 ], [ -E(5)-E(5)^4, -E(5)-E(5)^4, [0X
    [4X              1 ] ], [ [ 0, 1, 0 ], [ 0, 0, 1 ], [ 1, 0, 0 ] ] ], [0X
    [4X  groupname := "A5", standardization := 1, repnr := 17, [0X
    [4X  identifier := [ "A5", "A5G1-Ar3aB0.g", 1, 3 ], dim := 3, id := "a", [0X
    [4X  ring := NF(5,[ 1, 4 ]), size := 60 )[0X
  [4X------------------------------------------------------------------[0X
  
  Each of the above pairs of elements generates a group isomorphic to A_5.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> gens1max2:= AtlasGenerators( "A5", 1, 2 );[0X
    [4Xrec( generators := [ (1,2)(3,4), (2,3)(4,5) ], standardization := 1, [0X
    [4X  repnr := 1, identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5, [0X
    [4X      2 ], p := 5, id := "" )[0X
    [4Xgap> id:= gens1max2.identifier;;[0X
    [4Xgap> gens1max2 = AtlasGenerators( id );[0X
    [4Xtrue[0X
    [4Xgap> max2:= Group( gens1max2.generators );;[0X
    [4Xgap> Size( max2 );[0X
    [4X10[0X
    [4Xgap> IdGroup( max2 ) = IdGroup( DihedralGroup( 10 ) );[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  The  elements stored in [10Xgens1max2.generators[0X describe the restriction of the
  first  representation  of  A_5  to  a  group  in the second class of maximal
  subgroups   of   A_5   according   to  the  list  in  the  [5XATLAS[0X  of  Finite
  Groups [CCNPW85]; this subgroup is isomorphic to the dihedral group D_10.
  
  [1X2.5-3 AtlasProgram[0X
  
  [2X> AtlasProgram( [0X[3Xgapname[, std], ...[0X[2X ) ______________________________[0Xfunction
  [2X> AtlasProgram( [0X[3Xidentifier[0X[2X ) _______________________________________[0Xfunction
  [6XReturns:[0X  a record containing a program, or [9Xfail[0X.
  
  In the first form, [3Xgapname[0X must be a string denoting a [5XGAP[0X name (see Section
   [14X2.2[0X)  of  a  group G, say. If the [5XATLAS[0X of Group Representations contains a
  straight  line  program (see Section [14X'Reference: Straight Line Programs'[0X) or
  straight   line  decision  (see  Section [14X4.1[0X)  or  black  box  program  (see
  Section [14X4.2[0X)  as  described  by  the  remaining  arguments  (see below) then
  [2XAtlasProgram[0X  returns an immutable record containing this program. Otherwise
  [9Xfail[0X is returned.
  
  If   the   optional   argument  [3Xstd[0X  is  given,  only  those  straight  line
  programs/decisions  are  considered that take generators from the [3Xstd[0X-th set
  of standard generators of G as input, see Section [14X2.3[0X.
  
  The result record has the following components.
  
  [8X[10Xprogram[0X[0X
        the required straight line program/decision, or black box program,
  
  [8X[10Xstandardization[0X[0X
        the positive integer denoting the underlying standard generators of G,
  
  [8X[10Xidentifier[0X[0X
        a  [5XGAP[0X  object  (a list of filenames plus additional information) that
        uniquely  determines  the program; the value can be used as [3Xidentifier[0X
        argument of [2XAtlasProgram[0X (see below).
  
  In the first form, the last arguments must be as follows.
  
  [8X(the string [10X"maxes"[0X and) a positive integer [3Xmaxnr[0X
  [0X
        the  required  program  computes  generators  of  the [3Xmaxnr[0X-th maximal
        subgroup of the group with [5XGAP[0X name [3Xgapname[0X.
  
  [8Xone of the strings [10X"classes"[0X or [10X"cyclic"[0X[0X
        the  required program computes representatives of conjugacy classes of
        elements   or   representatives  of  generators  of  maximally  cyclic
        subgroups of G, respectively.
  
        See [BSWW01]  and [SWW00] for the background concerning these straight
        line  programs. In these cases, the result record of [2XAtlasProgram[0X also
        contains  a component [10Xoutputs[0X, whose value is a list of class names of
        the outputs, as described in Section [14X2.4[0X.
  
  [8Xthe strings [10X"automorphism"[0X and [3Xautname[0X[0X
        the  required program computes images of standard generators under the
        outer automorphism of G that is given by this string.
  
  [8Xthe string [10X"check"[0X[0X
        the  required  result is a straight line decision that takes a list of
        generators  for  G  and  returns [9Xtrue[0X if these generators are standard
        generators w.r.t. the standardization [3Xstd[0X, and [9Xfalse[0X otherwise.
  
  [8Xthe string [10X"presentation"[0X[0X
        the  required  result is a straight line decision that takes a list of
        group  elements  and  returns  [9Xtrue[0X  if  these  elements  are standard
        generators of G w.r.t. the standardization [3Xstd[0X, and [9Xfalse[0X otherwise.
  
  [8Xthe string [10X"find"[0X[0X
        the  required result is a black box program that takes G and returns a
        list of standard generators of G, w.r.t. the standardization [3Xstd[0X.
  
  [8Xthe string [10X"restandardize"[0X and an integer [3Xstd2[0X[0X
        the  required result is a straight line program that computes standard
        generators of G w.r.t. the [3Xstd2[0X-th set of standard generators of G; in
        this case, the argument [3Xstd[0X must be given.
  
  [8Xthe strings [10X"other"[0X and [3Xdescr[0X[0X
        the required program is described by [3Xdescr[0X.
  
  The second form of [2XAtlasProgram[0X, with only argument the list [3Xidentifier[0X, can
  be  used  to  fetch  the  result  record  with  [10Xidentifier[0X  value  equal  to
  [3Xidentifier[0X.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> prog:= AtlasProgram( "A5", 2 );[0X
    [4Xrec( program := <straight line program>, standardization := 1, [0X
    [4X  identifier := [ "A5", "A5G1-max2W1", 1 ], groupname := "A5" )[0X
    [4Xgap> StringOfResultOfStraightLineProgram( prog.program, [ "a", "b" ] );[0X
    [4X"[ a, bbab ]"[0X
    [4Xgap> gens1:= AtlasGenerators( "A5", 1 );[0X
    [4Xrec( generators := [ (1,2)(3,4), (1,3,5) ], groupname := "A5",[0X
    [4X  standardization := 1, repnr := 1, [0X
    [4X  identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], p := 5, [0X
    [4X  id := "", size := 60 )[0X
    [4Xgap> maxgens:= ResultOfStraightLineProgram( prog.program, gens1.generators );[0X
    [4X[ (1,2)(3,4), (2,3)(4,5) ][0X
    [4Xgap> maxgens = gens1max2.generators;[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  The  above  example  shows  that  for  restricting  representations given by
  standard  generators  to  a  maximal  subgroup of A_5, we can also fetch and
  apply the appropriate straight line program. Such a program (see [14X'Reference:
  Straight  Line  Programs'[0X)  takes  standard  generators of a group --in this
  example  A_5--  as  its  input, and returns a list of elements in this group
  --in  this  example generators of the D_10 subgroup we had met above-- which
  are  computed  essentially  by  evaluating  structured words in terms of the
  standard generators.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> prog:= AtlasProgram( "J1", "cyclic" );[0X
    [4Xrec( program := <straight line program>, standardization := 1, [0X
    [4X  identifier := [ "J1", "J1G1-cycW1", 1 ],[0X
    [4X  outputs := [ "6A", "7A", "10B", "11A", "15B", "19A" ], groupname := "J1" )[0X
    [4Xgap> gens:= GeneratorsOfGroup( FreeGroup( "x", "y" ) );;[0X
    [4Xgap> ResultOfStraightLineProgram( prog.program, gens );[0X
    [4X[ x*y*x*y^2*x*y*x*y^2*x*y*x*y*x*y^2*x*y^2, x*y, x*y*x*y^2*x*y*x*y*x*y^2*x*y^2,[0X
    [4X  x*y*x*y*x*y^2*x*y^2*x*y*x*y^2*x*y*x*y*x*y^2*x*y^2*x*y*x*y^2*x*y*x*y*x*y^[0X
    [4X    2*x*y^2, x*y*x*y*x*y^2*x*y^2, x*y*x*y^2 ][0X
  [4X------------------------------------------------------------------[0X
  
  The  above  example  shows  how  to fetch and use straight line programs for
  computing  generators  of representatives of maximally cyclic subgroups of a
  given group.
  
  [1X2.5-4 OneAtlasGeneratingSetInfo[0X
  
  [2X> OneAtlasGeneratingSetInfo( [0X[3X[gapname][,][std][,][...][0X[2X ) ___________[0Xfunction
  [6XReturns:[0X  a   record   describing   a   representation  that  satisfies  the
            conditions, or [9Xfail[0X.
  
  Let [3Xgapname[0X be a string denoting a [5XGAP[0X name (see Section  [14X2.2[0X) of a group G,
  say.   If   the  [5XATLAS[0X  of  Group  Representations  contains  at  least  one
  representation     for    G    with    the    required    properties    then
  [10XOneAtlasGeneratingSetInfo[0X  returns  a record [3Xr[0X whose components are the same
  as those of the records returned by [2XAtlasGenerators[0X ([14X2.5-2[0X), except that the
  component  [10Xgenerators[0X is not contained; the component [10Xidentifier[0X of [3Xr[0X can be
  used  as input for [2XAtlasGenerators[0X ([14X2.5-2[0X) in order to fetch the generators.
  If  no representation satisfying the given conditions ia available then [9Xfail[0X
  is returned.
  
  If the argument [3Xstd[0X is given then it must be a positive integer or a list of
  positive integers, denoting the sets of standard generators w.r.t. which the
  representation shall be given (see Section [14X2.3[0X).
  
  The  argument  [3Xgapname[0X  can  be  missing  (then  all  available  groups  are
  considered), or a list of group names can be given instead.
  
  Further  restrictions  can be entered as arguments, with the same meaning as
  described     for     [2XDisplayAtlasInfo[0X     ([14X2.5-1[0X).     The     result    of
  [2XOneAtlasGeneratingSetInfo[0X  describes  the  first  generating  set for G that
  matches the restrictions, in the ordering shown by [2XDisplayAtlasInfo[0X ([14X2.5-1[0X).
  
  Note  that  even  in the case that the user parameter "remote" has the value
  [9Xtrue[0X  (see  Section [14X1.7-1[0X),  [2XOneAtlasGeneratingSetInfo[0X  does  [13Xnot[0X attempt to
  [13Xtransfer[0X remote data files, just the table of contents is evaluated. So this
  function  (as  well  as  [2XAllAtlasGeneratingSetInfos[0X  ([14X2.5-5[0X)) can be used to
  check  for  the  availability of certain representations, and afterwards one
  can call [2XAtlasGenerators[0X ([14X2.5-2[0X) for those representations one wants to work
  with.
  
  In  the  following  example,  we try to access information about permutation
  representations for the alternating group A_5.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> info:= OneAtlasGeneratingSetInfo( "A5" );[0X
    [4Xrec( groupname := "A5", repnr := 1, [0X
    [4X  identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], p := 5, [0X
    [4X  id := "", size := 60 )[0X
    [4Xgap> gens:= AtlasGenerators( info.identifier );[0X
    [4Xrec( generators := [ (1,2)(3,4), (1,3,5) ], groupname := "A5",[0X
    [4X  standardization := 1, repnr := 1, [0X
    [4X  identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], p := 5, [0X
    [4X  id := "", size := 60 )[0X
    [4Xgap> info = OneAtlasGeneratingSetInfo( "A5", IsPermGroup, true );[0X
    [4Xtrue[0X
    [4Xgap> info = OneAtlasGeneratingSetInfo( "A5", NrMovedPoints, "minimal" );[0X
    [4Xtrue[0X
    [4Xgap> info = OneAtlasGeneratingSetInfo( "A5", NrMovedPoints, [ 1 .. 10 ] );[0X
    [4Xtrue[0X
    [4Xgap> OneAtlasGeneratingSetInfo( "A5", NrMovedPoints, 20 );[0X
    [4Xfail[0X
  [4X------------------------------------------------------------------[0X
  
  Note  that  a  permutation  representation of degree 20 could be obtained by
  taking  twice  the primitive representation on 10 points; however, the [5XATLAS[0X
  of Group Representations does not store this imprimitive representation (cf.
  Section [14X2.1[0X).
  
  We  continue this example a little. Next we access matrix representations of
  A_5.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> info:= OneAtlasGeneratingSetInfo( "A5", IsMatrixGroup, true );[0X
    [4Xrec( groupname := "A5", repnr := 4, [0X
    [4X  identifier := [ "A5", [ "A5G1-f2r4aB0.m1", "A5G1-f2r4aB0.m2" ], 1, 2 ], [0X
    [4X  dim := 4, id := "a", ring := GF(2), size := 60 )[0X
    [4Xgap> gens:= AtlasGenerators( info.identifier );[0X
    [4Xrec( [0X
    [4X  generators := [ <an immutable 4x4 matrix over GF2>, <an immutable 4x4 matrix\[0X
    [4X over GF2> ], groupname := "A5", standardization := 1, repnr := 4, [0X
    [4X  identifier := [ "A5", [ "A5G1-f2r4aB0.m1", "A5G1-f2r4aB0.m2" ], 1, 2 ], [0X
    [4X  dim := 4, id := "a", ring := GF(2), size := 60 )[0X
    [4Xgap> info = OneAtlasGeneratingSetInfo( "A5", Dimension, 4 );[0X
    [4Xtrue[0X
    [4Xgap> info = OneAtlasGeneratingSetInfo( "A5", Characteristic, 2 );[0X
    [4Xtrue[0X
    [4Xgap> info = OneAtlasGeneratingSetInfo( "A5", Ring, GF(2) );[0X
    [4Xtrue[0X
    [4Xgap> OneAtlasGeneratingSetInfo( "A5", Characteristic, [2,5], Dimension, 2 );[0X
    [4Xrec( groupname := "A5", repnr := 8, [0X
    [4X  identifier := [ "A5", [ "A5G1-f4r2aB0.m1", "A5G1-f4r2aB0.m2" ], 1, 4 ], [0X
    [4X  dim := 2, id := "a", ring := GF(2^2), size := 60 )[0X
    [4Xgap> OneAtlasGeneratingSetInfo( "A5", Characteristic, [2,5], Dimension, 1 );[0X
    [4Xfail[0X
    [4Xgap> info:= OneAtlasGeneratingSetInfo( "A5", Characteristic, 0, Dimension, 4 );[0X
    [4Xrec( groupname := "A5", repnr := 14, [0X
    [4X  identifier := [ "A5", "A5G1-Zr4B0.g", 1, 4 ], dim := 4, id := "", [0X
    [4X  ring := Integers, size := 60 )[0X
    [4Xgap> gens:= AtlasGenerators( info.identifier );[0X
    [4Xrec( [0X
    [4X  generators := [ [ [ 1, 0, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 1, 0, 0 ], [ -1, -1, [0X
    [4X              -1, -1 ] ], [0X
    [4X      [ [ 0, 1, 0, 0 ], [ 0, 0, 0, 1 ], [ 0, 0, 1, 0 ], [ 1, 0, 0, 0 ] ] ], [0X
    [4X  groupname := "A5", standardization := 1, repnr := 14, [0X
    [4X  identifier := [ "A5", "A5G1-Zr4B0.g", 1, 4 ], dim := 4, id := "", [0X
    [4X  ring := Integers, size := 60 )[0X
    [4Xgap> info = OneAtlasGeneratingSetInfo( "A5", Ring, Integers );[0X
    [4Xtrue[0X
    [4Xgap> info = OneAtlasGeneratingSetInfo( "A5", Ring, CF(37) );[0X
    [4Xtrue[0X
    [4Xgap> OneAtlasGeneratingSetInfo( "A5", Ring, Integers mod 77 );[0X
    [4Xfail[0X
    [4Xgap> info:= OneAtlasGeneratingSetInfo( "A5", Ring, CF(5), Dimension, 3 );[0X
    [4Xrec( groupname := "A5", repnr := 17, [0X
    [4X  identifier := [ "A5", "A5G1-Ar3aB0.g", 1, 3 ], dim := 3, id := "a", [0X
    [4X  ring := NF(5,[ 1, 4 ]), size := 60 )[0X
    [4Xgap> gens:= AtlasGenerators( info.identifier );[0X
    [4Xrec( [0X
    [4X  generators := [ [ [ -1, 0, 0 ], [ 0, -1, 0 ], [ -E(5)-E(5)^4, -E(5)-E(5)^4, [0X
    [4X              1 ] ], [ [ 0, 1, 0 ], [ 0, 0, 1 ], [ 1, 0, 0 ] ] ], [0X
    [4X  groupname := "A5", standardization := 1, repnr := 17, [0X
    [4X  identifier := [ "A5", "A5G1-Ar3aB0.g", 1, 3 ], dim := 3, id := "a", [0X
    [4X  ring := NF(5,[ 1, 4 ]), size := 60 )[0X
    [4Xgap> OneAtlasGeneratingSetInfo( "A5", Ring, GF(17) );[0X
    [4Xfail[0X
  [4X------------------------------------------------------------------[0X
  
  [1X2.5-5 AllAtlasGeneratingSetInfos[0X
  
  [2X> AllAtlasGeneratingSetInfos( [0X[3X[gapname][,][std][,][...][0X[2X ) __________[0Xfunction
  [6XReturns:[0X  the  list  of  all records describing representations that satisfy
            the conditions.
  
  [2XAllAtlasGeneratingSetInfos[0X  is similar to [2XOneAtlasGeneratingSetInfo[0X ([14X2.5-4[0X).
  The  difference  is  that  the  list of [13Xall[0X records describing the available
  representations  with  the  given properties is returned instead of just one
  such  component.  In  particular  an  empty  list  is  returned  if  no such
  representation is available.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> AllAtlasGeneratingSetInfos( "A5", IsPermGroup, true );[0X
    [4X[ rec( groupname := "A5", repnr := 1, [0X
    [4X      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], [0X
    [4X      p := 5, id := "", size := 60 ),[0X
    [4X  rec( groupname := "A5", repnr := 2, identifier := [0X
    [4X        [ "A5", [ "A5G1-p6B0.m1", "A5G1-p6B0.m2" ], 1, 6 ], p := 6, id := "", [0X
    [4X      size := 60 ),[0X
    [4X  rec( groupname := "A5", repnr := 3, identifier := [ "A5", [ "A5G1-p10B0.m1", [0X
    [4X              "A5G1-p10B0.m2" ], 1, 10 ], p := 10, id := "", size := 60 ) ][0X
  [4X------------------------------------------------------------------[0X
  
  Note  that  a matrix representation in any characteristic can be obtained by
  reducing  a permutation representation or an integral matrix representation;
  however,   the  [5XATLAS[0X  of  Group  Representations  does  not  [13Xstore[0X  such  a
  representation (cf. Section [14X2.1[0X).
  
  
  [1X2.6 Examples of Using the [5XAtlasRep[0X[1X Package[0X
  
  
  [1X2.6-1 Example: Class Representatives[0X
  
  First  we show the computation of class representatives of the Mathieu group
  M_11,  in  a 2-modular matrix representation. We start with the ordinary and
  Brauer character tables of this group.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> tbl:= CharacterTable( "M11" );;[0X
    [4Xgap> modtbl:= tbl mod 2;;[0X
    [4Xgap> CharacterDegrees( modtbl );[0X
    [4X[ [ 1, 1 ], [ 10, 1 ], [ 16, 2 ], [ 44, 1 ] ][0X
  [4X------------------------------------------------------------------[0X
  
  The  output of [2XCharacterDegrees[0X ([14XReference: CharacterDegrees[0X) means that the
  2-modular irreducibles of M_11 have degrees 1, 10, 16, 16, and 44.
  
  Using  [2XDisplayAtlasInfo[0X  ([14X2.5-1[0X), we find out that matrix generators for the
  irreducible 10-dimensional representation are available in the database.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> DisplayAtlasInfo( "M11", Characteristic, 2 );[0X
    [4XRepresentations for G = M11:    (all refer to std. generators 1)[0X
    [4X----------------------------[0X
    [4X 6: G <= GL(10,2)[0X
    [4X 7: G <= GL(32,2)[0X
    [4X 8: G <= GL(44,2)[0X
    [4X16: G <= GL(16a,4)[0X
    [4X17: G <= GL(16b,4)[0X
  [4X------------------------------------------------------------------[0X
  
  So  we  decide to work with this representation. We fetch the generators and
  compute the list of class representatives of M_11 in the representation. The
  ordering of class representatives is the same as that in the character table
  of the [5XATLAS[0X of Finite Groups ([CCNPW85]), which coincides with the ordering
  of columns in the [5XGAP[0X table we have fetched above.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> info:= OneAtlasGeneratingSetInfo( "M11", Characteristic, 2,[0X
    [4X>                                             Dimension, 10 );;[0X
    [4Xgap> gens:= AtlasGenerators( info.identifier );;[0X
    [4Xgap> ccls:= AtlasProgram( "M11", gens.standardization, "classes" );[0X
    [4Xrec( program := <straight line program>, standardization := 1,[0X
    [4X  identifier := [ "M11", "M11G1-cclsW1", 1 ],[0X
    [4X  outputs := [ "1A", "2A", "3A", "4A", "5A", "6A", "8A", "8B", "11A", "11B" ],[0X
    [4X  groupname := "M11" )[0X
    [4Xgap> reps:= ResultOfStraightLineProgram( ccls.program, gens.generators );;[0X
  [4X------------------------------------------------------------------[0X
  
  If  we  would  need  only  a few class representatives, we could use the [5XGAP[0X
  library  function  [2XRestrictOutputsOfSLP[0X ([14XReference: RestrictOutputsOfSLP[0X) to
  create a straight line program that computes only specified outputs. Here is
  an example where only the class representatives of order eight are computed.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> ord8prg:= RestrictOutputsOfSLP( ccls.program,[0X
    [4X>                   Filtered( [ 1 .. 10 ], i -> ccls.outputs[i][1] = '8' ) );[0X
    [4X<straight line program>[0X
    [4Xgap> ord8reps:= ResultOfStraightLineProgram( ord8prg, gens.generators );;[0X
    [4Xgap> List( ord8reps, m -> Position( reps, m ) );[0X
    [4X[ 7, 8 ][0X
  [4X------------------------------------------------------------------[0X
  
  Let us check that the class representatives have the right orders.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> List( reps, Order ) = OrdersClassRepresentatives( tbl );[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  From  the  class representatives, we can compute the Brauer character we had
  started  with.  This  Brauer  character  is  defined  on  all classes of the
  2-modular  table. So we first pick only those representatives, using the [5XGAP[0X
  function  [2XGetFusionMap[0X  ([14XReference:  GetFusionMap[0X);  in  this  situation, it
  returns the class fusion from the Brauer table into the ordinary table.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> fus:= GetFusionMap( modtbl, tbl );[0X
    [4X[ 1, 3, 5, 9, 10 ][0X
    [4Xgap> modreps:= reps{ fus };;[0X
  [4X------------------------------------------------------------------[0X
  
  Then   we   call   the   [5XGAP[0X   function   [2XBrauerCharacterValue[0X   ([14XReference:
  BrauerCharacterValue[0X),  which  computes  the Brauer character value from the
  matrix given.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> char:= List( modreps, BrauerCharacterValue );[0X
    [4X[ 10, 1, 0, -1, -1 ][0X
    [4Xgap> Position( Irr( modtbl ), char );[0X
    [4X2[0X
  [4X------------------------------------------------------------------[0X
  
  
  [1X2.6-2 Example: Permutation and Matrix Representations[0X
  
  The  second  example  shows  the computation of a permutation representation
  from a matrix representation. We work with the 10-dimensional representation
  used  above,  and  consider the action on the 2^10 vectors of the underlying
  row space.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> grp:= Group( gens.generators );;[0X
    [4Xgap> v:= GF(2)^10;;[0X
    [4Xgap> orbs:= Orbits( grp, AsList( v ) );;[0X
    [4Xgap> List( orbs, Length );[0X
    [4X[ 1, 396, 55, 330, 66, 165, 11 ][0X
  [4X------------------------------------------------------------------[0X
  
  We  see  that  there  are  six  nontrivial  orbits,  and  we can compute the
  permutation  actions  on  these  orbits  directly using [10XAction[0X. However, for
  larger  examples,  one cannot write down all orbits on the row space, so one
  has to use another strategy if one is interested in a particular orbit.
  
  Let  us  assume  that we are interested in the orbit of length 11. The point
  stabilizer  is  the  first maximal subgroup of M_11, thus the restriction of
  the representation to this subgroup has a nontrivial fixed point space. This
  restriction can be computed using the [5XAtlasRep[0X package.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> gens:= AtlasGenerators( "M11", 6, 1 );;[0X
  [4X------------------------------------------------------------------[0X
  
  Now computing the fixed point space is standard linear algebra.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> id:= IdentityMat( 10, GF(2) );;[0X
    [4Xgap> sub1:= Subspace( v, NullspaceMat( gens.generators[1] - id ) );;[0X
    [4Xgap> sub2:= Subspace( v, NullspaceMat( gens.generators[2] - id ) );;[0X
    [4Xgap> fix:= Intersection( sub1, sub2 );[0X
    [4X<vector space of dimension 1 over GF(2)>[0X
  [4X------------------------------------------------------------------[0X
  
  The final step is of course the computation of the permutation action on the
  orbit.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> orb:= Orbit( grp, Basis( fix )[1] );;[0X
    [4Xgap> act:= Action( grp, orb );;  Print( act, "\n" );[0X
    [4XGroup( [ ( 1, 2)( 4, 6)( 5, 8)( 7,10), ( 1, 3, 5, 9)( 2, 4, 7,11) ] )[0X
  [4X------------------------------------------------------------------[0X
  
  Note  that  this  group  is  [13Xnot[0X equal to the group obtained by fetching the
  permutation  representation  from  the  database. This is due to a different
  numbering of the points, so the groups are permutation isomorphic.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> permgrp:= Group( AtlasGenerators( "M11", 1 ).generators );;[0X
    [4Xgap> Print( permgrp, "\n" );[0X
    [4XGroup( [ ( 2,10)( 4,11)( 5, 7)( 8, 9), ( 1, 4, 3, 8)( 2, 5, 6, 9) ] )[0X
    [4Xgap> permgrp = act;[0X
    [4Xfalse[0X
    [4Xgap> IsConjugate( SymmetricGroup(11), permgrp, act );[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  
  [1X2.6-3 Example: Outer Automorphisms[0X
  
  The  straight  line  programs  for  applying outer automorphisms to standard
  generators  can  of course be used to define the automorphisms themselves as
  [5XGAP[0X mappings.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> DisplayAtlasInfo( "G2(3)", IsStraightLineProgram );[0X
    [4XPrograms for G = G2(3):    (all refer to std. generators 1)[0X
    [4X-----------------------[0X
    [4Xavailable maxes of G:  [ 1 .. 10 ][0X
    [4Xclass repres. of G available[0X
    [4Xrepres. of cyclic subgroups of G available[0X
    [4Xavailable automorphisms:  [ "2" ][0X
    [4Xstandard generators checker available[0X
    [4Xpresentation available[0X
    [4Xgap> prog:= AtlasProgram( "G2(3)", "automorphism", "2" ).program;;[0X
    [4Xgap> info:= OneAtlasGeneratingSetInfo( "G2(3)", Dimension, 7 );;[0X
    [4Xgap> gens:= AtlasGenerators( info ).generators;;[0X
    [4Xgap> imgs:= ResultOfStraightLineProgram( prog, gens );;[0X
  [4X------------------------------------------------------------------[0X
  
  If we are not suspicious whether the script really describes an automorphism
  then  we  should tell this to [5XGAP[0X, in order to avoid the expensive checks of
  the    properties    of    being   a   homomorphism   and   bijective   (see
  Section [14X'Reference: Creating Group Homomorphisms'[0X). This looks as follows.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> g:= Group( gens );;[0X
    [4Xgap> aut:= GroupHomomorphismByImagesNC( g, g, gens, imgs );;[0X
    [4Xgap> SetIsBijective( aut, true );[0X
  [4X------------------------------------------------------------------[0X
  
  If  we  are  suspicious whether the script describes an automorphism then we
  might have the idea to check it with [5XGAP[0X, as follows.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> aut:= GroupHomomorphismByImages( g, g, gens, imgs );;[0X
    [4Xgap> IsBijective( aut );[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  (Note  that  even for a comparatively small group such as G_2(3), this was a
  difficult task for [5XGAP[0X before version 4.3.)
  
  Often one can form images under an automorphism alpha, say, without creating
  the  homomorphism object. This is obvious for the standard generators of the
  group G themselves, but also for generators of a maximal subgroup M computed
  from  standard  generators of G, provided that the straight line programs in
  question  refer to the same standard generators. Note that the generators of
  M  are  given  by evaluating words in terms of standard generators of G, and
  their images under alpha can be obtained by evaluating the same words at the
  images under alpha of the standard generators of G.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> max1:= AtlasProgram( "G2(3)", 1 ).program;;[0X
    [4Xgap> mgens:= ResultOfStraightLineProgram( max1, gens );;[0X
    [4Xgap> comp:= CompositionOfStraightLinePrograms( max1, prog );;[0X
    [4Xgap> mimgs:= ResultOfStraightLineProgram( comp, gens );;[0X
  [4X------------------------------------------------------------------[0X
  
  The  list  [10Xmgens[0X  is the list of generators of the first maximal subgroup of
  G_2(3),  [10Xmimgs[0X  is  the  list  of images under the automorphism given by the
  straight  line  program  [10Xprog[0X.  Note  that  applying the program returned by
  [2XCompositionOfStraightLinePrograms[0X                                ([14XReference:
  CompositionOfStraightLinePrograms[0X)  means to apply first [10Xprog[0X and then [10Xmax1[0X,
  Since   we   have  already  constructed  the  [5XGAP[0X  object  representing  the
  automorphism, we can check whether the results are equal.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> mimgs = List( mgens, x -> x^aut );[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  However, it should be emphasized that using [10Xaut[0X requires a huge machinery of
  computations  behind the scenes, whereas applying the straight line programs
  [10Xprog[0X  and  [10Xmax1[0X involves only elementary operations with the generators. The
  latter  is  feasible  also for larger groups, for which constructing the [5XGAP[0X
  automorphism might be impossible.
  
  
  [1X2.6-4 Example: Using Semi-presentations and Black Box Programs[0X
  
  Let  us  suppose  that  we  want to restrict a representation of the Mathieu
  group  M_12  to a non-maximal subgroup of the type L_2(11). The idea is that
  this  subgroup  can  be found as a maximal subgroup of a maximal subgroup of
  the  type  M_11,  which  is  itself  maximal  in  M_12. For that, we fetch a
  representation of M_12 and use a straight line program for restricting it to
  the first maximal subgroup, which has the type M_11.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> info:= OneAtlasGeneratingSetInfo( "M12", NrMovedPoints, 12 );[0X
    [4Xrec( groupname := "M12", repnr := 1, [0X
    [4X  identifier := [ "M12", [ "M12G1-p12aB0.m1", "M12G1-p12aB0.m2" ], 1, 12 ], [0X
    [4X  p := 12, id := "a", size := 95040 )[0X
    [4Xgap> gensM12:= AtlasGenerators( info.identifier );;[0X
    [4Xgap> restM11:= AtlasProgram( "M12", "maxes", 1 );;[0X
    [4Xgap> gensM11:= ResultOfStraightLineProgram( restM11.program,[0X
    [4X>                                           gensM12.generators );[0X
    [4X[ (3,9)(4,12)(5,10)(6,8), (1,4,11,5)(2,10,8,3) ][0X
  [4X------------------------------------------------------------------[0X
  
  Now  we  cannot  simply  apply  a  straight  line  program for M_11 to these
  generators  of  M_11,  since they are not necessarily [13Xstandard[0X generators of
  M_11. We check this using a semi-presentation for M_11.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> checkM11:= AtlasProgram( "M11", "check" );[0X
    [4Xrec( program := <straight line decision>, standardization := 1, [0X
    [4X  identifier := [ "M11", "M11G1-check1", 1, 1 ], groupname := "M11" )[0X
    [4Xgap> ResultOfStraightLineDecision( checkM11.program, gensM11 );[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  So  we are lucky that applying the appropriate program for M_11 will give us
  the required generators for L_2(11).
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> restL211:= AtlasProgram( "M11", "maxes", 2 );;[0X
    [4Xgap> gensL211:= ResultOfStraightLineProgram( restL211.program, gensM11 );[0X
    [4X[ (3,9)(4,12)(5,10)(6,8), (1,11,9)(2,12,8)(3,6,10) ][0X
    [4Xgap> G:= Group( gensL211 );;  Size( G );  IsSimple( G );[0X
    [4X660[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  Usually  representations  are not given in terms of standard generators. For
  example,  let  us  take  the  M_11  type  group returned by the [5XGAP[0X function
  [2XMathieuGroup[0X ([14XReference: MathieuGroup[0X).
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> G:= MathieuGroup( 11 );;[0X
    [4Xgap> gens:= GeneratorsOfGroup( G );[0X
    [4X[ (1,2,3,4,5,6,7,8,9,10,11), (3,7,11,8)(4,10,5,6) ][0X
    [4Xgap> ResultOfStraightLineDecision( checkM11.program, gens );   [0X
    [4Xfalse[0X
  [4X------------------------------------------------------------------[0X
  
  If  we  want to compute an L_2(11) type subgroup of this group, we can use a
  black  box  program  for  computing  standard generators, and then apply the
  straight line program for computing the restriction.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> find:= AtlasProgram( "M11", "find" );[0X
    [4Xrec( program := <black box program>, standardization := 1, [0X
    [4X  identifier := [ "M11", "M11G1-find1", 1, 1 ], groupname := "M11" )[0X
    [4Xgap> stdgens:= ResultOfBBoxProgram( find.program, Group( gens ) );;[0X
    [4Xgap> List( stdgens, Order );[0X
    [4X[ 2, 4 ][0X
    [4Xgap> ResultOfStraightLineDecision( checkM11.program, stdgens );[0X
    [4Xtrue[0X
    [4Xgap> gensL211:= ResultOfStraightLineProgram( restL211.program, stdgens );;[0X
    [4Xgap> List( gensL211, Order );[0X
    [4X[ 2, 3 ][0X
    [4Xgap> G:= Group( gensL211 );;  Size( G );  IsSimple( G );[0X
    [4X660[0X
    [4Xtrue[0X
  [4X------------------------------------------------------------------[0X
  
  
  [1X2.6-5 Example: Using the [5XGAP[0X[1X Library of Tables of Marks[0X
  
  The  [5XGAP[0X library of tables of marks provides, for many almost simple groups,
  information  for  constructing  representatives  of all conjugacy classes of
  subgroups. If this information is compatible with the standard generators of
  the  [5XATLAS[0X  of  Group  Representations  then  we  can use it to restrict any
  representation  from  the  [5XATLAS[0X  to prescribed subgroups. This is useful in
  particular  for those subgroups for which the [5XATLAS[0X of Group Representations
  itself does not contain a straight line program.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> tom:= TableOfMarks( "A5" );[0X
    [4XTableOfMarks( "A5" )[0X
    [4Xgap> info:= StandardGeneratorsInfo( tom );[0X
    [4X[ rec( generators := "a, b", description := "|a|=2, |b|=3, |ab|=5", [0X
    [4X      script := [ [ 1, 2 ], [ 2, 3 ], [ 1, 1, 2, 1, 5 ] ], ATLAS := true ) ][0X
  [4X------------------------------------------------------------------[0X
  
  The  [9Xtrue[0X value of the component [10XATLAS[0X indicates that the information stored
  on  [10Xtom[0X  refers  to  the standard generators of type 1 in the [5XATLAS[0X of Group
  Representations.
  
  We  want  to  restrict  a  4-dimensional integral representation of A_5 to a
  Sylow 2 subgroup of A_5, and use [2XRepresentativeTomByGeneratorsNC[0X ([14XReference:
  RepresentativeTomByGeneratorsNC[0X) for that.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4Xgap> info:= OneAtlasGeneratingSetInfo( "A5", Ring, Integers, Dimension, 4 );;[0X
    [4Xgap> stdgens:= AtlasGenerators( info.identifier );[0X
    [4Xrec( [0X
    [4X  generators := [ [ [ 1, 0, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 1, 0, 0 ], [ -1, -1, [0X
    [4X              -1, -1 ] ], [0X
    [4X      [ [ 0, 1, 0, 0 ], [ 0, 0, 0, 1 ], [ 0, 0, 1, 0 ], [ 1, 0, 0, 0 ] ] ], [0X
    [4X  groupname := "A5", standardization := 1, repnr := 14, [0X
    [4X  identifier := [ "A5", "A5G1-Zr4B0.g", 1, 4 ], dim := 4, id := "", [0X
    [4X  ring := Integers, size := 60 )[0X
    [4Xgap> orders:= OrdersTom( tom );[0X
    [4X[ 1, 2, 3, 4, 5, 6, 10, 12, 60 ][0X
    [4Xgap> pos:= Position( orders, 4 );[0X
    [4X4[0X
    [4Xgap> sub:= RepresentativeTomByGeneratorsNC( tom, pos, stdgens.generators );[0X
    [4X<matrix group of size 4 with 2 generators>[0X
    [4Xgap> GeneratorsOfGroup( sub );[0X
    [4X[ [ [ 1, 0, 0, 0 ], [ -1, -1, -1, -1 ], [ 0, 0, 0, 1 ], [ 0, 0, 1, 0 ] ], [0X
    [4X  [ [ 1, 0, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 1, 0, 0 ], [ -1, -1, -1, -1 ] ] ][0X
  [4X------------------------------------------------------------------[0X
  
