GAP 4.8.9 installation with standard packages -- copy to your CoCalc project to get it

1
  
2
  3 The User Interface of the AtlasRep Package
3
  
4
  The  user  interface  is  the  part  of the GAP interface that allows one to
5
  display information about the current contents of the database and to access
6
  individual  data  (perhaps  from  a  remote  server, see Section 4.3-1). The
7
  corresponding  functions  are described in this chapter. See Section 2.4 for
8
  some small examples how to use the functions of the interface.
9
  
10
  Extensions  of  the AtlasRep package are regarded as another part of the GAP
11
  interface,  they  are described in Chapter 5. Finally, the low level part of
12
  the interface are described in Chapter 7.
13
  
14
  For  some  of  the  examples  in  this chapter, the GAP packages CTblLib and
15
  TomLib are needed, so we load them.
16
  
17
    Example  
18
    gap> LoadPackage( "ctbllib" );
19
    true
20
    gap> LoadPackage( "tomlib" );
21
    true
22
  
23
  
24
  
25
  3.1 Accessing vs. Constructing Representations
26
  
27
  Note  that  accessing the data means in particular that it is not the aim of
28
  this  package  to construct representations from known ones. For example, if
29
  at  least  one  permutation  representation  for  a group G is stored but no
30
  matrix   representation   in   a   positive   characteristic  p,  say,  then
31
  OneAtlasGeneratingSetInfo  (3.5-5)  returns  fail  when  it  is  asked for a
32
  description of an available set of matrix generators for G in characteristic
33
  p,  although  such a representation can be obtained by reduction modulo p of
34
  an integral matrix representation, which in turn can be constructed from any
35
  permutation representation.
36
  
37
  
38
  3.2 Group Names Used in the AtlasRep Package
39
  
40
  When  you  access  data  via  the AtlasRep package, you specify the group in
41
  question  by  an  admissible name. Thus it is essential to know these names,
42
  which are called the GAP names of the group in the following.
43
  
44
  For  a  group  G, say, whose character table is available in GAP's Character
45
  Table  Library,  the  admissible names of G are the admissible names of this
46
  character  table.  If  G  is  almost simple, one such name is the Identifier
47
  (Reference: Identifier (for character tables)) value of the character table,
48
  see Accessing  a  Character  Table  from  the  Library (CTblLib: Accessing a
49
  Character  Table from the Library). This name is usually very similar to the
50
  name  used  in the ATLAS of Finite Groups [CCNPW85]. For example, "M22" is a
51
  GAP  name  of  the  Mathieu  group  M_22,  "12_1.U4(3).2_1" is a GAP name of
52
  12_1.U_4(3).2_1,  the  two  names  "S5"  and  "A5.2"  are  GAP  names of the
53
  symmetric  group  S_5,  and the two names "F3+" and "Fi24'" are GAP names of
54
  the simple Fischer group Fi_24^'.
55
  
56
  When a GAP name is required as an input of a package function, this input is
57
  case  insensitive.  For  example,  both "A5" and "a5" are valid arguments of
58
  DisplayAtlasInfo (3.5-1).
59
  
60
  Internally,  for example as part of filenames (see Section 7.6), the package
61
  uses  names  that  may  differ  from  the  GAP names; these names are called
62
  ATLAS-file names. For example, "A5", "TE62", and "F24" are ATLAS-file names.
63
  Of  these,  only  "A5"  is  also  a  GAP  name,  but  the other two are not;
64
  corresponding GAP names are "2E6(2)" and "Fi24'", respectively.
65
  
66
  
67
  3.3 Standard Generators Used in the AtlasRep Package
68
  
69
  For the general definition of standard generators of a group, see [Wil96].
70
  
71
  Several  different  standard  generators  may  be  defined  for a group, the
72
  definitions can be found at
73
  
74
  http://brauer.maths.qmul.ac.uk/Atlas
75
  
76
  When  one specifies the standardization, the i-th set of standard generators
77
  is  denoted  by  the  number i. Note that when more than one set of standard
78
  generators  is  defined  for  a group, one must be careful to use compatible
79
  standardization.  For  example,  the  straight  line programs, straight line
80
  decisions  and  black  box  programs  in  the  database  refer to a specific
81
  standardization  of  their  inputs.  That  is,  a  straight line program for
82
  computing  generators of a certain subgroup of a group G is defined only for
83
  a  specific  set  of  standard  generators of G, and applying the program to
84
  matrix or permutation generators of G but w.r.t. a different standardization
85
  may  yield  unpredictable  results.  Therefore  the  results returned by the
86
  functions   described   in   this  chapter  contain  information  about  the
87
  standardizations they refer to.
88
  
89
  
90
  3.4 Class Names Used in the AtlasRep Package
91
  
92
  For  each  straight  line program (see AtlasProgram (3.5-3)) that is used to
93
  compute  lists  of  class  representatives,  it is essential to describe the
94
  classes  in  which these elements lie. Therefore, in these cases the records
95
  returned  by  the  function AtlasProgram (3.5-3) contain a component outputs
96
  with value a list of class names.
97
  
98
  Currently  we  define  these  class names only for simple groups and certain
99
  extensions of simple groups, see Section 3.4-1. The function AtlasClassNames
100
  (3.4-2)  can  be  used to compute the list of class names from the character
101
  table in the GAP Library.
102
  
103
  
104
  3.4-1 Definition of ATLAS Class Names
105
  
106
  For  the definition of class names of an almost simple group, we assume that
107
  the  ordinary  character tables of all nontrivial normal subgroups are shown
108
  in the ATLAS of Finite Groups [CCNPW85].
109
  
110
  Each  class name is a string consisting of the element order of the class in
111
  question  followed  by  a  combination  of  capital letters, digits, and the
112
  characters  ' and - (starting with a capital letter). For example, 1A, 12A1,
113
  and  3B'  denote  the  class  that contains the identity element, a class of
114
  element order 12, and a class of element order 3, respectively.
115
  
116
  1   For  the  table  of  a  simple  group, the class names are the same as
117
        returned  by  the  two argument version of the GAP function ClassNames
118
        (Reference:  ClassNames),  cf. [CCNPW85,  Chapter  7,  Section 5]: The
119
        classes  are  arranged  w.r.t. increasing  element  order and for each
120
        element  order  w.r.t. decreasing  centralizer  order,  the  conjugacy
121
        classes  that  contain  elements of order n are named nA, nB, nC, ...;
122
        the  alphabet  used  here  is potentially infinite, and reads A, B, C,
123
        ..., Z, A1, B1, ..., A2, B2, ....
124
  
125
        For  example,  the classes of the alternating group A_5 have the names
126
        1A, 2A, 3A, 5A, and 5B.
127
  
128
  2   Next we consider the case of an upward extension G.A of a simple group
129
        G by a cyclic group of order A. The ATLAS defines class names for each
130
        element  g of G.A only w.r.t. the group G.a, say, that is generated by
131
        G  and  g; namely, there is a power of g (with the exponent coprime to
132
        the order of g) for which the class has a name of the same form as the
133
        class  names  for  simple  groups,  and  the  name  of  the class of g
134
        w.r.t. G.a  is  then  obtained  from this name by appending a suitable
135
        number  of  dashes '.  So  dashed  class  names refer exactly to those
136
        classes that are not printed in the ATLAS.
137
  
138
        For  example, those classes of the symmetric group S_5 that do not lie
139
        in  A_5  have the names 2B, 4A, and 6A. The outer classes of the group
140
        L_2(8).3  have  the  names  3B,  6A,  9D, and 3B', 6A', 9D'. The outer
141
        elements  of  order  5  in  the group Sz(32).5 lie in the classes with
142
        names 5B, 5B', 5B'', and 5B'''.
143
  
144
        In the group G.A, the class of g may fuse with other classes. The name
145
        of  the  class  of g in G.A is obtained from the names of the involved
146
        classes of G.a by concatenating their names after removing the element
147
        order part from all of them except the first one.
148
  
149
        For  example,  the  elements  of  order  9  in the group L_2(27).6 are
150
        contained  in the subgroup L_2(27).3 but not in L_2(27). In L_2(27).3,
151
        they  lie  in  the  classes  9A, 9A', 9B, and 9B'; in L_2(27).6, these
152
        classes fuse to 9AB and 9A'B'.
153
  
154
  3   Now  we  define  class  names  for  general upward extensions G.A of a
155
        simple  group  G.  Each  element  g  of such a group lies in an upward
156
        extension  G.a  by  a cyclic group, and the class names w.r.t. G.a are
157
        already  defined.  The  name  of  the class of g in G.A is obtained by
158
        concatenating  the  names  of  the  classes in the orbit of G.A on the
159
        classes  of  cyclic  upward  extensions of G, after ordering the names
160
        lexicographically and removing the element order part from all of them
161
        except  the  first one. An exception is the situation where dashed and
162
        non-dashed  class  names  appear in an orbit; in this case, the dashed
163
        names are omitted.
164
  
165
        For  example,  the  classes  21A and 21B of the group U_3(5).3 fuse in
166
        U_3(5).S_3  to the class 21AB, and the class 2B of U_3(5).2 fuses with
167
        the  involution  classes  2B',  2B''  in  the  groups  U_3(5).2^'  and
168
        U_3(5).2^{''} to the class 2B of U_3(5).S_3.
169
  
170
        It  may  happen  that  some names in the outputs component of a record
171
        returned by AtlasProgram (3.5-3) do not uniquely determine the classes
172
        of   the  corresponding  elements.  For  example,  the  (algebraically
173
        conjugate)  classes  39A  and  39B  of  the  group  Co_1 have not been
174
        distinguished  yet. In such cases, the names used contain a minus sign
175
        -,  and  mean  one  of  the classes in the range described by the name
176
        before  and  the  name after the minus sign; the element order part of
177
        the  name  does not appear after the minus sign. So the name 39A-B for
178
        the  group  Co_1 means 39A or 39B, and the name 20A-B''' for the group
179
        Sz(32).5  means  one  of the classes of element order 20 in this group
180
        (these classes lie outside the simple group Sz).
181
  
182
  4   For  a  downward  extension  m.G.A  of an almost simple group G.A by a
183
        cyclic  group  of  order  m, let π denote the natural epimorphism from
184
        m.G.A onto G.A. Each class name of m.G.A has the form nX_0, nX_1 etc.,
185
        where  nX is the class name of the image under π, and the indices 0, 1
186
        etc.  are chosen according to the position of the class in the lifting
187
        order  rows for G, see [CCNPW85, Chapter 7, Section 7, and the example
188
        in Section 8]).
189
  
190
        For example, if m = 6 then 1A_1 and 1A_5 denote the classes containing
191
        the  generators of the kernel of π, that is, central elements of order
192
        6.
193
  
194
  3.4-2 AtlasClassNames
195
  
196
  AtlasClassNames( tbl )  function
197
  Returns:  a list of class names.
198
  
199
  Let  tbl  be the ordinary or modular character table of a group G, say, that
200
  is  almost simple or a downward extension of an almost simple group and such
201
  that  tbl  is an ATLAS table from the GAP Character Table Library, according
202
  to  its  InfoText  (Reference: InfoText) value. Then AtlasClassNames returns
203
  the  list of class names for G, as defined in Section 3.4-1. The ordering of
204
  class names is the same as the ordering of the columns of tbl.
205
  
206
  (The  function may work also for character tables that are not ATLAS tables,
207
  but then clearly the class names returned are somewhat arbitrary.)
208
  
209
    Example  
210
    gap> AtlasClassNames( CharacterTable( "L3(4).3" ) );
211
    [ "1A", "2A", "3A", "4ABC", "5A", "5B", "7A", "7B", "3B", "3B'", 
212
      "3C", "3C'", "6B", "6B'", "15A", "15A'", "15B", "15B'", "21A", 
213
      "21A'", "21B", "21B'" ]
214
    gap> AtlasClassNames( CharacterTable( "U3(5).2" ) );
215
    [ "1A", "2A", "3A", "4A", "5A", "5B", "5CD", "6A", "7AB", "8AB", 
216
      "10A", "2B", "4B", "6D", "8C", "10B", "12B", "20A", "20B" ]
217
    gap> AtlasClassNames( CharacterTable( "L2(27).6" ) );
218
    [ "1A", "2A", "3AB", "7ABC", "13ABC", "13DEF", "14ABC", "2B", "4A", 
219
      "26ABC", "26DEF", "28ABC", "28DEF", "3C", "3C'", "6A", "6A'", 
220
      "9AB", "9A'B'", "6B", "6B'", "12A", "12A'" ]
221
    gap> AtlasClassNames( CharacterTable( "L3(4).3.2_2" ) );
222
    [ "1A", "2A", "3A", "4ABC", "5AB", "7A", "7B", "3B", "3C", "6B", 
223
      "15A", "15B", "21A", "21B", "2C", "4E", "6E", "8D", "14A", "14B" ]
224
    gap> AtlasClassNames( CharacterTable( "3.A6" ) );
225
    [ "1A_0", "1A_1", "1A_2", "2A_0", "2A_1", "2A_2", "3A_0", "3B_0", 
226
      "4A_0", "4A_1", "4A_2", "5A_0", "5A_1", "5A_2", "5B_0", "5B_1", 
227
      "5B_2" ]
228
    gap> AtlasClassNames( CharacterTable( "2.A5.2" ) );
229
    [ "1A_0", "1A_1", "2A_0", "3A_0", "3A_1", "5AB_0", "5AB_1", "2B_0", 
230
      "4A_0", "4A_1", "6A_0", "6A_1" ]
231
  
232
  
233
  3.4-3 AtlasCharacterNames
234
  
235
  AtlasCharacterNames( tbl )  function
236
  Returns:  a list of character names.
237
  
238
  Let  tbl  be  the  ordinary  or  modular  character table of a simple group.
239
  AtlasCharacterNames returns a list of strings, the i-th entry being the name
240
  of  the  i-th irreducible character of tbl; this name consists of the degree
241
  of this character followed by distinguishing lowercase letters.
242
  
243
    Example  
244
    gap> AtlasCharacterNames( CharacterTable( "A5" ) );                   
245
    [ "1a", "3a", "3b", "4a", "5a" ]
246
  
247
  
248
  
249
  3.5 Accessing Data of the AtlasRep Package
250
  
251
  Note  that  the  output  of the examples in this section refers to a perhaps
252
  outdated  table of contents; the current version of the database may contain
253
  more information than is shown here.
254
  
255
  3.5-1 DisplayAtlasInfo
256
  
257
  DisplayAtlasInfo( [listofnames, ][std, ]["contents", sources, ][...] )  function
258
  DisplayAtlasInfo( gapname[, std][, ...] )  function
259
  
260
  This  function lists the information available via the AtlasRep package, for
261
  the  given input. Depending on whether remote access to data is enabled (see
262
  Section  4.3-1), all the data provided by the ATLAS of Group Representations
263
  or only those in the local installation are considered.
264
  
265
  An   interactive   alternative   to   DisplayAtlasInfo   is   the   function
266
  BrowseAtlasInfo (Browse: BrowseAtlasInfo), see [BL14].
267
  
268
  Called   without   arguments,   DisplayAtlasInfo  prints  an  overview  what
269
  information the ATLAS of Group Representations provides. One line is printed
270
  for each group G, with the following columns.
271
  
272
  group
273
        the GAP name of G (see Section 3.2),
274
  
275
  #
276
        the  number  of faithful representations stored for G that satisfy the
277
        additional conditions given (see below),
278
  
279
  maxes
280
        the   number   of  available  straight  line  programs  for  computing
281
        generators of maximal subgroups of G,
282
  
283
  cl
284
        a  +  sign  if  at  least one program for computing representatives of
285
        conjugacy classes of elements of G is stored,
286
  
287
  cyc
288
        a  +  sign  if  at  least one program for computing representatives of
289
        classes of maximally cyclic subgroups of G is stored,
290
  
291
  out
292
        descriptions  of  outer  automorphisms  of  G  for  which at least one
293
        program is stored,
294
  
295
  fnd
296
        a  +  sign  if  at least one program is available for finding standard
297
        generators,
298
  
299
  chk
300
        a  +  sign if at least one program is available for checking whether a
301
        set of generators is a set of standard generators, and
302
  
303
  prs
304
        a  +  sign  if  at  least  one  program  is  available  that encodes a
305
        presentation.
306
  
307
  (The  list  can  be  printed  to  the screen or can be fed into a pager, see
308
  Section 4.3-5.)
309
  
310
  Called  with  a  list  listofnames of strings that are GAP names for a group
311
  from  the  ATLAS  of  Group  Representations,  DisplayAtlasInfo  prints  the
312
  overview described above but restricted to the groups in this list.
313
  
314
  In  addition  to  or  instead  of  listofnames,  the string "contents" and a
315
  description  sources  of  the  data may be given about which the overview is
316
  formed. See below for admissible values of sources.
317
  
318
  Called  with  a string gapname that is a GAP name for a group from the ATLAS
319
  of  Group  Representations,  DisplayAtlasInfo  prints  an  overview  of  the
320
  information  that  is available for this group. One line is printed for each
321
  faithful  representation,  showing  the number of this representation (which
322
  can be used in calls of AtlasGenerators (3.5-2)), and a string of one of the
323
  following forms; in both cases, id is a (possibly empty) string.
324
  
325
  G <= Sym(nid)
326
        denotes  a  permutation  representation  of degree n, for example G <=
327
        Sym(40a)  and G <= Sym(40b) denote two (nonequivalent) representations
328
        of degree 40.
329
  
330
  G <= GL(nid,descr)
331
        denotes a matrix representation of dimension n over a coefficient ring
332
        described  by  descr, which can be a prime power, ℤ (denoting the ring
333
        of  integers),  a  description  of  an  algebraic  extension  field, ℂ
334
        (denoting  an  unspecified  algebraic extension field), or ℤ/mℤ for an
335
        integer  m  (denoting  the  ring of residues mod m); for example, G <=
336
        GL(2a,4)  and G <= GL(2b,4) denote two (nonequivalent) representations
337
        of dimension 2 over the field with four elements.
338
  
339
  After the representations, the programs available for gapname are listed.
340
  
341
  The following optional arguments can be used to restrict the overviews.
342
  
343
  std
344
        must  be  a  positive integer or a list of positive integers; if it is
345
        given then only those representations are considered that refer to the
346
        std-th  set  of  standard  generators  or  the  i-th  set  of standard
347
        generators, for i in std (see Section 3.3),
348
  
349
  "contents" and sources
350
        for  a  string  or  a list of strings sources, restrict the data about
351
        which  the  overview is formed; if sources is the string "public" then
352
        only  non-private data (see Chapter 5) are considered, if sources is a
353
        string  that  denotes  a  private  extension  in  the sense of a dirid
354
        argument  of AtlasOfGroupRepresentationsNotifyPrivateDirectory (5.1-1)
355
        then  only  the  data  that  belong  to  this  private  extension  are
356
        considered;  also  a list of such strings may be given, then the union
357
        of these data is considered,
358
  
359
  Identifier and id
360
        restrict  to  representations with identifier component in the list id
361
        (note  that this component is itself a list, entering this list is not
362
        admissible), or satisfying the function id,
363
  
364
  IsPermGroup and true
365
        restrict to permutation representations,
366
  
367
  NrMovedPoints and n
368
        for  a positive integer, a list of positive integers, or a property n,
369
        restrict  to  permutation  representations of degree equal to n, or in
370
        the list n, or satisfying the function n,
371
  
372
  NrMovedPoints and the string "minimal"
373
        restrict to faithful permutation representations of minimal degree (if
374
        this information is available),
375
  
376
  IsTransitive and true or false
377
        restrict to transitive or intransitive permutation representations (if
378
        this information is available),
379
  
380
  IsPrimitive and true or false
381
        restrict  to  primitive or imprimitive permutation representations (if
382
        this information is available),
383
  
384
  Transitivity and n
385
        for  a  nonnegative  integer,  a  list  of  nonnegative integers, or a
386
        property  n,  restrict  to permutation representations of transitivity
387
        equal  to  n,  or in the list n, or satisfying the function n (if this
388
        information is available),
389
  
390
  RankAction and n
391
        for  a  nonnegative  integer,  a  list  of  nonnegative integers, or a
392
        property  n,  restrict to permutation representations of rank equal to
393
        n, or in the list n, or satisfying the function n (if this information
394
        is available),
395
  
396
  IsMatrixGroup and true
397
        restrict to matrix representations,
398
  
399
  Characteristic and p
400
        for  a  prime  integer,  a  list  of  prime integers, or a property p,
401
        restrict to matrix representations over fields of characteristic equal
402
        to  p, or in the list p, or satisfying the function p (representations
403
        over  residue  class  rings  that  are  not fields can be addressed by
404
        entering fail as the value of p),
405
  
406
  Dimension and n
407
        for  a positive integer, a list of positive integers, or a property n,
408
        restrict  to matrix representations of dimension equal to n, or in the
409
        list n, or satisfying the function n,
410
  
411
  Characteristic, p, Dimension,
412
        and the string "minimal"
413
        for  a  prime  integer  p, restrict to faithful matrix representations
414
        over  fields  of characteristic p that have minimal dimension (if this
415
        information is available),
416
  
417
  Ring and R
418
        for  a  ring  or a property R, restrict to matrix representations over
419
        this  ring  or  satisfying this function (note that the representation
420
        might be defined over a proper subring of R),
421
  
422
  Ring, R, Dimension,
423
        and the string "minimal"
424
        for  a  ring  R, restrict to faithful matrix representations over this
425
        ring that have minimal dimension (if this information is available),
426
  
427
  Character and chi
428
        for  a  class  function  or a list of class functions chi, restrict to
429
        matrix representations with these characters (note that the underlying
430
        characteristic   of   the   class  function,  see  Section 'Reference:
431
        UnderlyingCharacteristic',   determines   the  characteristic  of  the
432
        matrices), and
433
  
434
  IsStraightLineProgram and true
435
        restrict  to  straight  line  programs,  straight  line decisions (see
436
        Section 6.1), and black box programs (see Section 6.2).
437
  
438
  Note  that  the  above  conditions  refer  only  to  the information that is
439
  available  without  accessing the representations. For example, if it is not
440
  stored  in  the  table  of  contents whether a permutation representation is
441
  primitive  then  this representation does not match an IsPrimitive condition
442
  in DisplayAtlasInfo.
443
  
444
  If  minimality  information  is  requested  and  no available representation
445
  matches this condition then either no minimal representation is available or
446
  the     information     about     the    minimality    is    missing.    See
447
  MinimalRepresentationInfo   (6.3-1)  for  checking  whether  the  minimality
448
  information  is  available for the group in question. Note that in the cases
449
  where  the string "minimal" occurs as an argument, MinimalRepresentationInfo
450
  (6.3-1)  is  called with third argument "lookup"; this is because the stored
451
  information  was  precomputed  just  for  the  groups  in the ATLAS of Group
452
  Representations,  so  trying  to  compute  non-stored minimality information
453
  (using other available databases) will hardly be successful.
454
  
455
  The representations are ordered as follows. Permutation representations come
456
  first   (ordered   according   to   their   degrees),   followed  by  matrix
457
  representations  over  finite  fields  (ordered first according to the field
458
  size and second according to the dimension), matrix representations over the
459
  integers,  and  then  matrix representations over algebraic extension fields
460
  (both  kinds  ordered  according to the dimension), the last representations
461
  are matrix representations over residue class rings (ordered first according
462
  to the modulus and second according to the dimension).
463
  
464
  The  maximal  subgroups are ordered according to decreasing group order. For
465
  an extension G.p of a simple group G by an outer automorphism of prime order
466
  p,  this  means  that  G  is  the  first  maximal subgroup and then come the
467
  extensions  of  the  maximal  subgroups  of G and the novelties; so the n-th
468
  maximal  subgroup  of  G and the n-th maximal subgroup of G.p are in general
469
  not related. (This coincides with the numbering used for the Maxes (CTblLib:
470
  Maxes) attribute for character tables.)
471
  
472
    Example  
473
    gap> DisplayAtlasInfo( [ "M11", "A5" ] );
474
    group |  # | maxes | cl | cyc | out | fnd | chk | prs
475
    ------+----+-------+----+-----+-----+-----+-----+----
476
    M11   | 42 |     5 |  + |  +  |     |  +  |  +  |  + 
477
    A5    | 18 |     3 |    |     |     |     |  +  |  + 
478
  
479
  
480
  The  above  output means that the ATLAS of Group Representations contains 42
481
  representations  of  the  Mathieu  group  M_11,  straight  line programs for
482
  computing  generators  of  representatives  of  all  five classes of maximal
483
  subgroups,  for  computing  representatives  of  the  conjugacy  classes  of
484
  elements  and  of  generators  of  maximally  cyclic  subgroups, contains no
485
  straight  line  program for applying outer automorphisms (well, in fact M_11
486
  admits  no  nontrivial  outer  automorphism),  and  contains  straight  line
487
  decisions  that  check  a  set  of generators or a set of group elements for
488
  being  a  set of standard generators. Analogously, 18 representations of the
489
  alternating  group  A_5  are available, straight line programs for computing
490
  generators of representatives of all three classes of maximal subgroups, and
491
  no  straight  line  programs  for computing representatives of the conjugacy
492
  classes of elements, of generators of maximally cyclic subgroups, and no for
493
  computing  images  under  outer  automorphisms;  straight line decisions for
494
  checking the standardization of generators or group elements are available.
495
  
496
    Example  
497
    gap> DisplayAtlasInfo( "A5", IsPermGroup, true );
498
    Representations for G = A5:    (all refer to std. generators 1)
499
    ---------------------------
500
    1: G <= Sym(5)  3-trans., on cosets of A4 (1st max.)
501
    2: G <= Sym(6)  2-trans., on cosets of D10 (2nd max.)
502
    3: G <= Sym(10) rank 3, on cosets of S3 (3rd max.)
503
    gap> DisplayAtlasInfo( "A5", NrMovedPoints, [ 4 .. 9 ] );
504
    Representations for G = A5:    (all refer to std. generators 1)
505
    ---------------------------
506
    1: G <= Sym(5) 3-trans., on cosets of A4 (1st max.)
507
    2: G <= Sym(6) 2-trans., on cosets of D10 (2nd max.)
508
  
509
  
510
  The  first  three  representations  stored  for  A_5 are (in fact primitive)
511
  permutation representations.
512
  
513
    Example  
514
    gap> DisplayAtlasInfo( "A5", Dimension, [ 1 .. 3 ] );
515
    Representations for G = A5:    (all refer to std. generators 1)
516
    ---------------------------
517
     8: G <= GL(2a,4)                
518
     9: G <= GL(2b,4)                
519
    10: G <= GL(3,5)                 
520
    12: G <= GL(3a,9)                
521
    13: G <= GL(3b,9)                
522
    17: G <= GL(3a,Field([Sqrt(5)])) 
523
    18: G <= GL(3b,Field([Sqrt(5)])) 
524
    gap> DisplayAtlasInfo( "A5", Characteristic, 0 );
525
    Representations for G = A5:    (all refer to std. generators 1)
526
    ---------------------------
527
    14: G <= GL(4,Z)                 
528
    15: G <= GL(5,Z)                 
529
    16: G <= GL(6,Z)                 
530
    17: G <= GL(3a,Field([Sqrt(5)])) 
531
    18: G <= GL(3b,Field([Sqrt(5)])) 
532
  
533
  
534
  The  representations  with number between 4 and 13 are (in fact irreducible)
535
  matrix  representations over various finite fields, those with numbers 14 to
536
  16  are  integral  matrix  representations,  and  the  last  two  are matrix
537
  representations over the field generated by sqrt{5} over the rational number
538
  field.
539
  
540
    Example  
541
    gap> DisplayAtlasInfo( "A5", Identifier, "a" );
542
    Representations for G = A5:    (all refer to std. generators 1)
543
    ---------------------------
544
     4: G <= GL(4a,2)                
545
     8: G <= GL(2a,4)                
546
    12: G <= GL(3a,9)                
547
    17: G <= GL(3a,Field([Sqrt(5)])) 
548
  
549
  
550
  Each  of  the  representations  with the numbers 4, 8, 12, and 17 is labeled
551
  with the distinguishing letter a.
552
  
553
    Example  
554
    gap> DisplayAtlasInfo( "A5", NrMovedPoints, IsPrimeInt );
555
    Representations for G = A5:    (all refer to std. generators 1)
556
    ---------------------------
557
    1: G <= Sym(5) 3-trans., on cosets of A4 (1st max.)
558
    gap> DisplayAtlasInfo( "A5", Characteristic, IsOddInt );
559
    Representations for G = A5:    (all refer to std. generators 1)
560
    ---------------------------
561
     6: G <= GL(4,3)  
562
     7: G <= GL(6,3)  
563
    10: G <= GL(3,5)  
564
    11: G <= GL(5,5)  
565
    12: G <= GL(3a,9) 
566
    13: G <= GL(3b,9) 
567
    gap> DisplayAtlasInfo( "A5", Dimension, IsPrimeInt );
568
    Representations for G = A5:    (all refer to std. generators 1)
569
    ---------------------------
570
     8: G <= GL(2a,4)                
571
     9: G <= GL(2b,4)                
572
    10: G <= GL(3,5)                 
573
    11: G <= GL(5,5)                 
574
    12: G <= GL(3a,9)                
575
    13: G <= GL(3b,9)                
576
    15: G <= GL(5,Z)                 
577
    17: G <= GL(3a,Field([Sqrt(5)])) 
578
    18: G <= GL(3b,Field([Sqrt(5)])) 
579
    gap> DisplayAtlasInfo( "A5", Ring, IsFinite and IsPrimeField );
580
    Representations for G = A5:    (all refer to std. generators 1)
581
    ---------------------------
582
     4: G <= GL(4a,2) 
583
     5: G <= GL(4b,2) 
584
     6: G <= GL(4,3)  
585
     7: G <= GL(6,3)  
586
    10: G <= GL(3,5)  
587
    11: G <= GL(5,5)  
588
  
589
  
590
  The above examples show how the output can be restricted using a property (a
591
  unary function that returns either true or false) that follows NrMovedPoints
592
  (Reference:  NrMovedPoints  (for a permutation)), Characteristic (Reference:
593
  Characteristic), Dimension (Reference: Dimension), or Ring (Reference: Ring)
594
  in the argument list of DisplayAtlasInfo.
595
  
596
    Example  
597
    gap> DisplayAtlasInfo( "A5", IsStraightLineProgram, true );
598
    Programs for G = A5:    (all refer to std. generators 1)
599
    --------------------
600
    presentation
601
    std. gen. checker
602
    maxes (all 3):
603
      1:  A4
604
      2:  D10
605
      3:  S3
606
  
607
  
608
  Straight   line   programs   are   available  for  computing  generators  of
609
  representatives  of  the  three  classes  of maximal subgroups of A_5, and a
610
  straight  line  decision  for  checking whether given generators are in fact
611
  standard  generators  is  available  as  well  as a presentation in terms of
612
  standard generators, see AtlasProgram (3.5-3).
613
  
614
  3.5-2 AtlasGenerators
615
  
616
  AtlasGenerators( gapname, repnr[, maxnr] )  function
617
  AtlasGenerators( identifier )  function
618
  Returns:  a record containing generators for a representation, or fail.
619
  
620
  In  the  first  form,  gapname  must  be  a  string denoting a GAP name (see
621
  Section 3.2) of a group, and repnr a positive integer. If the ATLAS of Group
622
  Representations  contains  at least repnr representations for the group with
623
  GAP  name  gapname then AtlasGenerators, when called with gapname and repnr,
624
  returns   an   immutable  record  describing  the  repnr-th  representation;
625
  otherwise  fail  is returned. If a third argument maxnr, a positive integer,
626
  is given then an immutable record describing the restriction of the repnr-th
627
  representation to the maxnr-th maximal subgroup is returned.
628
  
629
  The result record has at least the following components.
630
  
631
  generators
632
        a list of generators for the group,
633
  
634
  groupname
635
        the GAP name of the group (see Section 3.2),
636
  
637
  identifier
638
        a  GAP  object  (a list of filenames plus additional information) that
639
        uniquely  determines  the  representation;  the  value  can be used as
640
        identifier argument of AtlasGenerators.
641
  
642
  repnr
643
        the  number of the representation in the current session, equal to the
644
        argument repnr if this is given.
645
  
646
  standardization
647
        the positive integer denoting the underlying standard generators,
648
  
649
  Additionally,  the  group  order  may  be  stored in the component size, and
650
  describing  components  may be available that depend on the data type of the
651
  representation:  For permutation representations, these are p for the number
652
  of  moved  points,  id  for  the  distinguishing  string  as  described  for
653
  DisplayAtlasInfo   (3.5-1),   and   information   about  primitivity,  point
654
  stabilizers etc. if available; for matrix representations, these are dim for
655
  the dimension of the matrices, ring (if known) for the ring generated by the
656
  matrix  entries, id for the distinguishing string, and information about the
657
  character if available.
658
  
659
  It  should  be  noted  that  the  number repnr refers to the number shown by
660
  DisplayAtlasInfo  (3.5-1)  in  the current session; it may be that after the
661
  addition of new representations, repnr refers to another representation.
662
  
663
  The  alternative form of AtlasGenerators, with only argument identifier, can
664
  be  used  to  fetch  the  result  record  with  identifier  value  equal  to
665
  identifier. The purpose of this variant is to access the same representation
666
  also in different GAP sessions.
667
  
668
    Example  
669
    gap> gens1:= AtlasGenerators( "A5", 1 );
670
    rec( generators := [ (1,2)(3,4), (1,3,5) ], groupname := "A5", 
671
      id := "", 
672
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], 
673
      isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
674
      repname := "A5G1-p5B0", repnr := 1, size := 60, stabilizer := "A4", 
675
      standardization := 1, transitivity := 3, type := "perm" )
676
    gap> gens8:= AtlasGenerators( "A5", 8 );
677
    rec( dim := 2, 
678
      generators := [ [ [ Z(2)^0, 0*Z(2) ], [ Z(2^2), Z(2)^0 ] ], 
679
          [ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, Z(2)^0 ] ] ], groupname := "A5",
680
      id := "a", 
681
      identifier := [ "A5", [ "A5G1-f4r2aB0.m1", "A5G1-f4r2aB0.m2" ], 1, 
682
          4 ], repname := "A5G1-f4r2aB0", repnr := 8, ring := GF(2^2), 
683
      size := 60, standardization := 1, type := "matff" )
684
    gap> gens17:= AtlasGenerators( "A5", 17 );
685
    rec( dim := 3, 
686
      generators := 
687
        [ [ [ -1, 0, 0 ], [ 0, -1, 0 ], [ -E(5)-E(5)^4, -E(5)-E(5)^4, 1 ] 
688
             ], [ [ 0, 1, 0 ], [ 0, 0, 1 ], [ 1, 0, 0 ] ] ], 
689
      groupname := "A5", id := "a", 
690
      identifier := [ "A5", "A5G1-Ar3aB0.g", 1, 3 ], 
691
      repname := "A5G1-Ar3aB0", repnr := 17, ring := NF(5,[ 1, 4 ]), 
692
      size := 60, standardization := 1, type := "matalg" )
693
  
694
  
695
  Each of the above pairs of elements generates a group isomorphic to A_5.
696
  
697
    Example  
698
    gap> gens1max2:= AtlasGenerators( "A5", 1, 2 );
699
    rec( generators := [ (1,2)(3,4), (2,3)(4,5) ], groupname := "D10", 
700
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5, 2 ],
701
      repnr := 1, size := 10, standardization := 1 )
702
    gap> id:= gens1max2.identifier;;
703
    gap> gens1max2 = AtlasGenerators( id );
704
    true
705
    gap> max2:= Group( gens1max2.generators );;
706
    gap> Size( max2 );
707
    10
708
    gap> IdGroup( max2 ) = IdGroup( DihedralGroup( 10 ) );
709
    true
710
  
711
  
712
  The  elements stored in gens1max2.generators describe the restriction of the
713
  first  representation  of  A_5  to  a  group  in the second class of maximal
714
  subgroups   of   A_5   according   to  the  list  in  the  ATLAS  of  Finite
715
  Groups [CCNPW85]; this subgroup is isomorphic to the dihedral group D_10.
716
  
717
  3.5-3 AtlasProgram
718
  
719
  AtlasProgram( gapname[, std], ... )  function
720
  AtlasProgram( identifier )  function
721
  Returns:  a record containing a program, or fail.
722
  
723
  In the first form, gapname must be a string denoting a GAP name (see Section
724
   3.2)  of  a  group G, say. If the ATLAS of Group Representations contains a
725
  straight  line  program (see Section 'Reference: Straight Line Programs') or
726
  straight   line  decision  (see  Section 6.1)  or  black  box  program  (see
727
  Section 6.2)  as  described  by  the  remaining  arguments  (see below) then
728
  AtlasProgram  returns an immutable record containing this program. Otherwise
729
  fail is returned.
730
  
731
  If   the   optional   argument  std  is  given,  only  those  straight  line
732
  programs/decisions  are  considered that take generators from the std-th set
733
  of standard generators of G as input, see Section 3.3.
734
  
735
  The result record has the following components.
736
  
737
  program
738
        the required straight line program/decision, or black box program,
739
  
740
  standardization
741
        the positive integer denoting the underlying standard generators of G,
742
  
743
  identifier
744
        a  GAP  object  (a list of filenames plus additional information) that
745
        uniquely  determines  the program; the value can be used as identifier
746
        argument of AtlasProgram (see below).
747
  
748
  In the first form, the last arguments must be as follows.
749
  
750
  (the string "maxes" and) a positive integer maxnr
751
  
752
        the  required  program  computes  generators  of  the maxnr-th maximal
753
        subgroup of the group with GAP name gapname.
754
  
755
        In  this  case,  the  result record of AtlasProgram also may contain a
756
        component  size,  whose  value is the order of the maximal subgroup in
757
        question.
758
  
759
  one of the strings "classes" or "cyclic"
760
        the  required program computes representatives of conjugacy classes of
761
        elements   or   representatives  of  generators  of  maximally  cyclic
762
        subgroups of G, respectively.
763
  
764
        See [BSWW01]  and [SWW00] for the background concerning these straight
765
        line  programs. In these cases, the result record of AtlasProgram also
766
        contains  a component outputs, whose value is a list of class names of
767
        the outputs, as described in Section 3.4.
768
  
769
  the strings "automorphism" and autname
770
        the  required program computes images of standard generators under the
771
        outer automorphism of G that is given by this string.
772
  
773
        Note  that  a  value  "2"  of  autname  means  that  the square of the
774
        automorphism  is  an  inner  automorphism  of  G  (not necessarily the
775
        identity mapping) but the automorphism itself is not.
776
  
777
  the string "check"
778
        the  required  result is a straight line decision that takes a list of
779
        generators  for  G  and  returns true if these generators are standard
780
        generators of G w.r.t. the standardization std, and false otherwise.
781
  
782
  the string "presentation"
783
        the  required  result is a straight line decision that takes a list of
784
        group  elements  and  returns  true  if  these  elements  are standard
785
        generators of G w.r.t. the standardization std, and false otherwise.
786
  
787
        See StraightLineProgramFromStraightLineDecision (6.1-9) for an example
788
        how  to  derive  defining  relators  for  G  in  terms of the standard
789
        generators from such a straight line decision.
790
  
791
  the string "find"
792
        the  required result is a black box program that takes G and returns a
793
        list of standard generators of G, w.r.t. the standardization std.
794
  
795
  the string "restandardize" and an integer std2
796
        the  required result is a straight line program that computes standard
797
        generators of G w.r.t. the std2-th set of standard generators of G; in
798
        this case, the argument std must be given.
799
  
800
  the strings "other" and descr
801
        the required program is described by descr.
802
  
803
  The second form of AtlasProgram, with only argument the list identifier, can
804
  be  used  to  fetch  the  result  record  with  identifier  value  equal  to
805
  identifier.
806
  
807
    Example  
808
    gap> prog:= AtlasProgram( "A5", 2 );
809
    rec( groupname := "A5", identifier := [ "A5", "A5G1-max2W1", 1 ], 
810
      program := <straight line program>, size := 10, 
811
      standardization := 1, subgroupname := "D10" )
812
    gap> StringOfResultOfStraightLineProgram( prog.program, [ "a", "b" ] );
813
    "[ a, bbab ]"
814
    gap> gens1:= AtlasGenerators( "A5", 1 );
815
    rec( generators := [ (1,2)(3,4), (1,3,5) ], groupname := "A5", 
816
      id := "", 
817
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], 
818
      isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
819
      repname := "A5G1-p5B0", repnr := 1, size := 60, stabilizer := "A4", 
820
      standardization := 1, transitivity := 3, type := "perm" )
821
    gap> maxgens:= ResultOfStraightLineProgram( prog.program, gens1.generators );
822
    [ (1,2)(3,4), (2,3)(4,5) ]
823
    gap> maxgens = gens1max2.generators;
824
    true
825
  
826
  
827
  The  above  example  shows  that  for  restricting  representations given by
828
  standard  generators  to  a  maximal  subgroup of A_5, we can also fetch and
829
  apply the appropriate straight line program. Such a program (see 'Reference:
830
  Straight  Line  Programs')  takes  standard  generators of a group --in this
831
  example  A_5--  as  its  input, and returns a list of elements in this group
832
  --in  this  example generators of the D_10 subgroup we had met above-- which
833
  are  computed  essentially  by  evaluating  structured words in terms of the
834
  standard generators.
835
  
836
    Example  
837
    gap> prog:= AtlasProgram( "J1", "cyclic" );
838
    rec( groupname := "J1", identifier := [ "J1", "J1G1-cycW1", 1 ], 
839
      outputs := [ "6A", "7A", "10B", "11A", "15B", "19A" ], 
840
      program := <straight line program>, standardization := 1 )
841
    gap> gens:= GeneratorsOfGroup( FreeGroup( "x", "y" ) );;
842
    gap> ResultOfStraightLineProgram( prog.program, gens );
843
    [ (x*y)^2*((y*x)^2*y^2*x)^2*y^2, x*y, (x*(y*x*y)^2)^2*y, 
844
      (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, 
845
      (x*y)^2*y ]
846
  
847
  
848
  The  above  example  shows  how  to fetch and use straight line programs for
849
  computing  generators  of representatives of maximally cyclic subgroups of a
850
  given group.
851
  
852
  3.5-4 AtlasProgramInfo
853
  
854
  AtlasProgramInfo( gapname[, std][, "contents", sources][, ...] )  function
855
  Returns:  a record describing a program, or fail.
856
  
857
  AtlasProgramInfo  takes  the  same  arguments  as  AtlasProgram (3.5-3), and
858
  returns  a  similar result. The only difference is that the records returned
859
  by AtlasProgramInfo have no components program and outputs. The idea is that
860
  one  can use AtlasProgramInfo for testing whether the program in question is
861
  available  at  all,  but  without  transferring it from a remote server. The
862
  identifier  component  of the result of AtlasProgramInfo can then be used to
863
  fetch the program with AtlasProgram (3.5-3).
864
  
865
    Example  
866
    gap> AtlasProgramInfo( "J1", "cyclic" );
867
    rec( groupname := "J1", identifier := [ "J1", "J1G1-cycW1", 1 ], 
868
      standardization := 1 )
869
  
870
  
871
  3.5-5 OneAtlasGeneratingSetInfo
872
  
873
  OneAtlasGeneratingSetInfo( [gapname, ][std, ][...] )  function
874
  Returns:  a   record   describing   a   representation  that  satisfies  the
875
            conditions, or fail.
876
  
877
  Let gapname be a string denoting a GAP name (see Section  3.2) of a group G,
878
  say.   If   the  ATLAS  of  Group  Representations  contains  at  least  one
879
  representation     for    G    with    the    required    properties    then
880
  OneAtlasGeneratingSetInfo  returns  a record r whose components are the same
881
  as those of the records returned by AtlasGenerators (3.5-2), except that the
882
  component  generators is not contained; the component identifier of r can be
883
  used  as input for AtlasGenerators (3.5-2) in order to fetch the generators.
884
  If  no representation satisfying the given conditions is available then fail
885
  is returned.
886
  
887
  If the argument std is given then it must be a positive integer or a list of
888
  positive integers, denoting the sets of standard generators w.r.t. which the
889
  representation shall be given (see Section 3.3).
890
  
891
  The  argument  gapname  can  be  missing  (then  all  available  groups  are
892
  considered), or a list of group names can be given instead.
893
  
894
  Further  restrictions  can be entered as arguments, with the same meaning as
895
  described     for     DisplayAtlasInfo     (3.5-1).     The     result    of
896
  OneAtlasGeneratingSetInfo  describes  the  first  generating  set for G that
897
  matches the restrictions, in the ordering shown by DisplayAtlasInfo (3.5-1).
898
  
899
  Note that even in the case that the user parameter remote has the value true
900
  (see  Section 4.3-1), OneAtlasGeneratingSetInfo does not attempt to transfer
901
  remote data files, just the table of contents is evaluated. So this function
902
  (as well as AllAtlasGeneratingSetInfos (3.5-6)) can be used to check for the
903
  availability  of  certain  representations,  and  afterwards  one  can  call
904
  AtlasGenerators (3.5-2) for those representations one wants to work with.
905
  
906
  In  the  following  example,  we try to access information about permutation
907
  representations for the alternating group A_5.
908
  
909
    Example  
910
    gap> info:= OneAtlasGeneratingSetInfo( "A5" );
911
    rec( groupname := "A5", id := "", 
912
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], 
913
      isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
914
      repname := "A5G1-p5B0", repnr := 1, size := 60, stabilizer := "A4", 
915
      standardization := 1, transitivity := 3, type := "perm" )
916
    gap> gens:= AtlasGenerators( info.identifier );
917
    rec( generators := [ (1,2)(3,4), (1,3,5) ], groupname := "A5", 
918
      id := "", 
919
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], 
920
      isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
921
      repname := "A5G1-p5B0", repnr := 1, size := 60, stabilizer := "A4", 
922
      standardization := 1, transitivity := 3, type := "perm" )
923
    gap> info = OneAtlasGeneratingSetInfo( "A5", IsPermGroup, true );
924
    true
925
    gap> info = OneAtlasGeneratingSetInfo( "A5", NrMovedPoints, "minimal" );
926
    true
927
    gap> info = OneAtlasGeneratingSetInfo( "A5", NrMovedPoints, [ 1 .. 10 ] );
928
    true
929
    gap> OneAtlasGeneratingSetInfo( "A5", NrMovedPoints, 20 );
930
    fail
931
  
932
  
933
  Note  that  a  permutation  representation of degree 20 could be obtained by
934
  taking  twice  the primitive representation on 10 points; however, the ATLAS
935
  of Group Representations does not store this imprimitive representation (cf.
936
  Section 3.1).
937
  
938
  We  continue this example a little. Next we access matrix representations of
939
  A_5.
940
  
941
    Example  
942
    gap> info:= OneAtlasGeneratingSetInfo( "A5", IsMatrixGroup, true );
943
    rec( dim := 4, groupname := "A5", id := "a", 
944
      identifier := [ "A5", [ "A5G1-f2r4aB0.m1", "A5G1-f2r4aB0.m2" ], 1, 
945
          2 ], repname := "A5G1-f2r4aB0", repnr := 4, ring := GF(2), 
946
      size := 60, standardization := 1, type := "matff" )
947
    gap> gens:= AtlasGenerators( info.identifier );
948
    rec( dim := 4, 
949
      generators := [ <an immutable 4x4 matrix over GF2>, 
950
          <an immutable 4x4 matrix over GF2> ], groupname := "A5", 
951
      id := "a", 
952
      identifier := [ "A5", [ "A5G1-f2r4aB0.m1", "A5G1-f2r4aB0.m2" ], 1, 
953
          2 ], repname := "A5G1-f2r4aB0", repnr := 4, ring := GF(2), 
954
      size := 60, standardization := 1, type := "matff" )
955
    gap> info = OneAtlasGeneratingSetInfo( "A5", Dimension, 4 );
956
    true
957
    gap> info = OneAtlasGeneratingSetInfo( "A5", Characteristic, 2 );
958
    true
959
    gap> info = OneAtlasGeneratingSetInfo( "A5", Ring, GF(2) );
960
    true
961
    gap> OneAtlasGeneratingSetInfo( "A5", Characteristic, [2,5], Dimension, 2 );
962
    rec( dim := 2, groupname := "A5", id := "a", 
963
      identifier := [ "A5", [ "A5G1-f4r2aB0.m1", "A5G1-f4r2aB0.m2" ], 1, 
964
          4 ], repname := "A5G1-f4r2aB0", repnr := 8, ring := GF(2^2), 
965
      size := 60, standardization := 1, type := "matff" )
966
    gap> OneAtlasGeneratingSetInfo( "A5", Characteristic, [2,5], Dimension, 1 );
967
    fail
968
    gap> info:= OneAtlasGeneratingSetInfo( "A5", Characteristic, 0, Dimension, 4 );
969
    rec( dim := 4, groupname := "A5", id := "", 
970
      identifier := [ "A5", "A5G1-Zr4B0.g", 1, 4 ], 
971
      repname := "A5G1-Zr4B0", repnr := 14, ring := Integers, size := 60, 
972
      standardization := 1, type := "matint" )
973
    gap> gens:= AtlasGenerators( info.identifier );
974
    rec( dim := 4, 
975
      generators := 
976
        [ 
977
          [ [ 1, 0, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 1, 0, 0 ], 
978
              [ -1, -1, -1, -1 ] ], 
979
          [ [ 0, 1, 0, 0 ], [ 0, 0, 0, 1 ], [ 0, 0, 1, 0 ], 
980
              [ 1, 0, 0, 0 ] ] ], groupname := "A5", id := "", 
981
      identifier := [ "A5", "A5G1-Zr4B0.g", 1, 4 ], 
982
      repname := "A5G1-Zr4B0", repnr := 14, ring := Integers, size := 60, 
983
      standardization := 1, type := "matint" )
984
    gap> info = OneAtlasGeneratingSetInfo( "A5", Ring, Integers );
985
    true
986
    gap> info = OneAtlasGeneratingSetInfo( "A5", Ring, CF(37) );
987
    true
988
    gap> OneAtlasGeneratingSetInfo( "A5", Ring, Integers mod 77 );
989
    fail
990
    gap> info:= OneAtlasGeneratingSetInfo( "A5", Ring, CF(5), Dimension, 3 );
991
    rec( dim := 3, groupname := "A5", id := "a", 
992
      identifier := [ "A5", "A5G1-Ar3aB0.g", 1, 3 ], 
993
      repname := "A5G1-Ar3aB0", repnr := 17, ring := NF(5,[ 1, 4 ]), 
994
      size := 60, standardization := 1, type := "matalg" )
995
    gap> gens:= AtlasGenerators( info.identifier );
996
    rec( dim := 3, 
997
      generators := 
998
        [ [ [ -1, 0, 0 ], [ 0, -1, 0 ], [ -E(5)-E(5)^4, -E(5)-E(5)^4, 1 ] 
999
             ], [ [ 0, 1, 0 ], [ 0, 0, 1 ], [ 1, 0, 0 ] ] ], 
1000
      groupname := "A5", id := "a", 
1001
      identifier := [ "A5", "A5G1-Ar3aB0.g", 1, 3 ], 
1002
      repname := "A5G1-Ar3aB0", repnr := 17, ring := NF(5,[ 1, 4 ]), 
1003
      size := 60, standardization := 1, type := "matalg" )
1004
    gap> OneAtlasGeneratingSetInfo( "A5", Ring, GF(17) );
1005
    fail
1006
  
1007
  
1008
  3.5-6 AllAtlasGeneratingSetInfos
1009
  
1010
  AllAtlasGeneratingSetInfos( [gapname, ][std, ][...] )  function
1011
  Returns:  the  list  of  all records describing representations that satisfy
1012
            the conditions.
1013
  
1014
  AllAtlasGeneratingSetInfos  is similar to OneAtlasGeneratingSetInfo (3.5-5).
1015
  The  difference  is  that  the  list of all records describing the available
1016
  representations  with  the  given properties is returned instead of just one
1017
  such  component.  In  particular  an  empty  list  is  returned  if  no such
1018
  representation is available.
1019
  
1020
    Example  
1021
    gap> AllAtlasGeneratingSetInfos( "A5", IsPermGroup, true );
1022
    [ rec( groupname := "A5", id := "", 
1023
          identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ]
1024
            , isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
1025
          repname := "A5G1-p5B0", repnr := 1, size := 60, 
1026
          stabilizer := "A4", standardization := 1, transitivity := 3, 
1027
          type := "perm" ), 
1028
      rec( groupname := "A5", id := "", 
1029
          identifier := [ "A5", [ "A5G1-p6B0.m1", "A5G1-p6B0.m2" ], 1, 6 ]
1030
            , isPrimitive := true, maxnr := 2, p := 6, rankAction := 2, 
1031
          repname := "A5G1-p6B0", repnr := 2, size := 60, 
1032
          stabilizer := "D10", standardization := 1, transitivity := 2, 
1033
          type := "perm" ), 
1034
      rec( groupname := "A5", id := "", 
1035
          identifier := [ "A5", [ "A5G1-p10B0.m1", "A5G1-p10B0.m2" ], 1, 
1036
              10 ], isPrimitive := true, maxnr := 3, p := 10, 
1037
          rankAction := 3, repname := "A5G1-p10B0", repnr := 3, 
1038
          size := 60, stabilizer := "S3", standardization := 1, 
1039
          transitivity := 1, type := "perm" ) ]
1040
  
1041
  
1042
  Note  that  a matrix representation in any characteristic can be obtained by
1043
  reducing  a permutation representation or an integral matrix representation;
1044
  however,   the  ATLAS  of  Group  Representations  does  not  store  such  a
1045
  representation (cf. Section 3.1).
1046
  
1047
  
1048
  3.5-7 AtlasGroup
1049
  
1050
  AtlasGroup( [gapname[, std, ]][...] )  function
1051
  AtlasGroup( identifier )  function
1052
  Returns:  a group that satisfies the conditions, or fail.
1053
  
1054
  AtlasGroup  takes  the  same arguments as OneAtlasGeneratingSetInfo (3.5-5),
1055
  and  returns  the  group generated by the generators component of the record
1056
  that  is returned by OneAtlasGeneratingSetInfo (3.5-5) with these arguments;
1057
  if  OneAtlasGeneratingSetInfo  (3.5-5)  returns  fail  then  also AtlasGroup
1058
  returns fail.
1059
  
1060
    Example  
1061
    gap> g:= AtlasGroup( "A5" );
1062
    Group([ (1,2)(3,4), (1,3,5) ])
1063
  
1064
  
1065
  Alternatively,  it  is  possible  to  enter  exactly  one argument, a record
1066
  identifier    as    returned   by   OneAtlasGeneratingSetInfo   (3.5-5)   or
1067
  AllAtlasGeneratingSetInfos  (3.5-6),  or  the identifier component of such a
1068
  record.
1069
  
1070
    Example  
1071
    gap> info:= OneAtlasGeneratingSetInfo( "A5" );
1072
    rec( groupname := "A5", id := "", 
1073
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], 
1074
      isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
1075
      repname := "A5G1-p5B0", repnr := 1, size := 60, stabilizer := "A4", 
1076
      standardization := 1, transitivity := 3, type := "perm" )
1077
    gap> AtlasGroup( info );
1078
    Group([ (1,2)(3,4), (1,3,5) ])
1079
    gap> AtlasGroup( info.identifier );
1080
    Group([ (1,2)(3,4), (1,3,5) ])
1081
  
1082
  
1083
  In   the   groups  returned  by  AtlasGroup,  the  value  of  the  attribute
1084
  AtlasRepInfoRecord  (3.5-9)  is set. This information is used for example by
1085
  AtlasSubgroup  (3.5-8)  when  this function is called with second argument a
1086
  group created by AtlasGroup.
1087
  
1088
  
1089
  3.5-8 AtlasSubgroup
1090
  
1091
  AtlasSubgroup( gapname[, std][, ...], maxnr )  function
1092
  AtlasSubgroup( identifier, maxnr )  function
1093
  AtlasSubgroup( G, maxnr )  function
1094
  Returns:  a group that satisfies the conditions, or fail.
1095
  
1096
  The  arguments of AtlasSubgroup, except the last argument maxn, are the same
1097
  as  for AtlasGroup (3.5-7). If the ATLAS of Group Representations provides a
1098
  straight line program for restricting representations of the group with name
1099
  gapname  (given  w.r.t.  the  std-th  standard  generators)  to the maxnr-th
1100
  maximal  subgroup  and  if  a representation with the required properties is
1101
  available,  in  the  sense  that  calling  AtlasGroup  (3.5-7) with the same
1102
  arguments  except  maxnr  yields  a  group,  then  AtlasSubgroup returns the
1103
  restriction of this representation to the maxnr-th maximal subgroup.
1104
  
1105
  In all other cases, fail is returned.
1106
  
1107
  Note  that the conditions refer to the group and not to the subgroup. It may
1108
  happen  that  in  the  restriction  of  a  permutation  representation  to a
1109
  subgroup,  fewer  points  are  moved,  or  that  the restriction of a matrix
1110
  representation  turns  out  to  be  defined  over a smaller ring. Here is an
1111
  example.
1112
  
1113
    Example  
1114
    gap> g:= AtlasSubgroup( "A5", NrMovedPoints, 5, 1 );
1115
    Group([ (1,5)(2,3), (1,3,5) ])
1116
    gap> NrMovedPoints( g );
1117
    4
1118
  
1119
  
1120
  Alternatively,  it  is  possible  to  enter exactly two arguments, the first
1121
  being  a  record identifier as returned by OneAtlasGeneratingSetInfo (3.5-5)
1122
  or AllAtlasGeneratingSetInfos (3.5-6), or the identifier component of such a
1123
  record, or a group G constructed with AtlasGroup (3.5-7).
1124
  
1125
    Example  
1126
    gap> info:= OneAtlasGeneratingSetInfo( "A5" );
1127
    rec( groupname := "A5", id := "", 
1128
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], 
1129
      isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
1130
      repname := "A5G1-p5B0", repnr := 1, size := 60, stabilizer := "A4", 
1131
      standardization := 1, transitivity := 3, type := "perm" )
1132
    gap> AtlasSubgroup( info, 1 );
1133
    Group([ (1,5)(2,3), (1,3,5) ])
1134
    gap> AtlasSubgroup( info.identifier, 1 );
1135
    Group([ (1,5)(2,3), (1,3,5) ])
1136
    gap> AtlasSubgroup( AtlasGroup( "A5" ), 1 );
1137
    Group([ (1,5)(2,3), (1,3,5) ])
1138
  
1139
  
1140
  3.5-9 AtlasRepInfoRecord
1141
  
1142
  AtlasRepInfoRecord( G )  attribute
1143
  Returns:  the  record  stored  in the group G when this was constructed with
1144
            AtlasGroup (3.5-7).
1145
  
1146
  For  a  group G that has been constructed with AtlasGroup (3.5-7), the value
1147
  of  this  attribute  is  the info record that describes G, in the sense that
1148
  this  record was the first argument of the call to AtlasGroup (3.5-7), or it
1149
  is  the  result  of  the  call to OneAtlasGeneratingSetInfo (3.5-5) with the
1150
  conditions that were listed in the call to AtlasGroup (3.5-7).
1151
  
1152
    Example  
1153
    gap> AtlasRepInfoRecord( AtlasGroup( "A5" ) );
1154
    rec( groupname := "A5", id := "", 
1155
      identifier := [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ], 
1156
      isPrimitive := true, maxnr := 1, p := 5, rankAction := 2, 
1157
      repname := "A5G1-p5B0", repnr := 1, size := 60, stabilizer := "A4", 
1158
      standardization := 1, transitivity := 3, type := "perm" )
1159
  
1160
  
1161
  
1162
  3.6 Browse Applications Provided by AtlasRep
1163
  
1164
  The functions BrowseMinimalDegrees (3.6-1), BrowseBibliographySporadicSimple
1165
  (3.6-2),  and  BrowseAtlasInfo  (Browse: BrowseAtlasInfo) (an alternative to
1166
  DisplayAtlasInfo  (3.5-1)) are available only if the GAP package Browse (see
1167
  [BL14]) is loaded.
1168
  
1169
  3.6-1 BrowseMinimalDegrees
1170
  
1171
  BrowseMinimalDegrees( [groupnames] )  function
1172
  Returns:  the list of info records for the clicked representations.
1173
  
1174
  If  the  GAP  package  Browse  (see  [BL14]) is loaded then this function is
1175
  available.  It  opens a browse table whose rows correspond to the groups for
1176
  which  the  ATLAS  of  Group Representations contains some information about
1177
  minimal degrees, whose columns correspond to the characteristics that occur,
1178
  and whose entries are the known minimal degrees.
1179
  
1180
    Example  
1181
    gap> if IsBound( BrowseMinimalDegrees ) then
1182
    >   down:= NCurses.keys.DOWN;;  DOWN:= NCurses.keys.NPAGE;;
1183
    >   right:= NCurses.keys.RIGHT;;  END:= NCurses.keys.END;;
1184
    >   enter:= NCurses.keys.ENTER;;  nop:= [ 14, 14, 14 ];;
1185
    >   # just scroll in the table
1186
    >   BrowseData.SetReplay( Concatenation( [ DOWN, DOWN, DOWN,
1187
    >          right, right, right ], "sedddrrrddd", nop, nop, "Q" ) );
1188
    >   BrowseMinimalDegrees();;
1189
    >   # restrict the table to the groups with minimal ordinary degree 6
1190
    >   BrowseData.SetReplay( Concatenation( "scf6",
1191
    >        [ down, down, right, enter, enter ] , nop, nop, "Q" ) );
1192
    >   BrowseMinimalDegrees();;
1193
    >   BrowseData.SetReplay( false );
1194
    > fi;
1195
  
1196
  
1197
  If  an argument groupnames is given then it must be a list of group names of
1198
  the  ATLAS  of Group Representations; the browse table is then restricted to
1199
  the  rows  corresponding  to  these  group names and to the columns that are
1200
  relevant  for  these  groups.  A perhaps interesting example is the subtable
1201
  with  the  data concerning sporadic simple groups and their covering groups,
1202
  which has been published in [Jan05]. This table can be shown as follows.
1203
  
1204
    Example  
1205
    gap> if IsBound( BrowseMinimalDegrees ) then
1206
    >   # just scroll in the table
1207
    >   BrowseData.SetReplay( Concatenation( [ DOWN, DOWN, DOWN, END ],
1208
    >          "rrrrrrrrrrrrrr", nop, nop, "Q" ) );
1209
    >   BrowseMinimalDegrees( BibliographySporadicSimple.groupNamesJan05 );;
1210
    > fi;
1211
  
1212
  
1213
  The  browse  table  does  not  contain  rows for the groups 6.M_22, 12.M_22,
1214
  6.Fi_22.  Note that in spite of the title of [Jan05], the entries in Table 1
1215
  of  this  paper  are  in  fact  the  minimal degrees of faithful irreducible
1216
  representations, and in the above three cases, these degrees are larger than
1217
  the  minimal degrees of faithful representations. The underlying data of the
1218
  browse table is about the minimal faithful (but not necessarily irreducible)
1219
  degrees.
1220
  
1221
  The    return    value    of    BrowseMinimalDegrees    is   the   list   of
1222
  OneAtlasGeneratingSetInfo (3.5-5) values for those representations that have
1223
  been clicked in visual mode.
1224
  
1225
  The variant without arguments of this function is also available in the menu
1226
  shown by BrowseGapData (Browse: BrowseGapData).
1227
  
1228
  3.6-2 BrowseBibliographySporadicSimple
1229
  
1230
  BrowseBibliographySporadicSimple(  )  function
1231
  Returns:  a    record   as   returned   by   ParseBibXMLExtString   (GAPDoc:
1232
            ParseBibXMLextString).
1233
  
1234
  If  the  GAP  package  Browse  (see  [BL14]) is loaded then this function is
1235
  available.  It  opens a browse table whose rows correspond to the entries of
1236
  the  bibliographies in the ATLAS of Finite Groups [CCNPW85] and in the ATLAS
1237
  of Brauer Characters [JLPW95].
1238
  
1239
  The  function  is  based on BrowseBibliography (Browse: BrowseBibliography),
1240
  see  the  documentation of this function for details, e.g., about the return
1241
  value.
1242
  
1243
  The  returned record encodes the bibliography entries corresponding to those
1244
  rows of the table that are clicked in visual mode, in the same format as the
1245
  return value of ParseBibXMLExtString (GAPDoc: ParseBibXMLextString), see the
1246
  manual of the GAP package GAPDoc [LN12] for details.
1247
  
1248
  BrowseBibliographySporadicSimple  can  be  called also via the menu shown by
1249
  BrowseGapData (Browse: BrowseGapData).
1250
  
1251
    Example  
1252
    gap> if IsBound( BrowseBibliographySporadicSimple ) then
1253
    >   enter:= NCurses.keys.ENTER;;  nop:= [ 14, 14, 14 ];;
1254
    >   BrowseData.SetReplay( Concatenation(
1255
    >     # choose the application
1256
    >     "/Bibliography of Sporadic Simple Groups", [ enter, enter ],
1257
    >     # search in the title column for the Atlas of Finite Groups
1258
    >     "scr/Atlas of finite groups", [ enter,
1259
    >     # and quit
1260
    >     nop, nop, nop, nop ], "Q" ) );
1261
    >   BrowseGapData();;
1262
    >   BrowseData.SetReplay( false );
1263
    > fi;
1264
  
1265
  
1266
  The  bibliographies contained in the ATLAS of Finite Groups [CCNPW85] and in
1267
  the ATLAS of Brauer Characters [JLPW95] are available online in HTML format,
1268
  see http://www.math.rwth-aachen.de/~Thomas.Breuer/atlasrep/bibl/index.html.
1269
  
1270
  The    source    data    in    BibXMLext   format,   which   are   used   by
1271
  BrowseBibliographySporadicSimple,  is  part of the AtlasRep package, in four
1272
  files with suffix xml in the package's bibl directory. Note that each of the
1273
  two books contains two bibliographies.
1274
  
1275
  Details  about  the BibXMLext format, including information how to transform
1276
  the  data into other formats such as BibTeX, can be found in the GAP package
1277
  GAPDoc (see [LN12]).
1278
  
1279

1280