chap3.txt

  
  3 The User Interface of the AtlasRep Package
  
  The  user  interface  is  the  part  of the GAP 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 4.3-1). The
  corresponding  functions  are described in this chapter. See Section 2.4 for
  some small examples how to use the functions of the interface.
  
  Extensions  of  the AtlasRep package are regarded as another part of the GAP
  interface,  they  are described in Chapter 5. Finally, the low level part of
  the interface are described in Chapter 7.
  
  For  some  of  the  examples  in  this chapter, the GAP packages CTblLib and
  TomLib are needed, so we load them.
  
    Example  
    gap> LoadPackage( "ctbllib" );
    true
    gap> LoadPackage( "tomlib" );
    true
  
  
  
  3.1 Accessing vs. Constructing Representations
  
  Note  that  accessing the data means in particular that it is not the aim of
  this  package  to construct 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
  OneAtlasGeneratingSetInfo  (3.5-5)  returns  fail  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.
  
  
  3.2 Group Names Used in the AtlasRep Package
  
  When  you  access  data  via  the AtlasRep package, you specify the group in
  question  by  an  admissible name. Thus it is essential to know these names,
  which are called the GAP names of the group in the following.
  
  For  a  group  G, say, whose character table is available in GAP's Character
  Table  Library,  the  admissible names of G are the admissible names of this
  character  table.  If  G  is  almost simple, one such name is the Identifier
  (Reference: Identifier (for character tables)) value of the character table,
  see Accessing  a  Character  Table  from  the  Library (CTblLib: Accessing a
  Character  Table from the Library). This name is usually very similar to the
  name  used  in the ATLAS of Finite Groups [CCNPW85]. For example, "M22" is a
  GAP  name  of  the  Mathieu  group  M_22,  "12_1.U4(3).2_1" is a GAP name of
  12_1.U_4(3).2_1,  the  two  names  "S5"  and  "A5.2"  are  GAP  names of the
  symmetric  group  S_5,  and the two names "F3+" and "Fi24'" are GAP names of
  the simple Fischer group Fi_24^'.
  
  When a GAP name is required as an input of a package function, this input is
  case  insensitive.  For  example,  both "A5" and "a5" are valid arguments of
  DisplayAtlasInfo (3.5-1).
  
  Internally,  for example as part of filenames (see Section 7.6), the package
  uses  names  that  may  differ  from  the  GAP names; these names are called
  ATLAS-file names. For example, "A5", "TE62", and "F24" are ATLAS-file names.
  Of  these,  only  "A5"  is  also  a  GAP  name,  but  the other two are not;
  corresponding GAP names are "2E6(2)" and "Fi24'", respectively.
  
  
  3.3 Standard Generators Used in the AtlasRep Package
  
  For the general definition of standard generators of a group, see [Wil96].
  
  Several  different  standard  generators  may  be  defined  for a group, the
  definitions can be found at
  
  http://brauer.maths.qmul.ac.uk/Atlas
  
  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 compatible
  standardization.  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.
  
  
  3.4 Class Names Used in the AtlasRep Package
  
  For  each  straight  line program (see AtlasProgram (3.5-3)) 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 AtlasProgram (3.5-3) contain a component outputs
  with value a list of class names.
  
  Currently  we  define  these  class names only for simple groups and certain
  extensions of simple groups, see Section 3.4-1. The function AtlasClassNames
  (3.4-2)  can  be  used to compute the list of class names from the character
  table in the GAP Library.
  
  
  3.4-1 Definition of ATLAS Class Names
  
  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 ATLAS 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  ' and - (starting with a capital letter). For example, 1A, 12A1,
  and  3B'  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  simple  group, the class names are the same as
        returned  by  the  two argument version of the GAP function ClassNames
        (Reference:  ClassNames),  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 nA, nB, nC, ...;
        the  alphabet  used  here  is potentially infinite, and reads A, B, C,
        ..., Z, A1, B1, ..., A2, B2, ....
  
        For  example,  the classes of the alternating group A_5 have the names
        1A, 2A, 3A, 5A, and 5B.
  
  2   Next we consider the case of an upward extension G.A of a simple group
        G by a cyclic group of order A. The ATLAS 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 '.  So  dashed  class  names refer exactly to those
        classes that are not printed in the ATLAS.
  
        For  example, those classes of the symmetric group S_5 that do not lie
        in  A_5  have the names 2B, 4A, and 6A. The outer classes of the group
        L_2(8).3  have  the  names  3B,  6A,  9D, and 3B', 6A', 9D'. The outer
        elements  of  order  5  in  the group Sz(32).5 lie in the classes with
        names 5B, 5B', 5B'', and 5B'''.
  
        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  9A, 9A', 9B, and 9B'; in L_2(27).6, these
        classes fuse to 9AB and 9A'B'.
  
  3   Now  we  define  class  names  for  general upward extensions 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 exception 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  21A and 21B of the group U_3(5).3 fuse in
        U_3(5).S_3  to the class 21AB, and the class 2B of U_3(5).2 fuses with
        the  involution  classes  2B',  2B''  in  the  groups  U_3(5).2^'  and
        U_3(5).2^{''} to the class 2B of U_3(5).S_3.
  
        It  may  happen  that  some names in the outputs component of a record
        returned by AtlasProgram (3.5-3) do not uniquely determine the classes
        of   the  corresponding  elements.  For  example,  the  (algebraically
        conjugate)  classes  39A  and  39B  of  the  group  Co_1 have not been
        distinguished  yet. In such cases, the names used contain a minus sign
        -,  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 39A-B for
        the  group  Co_1 means 39A or 39B, and the name 20A-B''' 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  downward  extension  m.G.A  of an almost simple group G.A by a
        cyclic  group  of  order  m, let π denote the natural epimorphism from
        m.G.A onto G.A. Each class name of m.G.A has the form nX_0, nX_1 etc.,
        where  nX is the class name of the image under π, and the indices 0, 1
        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 1A_1 and 1A_5 denote the classes containing
        the  generators of the kernel of π, that is, central elements of order
        6.
  
  3.4-2 AtlasClassNames
  
  AtlasClassNames( tbl )  function
  Returns:  a list of class names.
  
  Let  tbl  be the ordinary or modular character table of a group G, say, that
  is  almost simple or a downward extension of an almost simple group and such
  that  tbl  is an ATLAS table from the GAP Character Table Library, according
  to  its  InfoText  (Reference: InfoText) value. Then AtlasClassNames returns
  the  list of class names for G, as defined in Section 3.4-1. The ordering of
  class names is the same as the ordering of the columns of tbl.
  
  (The  function may work also for character tables that are not ATLAS tables,
  but then clearly the class names returned are somewhat arbitrary.)
  
    Example  
    gap> AtlasClassNames( CharacterTable( "L3(4).3" ) );
    [ "1A", "2A", "3A", "4ABC", "5A", "5B", "7A", "7B", "3B", "3B'", 
      "3C", "3C'", "6B", "6B'", "15A", "15A'", "15B", "15B'", "21A", 
      "21A'", "21B", "21B'" ]
    gap> AtlasClassNames( CharacterTable( "U3(5).2" ) );
    [ "1A", "2A", "3A", "4A", "5A", "5B", "5CD", "6A", "7AB", "8AB", 
      "10A", "2B", "4B", "6D", "8C", "10B", "12B", "20A", "20B" ]
    gap> AtlasClassNames( CharacterTable( "L2(27).6" ) );
    [ "1A", "2A", "3AB", "7ABC", "13ABC", "13DEF", "14ABC", "2B", "4A", 
      "26ABC", "26DEF", "28ABC", "28DEF", "3C", "3C'", "6A", "6A'", 
      "9AB", "9A'B'", "6B", "6B'", "12A", "12A'" ]
    gap> AtlasClassNames( CharacterTable( "L3(4).3.2_2" ) );
    [ "1A", "2A", "3A", "4ABC", "5AB", "7A", "7B", "3B", "3C", "6B", 
      "15A", "15B", "21A", "21B", "2C", "4E", "6E", "8D", "14A", "14B" ]
    gap> AtlasClassNames( CharacterTable( "3.A6" ) );
    [ "1A_0", "1A_1", "1A_2", "2A_0", "2A_1", "2A_2", "3A_0", "3B_0", 
      "4A_0", "4A_1", "4A_2", "5A_0", "5A_1", "5A_2", "5B_0", "5B_1", 
      "5B_2" ]
    gap> AtlasClassNames( CharacterTable( "2.A5.2" ) );
    [ "1A_0", "1A_1", "2A_0", "3A_0", "3A_1", "5AB_0", "5AB_1", "2B_0", 
      "4A_0", "4A_1", "6A_0", "6A_1" ]
  
  
  3.4-3 AtlasCharacterNames
  
  AtlasCharacterNames( tbl )  function
  Returns:  a list of character names.
  
  Let  tbl  be  the  ordinary  or  modular  character table of a simple group.
  AtlasCharacterNames returns a list of strings, the i-th entry being the name
  of  the  i-th irreducible character of tbl; this name consists of the degree
  of this character followed by distinguishing lowercase letters.
  
    Example  
    gap> AtlasCharacterNames( CharacterTable( "A5" ) );                   
    [ "1a", "3a", "3b", "4a", "5a" ]
  
  
  
  3.5 Accessing Data of the AtlasRep Package
  
  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.
  
  3.5-1 DisplayAtlasInfo
  
  DisplayAtlasInfo( [listofnames, ][std, ]["contents", sources, ][...] )  function
  DisplayAtlasInfo( gapname[, std][, ...] )  function
  
  This  function lists the information available via the AtlasRep package, for
  the  given input. Depending on whether remote access to data is enabled (see
  Section  4.3-1), all the data provided by the ATLAS of Group Representations
  or only those in the local installation are considered.
  
  An   interactive   alternative   to   DisplayAtlasInfo   is   the   function
  BrowseAtlasInfo (Browse: BrowseAtlasInfo), see [BL14].
  
  Called   without   arguments,   DisplayAtlasInfo  prints  an  overview  what
  information the ATLAS of Group Representations provides. One line is printed
  for each group G, with the following columns.
  
  group
        the GAP name of G (see Section 3.2),
  
  #
        the  number  of faithful representations stored for G that satisfy the
        additional conditions given (see below),
  
  maxes
        the   number   of  available  straight  line  programs  for  computing
        generators of maximal subgroups of G,
  
  cl
        a  +  sign  if  at  least one program for computing representatives of
        conjugacy classes of elements of G is stored,
  
  cyc
        a  +  sign  if  at  least one program for computing representatives of
        classes of maximally cyclic subgroups of G is stored,
  
  out
        descriptions  of  outer  automorphisms  of  G  for  which at least one
        program is stored,
  
  fnd
        a  +  sign  if  at least one program is available for finding standard
        generators,
  
  chk
        a  +  sign if at least one program is available for checking whether a
        set of generators is a set of standard generators, and
  
  prs
        a  +  sign  if  at  least  one  program  is  available  that encodes a
        presentation.
  
  (The  list  can  be  printed  to  the screen or can be fed into a pager, see
  Section 4.3-5.)
  
  Called  with  a  list  listofnames of strings that are GAP names for a group
  from  the  ATLAS  of  Group  Representations,  DisplayAtlasInfo  prints  the
  overview described above but restricted to the groups in this list.
  
  In  addition  to  or  instead  of  listofnames,  the string "contents" and a
  description  sources  of  the  data may be given about which the overview is
  formed. See below for admissible values of sources.
  
  Called  with  a string gapname that is a GAP name for a group from the ATLAS
  of  Group  Representations,  DisplayAtlasInfo  prints  an  overview  of  the
  information  that  is available for this group. One line is printed for each
  faithful  representation,  showing  the number of this representation (which
  can be used in calls of AtlasGenerators (3.5-2)), and a string of one of the
  following forms; in both cases, id is a (possibly empty) string.
  
  G <= Sym(nid)
        denotes  a  permutation  representation  of degree n, for example G <=
        Sym(40a)  and G <= Sym(40b) denote two (nonequivalent) representations
        of degree 40.
  
  G <= GL(nid,descr)
        denotes a matrix representation of dimension n over a coefficient ring
        described  by  descr, which can be a prime power, ℤ (denoting the ring
        of  integers),  a  description  of  an  algebraic  extension  field, ℂ
        (denoting  an  unspecified  algebraic extension field), or ℤ/mℤ for an
        integer  m  (denoting  the  ring of residues mod m); for example, G <=
        GL(2a,4)  and G <= GL(2b,4) denote two (nonequivalent) representations
        of dimension 2 over the field with four elements.
  
  After the representations, the programs available for gapname are listed.
  
  The following optional arguments can be used to restrict the overviews.
  
  std
        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
        std-th  set  of  standard  generators  or  the  i-th  set  of standard
        generators, for i in std (see Section 3.3),
  
  "contents" and sources
        for  a  string  or  a list of strings sources, restrict the data about
        which  the  overview is formed; if sources is the string "public" then
        only  non-private data (see Chapter 5) are considered, if sources is a
        string  that  denotes  a  private  extension  in  the sense of a dirid
        argument  of AtlasOfGroupRepresentationsNotifyPrivateDirectory (5.1-1)
        then  only  the  data  that  belong  to  this  private  extension  are
        considered;  also  a list of such strings may be given, then the union
        of these data is considered,
  
  Identifier and id
        restrict  to  representations with identifier component in the list id
        (note  that this component is itself a list, entering this list is not
        admissible), or satisfying the function id,
  
  IsPermGroup and true
        restrict to permutation representations,
  
  NrMovedPoints and n
        for  a positive integer, a list of positive integers, or a property n,
        restrict  to  permutation  representations of degree equal to n, or in
        the list n, or satisfying the function n,
  
  NrMovedPoints and the string "minimal"
        restrict to faithful permutation representations of minimal degree (if
        this information is available),
  
  IsTransitive and true or false
        restrict to transitive or intransitive permutation representations (if
        this information is available),
  
  IsPrimitive and true or false
        restrict  to  primitive or imprimitive permutation representations (if
        this information is available),
  
  Transitivity and n
        for  a  nonnegative  integer,  a  list  of  nonnegative integers, or a
        property  n,  restrict  to permutation representations of transitivity
        equal  to  n,  or in the list n, or satisfying the function n (if this
        information is available),
  
  RankAction and n
        for  a  nonnegative  integer,  a  list  of  nonnegative integers, or a
        property  n,  restrict to permutation representations of rank equal to
        n, or in the list n, or satisfying the function n (if this information
        is available),
  
  IsMatrixGroup and true
        restrict to matrix representations,
  
  Characteristic and p
        for  a  prime  integer,  a  list  of  prime integers, or a property p,
        restrict to matrix representations over fields of characteristic equal
        to  p, or in the list p, or satisfying the function p (representations
        over  residue  class  rings  that  are  not fields can be addressed by
        entering fail as the value of p),
  
  Dimension and n
        for  a positive integer, a list of positive integers, or a property n,
        restrict  to matrix representations of dimension equal to n, or in the
        list n, or satisfying the function n,
  
  Characteristic, p, Dimension,
        and the string "minimal"
        for  a  prime  integer  p, restrict to faithful matrix representations
        over  fields  of characteristic p that have minimal dimension (if this
        information is available),
  
  Ring and R
        for  a  ring  or a property R, restrict to matrix representations over
        this  ring  or  satisfying this function (note that the representation
        might be defined over a proper subring of R),
  
  Ring, R, Dimension,
        and the string "minimal"
        for  a  ring  R, restrict to faithful matrix representations over this
        ring that have minimal dimension (if this information is available),
  
  Character and chi
        for  a  class  function  or a list of class functions chi, restrict to
        matrix representations with these characters (note that the underlying
        characteristic   of   the   class  function,  see  Section 'Reference:
        UnderlyingCharacteristic',   determines   the  characteristic  of  the
        matrices), and
  
  IsStraightLineProgram and true
        restrict  to  straight  line  programs,  straight  line decisions (see
        Section 6.1), and black box programs (see Section 6.2).
  
  Note  that  the  above  conditions  refer  only  to  the information that is
  available  without  accessing the representations. For example, if it is not
  stored  in  the  table  of  contents whether a permutation representation is
  primitive  then  this representation does not match an IsPrimitive condition
  in DisplayAtlasInfo.
  
  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
  MinimalRepresentationInfo   (6.3-1)  for  checking  whether  the  minimality
  information  is  available for the group in question. Note that in the cases
  where  the string "minimal" occurs as an argument, MinimalRepresentationInfo
  (6.3-1)  is  called with third argument "lookup"; this is because the stored
  information  was  precomputed  just  for  the  groups  in the ATLAS 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 Maxes (CTblLib:
  Maxes) attribute for character tables.)
  
    Example  
    gap> DisplayAtlasInfo( [ "M11", "A5" ] );
    group |  # | maxes | cl | cyc | out | fnd | chk | prs
    ------+----+-------+----+-----+-----+-----+-----+----
    M11   | 42 |     5 |  + |  +  |     |  +  |  +  |  + 
    A5    | 18 |     3 |    |     |     |     |  +  |  + 
  
  
  The  above  output means that the ATLAS 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  straight  line
  decisions  that  check  a  set  of generators or a set of group elements for
  being  a  set of 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;  straight line decisions for
  checking the standardization of generators or group elements are available.
  
    Example  
    gap> DisplayAtlasInfo( "A5", IsPermGroup, true );
    Representations for G = A5:    (all refer to std. generators 1)
    ---------------------------
    1: G <= Sym(5)  3-trans., on cosets of A4 (1st max.)
    2: G <= Sym(6)  2-trans., on cosets of D10 (2nd max.)
    3: G <= Sym(10) rank 3, on cosets of S3 (3rd max.)
    gap> DisplayAtlasInfo( "A5", NrMovedPoints, [ 4 .. 9 ] );
    Representations for G = A5:    (all refer to std. generators 1)
    ---------------------------
    1: G <= Sym(5) 3-trans., on cosets of A4 (1st max.)
    2: G <= Sym(6) 2-trans., on cosets of D10 (2nd max.)
  
  
  The  first  three  representations  stored  for  A_5 are (in fact primitive)
  permutation representations.
  
    Example  
    gap> DisplayAtlasInfo( "A5", Dimension, [ 1 .. 3 ] );
    Representations for G = A5:    (all refer to std. generators 1)
    ---------------------------
     8: G <= GL(2a,4)                
     9: G <= GL(2b,4)                
    10: G <= GL(3,5)                 
    12: G <= GL(3a,9)                
    13: G <= GL(3b,9)                
    17: G <= GL(3a,Field([Sqrt(5)])) 
    18: G <= GL(3b,Field([Sqrt(5)])) 
    gap> DisplayAtlasInfo( "A5", Characteristic, 0 );
    Representations for G = A5:    (all refer to std. generators 1)
    ---------------------------
    14: G <= GL(4,Z)                 
    15: G <= GL(5,Z)                 
    16: G <= GL(6,Z)                 
    17: G <= GL(3a,Field([Sqrt(5)])) 
    18: G <= GL(3b,Field([Sqrt(5)])) 
  
  
  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 sqrt{5} over the rational number
  field.
  
    Example  
    gap> DisplayAtlasInfo( "A5", Identifier, "a" );
    Representations for G = A5:    (all refer to std. generators 1)
    ---------------------------
     4: G <= GL(4a,2)                
     8: G <= GL(2a,4)                
    12: G <= GL(3a,9)                
    17: G <= GL(3a,Field([Sqrt(5)])) 
  
  
  Each  of  the  representations  with the numbers 4, 8, 12, and 17 is labeled
  with the distinguishing letter a.
  
    Example  
    gap> DisplayAtlasInfo( "A5", NrMovedPoints, IsPrimeInt );
    Representations for G = A5:    (all refer to std. generators 1)
    ---------------------------
    1: G <= Sym(5) 3-trans., on cosets of A4 (1st max.)
    gap> DisplayAtlasInfo( "A5", Characteristic, IsOddInt );
    Representations for G = A5:    (all refer to std. generators 1)
    ---------------------------
     6: G <= GL(4,3)  
     7: G <= GL(6,3)  
    10: G <= GL(3,5)  
    11: G <= GL(5,5)  
    12: G <= GL(3a,9) 
    13: G <= GL(3b,9) 
    gap> DisplayAtlasInfo( "A5", Dimension, IsPrimeInt );
    Representations for G = A5:    (all refer to std. generators 1)
    ---------------------------
     8: G <= GL(2a,4)                
     9: G <= GL(2b,4)                
    10: G <= GL(3,5)                 
    11: G <= GL(5,5)                 
    12: G <= GL(3a,9)                
    13: G <= GL(3b,9)                
    15: G <= GL(5,Z)                 
    17: G <= GL(3a,Field([Sqrt(5)])) 
    18: G <= GL(3b,Field([Sqrt(5)])) 
    gap> DisplayAtlasInfo( "A5", Ring, IsFinite and IsPrimeField );
    Representations for G = A5:    (all refer to std. generators 1)
    ---------------------------
     4: G <= GL(4a,2) 
     5: G <= GL(4b,2) 
     6: G <= GL(4,3)  
     7: G <= GL(6,3)  
    10: G <= GL(3,5)  
    11: G <= GL(5,5)  
  
  
  The above examples show how the output can be restricted using a property (a
  unary function that returns either true or false) that follows NrMovedPoints
  (Reference:  NrMovedPoints  (for a permutation)), Characteristic (Reference:
  Characteristic), Dimension (Reference: Dimension), or Ring (Reference: Ring)
  in the argument list of DisplayAtlasInfo.
  
    Example  
    gap> DisplayAtlasInfo( "A5", IsStraightLineProgram, true );
    Programs for G = A5:    (all refer to std. generators 1)
    --------------------
    presentation
    std. gen. checker
    maxes (all 3):
      1:  A4
      2:  D10
      3:  S3
  
  
  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  is  available  as  well  as a presentation in terms of
  standard generators, see AtlasProgram (3.5-3).
  
  3.5-2 AtlasGenerators
  
  AtlasGenerators( gapname, repnr[, maxnr] )  function
  AtlasGenerators( identifier )  function
  Returns:  a record containing generators for a representation, or fail.
  
  In  the  first  form,  gapname  must  be  a  string denoting a GAP name (see
  Section 3.2) of a group, and repnr a positive integer. If the ATLAS of Group
  Representations  contains  at least repnr representations for the group with
  GAP  name  gapname then AtlasGenerators, when called with gapname and repnr,
  returns   an   immutable  record  describing  the  repnr-th  representation;
  otherwise  fail  is returned. If a third argument maxnr, a positive integer,
  is given then an immutable record describing the restriction of the repnr-th
  representation to the maxnr-th maximal subgroup is returned.
  
  The result record has at least the following components.
  
  generators
        a list of generators for the group,
  
  groupname
        the GAP name of the group (see Section 3.2),
  
  identifier
        a  GAP  object  (a list of filenames plus additional information) that
        uniquely  determines  the  representation;  the  value  can be used as
        identifier argument of AtlasGenerators.
  
  repnr
        the  number of the representation in the current session, equal to the
        argument repnr if this is given.
  
  standardization
        the positive integer denoting the underlying standard generators,
  
  Additionally,  the  group  order  may  be  stored in the component size, and
  describing  components  may be available that depend on the data type of the
  representation:  For permutation representations, these are p for the number
  of  moved  points,  id  for  the  distinguishing  string  as  described  for
  DisplayAtlasInfo   (3.5-1),   and   information   about  primitivity,  point
  stabilizers etc. if available; for matrix representations, these are dim for
  the dimension of the matrices, ring (if known) for the ring generated by the
  matrix  entries, id for the distinguishing string, and information about the
  character if available.
  
  It  should  be  noted  that  the  number repnr refers to the number shown by
  DisplayAtlasInfo  (3.5-1)  in  the current session; it may be that after the
  addition of new representations, repnr refers to another representation.
  
  The  alternative form of AtlasGenerators, with only argument identifier, can
  be  used  to  fetch  the  result  record  with  identifier  value  equal  to
  identifier. The purpose of this variant is to access the same representation
  also in different GAP sessions.
  
    Example  
    gap> gens1:= AtlasGenerators( "A5", 1 );
    rec( generators := [ (1,2)(3,4), (1,3,5) ], groupname := "A5", 
      id := "", 
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], 
      isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
      repname := "A5G1-p5B0", repnr := 1, size := 60, stabilizer := "A4", 
      standardization := 1, transitivity := 3, type := "perm" )
    gap> gens8:= AtlasGenerators( "A5", 8 );
    rec( dim := 2, 
      generators := [ [ [ Z(2)^0, 0*Z(2) ], [ Z(2^2), Z(2)^0 ] ], 
          [ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, Z(2)^0 ] ] ], groupname := "A5",
      id := "a", 
      identifier := [ "A5", [ "A5G1-f4r2aB0.m1", "A5G1-f4r2aB0.m2" ], 1, 
          4 ], repname := "A5G1-f4r2aB0", repnr := 8, ring := GF(2^2), 
      size := 60, standardization := 1, type := "matff" )
    gap> gens17:= AtlasGenerators( "A5", 17 );
    rec( dim := 3, 
      generators := 
        [ [ [ -1, 0, 0 ], [ 0, -1, 0 ], [ -E(5)-E(5)^4, -E(5)-E(5)^4, 1 ] 
             ], [ [ 0, 1, 0 ], [ 0, 0, 1 ], [ 1, 0, 0 ] ] ], 
      groupname := "A5", id := "a", 
      identifier := [ "A5", "A5G1-Ar3aB0.g", 1, 3 ], 
      repname := "A5G1-Ar3aB0", repnr := 17, ring := NF(5,[ 1, 4 ]), 
      size := 60, standardization := 1, type := "matalg" )
  
  
  Each of the above pairs of elements generates a group isomorphic to A_5.
  
    Example  
    gap> gens1max2:= AtlasGenerators( "A5", 1, 2 );
    rec( generators := [ (1,2)(3,4), (2,3)(4,5) ], groupname := "D10", 
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5, 2 ],
      repnr := 1, size := 10, standardization := 1 )
    gap> id:= gens1max2.identifier;;
    gap> gens1max2 = AtlasGenerators( id );
    true
    gap> max2:= Group( gens1max2.generators );;
    gap> Size( max2 );
    10
    gap> IdGroup( max2 ) = IdGroup( DihedralGroup( 10 ) );
    true
  
  
  The  elements stored in gens1max2.generators 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  ATLAS  of  Finite
  Groups [CCNPW85]; this subgroup is isomorphic to the dihedral group D_10.
  
  3.5-3 AtlasProgram
  
  AtlasProgram( gapname[, std], ... )  function
  AtlasProgram( identifier )  function
  Returns:  a record containing a program, or fail.
  
  In the first form, gapname must be a string denoting a GAP name (see Section
   3.2)  of  a  group G, say. If the ATLAS of Group Representations contains a
  straight  line  program (see Section 'Reference: Straight Line Programs') or
  straight   line  decision  (see  Section 6.1)  or  black  box  program  (see
  Section 6.2)  as  described  by  the  remaining  arguments  (see below) then
  AtlasProgram  returns an immutable record containing this program. Otherwise
  fail is returned.
  
  If   the   optional   argument  std  is  given,  only  those  straight  line
  programs/decisions  are  considered that take generators from the std-th set
  of standard generators of G as input, see Section 3.3.
  
  The result record has the following components.
  
  program
        the required straight line program/decision, or black box program,
  
  standardization
        the positive integer denoting the underlying standard generators of G,
  
  identifier
        a  GAP  object  (a list of filenames plus additional information) that
        uniquely  determines  the program; the value can be used as identifier
        argument of AtlasProgram (see below).
  
  In the first form, the last arguments must be as follows.
  
  (the string "maxes" and) a positive integer maxnr
  
        the  required  program  computes  generators  of  the maxnr-th maximal
        subgroup of the group with GAP name gapname.
  
        In  this  case,  the  result record of AtlasProgram also may contain a
        component  size,  whose  value is the order of the maximal subgroup in
        question.
  
  one of the strings "classes" or "cyclic"
        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 AtlasProgram also
        contains  a component outputs, whose value is a list of class names of
        the outputs, as described in Section 3.4.
  
  the strings "automorphism" and autname
        the  required program computes images of standard generators under the
        outer automorphism of G that is given by this string.
  
        Note  that  a  value  "2"  of  autname  means  that  the square of the
        automorphism  is  an  inner  automorphism  of  G  (not necessarily the
        identity mapping) but the automorphism itself is not.
  
  the string "check"
        the  required  result is a straight line decision that takes a list of
        generators  for  G  and  returns true if these generators are standard
        generators of G w.r.t. the standardization std, and false otherwise.
  
  the string "presentation"
        the  required  result is a straight line decision that takes a list of
        group  elements  and  returns  true  if  these  elements  are standard
        generators of G w.r.t. the standardization std, and false otherwise.
  
        See StraightLineProgramFromStraightLineDecision (6.1-9) for an example
        how  to  derive  defining  relators  for  G  in  terms of the standard
        generators from such a straight line decision.
  
  the string "find"
        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 std.
  
  the string "restandardize" and an integer std2
        the  required result is a straight line program that computes standard
        generators of G w.r.t. the std2-th set of standard generators of G; in
        this case, the argument std must be given.
  
  the strings "other" and descr
        the required program is described by descr.
  
  The second form of AtlasProgram, with only argument the list identifier, can
  be  used  to  fetch  the  result  record  with  identifier  value  equal  to
  identifier.
  
    Example  
    gap> prog:= AtlasProgram( "A5", 2 );
    rec( groupname := "A5", identifier := [ "A5", "A5G1-max2W1", 1 ], 
      program := <straight line program>, size := 10, 
      standardization := 1, subgroupname := "D10" )
    gap> StringOfResultOfStraightLineProgram( prog.program, [ "a", "b" ] );
    "[ a, bbab ]"
    gap> gens1:= AtlasGenerators( "A5", 1 );
    rec( generators := [ (1,2)(3,4), (1,3,5) ], groupname := "A5", 
      id := "", 
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], 
      isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
      repname := "A5G1-p5B0", repnr := 1, size := 60, stabilizer := "A4", 
      standardization := 1, transitivity := 3, type := "perm" )
    gap> maxgens:= ResultOfStraightLineProgram( prog.program, gens1.generators );
    [ (1,2)(3,4), (2,3)(4,5) ]
    gap> maxgens = gens1max2.generators;
    true
  
  
  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 'Reference:
  Straight  Line  Programs')  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.
  
    Example  
    gap> prog:= AtlasProgram( "J1", "cyclic" );
    rec( groupname := "J1", identifier := [ "J1", "J1G1-cycW1", 1 ], 
      outputs := [ "6A", "7A", "10B", "11A", "15B", "19A" ], 
      program := <straight line program>, standardization := 1 )
    gap> gens:= GeneratorsOfGroup( FreeGroup( "x", "y" ) );;
    gap> ResultOfStraightLineProgram( prog.program, gens );
    [ (x*y)^2*((y*x)^2*y^2*x)^2*y^2, x*y, (x*(y*x*y)^2)^2*y, 
      (x*y*x*(y*x*y)^3*x*y^2)^2*x*y*x*(y*x*y)^2*y, x*y*x*(y*x*y)^2*y, 
      (x*y)^2*y ]
  
  
  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.
  
  3.5-4 AtlasProgramInfo
  
  AtlasProgramInfo( gapname[, std][, "contents", sources][, ...] )  function
  Returns:  a record describing a program, or fail.
  
  AtlasProgramInfo  takes  the  same  arguments  as  AtlasProgram (3.5-3), and
  returns  a  similar result. The only difference is that the records returned
  by AtlasProgramInfo have no components program and outputs. The idea is that
  one  can use AtlasProgramInfo for testing whether the program in question is
  available  at  all,  but  without  transferring it from a remote server. The
  identifier  component  of the result of AtlasProgramInfo can then be used to
  fetch the program with AtlasProgram (3.5-3).
  
    Example  
    gap> AtlasProgramInfo( "J1", "cyclic" );
    rec( groupname := "J1", identifier := [ "J1", "J1G1-cycW1", 1 ], 
      standardization := 1 )
  
  
  3.5-5 OneAtlasGeneratingSetInfo
  
  OneAtlasGeneratingSetInfo( [gapname, ][std, ][...] )  function
  Returns:  a   record   describing   a   representation  that  satisfies  the
            conditions, or fail.
  
  Let gapname be a string denoting a GAP name (see Section  3.2) of a group G,
  say.   If   the  ATLAS  of  Group  Representations  contains  at  least  one
  representation     for    G    with    the    required    properties    then
  OneAtlasGeneratingSetInfo  returns  a record r whose components are the same
  as those of the records returned by AtlasGenerators (3.5-2), except that the
  component  generators is not contained; the component identifier of r can be
  used  as input for AtlasGenerators (3.5-2) in order to fetch the generators.
  If  no representation satisfying the given conditions is available then fail
  is returned.
  
  If the argument std 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 3.3).
  
  The  argument  gapname  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     DisplayAtlasInfo     (3.5-1).     The     result    of
  OneAtlasGeneratingSetInfo  describes  the  first  generating  set for G that
  matches the restrictions, in the ordering shown by DisplayAtlasInfo (3.5-1).
  
  Note that even in the case that the user parameter remote has the value true
  (see  Section 4.3-1), OneAtlasGeneratingSetInfo does not attempt to transfer
  remote data files, just the table of contents is evaluated. So this function
  (as well as AllAtlasGeneratingSetInfos (3.5-6)) can be used to check for the
  availability  of  certain  representations,  and  afterwards  one  can  call
  AtlasGenerators (3.5-2) 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.
  
    Example  
    gap> info:= OneAtlasGeneratingSetInfo( "A5" );
    rec( groupname := "A5", id := "", 
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], 
      isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
      repname := "A5G1-p5B0", repnr := 1, size := 60, stabilizer := "A4", 
      standardization := 1, transitivity := 3, type := "perm" )
    gap> gens:= AtlasGenerators( info.identifier );
    rec( generators := [ (1,2)(3,4), (1,3,5) ], groupname := "A5", 
      id := "", 
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], 
      isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
      repname := "A5G1-p5B0", repnr := 1, size := 60, stabilizer := "A4", 
      standardization := 1, transitivity := 3, type := "perm" )
    gap> info = OneAtlasGeneratingSetInfo( "A5", IsPermGroup, true );
    true
    gap> info = OneAtlasGeneratingSetInfo( "A5", NrMovedPoints, "minimal" );
    true
    gap> info = OneAtlasGeneratingSetInfo( "A5", NrMovedPoints, [ 1 .. 10 ] );
    true
    gap> OneAtlasGeneratingSetInfo( "A5", NrMovedPoints, 20 );
    fail
  
  
  Note  that  a  permutation  representation of degree 20 could be obtained by
  taking  twice  the primitive representation on 10 points; however, the ATLAS
  of Group Representations does not store this imprimitive representation (cf.
  Section 3.1).
  
  We  continue this example a little. Next we access matrix representations of
  A_5.
  
    Example  
    gap> info:= OneAtlasGeneratingSetInfo( "A5", IsMatrixGroup, true );
    rec( dim := 4, groupname := "A5", id := "a", 
      identifier := [ "A5", [ "A5G1-f2r4aB0.m1", "A5G1-f2r4aB0.m2" ], 1, 
          2 ], repname := "A5G1-f2r4aB0", repnr := 4, ring := GF(2), 
      size := 60, standardization := 1, type := "matff" )
    gap> gens:= AtlasGenerators( info.identifier );
    rec( dim := 4, 
      generators := [ <an immutable 4x4 matrix over GF2>, 
          <an immutable 4x4 matrix over GF2> ], groupname := "A5", 
      id := "a", 
      identifier := [ "A5", [ "A5G1-f2r4aB0.m1", "A5G1-f2r4aB0.m2" ], 1, 
          2 ], repname := "A5G1-f2r4aB0", repnr := 4, ring := GF(2), 
      size := 60, standardization := 1, type := "matff" )
    gap> info = OneAtlasGeneratingSetInfo( "A5", Dimension, 4 );
    true
    gap> info = OneAtlasGeneratingSetInfo( "A5", Characteristic, 2 );
    true
    gap> info = OneAtlasGeneratingSetInfo( "A5", Ring, GF(2) );
    true
    gap> OneAtlasGeneratingSetInfo( "A5", Characteristic, [2,5], Dimension, 2 );
    rec( dim := 2, groupname := "A5", id := "a", 
      identifier := [ "A5", [ "A5G1-f4r2aB0.m1", "A5G1-f4r2aB0.m2" ], 1, 
          4 ], repname := "A5G1-f4r2aB0", repnr := 8, ring := GF(2^2), 
      size := 60, standardization := 1, type := "matff" )
    gap> OneAtlasGeneratingSetInfo( "A5", Characteristic, [2,5], Dimension, 1 );
    fail
    gap> info:= OneAtlasGeneratingSetInfo( "A5", Characteristic, 0, Dimension, 4 );
    rec( dim := 4, groupname := "A5", id := "", 
      identifier := [ "A5", "A5G1-Zr4B0.g", 1, 4 ], 
      repname := "A5G1-Zr4B0", repnr := 14, ring := Integers, size := 60, 
      standardization := 1, type := "matint" )
    gap> gens:= AtlasGenerators( info.identifier );
    rec( dim := 4, 
      generators := 
        [ 
          [ [ 1, 0, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 1, 0, 0 ], 
              [ -1, -1, -1, -1 ] ], 
          [ [ 0, 1, 0, 0 ], [ 0, 0, 0, 1 ], [ 0, 0, 1, 0 ], 
              [ 1, 0, 0, 0 ] ] ], groupname := "A5", id := "", 
      identifier := [ "A5", "A5G1-Zr4B0.g", 1, 4 ], 
      repname := "A5G1-Zr4B0", repnr := 14, ring := Integers, size := 60, 
      standardization := 1, type := "matint" )
    gap> info = OneAtlasGeneratingSetInfo( "A5", Ring, Integers );
    true
    gap> info = OneAtlasGeneratingSetInfo( "A5", Ring, CF(37) );
    true
    gap> OneAtlasGeneratingSetInfo( "A5", Ring, Integers mod 77 );
    fail
    gap> info:= OneAtlasGeneratingSetInfo( "A5", Ring, CF(5), Dimension, 3 );
    rec( dim := 3, groupname := "A5", id := "a", 
      identifier := [ "A5", "A5G1-Ar3aB0.g", 1, 3 ], 
      repname := "A5G1-Ar3aB0", repnr := 17, ring := NF(5,[ 1, 4 ]), 
      size := 60, standardization := 1, type := "matalg" )
    gap> gens:= AtlasGenerators( info.identifier );
    rec( dim := 3, 
      generators := 
        [ [ [ -1, 0, 0 ], [ 0, -1, 0 ], [ -E(5)-E(5)^4, -E(5)-E(5)^4, 1 ] 
             ], [ [ 0, 1, 0 ], [ 0, 0, 1 ], [ 1, 0, 0 ] ] ], 
      groupname := "A5", id := "a", 
      identifier := [ "A5", "A5G1-Ar3aB0.g", 1, 3 ], 
      repname := "A5G1-Ar3aB0", repnr := 17, ring := NF(5,[ 1, 4 ]), 
      size := 60, standardization := 1, type := "matalg" )
    gap> OneAtlasGeneratingSetInfo( "A5", Ring, GF(17) );
    fail
  
  
  3.5-6 AllAtlasGeneratingSetInfos
  
  AllAtlasGeneratingSetInfos( [gapname, ][std, ][...] )  function
  Returns:  the  list  of  all records describing representations that satisfy
            the conditions.
  
  AllAtlasGeneratingSetInfos  is similar to OneAtlasGeneratingSetInfo (3.5-5).
  The  difference  is  that  the  list of all 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.
  
    Example  
    gap> AllAtlasGeneratingSetInfos( "A5", IsPermGroup, true );
    [ rec( groupname := "A5", id := "", 
          identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ]
            , isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
          repname := "A5G1-p5B0", repnr := 1, size := 60, 
          stabilizer := "A4", standardization := 1, transitivity := 3, 
          type := "perm" ), 
      rec( groupname := "A5", id := "", 
          identifier := [ "A5", [ "A5G1-p6B0.m1", "A5G1-p6B0.m2" ], 1, 6 ]
            , isPrimitive := true, maxnr := 2, p := 6, rankAction := 2, 
          repname := "A5G1-p6B0", repnr := 2, size := 60, 
          stabilizer := "D10", standardization := 1, transitivity := 2, 
          type := "perm" ), 
      rec( groupname := "A5", id := "", 
          identifier := [ "A5", [ "A5G1-p10B0.m1", "A5G1-p10B0.m2" ], 1, 
              10 ], isPrimitive := true, maxnr := 3, p := 10, 
          rankAction := 3, repname := "A5G1-p10B0", repnr := 3, 
          size := 60, stabilizer := "S3", standardization := 1, 
          transitivity := 1, type := "perm" ) ]
  
  
  Note  that  a matrix representation in any characteristic can be obtained by
  reducing  a permutation representation or an integral matrix representation;
  however,   the  ATLAS  of  Group  Representations  does  not  store  such  a
  representation (cf. Section 3.1).
  
  
  3.5-7 AtlasGroup
  
  AtlasGroup( [gapname[, std, ]][...] )  function
  AtlasGroup( identifier )  function
  Returns:  a group that satisfies the conditions, or fail.
  
  AtlasGroup  takes  the  same arguments as OneAtlasGeneratingSetInfo (3.5-5),
  and  returns  the  group generated by the generators component of the record
  that  is returned by OneAtlasGeneratingSetInfo (3.5-5) with these arguments;
  if  OneAtlasGeneratingSetInfo  (3.5-5)  returns  fail  then  also AtlasGroup
  returns fail.
  
    Example  
    gap> g:= AtlasGroup( "A5" );
    Group([ (1,2)(3,4), (1,3,5) ])
  
  
  Alternatively,  it  is  possible  to  enter  exactly  one argument, a record
  identifier    as    returned   by   OneAtlasGeneratingSetInfo   (3.5-5)   or
  AllAtlasGeneratingSetInfos  (3.5-6),  or  the identifier component of such a
  record.
  
    Example  
    gap> info:= OneAtlasGeneratingSetInfo( "A5" );
    rec( groupname := "A5", id := "", 
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], 
      isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
      repname := "A5G1-p5B0", repnr := 1, size := 60, stabilizer := "A4", 
      standardization := 1, transitivity := 3, type := "perm" )
    gap> AtlasGroup( info );
    Group([ (1,2)(3,4), (1,3,5) ])
    gap> AtlasGroup( info.identifier );
    Group([ (1,2)(3,4), (1,3,5) ])
  
  
  In   the   groups  returned  by  AtlasGroup,  the  value  of  the  attribute
  AtlasRepInfoRecord  (3.5-9)  is set. This information is used for example by
  AtlasSubgroup  (3.5-8)  when  this function is called with second argument a
  group created by AtlasGroup.
  
  
  3.5-8 AtlasSubgroup
  
  AtlasSubgroup( gapname[, std][, ...], maxnr )  function
  AtlasSubgroup( identifier, maxnr )  function
  AtlasSubgroup( G, maxnr )  function
  Returns:  a group that satisfies the conditions, or fail.
  
  The  arguments of AtlasSubgroup, except the last argument maxn, are the same
  as  for AtlasGroup (3.5-7). If the ATLAS of Group Representations provides a
  straight line program for restricting representations of the group with name
  gapname  (given  w.r.t.  the  std-th  standard  generators)  to the maxnr-th
  maximal  subgroup  and  if  a representation with the required properties is
  available,  in  the  sense  that  calling  AtlasGroup  (3.5-7) with the same
  arguments  except  maxnr  yields  a  group,  then  AtlasSubgroup returns the
  restriction of this representation to the maxnr-th maximal subgroup.
  
  In all other cases, fail is returned.
  
  Note  that the conditions refer to the group and not to the subgroup. It may
  happen  that  in  the  restriction  of  a  permutation  representation  to a
  subgroup,  fewer  points  are  moved,  or  that  the restriction of a matrix
  representation  turns  out  to  be  defined  over a smaller ring. Here is an
  example.
  
    Example  
    gap> g:= AtlasSubgroup( "A5", NrMovedPoints, 5, 1 );
    Group([ (1,5)(2,3), (1,3,5) ])
    gap> NrMovedPoints( g );
    4
  
  
  Alternatively,  it  is  possible  to  enter exactly two arguments, the first
  being  a  record identifier as returned by OneAtlasGeneratingSetInfo (3.5-5)
  or AllAtlasGeneratingSetInfos (3.5-6), or the identifier component of such a
  record, or a group G constructed with AtlasGroup (3.5-7).
  
    Example  
    gap> info:= OneAtlasGeneratingSetInfo( "A5" );
    rec( groupname := "A5", id := "", 
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], 
      isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
      repname := "A5G1-p5B0", repnr := 1, size := 60, stabilizer := "A4", 
      standardization := 1, transitivity := 3, type := "perm" )
    gap> AtlasSubgroup( info, 1 );
    Group([ (1,5)(2,3), (1,3,5) ])
    gap> AtlasSubgroup( info.identifier, 1 );
    Group([ (1,5)(2,3), (1,3,5) ])
    gap> AtlasSubgroup( AtlasGroup( "A5" ), 1 );
    Group([ (1,5)(2,3), (1,3,5) ])
  
  
  3.5-9 AtlasRepInfoRecord
  
  AtlasRepInfoRecord( G )  attribute
  Returns:  the  record  stored  in the group G when this was constructed with
            AtlasGroup (3.5-7).
  
  For  a  group G that has been constructed with AtlasGroup (3.5-7), the value
  of  this  attribute  is  the info record that describes G, in the sense that
  this  record was the first argument of the call to AtlasGroup (3.5-7), or it
  is  the  result  of  the  call to OneAtlasGeneratingSetInfo (3.5-5) with the
  conditions that were listed in the call to AtlasGroup (3.5-7).
  
    Example  
    gap> AtlasRepInfoRecord( AtlasGroup( "A5" ) );
    rec( groupname := "A5", id := "", 
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], 
      isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
      repname := "A5G1-p5B0", repnr := 1, size := 60, stabilizer := "A4", 
      standardization := 1, transitivity := 3, type := "perm" )
  
  
  
  3.6 Browse Applications Provided by AtlasRep
  
  The functions BrowseMinimalDegrees (3.6-1), BrowseBibliographySporadicSimple
  (3.6-2),  and  BrowseAtlasInfo  (Browse: BrowseAtlasInfo) (an alternative to
  DisplayAtlasInfo  (3.5-1)) are available only if the GAP package Browse (see
  [BL14]) is loaded.
  
  3.6-1 BrowseMinimalDegrees
  
  BrowseMinimalDegrees( [groupnames] )  function
  Returns:  the list of info records for the clicked representations.
  
  If  the  GAP  package  Browse  (see  [BL14]) is loaded then this function is
  available.  It  opens a browse table whose rows correspond to the groups for
  which  the  ATLAS  of  Group Representations contains some information about
  minimal degrees, whose columns correspond to the characteristics that occur,
  and whose entries are the known minimal degrees.
  
    Example  
    gap> if IsBound( BrowseMinimalDegrees ) then
    >   down:= NCurses.keys.DOWN;;  DOWN:= NCurses.keys.NPAGE;;
    >   right:= NCurses.keys.RIGHT;;  END:= NCurses.keys.END;;
    >   enter:= NCurses.keys.ENTER;;  nop:= [ 14, 14, 14 ];;
    >   # just scroll in the table
    >   BrowseData.SetReplay( Concatenation( [ DOWN, DOWN, DOWN,
    >          right, right, right ], "sedddrrrddd", nop, nop, "Q" ) );
    >   BrowseMinimalDegrees();;
    >   # restrict the table to the groups with minimal ordinary degree 6
    >   BrowseData.SetReplay( Concatenation( "scf6",
    >        [ down, down, right, enter, enter ] , nop, nop, "Q" ) );
    >   BrowseMinimalDegrees();;
    >   BrowseData.SetReplay( false );
    > fi;
  
  
  If  an argument groupnames is given then it must be a list of group names of
  the  ATLAS  of Group Representations; the browse table is then restricted to
  the  rows  corresponding  to  these  group names and to the columns that are
  relevant  for  these  groups.  A perhaps interesting example is the subtable
  with  the  data concerning sporadic simple groups and their covering groups,
  which has been published in [Jan05]. This table can be shown as follows.
  
    Example  
    gap> if IsBound( BrowseMinimalDegrees ) then
    >   # just scroll in the table
    >   BrowseData.SetReplay( Concatenation( [ DOWN, DOWN, DOWN, END ],
    >          "rrrrrrrrrrrrrr", nop, nop, "Q" ) );
    >   BrowseMinimalDegrees( BibliographySporadicSimple.groupNamesJan05 );;
    > fi;
  
  
  The  browse  table  does  not  contain  rows for the groups 6.M_22, 12.M_22,
  6.Fi_22.  Note that in spite of the title of [Jan05], the entries in Table 1
  of  this  paper  are  in  fact  the  minimal degrees of faithful irreducible
  representations, and in the above three cases, these degrees are larger than
  the  minimal degrees of faithful representations. The underlying data of the
  browse table is about the minimal faithful (but not necessarily irreducible)
  degrees.
  
  The    return    value    of    BrowseMinimalDegrees    is   the   list   of
  OneAtlasGeneratingSetInfo (3.5-5) values for those representations that have
  been clicked in visual mode.
  
  The variant without arguments of this function is also available in the menu
  shown by BrowseGapData (Browse: BrowseGapData).
  
  3.6-2 BrowseBibliographySporadicSimple
  
  BrowseBibliographySporadicSimple(  )  function
  Returns:  a    record   as   returned   by   ParseBibXMLExtString   (GAPDoc:
            ParseBibXMLextString).
  
  If  the  GAP  package  Browse  (see  [BL14]) is loaded then this function is
  available.  It  opens a browse table whose rows correspond to the entries of
  the  bibliographies in the ATLAS of Finite Groups [CCNPW85] and in the ATLAS
  of Brauer Characters [JLPW95].
  
  The  function  is  based on BrowseBibliography (Browse: BrowseBibliography),
  see  the  documentation of this function for details, e.g., about the return
  value.
  
  The  returned record encodes the bibliography entries corresponding to those
  rows of the table that are clicked in visual mode, in the same format as the
  return value of ParseBibXMLExtString (GAPDoc: ParseBibXMLextString), see the
  manual of the GAP package GAPDoc [LN12] for details.
  
  BrowseBibliographySporadicSimple  can  be  called also via the menu shown by
  BrowseGapData (Browse: BrowseGapData).
  
    Example  
    gap> if IsBound( BrowseBibliographySporadicSimple ) then
    >   enter:= NCurses.keys.ENTER;;  nop:= [ 14, 14, 14 ];;
    >   BrowseData.SetReplay( Concatenation(
    >     # choose the application
    >     "/Bibliography of Sporadic Simple Groups", [ enter, enter ],
    >     # search in the title column for the Atlas of Finite Groups
    >     "scr/Atlas of finite groups", [ enter,
    >     # and quit
    >     nop, nop, nop, nop ], "Q" ) );
    >   BrowseGapData();;
    >   BrowseData.SetReplay( false );
    > fi;
  
  
  The  bibliographies contained in the ATLAS of Finite Groups [CCNPW85] and in
  the ATLAS of Brauer Characters [JLPW95] are available online in HTML format,
  see http://www.math.rwth-aachen.de/~Thomas.Breuer/atlasrep/bibl/index.html.
  
  The    source    data    in    BibXMLext   format,   which   are   used   by
  BrowseBibliographySporadicSimple,  is  part of the AtlasRep package, in four
  files with suffix xml in the package's bibl directory. Note that each of the
  two books contains two bibliographies.
  
  Details  about  the BibXMLext format, including information how to transform
  the  data into other formats such as BibTeX, can be found in the GAP package
  GAPDoc (see [LN12]).