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

1

2
<!-- %W  tutorial.xml    GAP 4 package AtlasRep             Thomas Breuer -->
3
<!-- %Y  Copyright 2008, Lehrstuhl D f�r Mathematik, RWTH Aachen, Germany -->
4

5

6
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
7
<Chapter Label="chap:tutorial">
8
<Heading>Tutorial for the <Package>AtlasRep</Package> Package</Heading>
9

10
This chapter gives an overview of the basic functionality
11
provided by the <Package>AtlasRep</Package> package.
12
The main concepts and interface functions are presented in the first sections,
13
and Section&nbsp;<Ref Sect="sect:Examples of Using the AtlasRep Package"/>
14
shows a few small examples.
15

16

17
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
18
<Section Label="sect:tutaccessgroup">
19
<Heading>Accessing a Specific Group in
20
<Package>AtlasRep</Package></Heading>
21

22
The <Package>AtlasRep</Package> package gives access to a database,
23
the &ATLAS; of Group Representations <Cite Key="AGRv3"/>,
24
that contains generators and related data for several groups,
25
mainly for extensions of simple groups
26
(see Section&nbsp;<Ref Subsect="sect:tutnearlysimple"/>)
27
and for their maximal subgroups
28
(see Section&nbsp;<Ref Subsect="sect:tutmaxes"/>).
29

30
<P/>
31

32
Note that the data are not part of the package.
33
They are fetched from a web server as soon as they are needed for the
34
first time, see Section&nbsp;<Ref Subsect="subsect:Local or remote access"/>.
35

36
<P/>
37

38
First of all, we load the <Package>AtlasRep</Package> package.
39
Some of the examples require also the &GAP; packages
40
<Package>CTblLib</Package> and <Package>TomLib</Package>,
41
so we load also these packages.
42

43
<Example><![CDATA[
44
gap> LoadPackage( "AtlasRep" );
45
true
46
gap> LoadPackage( "CTblLib" );
47
true
48
gap> LoadPackage( "TomLib" );
49
true
50
]]></Example>
51

52

53
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
54
<Subsection Label="sect:tutnearlysimple">
55
<Heading>Accessing a Group in
56
<Package>AtlasRep</Package> via its Name</Heading>
57

58
Each group that occurs in this database is specified by a <E>name</E>,
59
which is a string similar to the name used in the &ATLAS; of Finite Groups
60
<Cite Key="CCN85"/>.
61
For those groups whose character tables are contained in the
62
&GAP; Character Table Library&nbsp;<Cite Key="CTblLib"/>,
63
the names are equal to the
64
<Ref Func="Identifier" Label="for character tables" BookName="ref"/>
65
values of these character tables.
66
Examples of such names are
67
<C>"M24"</C> for the Mathieu group <M>M_{24}</M>,
68
<C>"2.A6"</C> for the double cover of the alternating group <M>A_6</M>, and
69
<C>"2.A6.2_1"</C> for the double cover of the symmetric group <M>S_6</M>.
70
The names that actually occur are listed in the first column of the
71
overview table that is printed by the function
72
<Ref Func="DisplayAtlasInfo"/>, called without arguments, see below.
73
The other columns of the table describe the data that are available in the
74
database.
75

76
<P/>
77

78
For example, <Ref Func="DisplayAtlasInfo"/> may print the following lines.
79
Omissions are indicated with <Q><C>...</C></Q>.
80

81
<Log><![CDATA[
82
gap> DisplayAtlasInfo();
83
group                    |  # | maxes | cl | cyc | out | fnd | chk | prs
84
-------------------------+----+-------+----+-----+-----+-----+-----+----
85
...
86
2.A5                     | 26 |     3 |    |     |     |     |  +  |  + 
87
2.A5.2                   | 11 |     4 |    |     |     |     |  +  |  + 
88
2.A6                     | 18 |     5 |    |     |     |     |     |    
89
2.A6.2_1                 |  3 |     6 |    |     |     |     |     |    
90
2.A7                     | 24 |       |    |     |     |     |     |    
91
2.A7.2                   |  7 |       |    |     |     |     |     |    
92
...
93
M22                      | 58 |     8 |  + |  +  |     |  +  |  +  |  + 
94
M22.2                    | 46 |     7 |  + |  +  |     |  +  |  +  |  + 
95
M23                      | 66 |     7 |  + |  +  |     |  +  |  +  |  + 
96
M24                      | 62 |     9 |  + |  +  |     |  +  |  +  |  + 
97
McL                      | 46 |    12 |  + |  +  |     |  +  |  +  |  + 
98
McL.2                    | 27 |    10 |    |  +  |     |  +  |  +  |  + 
99
O7(3)                    | 28 |       |    |     |     |     |     |    
100
O7(3).2                  |  3 |       |    |     |     |     |     |    
101
...
102
]]></Log>
103

104
<P/>
105

106
Called with a group name as the only argument,
107
the function <Ref Func="AtlasGroup" Label="for various arguments"/> returns
108
a group isomorphic to the group with the given name.
109
If permutation generators are available in the database
110
then a permutation group (of smallest available degree) is returned,
111
otherwise a matrix group.
112

113
<Example><![CDATA[
114
gap> g:= AtlasGroup( "M24" );
115
Group([ (1,4)(2,7)(3,17)(5,13)(6,9)(8,15)(10,19)(11,18)(12,21)(14,16)
116
(20,24)(22,23), (1,4,6)(2,21,14)(3,9,15)(5,18,10)(13,17,16)
117
(19,24,23) ])
118
gap> IsPermGroup( g );  NrMovedPoints( g );  Size( g );
119
true
120
24
121
244823040
122
]]></Example>
123

124
</Subsection>
125

126

127
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
128
<Subsection Label="sect:tutmaxes">
129
<Heading>Accessing a Maximal Subgroup of a Group in
130
<Package>AtlasRep</Package></Heading>
131

132
Many maximal subgroups of extensions of simple groups can be constructed
133
using the function
134
<Ref Func="AtlasSubgroup"
135
 Label="for a group name (and various arguments) and a number"/>.
136
Given the name of the extension of the simple group
137
and the number of the conjugacy class of maximal subgroups,
138
this function returns a representative from this class.
139

140
<Example><![CDATA[
141
gap> g:= AtlasSubgroup( "M24", 1 );
142
Group([ (2,10)(3,12)(4,14)(6,9)(8,16)(15,18)(20,22)(21,24), (1,7,2,9)
143
(3,22,10,23)(4,19,8,12)(5,14)(6,18)(13,16,17,24) ])
144
gap> IsPermGroup( g );  NrMovedPoints( g );  Size( g );
145
true
146
23
147
10200960
148
]]></Example>
149

150
The classes of maximal subgroups are ordered
151
w.&nbsp;r.&nbsp;t.&nbsp;decreasing subgroup order.
152
So the first class contains the largest maximal subgroups.
153

154
<P/>
155

156
Note that groups obtained by <Ref Func="AtlasSubgroup"
157
 Label="for a group name (and various arguments) and a number"/> may be
158
not very suitable for computations in the sense that much nicer
159
representations exist.
160
For example, the sporadic simple O'Nan group <M>O'N</M> contains a
161
maximal subgroup <M>S</M> isomorphic with the Janko group <M>J_1</M>;
162
the smallest permutation representation of <M>O'N</M> has degree <M>122760</M>,
163
so restricting this representation to <M>S</M> yields a representation of
164
<M>J_1</M> of that degree.
165
However,
166
<M>J_1</M> has a faithful permutation representation of degree <M>266</M>,
167
which admits much more efficient computations.
168
If you are just interested in <M>J_1</M> and not in
169
its embedding into <M>O'N</M>
170
then one possibility to get a <Q>nicer</Q> faithful representation is to call
171
<Ref Func="SmallerDegreePermutationRepresentation" BookName="ref"/>.
172
In the abovementioned example, this works quite well;
173
note that in general,
174
we cannot expect that we get a representation of smallest degree in this way.
175

176
<Example><![CDATA[
177
gap> s:= AtlasSubgroup( "ON", 3 );
178
<permutation group of size 175560 with 2 generators>
179
gap> NrMovedPoints( s );  Size( s );
180
122760
181
175560
182
gap> hom:= SmallerDegreePermutationRepresentation( s );;
183
gap> NrMovedPoints( Image( hom ) );
184
1540
185
]]></Example>
186

187
<!-- in earlier times, one got the degree 266 representation -->
188

189
<P/>
190

191
In this particular case, one could of course also ask directly for the group
192
<M>J_1</M>.
193

194
<Example><![CDATA[
195
gap> j1:= AtlasGroup( "J1" );
196
<permutation group of size 175560 with 2 generators>
197
gap> NrMovedPoints( j1 );
198
266
199
]]></Example>
200

201
If you have a group <M>G</M>, say,
202
and you are really interested in the embedding of a maximal subgroup of
203
<M>G</M> into <M>G</M> then an easy way to get compatible generators is to
204
create <M>G</M> with <Ref Func="AtlasGroup" Label="for various arguments"/>
205
and then to call <Ref Func="AtlasSubgroup" Label="for a group and a number"/>
206
with first argument the group <M>G</M>.
207

208
<Example><![CDATA[
209
gap> g:= AtlasGroup( "ON" );
210
<permutation group of size 460815505920 with 2 generators>
211
gap> s:= AtlasSubgroup( g, 3 );
212
<permutation group of size 175560 with 2 generators>
213
gap> IsSubset( g, s );
214
true
215
gap> IsSubset( g, j1 );
216
false
217
]]></Example>
218

219

220
</Subsection>
221

222
</Section>
223

224

225
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
226
<Section Label="sect:tutaccessrepres">
227
<Heading>Accessing Specific Generators in
228
<Package>AtlasRep</Package></Heading>
229

230
The function <Ref Func="DisplayAtlasInfo"/>, called with an admissible
231
name of a group as the only argument,
232
lists the &ATLAS; data available for this group.
233

234
<Example><![CDATA[
235
gap> DisplayAtlasInfo( "A5" );
236
Representations for G = A5:    (all refer to std. generators 1)
237
---------------------------
238
 1: G <= Sym(5)                  3-trans., on cosets of A4 (1st max.)
239
 2: G <= Sym(6)                  2-trans., on cosets of D10 (2nd max.)
240
 3: G <= Sym(10)                 rank 3, on cosets of S3 (3rd max.)
241
 4: G <= GL(4a,2)                
242
 5: G <= GL(4b,2)                
243
 6: G <= GL(4,3)                 
244
 7: G <= GL(6,3)                 
245
 8: G <= GL(2a,4)                
246
 9: G <= GL(2b,4)                
247
10: G <= GL(3,5)                 
248
11: G <= GL(5,5)                 
249
12: G <= GL(3a,9)                
250
13: G <= GL(3b,9)                
251
14: G <= GL(4,Z)                 
252
15: G <= GL(5,Z)                 
253
16: G <= GL(6,Z)                 
254
17: G <= GL(3a,Field([Sqrt(5)])) 
255
18: G <= GL(3b,Field([Sqrt(5)])) 
256

257
Programs for G = A5:    (all refer to std. generators 1)
258
--------------------
259
presentation
260
std. gen. checker
261
maxes (all 3):
262
  1:  A4
263
  2:  D10
264
  3:  S3
265
]]></Example>
266

267
In order to fetch one of the listed permutation groups or matrix groups,
268
you can call <Ref Func="AtlasGroup" Label="for various arguments"/>
269
with second argument the function
270
<Ref Func="Position" BookName="ref"/> and third argument the position in
271
the list.
272

273
<Example><![CDATA[
274
gap> AtlasGroup( "A5", Position, 1 );
275
Group([ (1,2)(3,4), (1,3,5) ])
276
]]></Example>
277

278
Note that this approach may yield a different group after an update
279
of the database, if new data for the group become available.
280

281
<P/>
282

283
Alternatively, you can describe the desired group by conditions,
284
such as the degree in the case of a permutation group,
285
and the dimension and the base ring in the case of a matrix group.
286

287
<Example><![CDATA[
288
gap> AtlasGroup( "A5", NrMovedPoints, 10 );
289
Group([ (2,4)(3,5)(6,8)(7,10), (1,2,3)(4,6,7)(5,8,9) ])
290
gap> AtlasGroup( "A5", Dimension, 4, Ring, GF(2) );
291
<matrix group of size 60 with 2 generators>
292
]]></Example>
293

294
<P/>
295

296
The same holds for the restriction to maximal subgroups:
297
Use
298
<Ref Func="AtlasSubgroup"
299
 Label="for a group name (and various arguments) and a number"/>
300
with the same arguments as
301
<Ref Func="AtlasGroup" Label="for various arguments"/>,
302
except that additionally the number of the class of maximal subgroups
303
is entered as the last argument.
304
Note that the conditions refer to the group, not to the subgroup;
305
it may happen that the subgroup moves fewer points than the big group.
306

307
<Example><![CDATA[
308
gap> AtlasSubgroup( "A5", Dimension, 4, Ring, GF(2), 1 );
309
<matrix group of size 12 with 2 generators>
310
gap> g:= AtlasSubgroup( "A5", NrMovedPoints, 10, 3 );
311
Group([ (2,4)(3,5)(6,8)(7,10), (1,4)(3,8)(5,7)(6,10) ])
312
gap> Size( g );  NrMovedPoints( g );
313
6
314
9
315
]]></Example>
316

317

318
</Section>
319

320

321
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
322
<Section Label="sect:tutconcepts">
323
<Heading>Basic Concepts used in <Package>AtlasRep</Package></Heading>
324

325

326
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
327
<Subsection Label="sect:tutstdgens">
328
<Heading>Groups, Generators, and Representations</Heading>
329

330
Up to now, we have talked only about groups and subgroups.
331
The <Package>AtlasRep</Package> package provides access to
332
<E>group generators</E>,
333
and in fact these generators have the property that mapping one set of
334
generators to another set of generators for the same group defines an
335
isomorphism.
336
These generators are called <E>standard generators</E>,
337
see Section&nbsp;<Ref Sect="sect:Standard Generators Used in AtlasRep"/>.
338

339
<P/>
340

341
So instead of thinking about several generating sets of a group <M>G</M>,
342
say, we can think about one abstract group <M>G</M>, with one fixed set
343
of generators,
344
and mapping these generators to any set of generators provided by
345
<Package>AtlasRep</Package> defines a representation of <M>G</M>.
346
This viewpoint motivates the name <Q>&ATLAS; of Group Representations</Q>
347
for the database.
348

349
<P/>
350

351
If you are interested in the generators provided by the database
352
rather than in the groups they generate,
353
you can use the function <Ref Func="OneAtlasGeneratingSetInfo"/>
354
instead of <Ref Func="AtlasGroup" Label="for various arguments"/>,
355
with the same arguments.
356
This will yield a record that describes the representation in question.
357
Calling the function <Ref Func="AtlasGenerators"/> with this record
358
will then yield a record with the additional component <C>generators</C>,
359
which holds the list of generators.
360

361
<P/>
362

363
<Example><![CDATA[
364
gap> info:= OneAtlasGeneratingSetInfo( "A5", NrMovedPoints, 10 );
365
rec( groupname := "A5", id := "", 
366
  identifier := [ "A5", [ "A5G1-p10B0.m1", "A5G1-p10B0.m2" ], 1, 10 ],
367
  isPrimitive := true, maxnr := 3, p := 10, rankAction := 3, 
368
  repname := "A5G1-p10B0", repnr := 3, size := 60, stabilizer := "S3",
369
  standardization := 1, transitivity := 1, type := "perm" )
370
gap> info2:= AtlasGenerators( info );
371
rec( generators := [ (2,4)(3,5)(6,8)(7,10), (1,2,3)(4,6,7)(5,8,9) ], 
372
  groupname := "A5", id := "", 
373
  identifier := [ "A5", [ "A5G1-p10B0.m1", "A5G1-p10B0.m2" ], 1, 10 ],
374
  isPrimitive := true, maxnr := 3, p := 10, rankAction := 3, 
375
  repname := "A5G1-p10B0", repnr := 3, size := 60, stabilizer := "S3",
376
  standardization := 1, transitivity := 1, type := "perm" )
377
gap> info2.generators;
378
[ (2,4)(3,5)(6,8)(7,10), (1,2,3)(4,6,7)(5,8,9) ]
379
]]></Example>
380

381
</Subsection>
382

383

384
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
385
<Subsection Label="sect:tutslp">
386
<Heading>Straight Line Programs</Heading>
387

388
For computing certain group elements from standard generators, such as
389
generators of a subgroup or class representatives,
390
<Package>AtlasRep</Package> uses <E>straight line programs</E>,
391
see <Ref Sect="Straight Line Programs" BookName="ref"/>.
392
Essentially this means to evaluate words in the generators, similar to
393
<Ref Func="MappedWord" BookName="ref"/> but more efficiently.
394

395
<P/>
396

397
It can be useful to deal with these straight line programs,
398
see <Ref Func="AtlasProgram"/>.
399
For example, an automorphism <M>\alpha</M>, say, of the group <M>G</M>,
400
if available in <Package>AtlasRep</Package>,
401
is given by a straight line program that defines the images of standard
402
generators of <M>G</M>.
403
This way, one can for example compute the image of a subgroup <M>U</M> of
404
<M>G</M> under <M>\alpha</M> by first applying the straight line program
405
for <M>\alpha</M> to standard generators of <M>G</M>,
406
and then applying the straight line program for the restriction from
407
<M>G</M> to <M>U</M>.
408

409
<P/>
410

411
<Example><![CDATA[
412
gap> prginfo:= AtlasProgramInfo( "A5", "maxes", 1 );
413
rec( groupname := "A5", identifier := [ "A5", "A5G1-max1W1", 1 ], 
414
  size := 12, standardization := 1, subgroupname := "A4" )
415
gap> prg:= AtlasProgram( prginfo.identifier );
416
rec( groupname := "A5", identifier := [ "A5", "A5G1-max1W1", 1 ], 
417
  program := <straight line program>, size := 12, 
418
  standardization := 1, subgroupname := "A4" )
419
gap> Display( prg.program );
420
# input:
421
r:= [ g1, g2 ];
422
# program:
423
r[3]:= r[1]*r[2];
424
r[4]:= r[2]*r[1];
425
r[5]:= r[3]*r[3];
426
r[1]:= r[5]*r[4];
427
# return values:
428
[ r[1], r[2] ]
429
gap> ResultOfStraightLineProgram( prg.program, info2.generators );
430
[ (1,10)(2,3)(4,9)(7,8), (1,2,3)(4,6,7)(5,8,9) ]
431
]]></Example>
432

433
</Subsection>
434

435
</Section>
436

437

438
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
439
<Section Label="sect:Examples of Using the AtlasRep Package">
440
<Heading>Examples of Using the <Package>AtlasRep</Package> Package</Heading>
441

442

443
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
444
<Subsection Label="subsect:Example: Class Representatives">
445
<Heading>Example: Class Representatives</Heading>
446

447
First we show the computation of class representatives of the Mathieu group
448
<M>M_{11}</M>, in a <M>2</M>-modular matrix representation.
449
We start with the ordinary and Brauer character tables of this group.
450

451
<P/>
452

453
<Example><![CDATA[
454
gap> tbl:= CharacterTable( "M11" );;
455
gap> modtbl:= tbl mod 2;;
456
gap> CharacterDegrees( modtbl );
457
[ [ 1, 1 ], [ 10, 1 ], [ 16, 2 ], [ 44, 1 ] ]
458
]]></Example>
459

460
<P/>
461

462
The output of <Ref Func="CharacterDegrees" BookName="ref"/>
463
means that the <M>2</M>-modular irreducibles of <M>M_{11}</M>
464
have degrees <M>1</M>, <M>10</M>, <M>16</M>, <M>16</M>, and <M>44</M>.
465

466
<P/>
467

468
Using <Ref Func="DisplayAtlasInfo"/>,
469
we find out that matrix generators for the irreducible <M>10</M>-dimensional
470
representation are available in the database.
471

472
<P/>
473

474
<Example><![CDATA[
475
gap> DisplayAtlasInfo( "M11", Characteristic, 2 );
476
Representations for G = M11:    (all refer to std. generators 1)
477
----------------------------
478
 6: G <= GL(10,2)  character 10a
479
 7: G <= GL(32,2)  character 16ab
480
 8: G <= GL(44,2)  character 44a
481
16: G <= GL(16a,4) character 16a
482
17: G <= GL(16b,4) character 16b
483
]]></Example>
484

485
<P/>
486

487
So we decide to work with this representation.
488
We fetch the generators and compute the list of class representatives
489
of <M>M_{11}</M> in the representation.
490
The ordering of class representatives is the same as that in the character
491
table of the &ATLAS; of Finite Groups (<Cite Key="CCN85"/>),
492
which coincides with the ordering of columns in the &GAP; table we have
493
fetched above.
494

495
<P/>
496

497
<Example><![CDATA[
498
gap> info:= OneAtlasGeneratingSetInfo( "M11", Characteristic, 2,
499
>                                             Dimension, 10 );;
500
gap> gens:= AtlasGenerators( info.identifier );;
501
gap> ccls:= AtlasProgram( "M11", gens.standardization, "classes" );
502
rec( groupname := "M11", identifier := [ "M11", "M11G1-cclsW1", 1 ], 
503
  outputs := [ "1A", "2A", "3A", "4A", "5A", "6A", "8A", "8B", "11A", 
504
      "11B" ], program := <straight line program>, 
505
  standardization := 1 )
506
gap> reps:= ResultOfStraightLineProgram( ccls.program, gens.generators );;
507
]]></Example>
508

509
<P/>
510

511
If we would need only a few class representatives, we could use
512
the &GAP; library function <Ref Func="RestrictOutputsOfSLP" BookName="ref"/>
513
to create a straight line program that computes only specified outputs.
514
Here is an example where only the class representatives of order eight are
515
computed.
516

517
<P/>
518

519
<Example><![CDATA[
520
gap> ord8prg:= RestrictOutputsOfSLP( ccls.program,
521
>                   Filtered( [ 1 .. 10 ], i -> ccls.outputs[i][1] = '8' ) );
522
<straight line program>
523
gap> ord8reps:= ResultOfStraightLineProgram( ord8prg, gens.generators );;
524
gap> List( ord8reps, m -> Position( reps, m ) );
525
[ 7, 8 ]
526
]]></Example>
527

528
<P/>
529

530
Let us check that the class representatives have the right orders.
531

532
<P/>
533

534
<Example><![CDATA[
535
gap> List( reps, Order ) = OrdersClassRepresentatives( tbl );
536
true
537
]]></Example>
538

539
<P/>
540

541
From the class representatives, we can compute the Brauer character
542
we had started with.
543
This Brauer character is defined on all classes of the <M>2</M>-modular
544
table.
545
So we first pick only those representatives,
546
using the &GAP; function <Ref Func="GetFusionMap" BookName="ref"/>;
547
in this situation, it returns the class fusion from the Brauer table into
548
the ordinary table.
549

550
<P/>
551

552
<Example><![CDATA[
553
gap> fus:= GetFusionMap( modtbl, tbl );
554
[ 1, 3, 5, 9, 10 ]
555
gap> modreps:= reps{ fus };;
556
]]></Example>
557

558
<P/>
559

560
Then we call the &GAP; function
561
<Ref Func="BrauerCharacterValue" BookName="ref"/>,
562
which computes the Brauer character value from the matrix given.
563

564
<P/>
565

566
<Example><![CDATA[
567
gap> char:= List( modreps, BrauerCharacterValue );
568
[ 10, 1, 0, -1, -1 ]
569
gap> Position( Irr( modtbl ), char );
570
2
571
]]></Example>
572

573
</Subsection>
574

575

576
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
577
<Subsection Label="subsect:Example: Permutation and Matrix Representations">
578
<Heading>Example: Permutation and Matrix Representations</Heading>
579

580
The second example shows the computation of a permutation representation
581
from a matrix representation.
582
We work with the <M>10</M>-dimensional representation used above,
583
and consider the action on the <M>2^{10}</M> vectors of the underlying row
584
space.
585

586
<P/>
587

588
<Example><![CDATA[
589
gap> grp:= Group( gens.generators );;
590
gap> v:= GF(2)^10;;
591
gap> orbs:= Orbits( grp, AsList( v ) );;
592
gap> List( orbs, Length );
593
[ 1, 396, 55, 330, 66, 165, 11 ]
594
]]></Example>
595

596
<P/>
597

598
We see that there are six nontrivial orbits,
599
and we can compute the permutation actions on these orbits directly
600
using <Ref Func="Action" BookName="ref"/>.
601
However, for larger examples, one cannot write down all orbits on the
602
row space, so one has to use another strategy if one is interested in
603
a particular orbit.
604

605
<P/>
606

607
Let us assume that we are interested in the orbit of length <M>11</M>.
608
The point stabilizer is the first maximal subgroup of <M>M_{11}</M>,
609
thus the restriction of the representation to this subgroup has a
610
nontrivial fixed point space.
611
This restriction can be computed using the <Package>AtlasRep</Package>
612
package.
613

614
<P/>
615

616
<Example><![CDATA[
617
gap> gens:= AtlasGenerators( "M11", 6, 1 );;
618
]]></Example>
619
<P/>
620
Now computing the fixed point space is standard linear algebra.
621
<P/>
622
<Example><![CDATA[
623
gap> id:= IdentityMat( 10, GF(2) );;
624
gap> sub1:= Subspace( v, NullspaceMat( gens.generators[1] - id ) );;
625
gap> sub2:= Subspace( v, NullspaceMat( gens.generators[2] - id ) );;
626
gap> fix:= Intersection( sub1, sub2 );
627
<vector space of dimension 1 over GF(2)>
628
]]></Example>
629

630
<P/>
631

632
The final step is of course the computation of the permutation action
633
on the orbit.
634

635
<P/>
636

637
<Example><![CDATA[
638
gap> orb:= Orbit( grp, Basis( fix )[1] );;
639
gap> act:= Action( grp, orb );;  Print( act, "\n" );
640
Group( [ ( 1, 2)( 4, 6)( 5, 8)( 7,10), ( 1, 3, 5, 9)( 2, 4, 7,11) ] )
641
]]></Example>
642

643
<P/>
644

645
Note that this group is <E>not</E> equal to the group obtained by fetching
646
the permutation representation from the database.
647
This is due to a different numbering of the points,
648
so the groups are permutation isomorphic.
649

650
<P/>
651

652
<Example><![CDATA[
653
gap> permgrp:= Group( AtlasGenerators( "M11", 1 ).generators );;
654
gap> Print( permgrp, "\n" );
655
Group( [ ( 2,10)( 4,11)( 5, 7)( 8, 9), ( 1, 4, 3, 8)( 2, 5, 6, 9) ] )
656
gap> permgrp = act;
657
false
658
gap> IsConjugate( SymmetricGroup(11), permgrp, act );
659
true
660
]]></Example>
661

662
</Subsection>
663

664

665
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
666
<Subsection Label="subsect:Example: Outer Automorphisms">
667
<Heading>Example: Outer Automorphisms</Heading>
668

669
The straight line programs for applying outer automorphisms to
670
standard generators can of course be used to define the automorphisms
671
themselves as &GAP; mappings.
672

673
<P/>
674

675
<Example><![CDATA[
676
gap> DisplayAtlasInfo( "G2(3)", IsStraightLineProgram );
677
Programs for G = G2(3):    (all refer to std. generators 1)
678
-----------------------
679
class repres.
680
presentation
681
repr. cyc. subg.
682
std. gen. checker
683
automorphisms:
684
  2
685
maxes (all 10):
686
   1:  U3(3).2
687
   2:  U3(3).2
688
   3:  (3^(1+2)+x3^2):2S4
689
   4:  (3^(1+2)+x3^2):2S4
690
   5:  L3(3).2
691
   6:  L3(3).2
692
   7:  L2(8).3
693
   8:  2^3.L3(2)
694
   9:  L2(13)
695
  10:  2^(1+4)+:3^2.2
696
gap> prog:= AtlasProgram( "G2(3)", "automorphism", "2" ).program;;
697
gap> info:= OneAtlasGeneratingSetInfo( "G2(3)", Dimension, 7 );;
698
gap> gens:= AtlasGenerators( info ).generators;;
699
gap> imgs:= ResultOfStraightLineProgram( prog, gens );;
700
]]></Example>
701

702
<P/>
703

704
If we are not suspicious whether the script really describes an
705
automorphism then we should tell this to &GAP;,
706
in order to avoid the expensive checks of the properties of being a
707
homomorphism and bijective
708
(see Section&nbsp;<Ref Sect="Creating Group Homomorphisms" BookName="ref"/>).
709
This looks as follows.
710

711
<P/>
712

713
<Example><![CDATA[
714
gap> g:= Group( gens );;
715
gap> aut:= GroupHomomorphismByImagesNC( g, g, gens, imgs );;
716
gap> SetIsBijective( aut, true );
717
]]></Example>
718

719
<P/>
720

721
If we are suspicious whether the script describes an automorphism
722
then we might have the idea to check it with &GAP;, as follows.
723

724
<P/>
725

726
<Example><![CDATA[
727
gap> aut:= GroupHomomorphismByImages( g, g, gens, imgs );;
728
gap> IsBijective( aut );
729
true
730
]]></Example>
731

732
<P/>
733

734
(Note that even for a comparatively small group such as <M>G_2(3)</M>,
735
this was a difficult task for &GAP; before version&nbsp;4.3.)
736

737
<P/>
738

739
Often one can form images under an automorphism <M>\alpha</M>, say,
740
without creating the homomorphism object.
741
This is obvious for the standard generators of the group <M>G</M> themselves,
742
but also for generators of a maximal subgroup <M>M</M> computed from standard
743
generators of <M>G</M>, provided that the straight line programs in question
744
refer to the same standard generators.
745
Note that the generators of <M>M</M> are given by evaluating words in terms
746
of standard generators of <M>G</M>,
747
and their images under <M>\alpha</M> can be obtained by evaluating the same
748
words at the images under <M>\alpha</M> of the standard generators of
749
<M>G</M>.
750

751
<P/>
752

753
<Example><![CDATA[
754
gap> max1:= AtlasProgram( "G2(3)", 1 ).program;;
755
gap> mgens:= ResultOfStraightLineProgram( max1, gens );;
756
gap> comp:= CompositionOfStraightLinePrograms( max1, prog );;
757
gap> mimgs:= ResultOfStraightLineProgram( comp, gens );;
758
]]></Example>
759

760
<P/>
761

762
The list <C>mgens</C> is the list of generators of the first maximal subgroup
763
of <M>G_2(3)</M>, <C>mimgs</C> is the list of images under the automorphism
764
given by the straight line program <C>prog</C>.
765
Note that applying the program returned by
766
<Ref Func="CompositionOfStraightLinePrograms" BookName="ref"/>
767
means to apply first <C>prog</C> and then <C>max1</C>.
768
Since we have already constructed the &GAP; object representing the
769
automorphism, we can check whether the results are equal.
770

771
<P/>
772

773
<Example><![CDATA[
774
gap> mimgs = List( mgens, x -> x^aut );
775
true
776
]]></Example>
777

778
<P/>
779

780
However, it should be emphasized that using <C>aut</C> requires a huge
781
machinery of computations behind the scenes, whereas applying the
782
straight line programs <C>prog</C> and <C>max1</C> involves only elementary
783
operations with the generators.
784
The latter is feasible also for larger groups,
785
for which constructing the &GAP; automorphism might be too hard.
786

787
</Subsection>
788

789

790
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
791
<Subsection Label="subsect:Example: Semi-presentations">
792
<Heading>Example: Using Semi-presentations and Black Box Programs</Heading>
793

794
Let us suppose that we want to restrict a representation of the
795
Mathieu group <M>M_{12}</M> to a non-maximal subgroup of the type
796
<M>L_2(11)</M>.
797
The idea is that this subgroup can be found as a maximal subgroup of a
798
maximal subgroup of the type <M>M_{11}</M>,
799
which is itself maximal in <M>M_{12}</M>.
800
For that,
801
we fetch a representation of <M>M_{12}</M> and use a straight line program
802
for restricting it to the first maximal subgroup,
803
which has the type <M>M_{11}</M>.
804

805
<P/>
806

807
<Example><![CDATA[
808
gap> info:= OneAtlasGeneratingSetInfo( "M12", NrMovedPoints, 12 );
809
rec( charactername := "1a+11a", groupname := "M12", id := "a", 
810
  identifier := [ "M12", [ "M12G1-p12aB0.m1", "M12G1-p12aB0.m2" ], 1, 
811
      12 ], isPrimitive := true, maxnr := 1, p := 12, rankAction := 2,
812
  repname := "M12G1-p12aB0", repnr := 1, size := 95040, 
813
  stabilizer := "M11", standardization := 1, transitivity := 5, 
814
  type := "perm" )
815
gap> gensM12:= AtlasGenerators( info.identifier );;
816
gap> restM11:= AtlasProgram( "M12", "maxes", 1 );;
817
gap> gensM11:= ResultOfStraightLineProgram( restM11.program,
818
>                                           gensM12.generators );
819
[ (3,9)(4,12)(5,10)(6,8), (1,4,11,5)(2,10,8,3) ]
820
]]></Example>
821

822
<P/>
823

824
Now we <E>cannot</E> simply apply a straight line program for a group
825
to some generators, since they are not necessarily
826
<E>standard</E> generators of the group.
827
We check this property using a semi-presentation for <M>M_{11}</M>,
828
see <Ref Subsect="Semi-Presentations and Presentations"/>.
829

830
<P/>
831

832
<Example><![CDATA[
833
gap> checkM11:= AtlasProgram( "M11", "check" );
834
rec( groupname := "M11", identifier := [ "M11", "M11G1-check1", 1, 1 ]
835
    , program := <straight line decision>, standardization := 1 )
836
gap> ResultOfStraightLineDecision( checkM11.program, gensM11 );
837
true
838
]]></Example>
839

840
<P/>
841

842
So we are lucky that applying the appropriate program for <M>M_{11}</M>
843
will give us the required generators for <M>L_2(11)</M>.
844

845
<P/>
846

847
<Example><![CDATA[
848
gap> restL211:= AtlasProgram( "M11", "maxes", 2 );;
849
gap> gensL211:= ResultOfStraightLineProgram( restL211.program, gensM11 );
850
[ (3,9)(4,12)(5,10)(6,8), (1,11,9)(2,12,8)(3,6,10) ]
851
gap> G:= Group( gensL211 );;  Size( G );  IsSimple( G );
852
660
853
true
854
]]></Example>
855

856
<P/>
857

858
Usually representations are not given in terms of standard generators.
859
For example, let us take the <M>M_{11}</M> type group returned by the &GAP;
860
function <Ref Func="MathieuGroup" BookName="ref"/>.
861

862
<P/>
863

864
<Example><![CDATA[
865
gap> G:= MathieuGroup( 11 );;
866
gap> gens:= GeneratorsOfGroup( G );
867
[ (1,2,3,4,5,6,7,8,9,10,11), (3,7,11,8)(4,10,5,6) ]
868
gap> ResultOfStraightLineDecision( checkM11.program, gens );
869
false
870
]]></Example>
871

872
<P/>
873

874
If we want to compute an <M>L_2(11)</M> type subgroup of this group,
875
we can use a black box program for computing standard generators,
876
and then apply the straight line program for computing the restriction.
877

878
<P/>
879

880
<Example><![CDATA[
881
gap> find:= AtlasProgram( "M11", "find" );
882
rec( groupname := "M11", identifier := [ "M11", "M11G1-find1", 1, 1 ],
883
  program := <black box program>, standardization := 1 )
884
gap> stdgens:= ResultOfBBoxProgram( find.program, Group( gens ) );;
885
gap> List( stdgens, Order );
886
[ 2, 4 ]
887
gap> ResultOfStraightLineDecision( checkM11.program, stdgens );
888
true
889
gap> gensL211:= ResultOfStraightLineProgram( restL211.program, stdgens );;
890
gap> List( gensL211, Order );
891
[ 2, 3 ]
892
gap> G:= Group( gensL211 );;  Size( G );  IsSimple( G );
893
660
894
true
895
]]></Example>
896

897
</Subsection>
898

899

900
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
901
<Subsection Label="subsect:Example: Using the GAP Library of Tables of Marks">
902
<Heading>Example: Using the &GAP; Library of Tables of Marks</Heading>
903

904
The &GAP; Library of Tables of Marks
905
(the &GAP; package <Package>TomLib</Package>, <Cite Key="TomLib"/>)
906
provides,
907
for many almost simple groups, information for constructing representatives
908
of all conjugacy classes of subgroups.
909
If this information is compatible with the standard generators of the
910
&ATLAS; of Group Representations then we can use it to restrict any
911
representation from the &ATLAS; to prescribed subgroups.
912
This is useful in particular for those subgroups for which the &ATLAS;
913
of Group Representations itself does not contain a straight line program.
914

915
<P/>
916

917
<Example><![CDATA[
918
gap> tom:= TableOfMarks( "A5" );
919
TableOfMarks( "A5" )
920
gap> info:= StandardGeneratorsInfo( tom );
921
[ rec( ATLAS := true, description := "|a|=2, |b|=3, |ab|=5", 
922
      generators := "a, b", 
923
      script := [ [ 1, 2 ], [ 2, 3 ], [ 1, 1, 2, 1, 5 ] ], 
924
      standardization := 1 ) ]
925
]]></Example>
926

927
<P/>
928

929
The <K>true</K> value of the component <C>ATLAS</C> indicates
930
that the information stored on <C>tom</C> refers to the standard generators
931
of type <M>1</M> in the &ATLAS; of Group Representations.
932

933
<P/>
934

935
We want to restrict a <M>4</M>-dimensional integral representation of
936
<M>A_5</M> to a Sylow <M>2</M> subgroup of <M>A_5</M>,
937
and use <Ref Func="RepresentativeTomByGeneratorsNC" BookName="ref"/>
938
for that.
939

940
<P/>
941

942
<Example><![CDATA[
943
gap> info:= OneAtlasGeneratingSetInfo( "A5", Ring, Integers, Dimension, 4 );;
944
gap> stdgens:= AtlasGenerators( info.identifier );
945
rec( dim := 4, 
946
  generators := 
947
    [ 
948
      [ [ 1, 0, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 1, 0, 0 ], 
949
          [ -1, -1, -1, -1 ] ], 
950
      [ [ 0, 1, 0, 0 ], [ 0, 0, 0, 1 ], [ 0, 0, 1, 0 ], 
951
          [ 1, 0, 0, 0 ] ] ], groupname := "A5", id := "", 
952
  identifier := [ "A5", "A5G1-Zr4B0.g", 1, 4 ], 
953
  repname := "A5G1-Zr4B0", repnr := 14, ring := Integers, size := 60, 
954
  standardization := 1, type := "matint" )
955
gap> orders:= OrdersTom( tom );
956
[ 1, 2, 3, 4, 5, 6, 10, 12, 60 ]
957
gap> pos:= Position( orders, 4 );
958
4
959
gap> sub:= RepresentativeTomByGeneratorsNC( tom, pos, stdgens.generators );
960
<matrix group of size 4 with 2 generators>
961
gap> GeneratorsOfGroup( sub );
962
[ [ [ 1, 0, 0, 0 ], [ -1, -1, -1, -1 ], [ 0, 0, 0, 1 ], 
963
      [ 0, 0, 1, 0 ] ], 
964
  [ [ 1, 0, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 1, 0, 0 ], 
965
      [ -1, -1, -1, -1 ] ] ]
966
]]></Example>
967

968
</Subsection>
969

970

971
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
972
<Subsection Label="subsect:Example: Index 770 Subgroups in M22">
973
<Heading>Example: Index <M>770</M> Subgroups in <M>M_{22}</M></Heading>
974

975
The sporadic simple Mathieu group <M>M_{22}</M> contains a unique class of
976
subgroups of index <M>770</M> (and order <M>576</M>).
977
This can be seen for example using &GAP;'s Library of Tables of Marks.
978

979
<P/>
980

981
<Example><![CDATA[
982
gap> tom:= TableOfMarks( "M22" );
983
TableOfMarks( "M22" )
984
gap> subord:= Size( UnderlyingGroup( tom ) ) / 770;
985
576
986
gap> ord:= OrdersTom( tom );;
987
gap> tomstabs:= Filtered( [ 1 .. Length( ord ) ], i -> ord[i] = subord );
988
[ 144 ]
989
]]></Example>
990

991
<P/>
992

993
The permutation representation of <M>M_{22}</M> on the right cosets of such
994
a subgroup <M>S</M> is contained in the &ATLAS; of Group Representations.
995

996
<P/>
997

998
<Example><![CDATA[
999
gap> DisplayAtlasInfo( "M22", NrMovedPoints, 770 );
1000
Representations for G = M22:    (all refer to std. generators 1)
1001
----------------------------
1002
12: G <= Sym(770) rank 9, on cosets of (A4xA4):4 < 2^4:A6
1003
]]></Example>
1004

1005
<P/>
1006

1007
We now verify the information shown about the point stabilizer and
1008
about the maximal overgroups of <M>S</M> in <M>M_{22}</M>.
1009

1010
<P/>
1011

1012
<Example><![CDATA[
1013
gap> maxtom:= MaximalSubgroupsTom( tom );
1014
[ [ 155, 154, 153, 152, 151, 150, 146, 145 ], 
1015
  [ 22, 77, 176, 176, 231, 330, 616, 672 ] ]
1016
gap> List( tomstabs, i -> List( maxtom[1], j -> ContainedTom( tom, i, j ) ) );
1017
[ [ 0, 10, 0, 0, 0, 0, 0, 0 ] ]
1018
]]></Example>
1019

1020
<P/>
1021

1022
We see that the only maximal subgroups of <M>M_{22}</M> that contain <M>S</M>
1023
have index <M>77</M> in <M>M_{22}</M>.
1024
According to the &ATLAS; of Finite Groups, these maximal subgroups have the
1025
structure <M>2^4:A_6</M>.  From that and from the structure of <M>A_6</M>,
1026
we conclude that <M>S</M> has the structure <M>2^4:(3^2:4)</M>.
1027

1028
<P/>
1029

1030
Alternatively, we look at the permutation representation of degree <M>770</M>.
1031
We fetch it from the &ATLAS; of Group Representations.
1032
There is exactly one nontrivial block system for this representation,
1033
with <M>77</M> blocks of length <M>10</M>.
1034

1035
<P/>
1036

1037
<Example><![CDATA[
1038
gap> g:= AtlasGroup( "M22", NrMovedPoints, 770 );
1039
<permutation group of size 443520 with 2 generators>
1040
gap> allbl:= AllBlocks( g );;
1041
gap> List( allbl, Length );
1042
[ 10 ]
1043
]]></Example>
1044

1045
<P/>
1046

1047
Furthermore, &GAP; computes that the point stabilizer <M>S</M> has the
1048
structure <M>(A_4 \times A_4):4</M>.
1049

1050
<P/>
1051

1052
<Example><![CDATA[
1053
gap> stab:= Stabilizer( g, 1 );;
1054
gap> StructureDescription( stab );
1055
"(A4 x A4) : C4"
1056
gap> blocks:= Orbit( g, allbl[1], OnSets );;
1057
gap> act:= Action( g, blocks, OnSets );;
1058
gap> StructureDescription( Stabilizer( act, 1 ) );
1059
"(C2 x C2 x C2 x C2) : A6"
1060
]]></Example>
1061

1062

1063
</Subsection>
1064

1065

1066
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
1067
<Subsection Label="subsect:Example: Index 462 Subgroups in M22">
1068
<Heading>Example: Index <M>462</M> Subgroups in <M>M_{22}</M></Heading>
1069

1070
The &ATLAS; of Group Representations contains three
1071
degree <M>462</M> permutation representations of the group <M>M_{22}</M>.
1072

1073
<P/>
1074

1075
<Example><![CDATA[
1076
gap> DisplayAtlasInfo( "M22", NrMovedPoints, 462 );
1077
Representations for G = M22:    (all refer to std. generators 1)
1078
----------------------------
1079
7: G <= Sym(462a) rank 5, on cosets of 2^4:A5 < 2^4:A6
1080
8: G <= Sym(462b) rank 8, on cosets of 2^4:A5 < L3(4), 2^4:S5
1081
9: G <= Sym(462c) rank 8, on cosets of 2^4:A5 < L3(4), 2^4:A6
1082
]]></Example>
1083

1084
<P/>
1085

1086
The point stabilizers in these three representations have the structure
1087
<M>2^4:A_5</M>.
1088
Using &GAP;'s Library of Tables of Marks,
1089
we can show that these stabilizers are exactly the three classes of subgroups
1090
of order <M>960</M> in <M>M_{22}</M>.
1091
For that, we first verify that the group generators stored in &GAP;'s
1092
table of marks coincide with the standard generators used by the
1093
&ATLAS; of Group Representations.
1094

1095
<P/>
1096

1097
<Example><![CDATA[
1098
gap> tom:= TableOfMarks( "M22" );
1099
TableOfMarks( "M22" )
1100
gap> genstom:= GeneratorsOfGroup( UnderlyingGroup( tom ) );;
1101
gap> checkM22:= AtlasProgram( "M22", "check" );
1102
rec( groupname := "M22", identifier := [ "M22", "M22G1-check1", 1, 1 ]
1103
    , program := <straight line decision>, standardization := 1 )
1104
gap> ResultOfStraightLineDecision( checkM22.program, genstom );
1105
true
1106
]]></Example>
1107

1108
<P/>
1109

1110
There are indeed three classes of subgroups of order <M>960</M>
1111
in <M>M_{22}</M>.
1112

1113
<P/>
1114

1115
<Example><![CDATA[
1116
gap> ord:= OrdersTom( tom );;
1117
gap> tomstabs:= Filtered( [ 1 .. Length( ord ) ], i -> ord[i] = 960 );
1118
[ 147, 148, 149 ]
1119
]]></Example>
1120

1121
<P/>
1122

1123
Now we compute representatives of these three classes in the three
1124
representations <C>462a</C>, <C>462b</C>, and <C>462c</C>.
1125
We see that each of the three classes occurs as a point stabilizer
1126
in exactly one of the three representations.
1127

1128
<P/>
1129

1130
<Example><![CDATA[
1131
gap> atlasreps:= AllAtlasGeneratingSetInfos( "M22", NrMovedPoints, 462 );
1132
[ rec( charactername := "1a+21a+55a+154a+231a", groupname := "M22", 
1133
      id := "a", 
1134
      identifier := 
1135
        [ "M22", [ "M22G1-p462aB0.m1", "M22G1-p462aB0.m2" ], 1, 462 ],
1136
      isPrimitive := false, p := 462, rankAction := 5, 
1137
      repname := "M22G1-p462aB0", repnr := 7, size := 443520, 
1138
      stabilizer := "2^4:A5 < 2^4:A6", standardization := 1, 
1139
      transitivity := 1, type := "perm" ), 
1140
  rec( charactername := "1a+21a^2+55a+154a+210a", groupname := "M22", 
1141
      id := "b", 
1142
      identifier := 
1143
        [ "M22", [ "M22G1-p462bB0.m1", "M22G1-p462bB0.m2" ], 1, 462 ],
1144
      isPrimitive := false, p := 462, rankAction := 8, 
1145
      repname := "M22G1-p462bB0", repnr := 8, size := 443520, 
1146
      stabilizer := "2^4:A5 < L3(4), 2^4:S5", standardization := 1, 
1147
      transitivity := 1, type := "perm" ), 
1148
  rec( charactername := "1a+21a^2+55a+154a+210a", groupname := "M22", 
1149
      id := "c", 
1150
      identifier := 
1151
        [ "M22", [ "M22G1-p462cB0.m1", "M22G1-p462cB0.m2" ], 1, 462 ],
1152
      isPrimitive := false, p := 462, rankAction := 8, 
1153
      repname := "M22G1-p462cB0", repnr := 9, size := 443520, 
1154
      stabilizer := "2^4:A5 < L3(4), 2^4:A6", standardization := 1, 
1155
      transitivity := 1, type := "perm" ) ]
1156
gap> atlasreps:= List( atlasreps, AtlasGroup );;
1157
gap> tomstabreps:= List( atlasreps, G -> List( tomstabs,
1158
> i -> RepresentativeTomByGenerators( tom, i, GeneratorsOfGroup( G ) ) ) );;
1159
gap> List( tomstabreps, x -> List( x, NrMovedPoints ) );
1160
[ [ 462, 462, 461 ], [ 460, 462, 462 ], [ 462, 461, 462 ] ]
1161
]]></Example>
1162

1163
<P/>
1164

1165
More precisely, we see that the point stabilizers in the three
1166
representations <C>462a</C>, <C>462b</C>, <C>462c</C> lie in the
1167
subgroup classes <M>149</M>, <M>147</M>, <M>148</M>, respectively,
1168
of the table of marks.
1169

1170
<P/>
1171

1172
The point stabilizers in the representations <C>462b</C> and <C>462c</C>
1173
are isomorphic, but not isomorphic with the point stabilizer in <C>462a</C>.
1174

1175
<P/>
1176

1177
<Example><![CDATA[
1178
gap> stabs:= List( atlasreps, G -> Stabilizer( G, 1 ) );;
1179
gap> List( stabs, IdGroup );
1180
[ [ 960, 11358 ], [ 960, 11357 ], [ 960, 11357 ] ]
1181
gap> List( stabs, PerfectIdentification );
1182
[ [ 960, 2 ], [ 960, 1 ], [ 960, 1 ] ]
1183
]]></Example>
1184

1185
<P/>
1186

1187
The three representations are imprimitive.
1188
The containment of the point stabilizers in maximal subgroups of
1189
<M>M_{22}</M> can be computed using the table of marks of <M>M_{22}</M>.
1190

1191
<P/>
1192

1193
<Example><![CDATA[
1194
gap> maxtom:= MaximalSubgroupsTom( tom );
1195
[ [ 155, 154, 153, 152, 151, 150, 146, 145 ], 
1196
  [ 22, 77, 176, 176, 231, 330, 616, 672 ] ]
1197
gap> List( tomstabs, i -> List( maxtom[1], j -> ContainedTom( tom, i, j ) ) );
1198
[ [ 21, 0, 0, 0, 1, 0, 0, 0 ], [ 21, 6, 0, 0, 0, 0, 0, 0 ], 
1199
  [ 0, 6, 0, 0, 0, 0, 0, 0 ] ]
1200
]]></Example>
1201

1202
<P/>
1203

1204
We see:
1205

1206
<List>
1207
<Item>
1208
  The point stabilizers in <C>462a</C> (subgroups in the class
1209
  <M>149</M> of the table of marks) are contained only in maximal subgroups
1210
  in class <M>154</M>; these groups have the structure <M>2^4:A_6</M>.
1211
</Item>
1212
<Item>
1213
  The point stabilizers in <C>462b</C> (subgroups in the class <M>147</M>)
1214
  are contained in maximal subgroups in the classes <M>155</M> and <M>151</M>;
1215
  these groups have the structures <M>L_3(4)</M> and <M>2^4:S_5</M>,
1216
  respectively.
1217
</Item>
1218
<Item>
1219
  The point stabilizers in <C>462c</C> (subgroups in the class <M>148</M>)
1220
  are contained in maximal subgroups in the classes <M>155</M> and <M>154</M>.
1221
</Item>
1222
</List>
1223

1224
<P/>
1225

1226
We identify the supergroups of the point stabilizers by computing the
1227
block systems.
1228

1229
<P/>
1230

1231
<Example><![CDATA[
1232
gap> bl:= List( atlasreps, AllBlocks );;
1233
gap> List( bl, Length );
1234
[ 1, 3, 2 ]
1235
gap> List( bl, l -> List( l, Length ) );
1236
[ [ 6 ], [ 21, 21, 2 ], [ 21, 6 ] ]
1237
]]></Example>
1238

1239
<P/>
1240

1241
Note that the two block systems with blocks of length <M>21</M> for
1242
<C>462b</C> belong to the same supergroups (of the type <M>L_3(4)</M>);
1243
each of these subgroups fixes two different subsets of <M>21</M> points.
1244

1245
<P/>
1246

1247
The representation <C>462a</C> is <E>multiplicity-free</E>,
1248
that is, it splits into a sum of pairwise nonisomorphic irreducible
1249
representations.
1250
This can be seen from the fact that the rank of this permutation
1251
representation (that is, the number of orbits of the point stabilizer)
1252
is five; each permutation representation with this property is
1253
multiplicity-free.
1254

1255
<P/>
1256

1257
The other two representations have rank eight.
1258
We have seen the ranks in the overview that was shown by
1259
<Ref Func="DisplayAtlasInfo"/> in the beginning.
1260
Now we compute the ranks from the permutation groups.
1261

1262
<P/>
1263

1264
<Example><![CDATA[
1265
gap> List( atlasreps, RankAction );
1266
[ 5, 8, 8 ]
1267
]]></Example>
1268

1269
<P/>
1270

1271
In fact the two representations <C>462b</C> and <C>462c</C> have the same
1272
permutation character.
1273
We check this by computing the possible permutation characters
1274
of degree <M>462</M> for <M>M_{22}</M>,
1275
and decomposing them into irreducible characters,
1276
using the character table from &GAP;'s Character Table Library.
1277

1278
<P/>
1279

1280
<Example><![CDATA[
1281
gap> t:= CharacterTable( "M22" );;
1282
gap> perms:= PermChars( t, 462 );
1283
[ Character( CharacterTable( "M22" ),
1284
  [ 462, 30, 3, 2, 2, 2, 3, 0, 0, 0, 0, 0 ] ), 
1285
  Character( CharacterTable( "M22" ),
1286
  [ 462, 30, 12, 2, 2, 2, 0, 0, 0, 0, 0, 0 ] ) ]
1287
gap> MatScalarProducts( t, Irr( t ), perms );
1288
[ [ 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0 ], 
1289
  [ 1, 2, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0 ] ]
1290
]]></Example>
1291

1292
<P/>
1293

1294
In particular, we see that the rank eight characters are not
1295
multiplicity-free.
1296

1297
</Subsection>
1298

1299
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
1300

1301
</Section>
1302

1303
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
1304

1305
</Chapter>
1306

1307

1308