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

1
  
2
  2 Tutorial for the AtlasRep Package
3
  
4
  This  chapter  gives  an overview of the basic functionality provided by the
5
  AtlasRep package. The main concepts and interface functions are presented in
6
  the first sections, and Section 2.4 shows a few small examples.
7
  
8
  
9
  2.1 Accessing a Specific Group in AtlasRep
10
  
11
  The  AtlasRep  package  gives  access  to  a  database,  the  ATLAS of Group
12
  Representations  [ATLAS],  that  contains  generators  and  related data for
13
  several  groups,  mainly for extensions of simple groups (see Section 2.1-1)
14
  and for their maximal subgroups (see Section 2.1-2).
15
  
16
  Note  that the data are not part of the package. They are fetched from a web
17
  server as soon as they are needed for the first time, see Section 4.3-1.
18
  
19
  First  of  all,  we  load the AtlasRep package. Some of the examples require
20
  also the GAP packages CTblLib and TomLib, so we load also these packages.
21
  
22
    Example  
23
    gap> LoadPackage( "AtlasRep" );
24
    true
25
    gap> LoadPackage( "CTblLib" );
26
    true
27
    gap> LoadPackage( "TomLib" );
28
    true
29
  
30
  
31
  
32
  2.1-1 Accessing a Group in AtlasRep via its Name
33
  
34
  Each  group  that occurs in this database is specified by a name, which is a
35
  string similar to the name used in the ATLAS of Finite Groups [CCNPW85]. For
36
  those groups whose character tables are contained in the GAP Character Table
37
  Library [Bre13],   the   names  are  equal  to  the  Identifier  (Reference:
38
  Identifier  (for  character  tables))  values  of  these  character  tables.
39
  Examples  of such names are "M24" for the Mathieu group M_24, "2.A6" for the
40
  double  cover  of  the  alternating group A_6, and "2.A6.2_1" for the double
41
  cover  of  the symmetric group S_6. The names that actually occur are listed
42
  in  the  first  column of the overview table that is printed by the function
43
  DisplayAtlasInfo  (3.5-1),  called  without  arguments, see below. The other
44
  columns of the table describe the data that are available in the database.
45
  
46
  For  example,  DisplayAtlasInfo  (3.5-1)  may  print  the  following  lines.
47
  Omissions are indicated with ....
48
  
49
    Example  
50
    gap> DisplayAtlasInfo();
51
    group                    |  # | maxes | cl | cyc | out | fnd | chk | prs
52
    -------------------------+----+-------+----+-----+-----+-----+-----+----
53
    ...
54
    2.A5                     | 26 |     3 |    |     |     |     |  +  |  + 
55
    2.A5.2                   | 11 |     4 |    |     |     |     |  +  |  + 
56
    2.A6                     | 18 |     5 |    |     |     |     |     |    
57
    2.A6.2_1                 |  3 |     6 |    |     |     |     |     |    
58
    2.A7                     | 24 |       |    |     |     |     |     |    
59
    2.A7.2                   |  7 |       |    |     |     |     |     |    
60
    ...
61
    M22                      | 58 |     8 |  + |  +  |     |  +  |  +  |  + 
62
    M22.2                    | 46 |     7 |  + |  +  |     |  +  |  +  |  + 
63
    M23                      | 66 |     7 |  + |  +  |     |  +  |  +  |  + 
64
    M24                      | 62 |     9 |  + |  +  |     |  +  |  +  |  + 
65
    McL                      | 46 |    12 |  + |  +  |     |  +  |  +  |  + 
66
    McL.2                    | 27 |    10 |    |  +  |     |  +  |  +  |  + 
67
    O7(3)                    | 28 |       |    |     |     |     |     |    
68
    O7(3).2                  |  3 |       |    |     |     |     |     |    
69
    ...
70
  
71
  
72
  Called  with  a  group  name  as  the only argument, the function AtlasGroup
73
  (3.5-7)  returns  a  group  isomorphic  to the group with the given name. If
74
  permutation  generators  are  available  in  the database then a permutation
75
  group (of smallest available degree) is returned, otherwise a matrix group.
76
  
77
    Example  
78
    gap> g:= AtlasGroup( "M24" );
79
    Group([ (1,4)(2,7)(3,17)(5,13)(6,9)(8,15)(10,19)(11,18)(12,21)(14,16)
80
    (20,24)(22,23), (1,4,6)(2,21,14)(3,9,15)(5,18,10)(13,17,16)
81
    (19,24,23) ])
82
    gap> IsPermGroup( g );  NrMovedPoints( g );  Size( g );
83
    true
84
    24
85
    244823040
86
  
87
  
88
  
89
  2.1-2 Accessing a Maximal Subgroup of a Group in AtlasRep
90
  
91
  Many  maximal  subgroups  of  extensions of simple groups can be constructed
92
  using the function AtlasSubgroup (3.5-8). Given the name of the extension of
93
  the simple group and the number of the conjugacy class of maximal subgroups,
94
  this function returns a representative from this class.
95
  
96
    Example  
97
    gap> g:= AtlasSubgroup( "M24", 1 );
98
    Group([ (2,10)(3,12)(4,14)(6,9)(8,16)(15,18)(20,22)(21,24), (1,7,2,9)
99
    (3,22,10,23)(4,19,8,12)(5,14)(6,18)(13,16,17,24) ])
100
    gap> IsPermGroup( g );  NrMovedPoints( g );  Size( g );
101
    true
102
    23
103
    10200960
104
  
105
  
106
  The  classes  of  maximal subgroups are ordered w. r. t. decreasing subgroup
107
  order. So the first class contains the largest maximal subgroups.
108
  
109
  Note  that groups obtained by AtlasSubgroup (3.5-8) may be not very suitable
110
  for  computations  in  the  sense that much nicer representations exist. For
111
  example,  the  sporadic simple O'Nan group O'N contains a maximal subgroup S
112
  isomorphic with the Janko group J_1; the smallest permutation representation
113
  of  O'N  has degree 122760, so restricting this representation to S yields a
114
  representation   of  J_1  of  that  degree.  However,  J_1  has  a  faithful
115
  permutation  representation  of degree 266, which admits much more efficient
116
  computations.  If  you  are  just interested in J_1 and not in its embedding
117
  into  O'N  then one possibility to get a nicer faithful representation is to
118
  call            SmallerDegreePermutationRepresentation           (Reference:
119
  SmallerDegreePermutationRepresentation). In the abovementioned example, this
120
  works  quite  well;  note  that  in  general, we cannot expect that we get a
121
  representation of smallest degree in this way.
122
  
123
    Example  
124
    gap> s:= AtlasSubgroup( "ON", 3 );
125
    <permutation group of size 175560 with 2 generators>
126
    gap> NrMovedPoints( s );  Size( s );
127
    122760
128
    175560
129
    gap> hom:= SmallerDegreePermutationRepresentation( s );;
130
    gap> NrMovedPoints( Image( hom ) );
131
    1540
132
  
133
  
134
  In this particular case, one could of course also ask directly for the group
135
  J_1.
136
  
137
    Example  
138
    gap> j1:= AtlasGroup( "J1" );
139
    <permutation group of size 175560 with 2 generators>
140
    gap> NrMovedPoints( j1 );
141
    266
142
  
143
  
144
  If  you  have a group G, say, and you are really interested in the embedding
145
  of  a  maximal  subgroup  of  G  into  G  then an easy way to get compatible
146
  generators  is  to  create  G  with  AtlasGroup  (3.5-7)  and  then  to call
147
  AtlasSubgroup (3.5-8) with first argument the group G.
148
  
149
    Example  
150
    gap> g:= AtlasGroup( "ON" );
151
    <permutation group of size 460815505920 with 2 generators>
152
    gap> s:= AtlasSubgroup( g, 3 );
153
    <permutation group of size 175560 with 2 generators>
154
    gap> IsSubset( g, s );
155
    true
156
    gap> IsSubset( g, j1 );
157
    false
158
  
159
  
160
  
161
  2.2 Accessing Specific Generators in AtlasRep
162
  
163
  The  function  DisplayAtlasInfo (3.5-1), called with an admissible name of a
164
  group as the only argument, lists the ATLAS data available for this group.
165
  
166
    Example  
167
    gap> DisplayAtlasInfo( "A5" );
168
    Representations for G = A5:    (all refer to std. generators 1)
169
    ---------------------------
170
     1: G <= Sym(5)                  3-trans., on cosets of A4 (1st max.)
171
     2: G <= Sym(6)                  2-trans., on cosets of D10 (2nd max.)
172
     3: G <= Sym(10)                 rank 3, on cosets of S3 (3rd max.)
173
     4: G <= GL(4a,2)                
174
     5: G <= GL(4b,2)                
175
     6: G <= GL(4,3)                 
176
     7: G <= GL(6,3)                 
177
     8: G <= GL(2a,4)                
178
     9: G <= GL(2b,4)                
179
    10: G <= GL(3,5)                 
180
    11: G <= GL(5,5)                 
181
    12: G <= GL(3a,9)                
182
    13: G <= GL(3b,9)                
183
    14: G <= GL(4,Z)                 
184
    15: G <= GL(5,Z)                 
185
    16: G <= GL(6,Z)                 
186
    17: G <= GL(3a,Field([Sqrt(5)])) 
187
    18: G <= GL(3b,Field([Sqrt(5)])) 
188
    
189
    Programs for G = A5:    (all refer to std. generators 1)
190
    --------------------
191
    presentation
192
    std. gen. checker
193
    maxes (all 3):
194
      1:  A4
195
      2:  D10
196
      3:  S3
197
  
198
  
199
  In order to fetch one of the listed permutation groups or matrix groups, you
200
  can  call  AtlasGroup  (3.5-7)  with  second  argument the function Position
201
  (Reference: Position) and third argument the position in the list.
202
  
203
    Example  
204
    gap> AtlasGroup( "A5", Position, 1 );
205
    Group([ (1,2)(3,4), (1,3,5) ])
206
  
207
  
208
  Note  that  this approach may yield a different group after an update of the
209
  database, if new data for the group become available.
210
  
211
  Alternatively, you can describe the desired group by conditions, such as the
212
  degree  in  the  case of a permutation group, and the dimension and the base
213
  ring in the case of a matrix group.
214
  
215
    Example  
216
    gap> AtlasGroup( "A5", NrMovedPoints, 10 );
217
    Group([ (2,4)(3,5)(6,8)(7,10), (1,2,3)(4,6,7)(5,8,9) ])
218
    gap> AtlasGroup( "A5", Dimension, 4, Ring, GF(2) );
219
    <matrix group of size 60 with 2 generators>
220
  
221
  
222
  The  same  holds for the restriction to maximal subgroups: Use AtlasSubgroup
223
  (3.5-8)   with  the  same  arguments  as  AtlasGroup  (3.5-7),  except  that
224
  additionally  the number of the class of maximal subgroups is entered as the
225
  last  argument.  Note  that  the  conditions  refer to the group, not to the
226
  subgroup;  it  may  happen that the subgroup moves fewer points than the big
227
  group.
228
  
229
    Example  
230
    gap> AtlasSubgroup( "A5", Dimension, 4, Ring, GF(2), 1 );
231
    <matrix group of size 12 with 2 generators>
232
    gap> g:= AtlasSubgroup( "A5", NrMovedPoints, 10, 3 );
233
    Group([ (2,4)(3,5)(6,8)(7,10), (1,4)(3,8)(5,7)(6,10) ])
234
    gap> Size( g );  NrMovedPoints( g );
235
    6
236
    9
237
  
238
  
239
  
240
  2.3 Basic Concepts used in AtlasRep
241
  
242
  
243
  2.3-1 Groups, Generators, and Representations
244
  
245
  Up  to  now,  we  have  talked only about groups and subgroups. The AtlasRep
246
  package  provides  access  to group generators, and in fact these generators
247
  have  the  property  that  mapping  one  set of generators to another set of
248
  generators  for  the same group defines an isomorphism. These generators are
249
  called standard generators, see Section 3.3.
250
  
251
  So  instead  of thinking about several generating sets of a group G, say, we
252
  can  think about one abstract group G, with one fixed set of generators, and
253
  mapping  these  generators  to  any  set  of generators provided by AtlasRep
254
  defines  a  representation  of G. This viewpoint motivates the name ATLAS of
255
  Group Representations for the database.
256
  
257
  If you are interested in the generators provided by the database rather than
258
  in    the    groups    they    generate,    you   can   use   the   function
259
  OneAtlasGeneratingSetInfo  (3.5-5)  instead  of AtlasGroup (3.5-7), with the
260
  same  arguments.  This will yield a record that describes the representation
261
  in  question.  Calling the function AtlasGenerators (3.5-2) with this record
262
  will  then  yield  a  record with the additional component generators, which
263
  holds the list of generators.
264
  
265
    Example  
266
    gap> info:= OneAtlasGeneratingSetInfo( "A5", NrMovedPoints, 10 );
267
    rec( groupname := "A5", id := "", 
268
      identifier := [ "A5", [ "A5G1-p10B0.m1", "A5G1-p10B0.m2" ], 1, 10 ],
269
      isPrimitive := true, maxnr := 3, p := 10, rankAction := 3, 
270
      repname := "A5G1-p10B0", repnr := 3, size := 60, stabilizer := "S3",
271
      standardization := 1, transitivity := 1, type := "perm" )
272
    gap> info2:= AtlasGenerators( info );
273
    rec( generators := [ (2,4)(3,5)(6,8)(7,10), (1,2,3)(4,6,7)(5,8,9) ], 
274
      groupname := "A5", id := "", 
275
      identifier := [ "A5", [ "A5G1-p10B0.m1", "A5G1-p10B0.m2" ], 1, 10 ],
276
      isPrimitive := true, maxnr := 3, p := 10, rankAction := 3, 
277
      repname := "A5G1-p10B0", repnr := 3, size := 60, stabilizer := "S3",
278
      standardization := 1, transitivity := 1, type := "perm" )
279
    gap> info2.generators;
280
    [ (2,4)(3,5)(6,8)(7,10), (1,2,3)(4,6,7)(5,8,9) ]
281
  
282
  
283
  
284
  2.3-2 Straight Line Programs
285
  
286
  For  computing  certain  group  elements  from  standard generators, such as
287
  generators  of  a  subgroup or class representatives, AtlasRep uses straight
288
  line  programs,  see  'Reference:  Straight Line Programs'. Essentially this
289
  means to evaluate words in the generators, similar to MappedWord (Reference:
290
  MappedWord) but more efficiently.
291
  
292
  It can be useful to deal with these straight line programs, see AtlasProgram
293
  (3.5-3).  For  example, an automorphism α, say, of the group G, if available
294
  in  AtlasRep, is given by a straight line program that defines the images of
295
  standard generators of G. This way, one can for example compute the image of
296
  a  subgroup U of G under α by first applying the straight line program for α
297
  to standard generators of G, and then applying the straight line program for
298
  the restriction from G to U.
299
  
300
    Example  
301
    gap> prginfo:= AtlasProgramInfo( "A5", "maxes", 1 );
302
    rec( groupname := "A5", identifier := [ "A5", "A5G1-max1W1", 1 ], 
303
      size := 12, standardization := 1, subgroupname := "A4" )
304
    gap> prg:= AtlasProgram( prginfo.identifier );
305
    rec( groupname := "A5", identifier := [ "A5", "A5G1-max1W1", 1 ], 
306
      program := <straight line program>, size := 12, 
307
      standardization := 1, subgroupname := "A4" )
308
    gap> Display( prg.program );
309
    # input:
310
    r:= [ g1, g2 ];
311
    # program:
312
    r[3]:= r[1]*r[2];
313
    r[4]:= r[2]*r[1];
314
    r[5]:= r[3]*r[3];
315
    r[1]:= r[5]*r[4];
316
    # return values:
317
    [ r[1], r[2] ]
318
    gap> ResultOfStraightLineProgram( prg.program, info2.generators );
319
    [ (1,10)(2,3)(4,9)(7,8), (1,2,3)(4,6,7)(5,8,9) ]
320
  
321
  
322
  
323
  2.4 Examples of Using the AtlasRep Package
324
  
325
  
326
  2.4-1 Example: Class Representatives
327
  
328
  First  we show the computation of class representatives of the Mathieu group
329
  M_11,  in  a 2-modular matrix representation. We start with the ordinary and
330
  Brauer character tables of this group.
331
  
332
    Example  
333
    gap> tbl:= CharacterTable( "M11" );;
334
    gap> modtbl:= tbl mod 2;;
335
    gap> CharacterDegrees( modtbl );
336
    [ [ 1, 1 ], [ 10, 1 ], [ 16, 2 ], [ 44, 1 ] ]
337
  
338
  
339
  The  output of CharacterDegrees (Reference: CharacterDegrees) means that the
340
  2-modular irreducibles of M_11 have degrees 1, 10, 16, 16, and 44.
341
  
342
  Using  DisplayAtlasInfo  (3.5-1), we find out that matrix generators for the
343
  irreducible 10-dimensional representation are available in the database.
344
  
345
    Example  
346
    gap> DisplayAtlasInfo( "M11", Characteristic, 2 );
347
    Representations for G = M11:    (all refer to std. generators 1)
348
    ----------------------------
349
     6: G <= GL(10,2)  character 10a
350
     7: G <= GL(32,2)  character 16ab
351
     8: G <= GL(44,2)  character 44a
352
    16: G <= GL(16a,4) character 16a
353
    17: G <= GL(16b,4) character 16b
354
  
355
  
356
  So  we  decide to work with this representation. We fetch the generators and
357
  compute the list of class representatives of M_11 in the representation. The
358
  ordering of class representatives is the same as that in the character table
359
  of the ATLAS of Finite Groups ([CCNPW85]), which coincides with the ordering
360
  of columns in the GAP table we have fetched above.
361
  
362
    Example  
363
    gap> info:= OneAtlasGeneratingSetInfo( "M11", Characteristic, 2,
364
    >                                             Dimension, 10 );;
365
    gap> gens:= AtlasGenerators( info.identifier );;
366
    gap> ccls:= AtlasProgram( "M11", gens.standardization, "classes" );
367
    rec( groupname := "M11", identifier := [ "M11", "M11G1-cclsW1", 1 ], 
368
      outputs := [ "1A", "2A", "3A", "4A", "5A", "6A", "8A", "8B", "11A", 
369
          "11B" ], program := <straight line program>, 
370
      standardization := 1 )
371
    gap> reps:= ResultOfStraightLineProgram( ccls.program, gens.generators );;
372
  
373
  
374
  If  we  would  need  only  a few class representatives, we could use the GAP
375
  library  function  RestrictOutputsOfSLP (Reference: RestrictOutputsOfSLP) to
376
  create a straight line program that computes only specified outputs. Here is
377
  an example where only the class representatives of order eight are computed.
378
  
379
    Example  
380
    gap> ord8prg:= RestrictOutputsOfSLP( ccls.program,
381
    >                   Filtered( [ 1 .. 10 ], i -> ccls.outputs[i][1] = '8' ) );
382
    <straight line program>
383
    gap> ord8reps:= ResultOfStraightLineProgram( ord8prg, gens.generators );;
384
    gap> List( ord8reps, m -> Position( reps, m ) );
385
    [ 7, 8 ]
386
  
387
  
388
  Let us check that the class representatives have the right orders.
389
  
390
    Example  
391
    gap> List( reps, Order ) = OrdersClassRepresentatives( tbl );
392
    true
393
  
394
  
395
  From  the  class representatives, we can compute the Brauer character we had
396
  started  with.  This  Brauer  character  is  defined  on  all classes of the
397
  2-modular  table. So we first pick only those representatives, using the GAP
398
  function  GetFusionMap  (Reference:  GetFusionMap);  in  this  situation, it
399
  returns the class fusion from the Brauer table into the ordinary table.
400
  
401
    Example  
402
    gap> fus:= GetFusionMap( modtbl, tbl );
403
    [ 1, 3, 5, 9, 10 ]
404
    gap> modreps:= reps{ fus };;
405
  
406
  
407
  Then   we   call   the   GAP   function   BrauerCharacterValue   (Reference:
408
  BrauerCharacterValue),  which  computes  the Brauer character value from the
409
  matrix given.
410
  
411
    Example  
412
    gap> char:= List( modreps, BrauerCharacterValue );
413
    [ 10, 1, 0, -1, -1 ]
414
    gap> Position( Irr( modtbl ), char );
415
    2
416
  
417
  
418
  
419
  2.4-2 Example: Permutation and Matrix Representations
420
  
421
  The  second  example  shows  the computation of a permutation representation
422
  from a matrix representation. We work with the 10-dimensional representation
423
  used  above,  and  consider the action on the 2^10 vectors of the underlying
424
  row space.
425
  
426
    Example  
427
    gap> grp:= Group( gens.generators );;
428
    gap> v:= GF(2)^10;;
429
    gap> orbs:= Orbits( grp, AsList( v ) );;
430
    gap> List( orbs, Length );
431
    [ 1, 396, 55, 330, 66, 165, 11 ]
432
  
433
  
434
  We  see  that  there  are  six  nontrivial  orbits,  and  we can compute the
435
  permutation actions on these orbits directly using Action (Reference: Action
436
  homomorphisms).  However,  for  larger  examples,  one cannot write down all
437
  orbits  on  the  row  space,  so  one  has to use another strategy if one is
438
  interested in a particular orbit.
439
  
440
  Let  us  assume  that we are interested in the orbit of length 11. The point
441
  stabilizer  is  the  first maximal subgroup of M_11, thus the restriction of
442
  the representation to this subgroup has a nontrivial fixed point space. This
443
  restriction can be computed using the AtlasRep package.
444
  
445
    Example  
446
    gap> gens:= AtlasGenerators( "M11", 6, 1 );;
447
  
448
  
449
  Now computing the fixed point space is standard linear algebra.
450
  
451
    Example  
452
    gap> id:= IdentityMat( 10, GF(2) );;
453
    gap> sub1:= Subspace( v, NullspaceMat( gens.generators[1] - id ) );;
454
    gap> sub2:= Subspace( v, NullspaceMat( gens.generators[2] - id ) );;
455
    gap> fix:= Intersection( sub1, sub2 );
456
    <vector space of dimension 1 over GF(2)>
457
  
458
  
459
  The final step is of course the computation of the permutation action on the
460
  orbit.
461
  
462
    Example  
463
    gap> orb:= Orbit( grp, Basis( fix )[1] );;
464
    gap> act:= Action( grp, orb );;  Print( act, "\n" );
465
    Group( [ ( 1, 2)( 4, 6)( 5, 8)( 7,10), ( 1, 3, 5, 9)( 2, 4, 7,11) ] )
466
  
467
  
468
  Note  that  this  group  is  not equal to the group obtained by fetching the
469
  permutation  representation  from  the  database. This is due to a different
470
  numbering of the points, so the groups are permutation isomorphic.
471
  
472
    Example  
473
    gap> permgrp:= Group( AtlasGenerators( "M11", 1 ).generators );;
474
    gap> Print( permgrp, "\n" );
475
    Group( [ ( 2,10)( 4,11)( 5, 7)( 8, 9), ( 1, 4, 3, 8)( 2, 5, 6, 9) ] )
476
    gap> permgrp = act;
477
    false
478
    gap> IsConjugate( SymmetricGroup(11), permgrp, act );
479
    true
480
  
481
  
482
  
483
  2.4-3 Example: Outer Automorphisms
484
  
485
  The  straight  line  programs  for  applying outer automorphisms to standard
486
  generators  can  of course be used to define the automorphisms themselves as
487
  GAP mappings.
488
  
489
    Example  
490
    gap> DisplayAtlasInfo( "G2(3)", IsStraightLineProgram );
491
    Programs for G = G2(3):    (all refer to std. generators 1)
492
    -----------------------
493
    class repres.
494
    presentation
495
    repr. cyc. subg.
496
    std. gen. checker
497
    automorphisms:
498
      2
499
    maxes (all 10):
500
       1:  U3(3).2
501
       2:  U3(3).2
502
       3:  (3^(1+2)+x3^2):2S4
503
       4:  (3^(1+2)+x3^2):2S4
504
       5:  L3(3).2
505
       6:  L3(3).2
506
       7:  L2(8).3
507
       8:  2^3.L3(2)
508
       9:  L2(13)
509
      10:  2^(1+4)+:3^2.2
510
    gap> prog:= AtlasProgram( "G2(3)", "automorphism", "2" ).program;;
511
    gap> info:= OneAtlasGeneratingSetInfo( "G2(3)", Dimension, 7 );;
512
    gap> gens:= AtlasGenerators( info ).generators;;
513
    gap> imgs:= ResultOfStraightLineProgram( prog, gens );;
514
  
515
  
516
  If we are not suspicious whether the script really describes an automorphism
517
  then  we  should tell this to GAP, in order to avoid the expensive checks of
518
  the    properties    of    being   a   homomorphism   and   bijective   (see
519
  Section 'Reference: Creating Group Homomorphisms'). This looks as follows.
520
  
521
    Example  
522
    gap> g:= Group( gens );;
523
    gap> aut:= GroupHomomorphismByImagesNC( g, g, gens, imgs );;
524
    gap> SetIsBijective( aut, true );
525
  
526
  
527
  If  we  are  suspicious whether the script describes an automorphism then we
528
  might have the idea to check it with GAP, as follows.
529
  
530
    Example  
531
    gap> aut:= GroupHomomorphismByImages( g, g, gens, imgs );;
532
    gap> IsBijective( aut );
533
    true
534
  
535
  
536
  (Note  that  even for a comparatively small group such as G_2(3), this was a
537
  difficult task for GAP before version 4.3.)
538
  
539
  Often one can form images under an automorphism α, say, without creating the
540
  homomorphism  object.  This  is  obvious  for the standard generators of the
541
  group G themselves, but also for generators of a maximal subgroup M computed
542
  from  standard  generators of G, provided that the straight line programs in
543
  question  refer to the same standard generators. Note that the generators of
544
  M  are  given  by evaluating words in terms of standard generators of G, and
545
  their  images  under  α  can be obtained by evaluating the same words at the
546
  images under α of the standard generators of G.
547
  
548
    Example  
549
    gap> max1:= AtlasProgram( "G2(3)", 1 ).program;;
550
    gap> mgens:= ResultOfStraightLineProgram( max1, gens );;
551
    gap> comp:= CompositionOfStraightLinePrograms( max1, prog );;
552
    gap> mimgs:= ResultOfStraightLineProgram( comp, gens );;
553
  
554
  
555
  The  list  mgens  is the list of generators of the first maximal subgroup of
556
  G_2(3),  mimgs  is  the  list  of images under the automorphism given by the
557
  straight  line  program  prog.  Note  that  applying the program returned by
558
  CompositionOfStraightLinePrograms                                (Reference:
559
  CompositionOfStraightLinePrograms)  means to apply first prog and then max1.
560
  Since   we   have  already  constructed  the  GAP  object  representing  the
561
  automorphism, we can check whether the results are equal.
562
  
563
    Example  
564
    gap> mimgs = List( mgens, x -> x^aut );
565
    true
566
  
567
  
568
  However, it should be emphasized that using aut requires a huge machinery of
569
  computations  behind the scenes, whereas applying the straight line programs
570
  prog  and  max1 involves only elementary operations with the generators. The
571
  latter  is  feasible  also for larger groups, for which constructing the GAP
572
  automorphism might be too hard.
573
  
574
  
575
  2.4-4 Example: Using Semi-presentations and Black Box Programs
576
  
577
  Let  us  suppose  that  we  want to restrict a representation of the Mathieu
578
  group  M_12  to a non-maximal subgroup of the type L_2(11). The idea is that
579
  this  subgroup  can  be found as a maximal subgroup of a maximal subgroup of
580
  the  type  M_11,  which  is  itself  maximal  in  M_12. For that, we fetch a
581
  representation of M_12 and use a straight line program for restricting it to
582
  the first maximal subgroup, which has the type M_11.
583
  
584
    Example  
585
    gap> info:= OneAtlasGeneratingSetInfo( "M12", NrMovedPoints, 12 );
586
    rec( charactername := "1a+11a", groupname := "M12", id := "a", 
587
      identifier := [ "M12", [ "M12G1-p12aB0.m1", "M12G1-p12aB0.m2" ], 1, 
588
          12 ], isPrimitive := true, maxnr := 1, p := 12, rankAction := 2,
589
      repname := "M12G1-p12aB0", repnr := 1, size := 95040, 
590
      stabilizer := "M11", standardization := 1, transitivity := 5, 
591
      type := "perm" )
592
    gap> gensM12:= AtlasGenerators( info.identifier );;
593
    gap> restM11:= AtlasProgram( "M12", "maxes", 1 );;
594
    gap> gensM11:= ResultOfStraightLineProgram( restM11.program,
595
    >                                           gensM12.generators );
596
    [ (3,9)(4,12)(5,10)(6,8), (1,4,11,5)(2,10,8,3) ]
597
  
598
  
599
  Now  we  cannot  simply  apply  a  straight line program for a group to some
600
  generators, since they are not necessarily standard generators of the group.
601
  We check this property using a semi-presentation for M_11, see 6.1-7.
602
  
603
    Example  
604
    gap> checkM11:= AtlasProgram( "M11", "check" );
605
    rec( groupname := "M11", identifier := [ "M11", "M11G1-check1", 1, 1 ]
606
        , program := <straight line decision>, standardization := 1 )
607
    gap> ResultOfStraightLineDecision( checkM11.program, gensM11 );
608
    true
609
  
610
  
611
  So  we are lucky that applying the appropriate program for M_11 will give us
612
  the required generators for L_2(11).
613
  
614
    Example  
615
    gap> restL211:= AtlasProgram( "M11", "maxes", 2 );;
616
    gap> gensL211:= ResultOfStraightLineProgram( restL211.program, gensM11 );
617
    [ (3,9)(4,12)(5,10)(6,8), (1,11,9)(2,12,8)(3,6,10) ]
618
    gap> G:= Group( gensL211 );;  Size( G );  IsSimple( G );
619
    660
620
    true
621
  
622
  
623
  Usually  representations  are not given in terms of standard generators. For
624
  example,  let  us  take  the  M_11  type  group returned by the GAP function
625
  MathieuGroup (Reference: MathieuGroup).
626
  
627
    Example  
628
    gap> G:= MathieuGroup( 11 );;
629
    gap> gens:= GeneratorsOfGroup( G );
630
    [ (1,2,3,4,5,6,7,8,9,10,11), (3,7,11,8)(4,10,5,6) ]
631
    gap> ResultOfStraightLineDecision( checkM11.program, gens );
632
    false
633
  
634
  
635
  If  we  want to compute an L_2(11) type subgroup of this group, we can use a
636
  black  box  program  for  computing  standard generators, and then apply the
637
  straight line program for computing the restriction.
638
  
639
    Example  
640
    gap> find:= AtlasProgram( "M11", "find" );
641
    rec( groupname := "M11", identifier := [ "M11", "M11G1-find1", 1, 1 ],
642
      program := <black box program>, standardization := 1 )
643
    gap> stdgens:= ResultOfBBoxProgram( find.program, Group( gens ) );;
644
    gap> List( stdgens, Order );
645
    [ 2, 4 ]
646
    gap> ResultOfStraightLineDecision( checkM11.program, stdgens );
647
    true
648
    gap> gensL211:= ResultOfStraightLineProgram( restL211.program, stdgens );;
649
    gap> List( gensL211, Order );
650
    [ 2, 3 ]
651
    gap> G:= Group( gensL211 );;  Size( G );  IsSimple( G );
652
    660
653
    true
654
  
655
  
656
  
657
  2.4-5 Example: Using the GAP Library of Tables of Marks
658
  
659
  The  GAP  Library  of  Tables  of  Marks  (the  GAP package TomLib, [NMP13])
660
  provides,  for  many  almost  simple  groups,  information  for constructing
661
  representatives  of  all conjugacy classes of subgroups. If this information
662
  is   compatible   with  the  standard  generators  of  the  ATLAS  of  Group
663
  Representations  then  we can use it to restrict any representation from the
664
  ATLAS  to  prescribed  subgroups.  This  is  useful  in particular for those
665
  subgroups  for  which  the  ATLAS  of  Group Representations itself does not
666
  contain a straight line program.
667
  
668
    Example  
669
    gap> tom:= TableOfMarks( "A5" );
670
    TableOfMarks( "A5" )
671
    gap> info:= StandardGeneratorsInfo( tom );
672
    [ rec( ATLAS := true, description := "|a|=2, |b|=3, |ab|=5", 
673
          generators := "a, b", 
674
          script := [ [ 1, 2 ], [ 2, 3 ], [ 1, 1, 2, 1, 5 ] ], 
675
          standardization := 1 ) ]
676
  
677
  
678
  The  true value of the component ATLAS indicates that the information stored
679
  on  tom  refers  to  the standard generators of type 1 in the ATLAS of Group
680
  Representations.
681
  
682
  We  want  to  restrict  a  4-dimensional integral representation of A_5 to a
683
  Sylow 2 subgroup of A_5, and use RepresentativeTomByGeneratorsNC (Reference:
684
  RepresentativeTomByGeneratorsNC) for that.
685
  
686
    Example  
687
    gap> info:= OneAtlasGeneratingSetInfo( "A5", Ring, Integers, Dimension, 4 );;
688
    gap> stdgens:= AtlasGenerators( info.identifier );
689
    rec( dim := 4, 
690
      generators := 
691
        [ 
692
          [ [ 1, 0, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 1, 0, 0 ], 
693
              [ -1, -1, -1, -1 ] ], 
694
          [ [ 0, 1, 0, 0 ], [ 0, 0, 0, 1 ], [ 0, 0, 1, 0 ], 
695
              [ 1, 0, 0, 0 ] ] ], groupname := "A5", id := "", 
696
      identifier := [ "A5", "A5G1-Zr4B0.g", 1, 4 ], 
697
      repname := "A5G1-Zr4B0", repnr := 14, ring := Integers, size := 60, 
698
      standardization := 1, type := "matint" )
699
    gap> orders:= OrdersTom( tom );
700
    [ 1, 2, 3, 4, 5, 6, 10, 12, 60 ]
701
    gap> pos:= Position( orders, 4 );
702
    4
703
    gap> sub:= RepresentativeTomByGeneratorsNC( tom, pos, stdgens.generators );
704
    <matrix group of size 4 with 2 generators>
705
    gap> GeneratorsOfGroup( sub );
706
    [ [ [ 1, 0, 0, 0 ], [ -1, -1, -1, -1 ], [ 0, 0, 0, 1 ], 
707
          [ 0, 0, 1, 0 ] ], 
708
      [ [ 1, 0, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 1, 0, 0 ], 
709
          [ -1, -1, -1, -1 ] ] ]
710
  
711
  
712
  
713
  2.4-6 Example: Index 770 Subgroups in M_22
714
  
715
  The  sporadic simple Mathieu group M_22 contains a unique class of subgroups
716
  of  index  770  (and  order  576).  This can be seen for example using GAP's
717
  Library of Tables of Marks.
718
  
719
    Example  
720
    gap> tom:= TableOfMarks( "M22" );
721
    TableOfMarks( "M22" )
722
    gap> subord:= Size( UnderlyingGroup( tom ) ) / 770;
723
    576
724
    gap> ord:= OrdersTom( tom );;
725
    gap> tomstabs:= Filtered( [ 1 .. Length( ord ) ], i -> ord[i] = subord );
726
    [ 144 ]
727
  
728
  
729
  The  permutation  representation  of  M_22  on  the  right  cosets of such a
730
  subgroup S is contained in the ATLAS of Group Representations.
731
  
732
    Example  
733
    gap> DisplayAtlasInfo( "M22", NrMovedPoints, 770 );
734
    Representations for G = M22:    (all refer to std. generators 1)
735
    ----------------------------
736
    12: G <= Sym(770) rank 9, on cosets of (A4xA4):4 < 2^4:A6
737
  
738
  
739
  We now verify the information shown about the point stabilizer and about the
740
  maximal overgroups of S in M_22.
741
  
742
    Example  
743
    gap> maxtom:= MaximalSubgroupsTom( tom );
744
    [ [ 155, 154, 153, 152, 151, 150, 146, 145 ], 
745
      [ 22, 77, 176, 176, 231, 330, 616, 672 ] ]
746
    gap> List( tomstabs, i -> List( maxtom[1], j -> ContainedTom( tom, i, j ) ) );
747
    [ [ 0, 10, 0, 0, 0, 0, 0, 0 ] ]
748
  
749
  
750
  We  see that the only maximal subgroups of M_22 that contain S have index 77
751
  in  M_22.  According  to the ATLAS of Finite Groups, these maximal subgroups
752
  have  the  structure  2^4:A_6.  From  that and from the structure of A_6, we
753
  conclude that S has the structure 2^4:(3^2:4).
754
  
755
  Alternatively,  we  look at the permutation representation of degree 770. We
756
  fetch  it  from  the  ATLAS  of  Group Representations. There is exactly one
757
  nontrivial  block  system  for this representation, with 77 blocks of length
758
  10.
759
  
760
    Example  
761
    gap> g:= AtlasGroup( "M22", NrMovedPoints, 770 );
762
    <permutation group of size 443520 with 2 generators>
763
    gap> allbl:= AllBlocks( g );;
764
    gap> List( allbl, Length );
765
    [ 10 ]
766
  
767
  
768
  Furthermore, GAP computes that the point stabilizer S has the structure (A_4
769
  × A_4):4.
770
  
771
    Example  
772
    gap> stab:= Stabilizer( g, 1 );;
773
    gap> StructureDescription( stab );
774
    "(A4 x A4) : C4"
775
    gap> blocks:= Orbit( g, allbl[1], OnSets );;
776
    gap> act:= Action( g, blocks, OnSets );;
777
    gap> StructureDescription( Stabilizer( act, 1 ) );
778
    "(C2 x C2 x C2 x C2) : A6"
779
  
780
  
781
  
782
  2.4-7 Example: Index 462 Subgroups in M_22
783
  
784
  The  ATLAS  of  Group  Representations contains three degree 462 permutation
785
  representations of the group M_22.
786
  
787
    Example  
788
    gap> DisplayAtlasInfo( "M22", NrMovedPoints, 462 );
789
    Representations for G = M22:    (all refer to std. generators 1)
790
    ----------------------------
791
    7: G <= Sym(462a) rank 5, on cosets of 2^4:A5 < 2^4:A6
792
    8: G <= Sym(462b) rank 8, on cosets of 2^4:A5 < L3(4), 2^4:S5
793
    9: G <= Sym(462c) rank 8, on cosets of 2^4:A5 < L3(4), 2^4:A6
794
  
795
  
796
  The  point  stabilizers  in  these  three representations have the structure
797
  2^4:A_5.  Using  GAP's  Library  of  Tables of Marks, we can show that these
798
  stabilizers are exactly the three classes of subgroups of order 960 in M_22.
799
  For that, we first verify that the group generators stored in GAP's table of
800
  marks  coincide  with  the  standard  generators  used by the ATLAS of Group
801
  Representations.
802
  
803
    Example  
804
    gap> tom:= TableOfMarks( "M22" );
805
    TableOfMarks( "M22" )
806
    gap> genstom:= GeneratorsOfGroup( UnderlyingGroup( tom ) );;
807
    gap> checkM22:= AtlasProgram( "M22", "check" );
808
    rec( groupname := "M22", identifier := [ "M22", "M22G1-check1", 1, 1 ]
809
        , program := <straight line decision>, standardization := 1 )
810
    gap> ResultOfStraightLineDecision( checkM22.program, genstom );
811
    true
812
  
813
  
814
  There are indeed three classes of subgroups of order 960 in M_22.
815
  
816
    Example  
817
    gap> ord:= OrdersTom( tom );;
818
    gap> tomstabs:= Filtered( [ 1 .. Length( ord ) ], i -> ord[i] = 960 );
819
    [ 147, 148, 149 ]
820
  
821
  
822
  Now  we  compute  representatives  of  these  three  classes  in  the  three
823
  representations  462a, 462b, and 462c. We see that each of the three classes
824
  occurs as a point stabilizer in exactly one of the three representations.
825
  
826
    Example  
827
    gap> atlasreps:= AllAtlasGeneratingSetInfos( "M22", NrMovedPoints, 462 );
828
    [ rec( charactername := "1a+21a+55a+154a+231a", groupname := "M22", 
829
          id := "a", 
830
          identifier := 
831
            [ "M22", [ "M22G1-p462aB0.m1", "M22G1-p462aB0.m2" ], 1, 462 ],
832
          isPrimitive := false, p := 462, rankAction := 5, 
833
          repname := "M22G1-p462aB0", repnr := 7, size := 443520, 
834
          stabilizer := "2^4:A5 < 2^4:A6", standardization := 1, 
835
          transitivity := 1, type := "perm" ), 
836
      rec( charactername := "1a+21a^2+55a+154a+210a", groupname := "M22", 
837
          id := "b", 
838
          identifier := 
839
            [ "M22", [ "M22G1-p462bB0.m1", "M22G1-p462bB0.m2" ], 1, 462 ],
840
          isPrimitive := false, p := 462, rankAction := 8, 
841
          repname := "M22G1-p462bB0", repnr := 8, size := 443520, 
842
          stabilizer := "2^4:A5 < L3(4), 2^4:S5", standardization := 1, 
843
          transitivity := 1, type := "perm" ), 
844
      rec( charactername := "1a+21a^2+55a+154a+210a", groupname := "M22", 
845
          id := "c", 
846
          identifier := 
847
            [ "M22", [ "M22G1-p462cB0.m1", "M22G1-p462cB0.m2" ], 1, 462 ],
848
          isPrimitive := false, p := 462, rankAction := 8, 
849
          repname := "M22G1-p462cB0", repnr := 9, size := 443520, 
850
          stabilizer := "2^4:A5 < L3(4), 2^4:A6", standardization := 1, 
851
          transitivity := 1, type := "perm" ) ]
852
    gap> atlasreps:= List( atlasreps, AtlasGroup );;
853
    gap> tomstabreps:= List( atlasreps, G -> List( tomstabs,
854
    > i -> RepresentativeTomByGenerators( tom, i, GeneratorsOfGroup( G ) ) ) );;
855
    gap> List( tomstabreps, x -> List( x, NrMovedPoints ) );
856
    [ [ 462, 462, 461 ], [ 460, 462, 462 ], [ 462, 461, 462 ] ]
857
  
858
  
859
  More   precisely,   we   see   that  the  point  stabilizers  in  the  three
860
  representations  462a, 462b, 462c lie in the subgroup classes 149, 147, 148,
861
  respectively, of the table of marks.
862
  
863
  The  point  stabilizers in the representations 462b and 462c are isomorphic,
864
  but not isomorphic with the point stabilizer in 462a.
865
  
866
    Example  
867
    gap> stabs:= List( atlasreps, G -> Stabilizer( G, 1 ) );;
868
    gap> List( stabs, IdGroup );
869
    [ [ 960, 11358 ], [ 960, 11357 ], [ 960, 11357 ] ]
870
    gap> List( stabs, PerfectIdentification );
871
    [ [ 960, 2 ], [ 960, 1 ], [ 960, 1 ] ]
872
  
873
  
874
  The  three  representations  are  imprimitive.  The containment of the point
875
  stabilizers  in maximal subgroups of M_22 can be computed using the table of
876
  marks of M_22.
877
  
878
    Example  
879
    gap> maxtom:= MaximalSubgroupsTom( tom );
880
    [ [ 155, 154, 153, 152, 151, 150, 146, 145 ], 
881
      [ 22, 77, 176, 176, 231, 330, 616, 672 ] ]
882
    gap> List( tomstabs, i -> List( maxtom[1], j -> ContainedTom( tom, i, j ) ) );
883
    [ [ 21, 0, 0, 0, 1, 0, 0, 0 ], [ 21, 6, 0, 0, 0, 0, 0, 0 ], 
884
      [ 0, 6, 0, 0, 0, 0, 0, 0 ] ]
885
  
886
  
887
  We see:
888
  
889
      The point stabilizers in 462a (subgroups in the class 149 of the table
890
        of  marks) are contained only in maximal subgroups in class 154; these
891
        groups have the structure 2^4:A_6.
892
  
893
      The  point  stabilizers  in  462b  (subgroups  in  the  class 147) are
894
        contained  in  maximal  subgroups  in  the  classes 155 and 151; these
895
        groups have the structures L_3(4) and 2^4:S_5, respectively.
896
  
897
      The  point  stabilizers  in  462c  (subgroups  in  the  class 148) are
898
        contained in maximal subgroups in the classes 155 and 154.
899
  
900
  We  identify the supergroups of the point stabilizers by computing the block
901
  systems.
902
  
903
    Example  
904
    gap> bl:= List( atlasreps, AllBlocks );;
905
    gap> List( bl, Length );
906
    [ 1, 3, 2 ]
907
    gap> List( bl, l -> List( l, Length ) );
908
    [ [ 6 ], [ 21, 21, 2 ], [ 21, 6 ] ]
909
  
910
  
911
  Note  that the two block systems with blocks of length 21 for 462b belong to
912
  the same supergroups (of the type L_3(4)); each of these subgroups fixes two
913
  different subsets of 21 points.
914
  
915
  The  representation 462a is multiplicity-free, that is, it splits into a sum
916
  of pairwise nonisomorphic irreducible representations. This can be seen from
917
  the  fact  that  the  rank  of this permutation representation (that is, the
918
  number  of  orbits  of  the  point  stabilizer)  is  five;  each permutation
919
  representation with this property is multiplicity-free.
920
  
921
  The other two representations have rank eight. We have seen the ranks in the
922
  overview that was shown by DisplayAtlasInfo (3.5-1) in the beginning. Now we
923
  compute the ranks from the permutation groups.
924
  
925
    Example  
926
    gap> List( atlasreps, RankAction );
927
    [ 5, 8, 8 ]
928
  
929
  
930
  In  fact  the  two  representations  462b and 462c have the same permutation
931
  character. We check this by computing the possible permutation characters of
932
  degree 462 for M_22, and decomposing them into irreducible characters, using
933
  the character table from GAP's Character Table Library.
934
  
935
    Example  
936
    gap> t:= CharacterTable( "M22" );;
937
    gap> perms:= PermChars( t, 462 );
938
    [ Character( CharacterTable( "M22" ),
939
      [ 462, 30, 3, 2, 2, 2, 3, 0, 0, 0, 0, 0 ] ), 
940
      Character( CharacterTable( "M22" ),
941
      [ 462, 30, 12, 2, 2, 2, 0, 0, 0, 0, 0, 0 ] ) ]
942
    gap> MatScalarProducts( t, Irr( t ), perms );
943
    [ [ 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0 ], 
944
      [ 1, 2, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0 ] ]
945
  
946
  
947
  In   particular,   we   see   that   the   rank  eight  characters  are  not
948
  multiplicity-free.
949
  
950

951