1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
|
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<title>GAP (AtlasRep) - Chapter 7: Technicalities of the AtlasRep Package</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<meta name="generator" content="GAPDoc2HTML" />
<link rel="stylesheet" type="text/css" href="manual.css" />
<script src="manual.js" type="text/javascript"></script>
<script type="text/javascript">overwriteStyle();</script>
</head>
<body class="chap7" onload="jscontent()">
<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chap7.html">7</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
<div class="chlinkprevnexttop"> <a href="chap0.html">[Top of Book]</a> <a href="chap0.html#contents">[Contents]</a> <a href="chap6.html">[Previous Chapter]</a> <a href="chapBib.html">[Next Chapter]</a> </div>
<p id="mathjaxlink" class="pcenter"><a href="chap7_mj.html">[MathJax on]</a></p>
<p><a id="X7F77634D817156B3" name="X7F77634D817156B3"></a></p>
<div class="ChapSects"><a href="chap7.html#X7F77634D817156B3">7 <span class="Heading">Technicalities of the <strong class="pkg">AtlasRep</strong> Package</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap7.html#X7DC2B7917DC30B28">7.1 <span class="Heading">Global Variables Used by the <strong class="pkg">AtlasRep</strong> Package</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X8006BE167EB81E16">7.1-1 InfoAtlasRep</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X78601C3A87921E08">7.1-2 InfoCMeatAxe</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X80D5EF9A7FEF124B">7.1-3 InfoBBox</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X84A157BF7D0CB270">7.1-4 AGR</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X7BEC94A6781E126E">7.1-5 AtlasOfGroupRepresentationsInfo</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap7.html#X81C5B5E78215169D">7.2 <span class="Heading">How to Customize the Access to Data files</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap7.html#X7D76D4437A9646E7">7.3 <span class="Heading">Reading and Writing MeatAxe Format Files</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X83D5103780E1238F">7.3-1 ScanMeatAxeFile</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X7DDD09BE87063052">7.3-2 MeatAxeString</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X79D9AE4878E9DFA6">7.3-3 FFList</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X8477AA668733255C">7.3-4 CMtxBinaryFFMatOrPerm</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X872FA00C7F791FBB">7.3-5 FFMatOrPermCMtxBinary</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap7.html#X7FEE162B7F63BEA0">7.4 <span class="Heading">Reading and Writing <strong class="pkg">ATLAS</strong> Straight Line Programs</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X7D6617E47B013A37">7.4-1 ScanStraightLineProgram</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X82842D807A7B7DF7">7.4-2 AtlasStringOfProgram</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap7.html#X809898027EFDA56E">7.5 <span class="Heading">Data Types Used in the <strong class="pkg">AtlasRep</strong> Package</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X836AA4EA8346BE5B">7.5-1 AGR.DeclareDataType</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap7.html#X7A86627B80980F61">7.6 <span class="Heading">Filenames Used in the <strong class="pkg">AtlasRep</strong> Package</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X8486CCB181FC99A3">7.6-1 AGR.ParseFilenameFormat</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X78AB92DB7C2CAB6E">7.6-2 AGR.FileContents</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap7.html#X7CCA3DE97E756F01">7.7 <span class="Heading">The record component <code class="code">identifier</code> used by the <strong class="pkg">AtlasRep</strong> Package</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X81685FC979BC3FB8">7.7-1 <span class="Heading">AtlasRepIdentifier</span></a>
</span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap7.html#X7B1DECF080AEB806">7.8 <span class="Heading">The Tables of Contents of the <strong class="pkg">AtlasRep</strong> Package</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap7.html#X79C5F2267ACCF52A">7.9 <span class="Heading">Sanity Checks for the <strong class="pkg">AtlasRep</strong> Package</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X86FDCF0B85496AE5">7.9-1 <span class="Heading">Sanity Checks for a Table of Contents</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap7.html#X7FBFA8D287B807D2">7.9-2 <span class="Heading">Other Sanity Checks</span></a>
</span>
</div></div>
</div>
<h3>7 <span class="Heading">Technicalities of the <strong class="pkg">AtlasRep</strong> Package</span></h3>
<p>This chapter describes those parts of the <strong class="pkg">GAP</strong> interface to the <strong class="pkg">ATLAS</strong> of Group Representations that do not belong to the user interface (cf. Chapter <a href="chap3.html#X87EAF8E578D95793"><span class="RefLink">3</span></a>).</p>
<p>Besides global variables used for administrational purposes (see Section <a href="chap7.html#X7DC2B7917DC30B28"><span class="RefLink">7.1</span></a>) and several sanity checks (see Section <a href="chap7.html#X79C5F2267ACCF52A"><span class="RefLink">7.9</span></a>), they can be regarded as the interface between the data actually contained in the files and the corresponding <strong class="pkg">GAP</strong> objects (see Section <a href="chap7.html#X81C5B5E78215169D"><span class="RefLink">7.2</span></a>, <a href="chap7.html#X7D76D4437A9646E7"><span class="RefLink">7.3</span></a>, <a href="chap7.html#X7FEE162B7F63BEA0"><span class="RefLink">7.4</span></a>, and <a href="chap7.html#X809898027EFDA56E"><span class="RefLink">7.5</span></a>), and the interface between the remote and the local version of the database (see Section <a href="chap7.html#X7A86627B80980F61"><span class="RefLink">7.6</span></a> and <a href="chap7.html#X7B1DECF080AEB806"><span class="RefLink">7.8</span></a>). The former interface contains functions to read and write files in <strong class="pkg">MeatAxe</strong> format, which may be interesting for users familiar with <strong class="pkg">MeatAxe</strong> standalones (see for example <a href="chapBib.html#biBCMeatAxe">[Rin]</a>). Other low level functions may be undocumented in the sense that they are not described in this manual. Users interested in them may look at the actual implementation in the <code class="file">gap</code> directory of the package, but it may happen that this will be changed in future versions of the package.</p>
<p><a id="X7DC2B7917DC30B28" name="X7DC2B7917DC30B28"></a></p>
<h4>7.1 <span class="Heading">Global Variables Used by the <strong class="pkg">AtlasRep</strong> Package</span></h4>
<p>For debugging purposes, <strong class="pkg">AtlasRep</strong> functions print information depending on the info level of the info classes <code class="func">InfoAtlasRep</code> (<a href="chap7.html#X8006BE167EB81E16"><span class="RefLink">7.1-1</span></a>), <code class="func">InfoCMeatAxe</code> (<a href="chap7.html#X78601C3A87921E08"><span class="RefLink">7.1-2</span></a>), and <code class="func">InfoBBox</code> (<a href="chap7.html#X80D5EF9A7FEF124B"><span class="RefLink">7.1-3</span></a>) (cf. <a href="../../../doc/ref/chap7.html#X7A9C902479CB6F7C"><span class="RefLink">Reference: Info Functions</span></a>).</p>
<p>The info level of an info class can be changed using <code class="func">SetInfoLevel</code> (<a href="../../../doc/ref/chap7.html#X7B2ADC37783104B9"><span class="RefLink">Reference: InfoLevel</span></a>). For example, the info level of <code class="func">InfoAtlasRep</code> (<a href="chap7.html#X8006BE167EB81E16"><span class="RefLink">7.1-1</span></a>) can be set to the nonnegative integer <span class="SimpleMath">n</span> using <code class="code">SetInfoLevel( InfoAtlasRep, </code><span class="SimpleMath">n</span><code class="code"> )</code>.</p>
<p><a id="X8006BE167EB81E16" name="X8006BE167EB81E16"></a></p>
<h5>7.1-1 InfoAtlasRep</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ InfoAtlasRep</code></td><td class="tdright">( info class )</td></tr></table></div>
<p>If the info level of <code class="func">InfoAtlasRep</code> is at least <span class="SimpleMath">1</span> then information about <code class="keyw">fail</code> results of <strong class="pkg">AtlasRep</strong> functions is printed. If the info level is at least <span class="SimpleMath">2</span> then also information about calls to external programs is printed. The default level is <span class="SimpleMath">0</span>, no information is printed on this level.</p>
<p><a id="X78601C3A87921E08" name="X78601C3A87921E08"></a></p>
<h5>7.1-2 InfoCMeatAxe</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ InfoCMeatAxe</code></td><td class="tdright">( info class )</td></tr></table></div>
<p>If the info level of <code class="func">InfoCMeatAxe</code> is at least <span class="SimpleMath">1</span> then information about <code class="keyw">fail</code> results of <code class="code">C</code>-<strong class="pkg">MeatAxe</strong> functions (see Section <a href="chap7.html#X7D76D4437A9646E7"><span class="RefLink">7.3</span></a>) is printed. The default level is zero, no information is printed on this level.</p>
<p><a id="X80D5EF9A7FEF124B" name="X80D5EF9A7FEF124B"></a></p>
<h5>7.1-3 InfoBBox</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ InfoBBox</code></td><td class="tdright">( info class )</td></tr></table></div>
<p>If the info level of <code class="func">InfoBBox</code> is at least <span class="SimpleMath">1</span> then information about <code class="keyw">fail</code> results of functions dealing with black box programs (see Section <a href="chap6.html#X7BE856BC785A9E8F"><span class="RefLink">6.2</span></a>) is printed. The default level is <span class="SimpleMath">0</span>, no information is printed on this level.</p>
<p><a id="X84A157BF7D0CB270" name="X84A157BF7D0CB270"></a></p>
<h5>7.1-4 AGR</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AGR</code></td><td class="tdright">( global variable )</td></tr></table></div>
<p>is a record whose components are functions and data that are used by the high level interface functions. Some of the components are documented, see for example the index of the package manual.</p>
<p><a id="X7BEC94A6781E126E" name="X7BEC94A6781E126E"></a></p>
<h5>7.1-5 AtlasOfGroupRepresentationsInfo</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AtlasOfGroupRepresentationsInfo</code></td><td class="tdright">( global variable )</td></tr></table></div>
<p>This is a record that is defined in the file <code class="file">gap/types.g</code> of the package, with the following components.</p>
<dl>
<dt><strong class="Mark"><code class="code">GAPnames</code></strong></dt>
<dd><p>a list of pairs, each containing the <strong class="pkg">GAP</strong> name and the <strong class="pkg">ATLAS</strong>-file name of a group, see Section <a href="chap3.html#X81BF52FC7B8C08D4"><span class="RefLink">3.2</span></a>,</p>
</dd>
<dt><strong class="Mark"><code class="code">notified</code></strong></dt>
<dd><p>a list used for administrating extensions of the database (see Chapter <a href="chap5.html#X7B0718A178BB10CA"><span class="RefLink">5</span></a>); the value is changed by <code class="func">AtlasOfGroupRepresentationsNotifyData</code> (<a href="chap5.html#X81B5FA0578257653"><span class="RefLink">5.1-1</span></a>) and <code class="func">AtlasOfGroupRepresentationsForgetData</code> (<a href="chap5.html#X7E0DC24681F17A9D"><span class="RefLink">5.1-2</span></a>),</p>
</dd>
<dt><strong class="Mark"><code class="code">characterinfo</code>, <code class="code">permrepinfo</code>, <code class="code">ringinfo</code></strong></dt>
<dd><p>additional information about representations, concerning the afforded characters, the point stabilizers of permutation representations, and the rings of definition of matrix representations; this information is used by <code class="func">DisplayAtlasInfo</code> (<a href="chap3.html#X79DACFFA7E2D1A99"><span class="RefLink">3.5-1</span></a>),</p>
</dd>
<dt><strong class="Mark"><code class="code">TableOfContents</code></strong></dt>
<dd><p>a record with at most the components <code class="code">core</code>, <code class="code">internal</code>, <code class="code">local</code>, <code class="code">merged</code>, <code class="code">types</code>, and the identifiers of database extensions. The value of the component <code class="code">types</code> is set in <code class="func">AGR.DeclareDataType</code> (<a href="chap7.html#X836AA4EA8346BE5B"><span class="RefLink">7.5-1</span></a>), and the values of the other components are created by <code class="func">AtlasOfGroupRepresentationsNotifyData</code> (<a href="chap5.html#X81B5FA0578257653"><span class="RefLink">5.1-1</span></a>).</p>
</dd>
<dt><strong class="Mark"><code class="code">accessFunctions</code></strong></dt>
<dd><p>a list of records, each describing how to access the data files, see Sections <a href="chap4.html#X81AD105979465162"><span class="RefLink">4.2-5</span></a> and <a href="chap7.html#X81C5B5E78215169D"><span class="RefLink">7.2</span></a>, and</p>
</dd>
</dl>
<p><a id="X81C5B5E78215169D" name="X81C5B5E78215169D"></a></p>
<h4>7.2 <span class="Heading">How to Customize the Access to Data files</span></h4>
<p>By default, locally available data files are stored in prescribed directories, and the files are exactly the text files that have been downloaded from appropriate places in the internet. However, a more flexible approach may be useful.</p>
<p>First, one may want to use <em>different file formats</em>, for example <strong class="pkg">MeatAxe</strong> binary files may be provided parallel to <strong class="pkg">MeatAxe</strong> text files. Second, one may want to use <em>a different directory structure</em>, for example the same structure as used on some server –this makes sense for example if a local mirror of a server is available, because then one can read the server files directly, without transferring/copying them to another directory.</p>
<p>In order to achieve this (and perhaps more), we admit to customize the meaning of the following three access steps.</p>
<dl>
<dt><strong class="Mark">Are the required data locally available?</strong></dt>
<dd><p>There may be different file formats available, such as text or binary files, and it may happen that the data are available in one file or are distributed to several files.</p>
</dd>
<dt><strong class="Mark">How can a file be made locally available?</strong></dt>
<dd><p>A different remote file may be fetched, or some postprocessing may be required.</p>
</dd>
<dt><strong class="Mark">How is the data of a file accessed by <strong class="pkg">GAP</strong>?</strong></dt>
<dd><p>A different function may be needed to evaluate the file contents.</p>
</dd>
</dl>
<p>For creating an overview of the locally available data, the first of these steps must be available independent of actually accessing the file in question. For updating the local copy of the server data, the second of the above steps must be available independent of the third one. Therefore, the package provides the possibility to extend the default behaviour by adding new records to the <code class="code">accessFunctions</code> component of <code class="func">AtlasOfGroupRepresentationsInfo</code> (<a href="chap7.html#X7BEC94A6781E126E"><span class="RefLink">7.1-5</span></a>). The relevant record components are as follows.</p>
<dl>
<dt><strong class="Mark"><code class="code">description</code></strong></dt>
<dd><p>This must be a short string that describes for which kinds of files the functions in the current record are intended, which file formats are supported etc. The value is used as key in the user preference <code class="code">FileAccessFunctions</code>, see Section <a href="chap4.html#X81AD105979465162"><span class="RefLink">4.2-5</span></a>.</p>
</dd>
<dt><strong class="Mark">
<code class="code">location( </code><span class="SimpleMath">files, type</span><code class="code"> )</code>
</strong></dt>
<dd><p>Let <span class="SimpleMath">files</span> be a list of pairs <code class="code">[ dirname, filename ]</code>, and <span class="SimpleMath">type</span> be the data type (see <code class="func">AGR.DeclareDataType</code> (<a href="chap7.html#X836AA4EA8346BE5B"><span class="RefLink">7.5-1</span></a>)) to which the files belong. This function must return either the absolute paths where the mechanism implemented by the current record expects the local version of the given files, or <code class="keyw">fail</code> if this function does not feel responsible for these files.</p>
<p>The files are regarded as not locally available if all installed <code class="code">location</code> functions return either <code class="keyw">fail</code> or paths of nonexisting files, in the sense of <code class="func">IsExistingFile</code> (<a href="../../../doc/ref/chap9.html#X8269697A7B927AF1"><span class="RefLink">Reference: IsExistingFile</span></a>).</p>
</dd>
<dt><strong class="Mark">
<code class="code">fetch( </code><span class="SimpleMath">filepath, filename, dirname, type</span><code class="code"> )</code>
</strong></dt>
<dd><p>This function is called if a file is not locally available and if the <code class="code">location</code> function in the current record has returned a list of paths. The argument <span class="SimpleMath">type</span> must be the same as for the <code class="code">location</code> function, and <span class="SimpleMath">filepath</span> and <span class="SimpleMath">filename</span> must be strings (<em>not</em> lists of strings).</p>
<p>The return value must be <code class="keyw">true</code> if the function succeeded with making the file locally available (including postprocessing if applicable), a string with the contents of the data file if the remote data were directly loaded into the <strong class="pkg">GAP</strong> session (if no local caching is possible), and <code class="keyw">false</code> otherwise.</p>
</dd>
<dt><strong class="Mark"><code class="code">contents( </code><span class="SimpleMath">files, type, filepaths</span><code class="code"> )</code></strong></dt>
<dd><p>This function is called when the <code class="code">location</code> function in the current record has returned the path(s) <span class="SimpleMath">filepath</span>, and if either these are paths of existing files or the <code class="code">fetch</code> function in the current record has been called for these paths, and the return value was <code class="keyw">true</code>. The first three arguments must be the same as for the <code class="code">location</code> function.</p>
<p>The return value must be the contents of the file(s), in the sense that the <strong class="pkg">GAP</strong> matrix, matrix list, permutation, permutation list, or program described by the file(s) is returned. This means that besides reading the file(s) via the appropriate function, interpreting the contents may be necessary.</p>
</dd>
</dl>
<p>In <code class="func">AGR.FileContents</code> (<a href="chap7.html#X78AB92DB7C2CAB6E"><span class="RefLink">7.6-2</span></a>), those records in the <code class="code">accessFunctions</code> component of <code class="func">AtlasOfGroupRepresentationsInfo</code> (<a href="chap7.html#X7BEC94A6781E126E"><span class="RefLink">7.1-5</span></a>) are considered –in reversed order– whose <code class="code">description</code> component occurs in the user preference <code class="code">FileAccessFunctions</code>, see Section <a href="chap4.html#X81AD105979465162"><span class="RefLink">4.2-5</span></a>.</p>
<p><a id="X7D76D4437A9646E7" name="X7D76D4437A9646E7"></a></p>
<h4>7.3 <span class="Heading">Reading and Writing MeatAxe Format Files</span></h4>
<p><a id="X83D5103780E1238F" name="X83D5103780E1238F"></a></p>
<h5>7.3-1 ScanMeatAxeFile</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ScanMeatAxeFile</code>( <var class="Arg">filename</var>[, <var class="Arg">q</var>][, <var class="Arg">"string"</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the matrix or list of permutations stored in the file or encoded by the string.</p>
<p>Let <var class="Arg">filename</var> be the name of a <strong class="pkg">GAP</strong> readable file (see <a href="../../../doc/ref/chap9.html#X7E352E1F87060602"><span class="RefLink">Reference: Filename</span></a>) that contains a matrix or a permutation or a list of permutations in <strong class="pkg">MeatAxe</strong> text format (see the section about the program <code class="file">zcv</code> in the <code class="code">C</code>-<strong class="pkg">MeatAxe</strong> documentation <a href="chapBib.html#biBCMeatAxe">[Rin]</a>), and let <var class="Arg">q</var> be a prime power. <code class="func">ScanMeatAxeFile</code> returns the corresponding <strong class="pkg">GAP</strong> matrix or list of permutations, respectively.</p>
<p>If the file contains a matrix then the way how it is read by <code class="func">ScanMeatAxeFile</code> depends on the value of the user preference <code class="code">HowToReadMeatAxeTextFiles</code>, see Section <a href="chap4.html#X79993585808450FA"><span class="RefLink">4.2-7</span></a>.</p>
<p>If the parameter <var class="Arg">q</var> is given then the result matrix is represented over the field with <var class="Arg">q</var> elements, the default for <var class="Arg">q</var> is the field size stored in the file.</p>
<p>If the file contains a list of permutations then it is read with <code class="func">StringFile</code> (<a href="../../../pkg/gapdoc/doc/chap6.html#X7E14D32181FBC3C3"><span class="RefLink">GAPDoc: StringFile</span></a>); the parameter <var class="Arg">q</var>, if given, is ignored in this case.</p>
<p>If the string <code class="code">"string"</code> is entered as the third argument then the first argument must be a string as obtained by reading a file in <strong class="pkg">MeatAxe</strong> text format as a text stream (see <code class="func">InputTextFile</code> (<a href="../../../doc/ref/chap10.html#X8343D04981128784"><span class="RefLink">Reference: InputTextFile</span></a>)). Also in this case, <code class="func">ScanMeatAxeFile</code> returns the corresponding <strong class="pkg">GAP</strong> matrix or list of permutations, respectively.</p>
<p><a id="X7DDD09BE87063052" name="X7DDD09BE87063052"></a></p>
<h5>7.3-2 MeatAxeString</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ MeatAxeString</code>( <var class="Arg">mat</var>, <var class="Arg">q</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ MeatAxeString</code>( <var class="Arg">perms</var>, <var class="Arg">degree</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ MeatAxeString</code>( <var class="Arg">perm</var>, <var class="Arg">q</var>, <var class="Arg">dims</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ MeatAxeString</code>( <var class="Arg">intmat</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Returns: a string encoding the <strong class="pkg">GAP</strong> objects given as input in <code class="code">C</code>-<strong class="pkg">MeatAxe</strong> text format, see <a href="chapBib.html#biBCMeatAxe">[Rin]</a>.</p>
<p>In the first form, for a matrix <var class="Arg">mat</var> whose entries lie in the finite field with <var class="Arg">q</var> elements, <code class="func">MeatAxeString</code> returns a string that encodes <var class="Arg">mat</var> as a matrix over <code class="code">GF(<var class="Arg">q</var>)</code>.</p>
<p>In the second form, for a nonempty list <var class="Arg">perms</var> of permutations that move only points up to the positive integer <var class="Arg">degree</var>, <code class="func">MeatAxeString</code> returns a string that encodes <var class="Arg">perms</var> as permutations of degree <var class="Arg">degree</var>.</p>
<p>In the third form, for a permutation <var class="Arg">perm</var> with largest moved point <span class="SimpleMath">n</span>, say, a prime power <var class="Arg">q</var>, and a list <var class="Arg">dims</var> of length two containing two positive integers larger than or equal to <span class="SimpleMath">n</span>, <code class="func">MeatAxeString</code> returns a string that encodes <var class="Arg">perm</var> as a matrix over <code class="code">GF(<var class="Arg">q</var>)</code>, of dimensions <var class="Arg">dims</var>, whose first <span class="SimpleMath">n</span> rows and columns describe the permutation matrix corresponding to <var class="Arg">perm</var>, and the remaining rows and columns are zero.</p>
<p>In the fourth form, for a matrix <var class="Arg">intmat</var> of integers, <code class="func">MeatAxeString</code> returns a string that encodes <var class="Arg">intmat</var> as an integer matrix.</p>
<p>When strings are printed to files using <code class="func">PrintTo</code> (<a href="../../../doc/ref/chap9.html#X86956C577FFEE1F9"><span class="RefLink">Reference: PrintTo</span></a>) or <code class="func">AppendTo</code> (<a href="../../../doc/ref/chap9.html#X86956C577FFEE1F9"><span class="RefLink">Reference: AppendTo</span></a>) then line breaks are inserted whenever lines exceed the number of characters given by the second entry of the list returned by <code class="func">SizeScreen</code> (<a href="../../../doc/ref/chap6.html#X8723E0A1837894F3"><span class="RefLink">Reference: SizeScreen</span></a>), see <a href="../../../doc/ref/chap10.html#X7F454EB286947C85"><span class="RefLink">Reference: Operations for Output Streams</span></a>. This behaviour is not desirable for creating data files. So the recommended functions for printing the result of <code class="func">MeatAxeString</code> to a file are <code class="func">FileString</code> (<a href="../../../pkg/gapdoc/doc/chap6.html#X7E14D32181FBC3C3"><span class="RefLink">GAPDoc: FileString</span></a>) and <code class="func">WriteAll</code> (<a href="../../../doc/ref/chap10.html#X78C113917936058D"><span class="RefLink">Reference: WriteAll</span></a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">mat:= [ [ 1, -1 ], [ 0, 1 ] ] * Z(3)^0;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">str:= MeatAxeString( mat, 3 );</span>
"1 3 2 2\n12\n01\n"
<span class="GAPprompt">gap></span> <span class="GAPinput">mat = ScanMeatAxeFile( str, "string" );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">str:= MeatAxeString( mat, 9 );</span>
"1 9 2 2\n12\n01\n"
<span class="GAPprompt">gap></span> <span class="GAPinput">mat = ScanMeatAxeFile( str, "string" );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= [ (1,2,3)(5,6) ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">str:= MeatAxeString( perms, 6 );</span>
"12 1 6 1\n2\n3\n1\n4\n6\n5\n"
<span class="GAPprompt">gap></span> <span class="GAPinput">perms = ScanMeatAxeFile( str, "string" );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">str:= MeatAxeString( perms, 8 );</span>
"12 1 8 1\n2\n3\n1\n4\n6\n5\n7\n8\n"
<span class="GAPprompt">gap></span> <span class="GAPinput">perms = ScanMeatAxeFile( str, "string" );</span>
true
</pre></div>
<p>Note that the output of <code class="func">MeatAxeString</code> in the case of permutation matrices depends on the user preference <code class="code">WriteMeatAxeFilesOfMode2</code>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">perm:= (1,2,4);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">str:= MeatAxeString( perm, 3, [ 5, 6 ] );</span>
"2 3 5 6\n2\n4\n3\n1\n5\n"
<span class="GAPprompt">gap></span> <span class="GAPinput">mat:= ScanMeatAxeFile( str, "string" );; Print( mat, "\n" );</span>
[ [ 0*Z(3), Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3) ],
[ 0*Z(3), 0*Z(3), 0*Z(3), Z(3)^0, 0*Z(3), 0*Z(3) ],
[ 0*Z(3), 0*Z(3), Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3) ],
[ Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3) ],
[ 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3), Z(3)^0, 0*Z(3) ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">pref:= UserPreference( "AtlasRep", "WriteMeatAxeFilesOfMode2" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetUserPreference( "AtlasRep", "WriteMeatAxeFilesOfMode2", true );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">MeatAxeString( mat, 3 ) = str;</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">SetUserPreference( "AtlasRep", "WriteMeatAxeFilesOfMode2", false );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">MeatAxeString( mat, 3 );</span>
"1 3 5 6\n010000\n000100\n001000\n100000\n000010\n"
<span class="GAPprompt">gap></span> <span class="GAPinput">SetUserPreference( "AtlasRep", "WriteMeatAxeFilesOfMode2", pref );</span>
</pre></div>
<p><a id="X79D9AE4878E9DFA6" name="X79D9AE4878E9DFA6"></a></p>
<h5>7.3-3 FFList</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ FFList</code>( <var class="Arg">F</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a list of elements in the given finite field.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ FFLists</code></td><td class="tdright">( global variable )</td></tr></table></div>
<p><code class="func">FFList</code> is a utility program for the conversion of vectors and matrices from <strong class="pkg">MeatAxe</strong> format to <strong class="pkg">GAP</strong> format and vice versa. It is used by <code class="func">ScanMeatAxeFile</code> (<a href="chap7.html#X83D5103780E1238F"><span class="RefLink">7.3-1</span></a>) and <code class="func">MeatAxeString</code> (<a href="chap7.html#X7DDD09BE87063052"><span class="RefLink">7.3-2</span></a>).</p>
<p>For a finite field <var class="Arg">F</var>, <code class="func">FFList</code> returns a list <span class="SimpleMath">l</span> giving the correspondence between the <strong class="pkg">MeatAxe</strong> numbering and the <strong class="pkg">GAP</strong> numbering of the elements in <var class="Arg">F</var>.</p>
<p>The element of <var class="Arg">F</var> corresponding to <strong class="pkg">MeatAxe</strong> number <span class="SimpleMath">n</span> is <span class="SimpleMath">l[ n+1 ]</span>, and the <strong class="pkg">MeatAxe</strong> number of the field element <span class="SimpleMath">z</span> is <code class="code">Position( </code><span class="SimpleMath">l, z</span><code class="code"> ) - 1</code>.</p>
<p>The global variable <code class="func">FFLists</code> is used to store the information about <var class="Arg">F</var> once it has been computed.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">FFList( GF(4) );</span>
[ 0*Z(2), Z(2)^0, Z(2^2), Z(2^2)^2 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">IsBound( FFLists[4] );</span>
true
</pre></div>
<p>The <strong class="pkg">MeatAxe</strong> defines the bijection between the elements in the field with <span class="SimpleMath">q = p^d</span> elements and the set <span class="SimpleMath">{ 0, 1, ..., q-1 }</span> of integers by assigning the field element <span class="SimpleMath">∑_{i=0}^{d-1} c_i z^i</span> to the integer <span class="SimpleMath">∑_{i=0}^{d-1} c_i p^i</span>, where the <span class="SimpleMath">c_i</span> are in the set <span class="SimpleMath">{ 0, 1, ..., p-1 }</span> and <span class="SimpleMath">z</span> is the primitive root of the field with <span class="SimpleMath">q</span> elements that corresponds to the residue class of the indeterminate, modulo the ideal spanned by the Conway polynomial of degree <span class="SimpleMath">d</span> over the field with <span class="SimpleMath">p</span> elements.</p>
<p>The finite fields introduced by the <strong class="pkg">StandardFF</strong> package <a href="chapBib.html#biBStandardFF">[Lüb21]</a> are supported by <code class="func">FFList</code> and <code class="func">FFLists</code>, in the sense that the bijection defined by <code class="func">StandardIsomorphismGF</code> (<a href="../../../pkg/standardff/doc/chap2.html#X7ECCD8D27FBA9505"><span class="RefLink">StandardFF: StandardIsomorphismGF</span></a>) is applied automatically when <var class="Arg">F</var> is a field in the filter <code class="func">IsStandardFiniteField</code> (<a href="../../../pkg/standardff/doc/chap2.html#X7DD6C7C3867D84B8"><span class="RefLink">StandardFF: IsStandardFiniteField</span></a>).</p>
<p><a id="X8477AA668733255C" name="X8477AA668733255C"></a></p>
<h5>7.3-4 CMtxBinaryFFMatOrPerm</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CMtxBinaryFFMatOrPerm</code>( <var class="Arg">elm</var>, <var class="Arg">def</var>, <var class="Arg">outfile</var>[, <var class="Arg">base</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>Let the pair <span class="SimpleMath">(<var class="Arg">elm</var>, <var class="Arg">def</var>)</span> be either of the form <span class="SimpleMath">(M, q)</span> where <span class="SimpleMath">M</span> is a matrix over a finite field <span class="SimpleMath">F</span>, say, with <span class="SimpleMath">q ≤ 256</span> elements, or of the form <span class="SimpleMath">(π, n)</span> where <span class="SimpleMath">π</span> is a permutation with largest moved point at most <span class="SimpleMath">n</span>. Let <var class="Arg">outfile</var> be a string. <code class="func">CMtxBinaryFFMatOrPerm</code> writes the <code class="code">C</code>-<strong class="pkg">MeatAxe</strong> binary format of <span class="SimpleMath">M</span>, viewed as a matrix over <span class="SimpleMath">F</span>, or of <span class="SimpleMath">π</span>, viewed as a permutation on the points up to <span class="SimpleMath">n</span>, to the file with name <var class="Arg">outfile</var>.</p>
<p>In the case of a permutation <span class="SimpleMath">π</span>, the optional argument <var class="Arg">base</var> prescribes whether the binary file contains the points from <span class="SimpleMath">0</span> to <var class="Arg">deg</var><span class="SimpleMath">- 1</span> (<var class="Arg">base</var><span class="SimpleMath">= 0</span>, supported by version 2.4 of the <code class="code">C</code>-<strong class="pkg">MeatAxe</strong>) or the points from <span class="SimpleMath">1</span> to <var class="Arg">deg</var> (<var class="Arg">base</var><span class="SimpleMath">= 1</span>, supported by older versions of the <code class="code">C</code>-<strong class="pkg">MeatAxe</strong>). The default for <var class="Arg">base</var> is given by the value of the user preference <code class="code">BaseOfMeatAxePermutation</code>, see Section <a href="chap4.html#X877E40DB7A4E36C9"><span class="RefLink">4.2-10</span></a>.</p>
<p>(The binary format is described in the <code class="code">C</code>-<strong class="pkg">MeatAxe</strong> manual <a href="chapBib.html#biBCMeatAxe">[Rin]</a>.)</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tmpdir:= DirectoryTemporary();;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">mat:= Filename( tmpdir, "mat" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">q:= 4;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">mats:= GeneratorsOfGroup( GL(10,q) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">CMtxBinaryFFMatOrPerm( mats[1], q, Concatenation( mat, "1" ) );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">CMtxBinaryFFMatOrPerm( mats[2], q, Concatenation( mat, "2" ) );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">prm:= Filename( tmpdir, "prm" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">n:= 200;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= GeneratorsOfGroup( SymmetricGroup( n ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">CMtxBinaryFFMatOrPerm( perms[1], n, Concatenation( prm, "1" ) );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">CMtxBinaryFFMatOrPerm( perms[2], n, Concatenation( prm, "2" ) );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">CMtxBinaryFFMatOrPerm( perms[1], n, Concatenation( prm, "1a" ), 0 );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">CMtxBinaryFFMatOrPerm( perms[2], n, Concatenation( prm, "2b" ), 1 );</span>
</pre></div>
<p><a id="X872FA00C7F791FBB" name="X872FA00C7F791FBB"></a></p>
<h5>7.3-5 FFMatOrPermCMtxBinary</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ FFMatOrPermCMtxBinary</code>( <var class="Arg">fname</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the matrix or permutation stored in the file.</p>
<p>Let <var class="Arg">fname</var> be the name of a file that contains the <code class="code">C</code>-<strong class="pkg">MeatAxe</strong> binary format of a matrix over a finite field or of a permutation, as is described in <a href="chapBib.html#biBCMeatAxe">[Rin]</a>. <code class="func">FFMatOrPermCMtxBinary</code> returns the corresponding <strong class="pkg">GAP</strong> matrix or permutation.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">FFMatOrPermCMtxBinary( Concatenation( mat, "1" ) ) = mats[1];</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">FFMatOrPermCMtxBinary( Concatenation( mat, "2" ) ) = mats[2];</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">FFMatOrPermCMtxBinary( Concatenation( prm, "1" ) ) = perms[1];</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">FFMatOrPermCMtxBinary( Concatenation( prm, "2" ) ) = perms[2];</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">FFMatOrPermCMtxBinary( Concatenation( prm, "1a" ) ) = perms[1];</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">FFMatOrPermCMtxBinary( Concatenation( prm, "2b" ) ) = perms[2];</span>
true
</pre></div>
<p><a id="X7FEE162B7F63BEA0" name="X7FEE162B7F63BEA0"></a></p>
<h4>7.4 <span class="Heading">Reading and Writing <strong class="pkg">ATLAS</strong> Straight Line Programs</span></h4>
<p><a id="X7D6617E47B013A37" name="X7D6617E47B013A37"></a></p>
<h5>7.4-1 ScanStraightLineProgram</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ScanStraightLineProgram</code>( <var class="Arg">filename</var>[, <var class="Arg">"string"</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a record containing the straight line program, or <code class="keyw">fail</code>.</p>
<p>Let <var class="Arg">filename</var> be the name of a file that contains a straight line program in the sense that it consists only of lines in the following form.</p>
<dl>
<dt><strong class="Mark"><code class="code">#</code><span class="SimpleMath">anything</span></strong></dt>
<dd><p>lines starting with a hash sign <code class="code">#</code> are ignored,</p>
</dd>
<dt><strong class="Mark"><code class="code">echo </code><span class="SimpleMath">anything</span></strong></dt>
<dd><p>lines starting with <code class="code">echo</code> are ignored for the <code class="code">program</code> component of the result record (see below), they are used to set up the bijection between the labels used in the program and conjugacy class names in the case that the program computes dedicated class representatives,</p>
</dd>
<dt><strong class="Mark"><code class="code">inp </code><span class="SimpleMath">n</span></strong></dt>
<dd><p>means that there are <span class="SimpleMath">n</span> inputs, referred to via the labels <code class="code">1</code>, <code class="code">2</code>, <span class="SimpleMath">...</span>, <span class="SimpleMath">n</span>,</p>
</dd>
<dt><strong class="Mark"><code class="code">inp </code><span class="SimpleMath">k</span> <span class="SimpleMath">a1</span> <span class="SimpleMath">a2</span> ... <span class="SimpleMath">ak</span></strong></dt>
<dd><p>means that the next <span class="SimpleMath">k</span> inputs are referred to via the labels <span class="SimpleMath">a1</span>, <span class="SimpleMath">a2</span>, ..., <span class="SimpleMath">ak</span>,</p>
</dd>
<dt><strong class="Mark"><code class="code">cjr </code><span class="SimpleMath">a</span> <span class="SimpleMath">b</span></strong></dt>
<dd><p>means that <span class="SimpleMath">a</span> is replaced by <span class="SimpleMath">b</span><code class="code">^(-1) * </code><span class="SimpleMath">a</span><code class="code"> * </code><span class="SimpleMath">b</span>,</p>
</dd>
<dt><strong class="Mark"><code class="code">cj </code><span class="SimpleMath">a</span> <span class="SimpleMath">b</span> <span class="SimpleMath">c</span></strong></dt>
<dd><p>means that <span class="SimpleMath">c</span> is defined as <span class="SimpleMath">b</span><code class="code">^(-1) * </code><span class="SimpleMath">a</span><code class="code"> * </code><span class="SimpleMath">b</span>,</p>
</dd>
<dt><strong class="Mark"><code class="code">com </code><span class="SimpleMath">a</span> <span class="SimpleMath">b</span> <span class="SimpleMath">c</span></strong></dt>
<dd><p>means that <span class="SimpleMath">c</span> is defined as <span class="SimpleMath">a</span><code class="code">^(-1) * </code><span class="SimpleMath">b</span>^(-1)<code class="code"> * </code><span class="SimpleMath">a</span><code class="code"> * </code><span class="SimpleMath">b</span>,</p>
</dd>
<dt><strong class="Mark"><code class="code">iv </code><span class="SimpleMath">a</span> <span class="SimpleMath">b</span></strong></dt>
<dd><p>means that <span class="SimpleMath">b</span> is defined as <span class="SimpleMath">a</span><code class="code">^(-1)</code>,</p>
</dd>
<dt><strong class="Mark"><code class="code">mu </code><span class="SimpleMath">a</span> <span class="SimpleMath">b</span> <span class="SimpleMath">c</span></strong></dt>
<dd><p>means that <span class="SimpleMath">c</span> is defined as <span class="SimpleMath">a</span><code class="code"> * </code><span class="SimpleMath">b</span>,</p>
</dd>
<dt><strong class="Mark"><code class="code">pwr </code><span class="SimpleMath">a</span> <span class="SimpleMath">b</span> <span class="SimpleMath">c</span></strong></dt>
<dd><p>means that <span class="SimpleMath">c</span> is defined as <span class="SimpleMath">b</span><code class="code">^</code><span class="SimpleMath">a</span>,</p>
</dd>
<dt><strong class="Mark"><code class="code">cp </code><span class="SimpleMath">a</span> <span class="SimpleMath">b</span></strong></dt>
<dd><p>means that <span class="SimpleMath">b</span> is defined as a copy of <span class="SimpleMath">a</span>,</p>
</dd>
<dt><strong class="Mark"><code class="code">oup </code><span class="SimpleMath">l</span></strong></dt>
<dd><p>means that there are <span class="SimpleMath">l</span> outputs, stored in the labels <code class="code">1</code>, <code class="code">2</code>, <span class="SimpleMath">...</span>, <span class="SimpleMath">l</span>, and</p>
</dd>
<dt><strong class="Mark"><code class="code">oup </code><span class="SimpleMath">l</span> <span class="SimpleMath">b1</span> <span class="SimpleMath">b2</span> ... <span class="SimpleMath">bl</span></strong></dt>
<dd><p>means that the next <span class="SimpleMath">l</span> outputs are stored in the labels <span class="SimpleMath">b1</span>, <span class="SimpleMath">b2</span>, ... <span class="SimpleMath">bl</span>.</p>
</dd>
</dl>
<p>Each of the labels <span class="SimpleMath">a</span>, <span class="SimpleMath">b</span>, <span class="SimpleMath">c</span> can be any nonempty sequence of digits and alphabet characters, except that the first argument of <code class="code">pwr</code> must denote an integer.</p>
<p>If the <code class="code">inp</code> or <code class="code">oup</code> statements are missing then the input or output, respectively, is assumed to be given by the labels <code class="code">1</code> and <code class="code">2</code>. There can be multiple <code class="code">inp</code> lines at the beginning of the program and multiple <code class="code">oup</code> lines at the end of the program. Only the first <code class="code">inp</code> or <code class="code">oup</code> line may omit the names of the elements. For example, an empty file <var class="Arg">filename</var> or an empty string <var class="Arg">string</var> represent a straight line program with two inputs that are returned as outputs.</p>
<p>No command except <code class="code">cjr</code> may overwrite its own input. For example, the line <code class="code">mu a b a</code> is not legal. (This is not checked.)</p>
<p><code class="func">ScanStraightLineProgram</code> returns a record containing as the value of its component <code class="code">program</code> the corresponding <strong class="pkg">GAP</strong> straight line program (see <code class="func">IsStraightLineProgram</code> (<a href="../../../doc/ref/chap37.html#X7F69FF3F7C6694CB"><span class="RefLink">Reference: IsStraightLineProgram</span></a>)) if the input string satisfies the syntax rules stated above, and returns <code class="keyw">fail</code> otherwise. In the latter case, information about the first corrupted line of the program is printed if the info level of <code class="func">InfoCMeatAxe</code> (<a href="chap7.html#X78601C3A87921E08"><span class="RefLink">7.1-2</span></a>) is at least <span class="SimpleMath">1</span>.</p>
<p>If the string <code class="code">"string"</code> is entered as the second argument then the first argument must be a string as obtained by reading a file in <strong class="pkg">MeatAxe</strong> text format as a text stream (see <code class="func">InputTextFile</code> (<a href="../../../doc/ref/chap10.html#X8343D04981128784"><span class="RefLink">Reference: InputTextFile</span></a>)). Also in this case, <code class="func">ScanStraightLineProgram</code> returns either a record with the corresponding <strong class="pkg">GAP</strong> straight line program or <code class="keyw">fail</code>.</p>
<p>If the input describes a straight line program that computes certain class representatives of the group in question then the result record also contains the component <code class="code">outputs</code>. Its value is a list of strings, the entry at position <span class="SimpleMath">i</span> denoting the name of the class in which the <span class="SimpleMath">i</span> output of the straight line program lies; see Section <a href="chap3.html#X861CD545803B97E8"><span class="RefLink">3.4</span></a> for the definition of the class names that occur.</p>
<p>Such straight line programs must end with a sequence of output specifications of the following form.</p>
<div class="example"><pre>
echo "Classes 1A 2A 3A 5A 5B"
oup 5 3 1 2 4 5
</pre></div>
<p>This example means that the list of outputs of the program contains elements of the classes <code class="code">1A</code>, <code class="code">2A</code>, <code class="code">3A</code>, <code class="code">5A</code>, and <code class="code">5B</code> (in this order), and that inside the program, these elements are referred to by the five names <code class="code">3</code>, <code class="code">1</code>, <code class="code">2</code>, <code class="code">4</code>, and <code class="code">5</code>.</p>
<p><a id="X82842D807A7B7DF7" name="X82842D807A7B7DF7"></a></p>
<h5>7.4-2 AtlasStringOfProgram</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AtlasStringOfProgram</code>( <var class="Arg">prog</var>[, <var class="Arg">outputnames</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AtlasStringOfProgram</code>( <var class="Arg">prog</var>, <var class="Arg">"mtx"</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a string encoding the straight line program/decision in the format used in <strong class="pkg">ATLAS</strong> files.</p>
<p>For a straight line program or straight line decision <var class="Arg">prog</var> (see <code class="func">IsStraightLineProgram</code> (<a href="../../../doc/ref/chap37.html#X7F69FF3F7C6694CB"><span class="RefLink">Reference: IsStraightLineProgram</span></a>) and <code class="func">IsStraightLineDecision</code> (<a href="chap6.html#X8787E2EC7DB85A89"><span class="RefLink">6.1-1</span></a>)), this function returns a string describing the input format of an equivalent straight line program or straight line decision as used in the data files, that is, the lines are of the form described in <code class="func">ScanStraightLineProgram</code> (<a href="chap7.html#X7D6617E47B013A37"><span class="RefLink">7.4-1</span></a>).</p>
<p>A list of strings that is given as the optional second argument <var class="Arg">outputnames</var> is interpreted as the class names corresponding to the outputs; this argument has the effect that appropriate <code class="code">echo</code> statements appear in the result string.</p>
<p>If the string <code class="code">"mtx"</code> is given as the second argument then the result has the format used in the <code class="code">C</code>-<strong class="pkg">MeatAxe</strong> (see <a href="chapBib.html#biBCMeatAxe">[Rin]</a>) rather than the format described for <code class="func">ScanStraightLineProgram</code> (<a href="chap7.html#X7D6617E47B013A37"><span class="RefLink">7.4-1</span></a>). (Note that the <code class="code">C</code>-<strong class="pkg">MeatAxe</strong> format does not make sense if the argument <var class="Arg">outputnames</var> is given, and that this format does not support <code class="code">inp</code> and <code class="code">oup</code> statements.)</p>
<p>The argument <var class="Arg">prog</var> must not be a black box program (see <code class="func">IsBBoxProgram</code> (<a href="chap6.html#X87CAF2DE870D0E3B"><span class="RefLink">6.2-1</span></a>)).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">str:= "inp 2\nmu 1 2 3\nmu 3 1 2\niv 2 1\noup 2 1 2";;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">prg:= ScanStraightLineProgram( str, "string" );</span>
rec( program := <straight line program> )
<span class="GAPprompt">gap></span> <span class="GAPinput">prg:= prg.program;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( prg );</span>
# input:
r:= [ g1, g2 ];
# program:
r[3]:= r[1]*r[2];
r[2]:= r[3]*r[1];
r[1]:= r[2]^-1;
# return values:
[ r[1], r[2] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">StringOfResultOfStraightLineProgram( prg, [ "a", "b" ] );</span>
"[ (aba)^-1, aba ]"
<span class="GAPprompt">gap></span> <span class="GAPinput">AtlasStringOfProgram( prg );</span>
"inp 2\nmu 1 2 3\nmu 3 1 2\niv 2 1\noup 2\n"
<span class="GAPprompt">gap></span> <span class="GAPinput">prg:= StraightLineProgram( "(a^2b^3)^-1", [ "a", "b" ] );</span>
<straight line program>
<span class="GAPprompt">gap></span> <span class="GAPinput">Print( AtlasStringOfProgram( prg ) );</span>
inp 2
pwr 2 1 4
pwr 3 2 5
mu 4 5 3
iv 3 4
oup 1 4
<span class="GAPprompt">gap></span> <span class="GAPinput">prg:= StraightLineProgram( [ [2,3], [ [3,1,1,4], [1,2,3,1] ] ], 2 );</span>
<straight line program>
<span class="GAPprompt">gap></span> <span class="GAPinput">Print( AtlasStringOfProgram( prg ) );</span>
inp 2
pwr 3 2 3
pwr 4 1 5
mu 3 5 4
pwr 2 1 6
mu 6 3 5
oup 2 4 5
<span class="GAPprompt">gap></span> <span class="GAPinput">Print( AtlasStringOfProgram( prg, "mtx" ) );</span>
# inputs are expected in 1 2
zsm pwr3 2 3
zsm pwr4 1 5
zmu 3 5 4
zsm pwr2 1 6
zmu 6 3 5
echo "outputs are in 4 5"
<span class="GAPprompt">gap></span> <span class="GAPinput">str:= "inp 2\nchor 1 2\nchor 2 3\nmu 1 2 3\nchor 3 5";;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">prg:= ScanStraightLineDecision( str );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AtlasStringOfProgram( prg.program );</span>
"inp 2\nchor 1 2\nchor 2 3\nmu 1 2 3\nchor 3 5\n"
</pre></div>
<p><a id="X809898027EFDA56E" name="X809898027EFDA56E"></a></p>
<h4>7.5 <span class="Heading">Data Types Used in the <strong class="pkg">AtlasRep</strong> Package</span></h4>
<p>Each representation or program that is administrated by the <strong class="pkg">AtlasRep</strong> package belongs to a unique <em>data type</em>. Informally, examples of data types are <q>permutation representation</q>, <q>matrix representation over the integers</q>, or <q>straight line program for computing class representatives</q>.</p>
<p>The idea is that for each data type, there can be</p>
<ul>
<li><p>a column of its own in the output produced by <code class="func">DisplayAtlasInfo</code> (<a href="chap3.html#X79DACFFA7E2D1A99"><span class="RefLink">3.5-1</span></a>) when called without arguments or with only argument a list of group names,</p>
</li>
<li><p>a line format of its own for the output produced by <code class="func">DisplayAtlasInfo</code> (<a href="chap3.html#X79DACFFA7E2D1A99"><span class="RefLink">3.5-1</span></a>) when called with first argument a group name,</p>
</li>
<li><p>an input format of its own for <code class="func">AtlasProgram</code> (<a href="chap3.html#X801F2E657C8A79ED"><span class="RefLink">3.5-4</span></a>),</p>
</li>
<li><p>an input format of its own for <code class="func">OneAtlasGeneratingSetInfo</code> (<a href="chap3.html#X841478AB7CD06D44"><span class="RefLink">3.5-6</span></a>), and</p>
</li>
<li><p>specific tests for the data of this data type; these functions are used by the global tests described in Section <a href="chap7.html#X79C5F2267ACCF52A"><span class="RefLink">7.9</span></a>.</p>
</li>
</ul>
<p>Formally, a data type is defined by a record whose components are used by the interface functions. The details are described in the following.</p>
<p><a id="X836AA4EA8346BE5B" name="X836AA4EA8346BE5B"></a></p>
<h5>7.5-1 AGR.DeclareDataType</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AGR.DeclareDataType</code>( <var class="Arg">kind</var>, <var class="Arg">name</var>, <var class="Arg">record</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Let <var class="Arg">kind</var> be one of the strings <code class="code">"rep"</code> or <code class="code">"prg"</code>, and <var class="Arg">record</var> be a record. If <var class="Arg">kind</var> is <code class="code">"rep"</code> then <code class="func">AGR.DeclareDataType</code> declares a new data type of representations, if <var class="Arg">kind</var> is <code class="code">"prg"</code> then it declares a new data type of programs. The string <var class="Arg">name</var> is the name of the type, for example <code class="code">"perm"</code>, <code class="code">"matff"</code>, or <code class="code">"classes"</code>. <strong class="pkg">AtlasRep</strong> stores the data for each group internally in a record whose component <var class="Arg">name</var> holds the list of the data about the type with this name.</p>
<p><em>Mandatory components</em> of <var class="Arg">record</var> are</p>
<dl>
<dt><strong class="Mark"><code class="code">FilenameFormat</code></strong></dt>
<dd><p>This defines the format of the filenames containing data of the type in question. The value must be a list that can be used as the second argument of <code class="func">AGR.ParseFilenameFormat</code> (<a href="chap7.html#X8486CCB181FC99A3"><span class="RefLink">7.6-1</span></a>), such that only filenames of the type in question match. (It is not checked whether this <q>detection function</q> matches exactly one type, so declaring a new type needs care.)</p>
</dd>
<dt><strong class="Mark"><code class="code">AddFileInfo</code></strong></dt>
<dd><p>This defines the information stored in the table of contents for the data of the type. The value must be a function that takes three arguments (the current list of data for the type and the given group, a list returned by <code class="func">AGR.ParseFilenameFormat</code> (<a href="chap7.html#X8486CCB181FC99A3"><span class="RefLink">7.6-1</span></a>) for the given type, and a filename). This function adds the necessary parts of the data entry to the list, and returns <code class="keyw">true</code> if the data belongs to the type, otherwise <code class="keyw">false</code> is returned; note that the latter case occurs if the filename matches the format description but additional conditions on the parts of the name are not satisfied (for example integer parts may be required to be positive or prime powers).</p>
</dd>
<dt><strong class="Mark"><code class="code">ReadAndInterpretDefault</code></strong></dt>
<dd><p>This is the function that does the work for the default <code class="code">contents</code> value of the <code class="code">accessFunctions</code> component of <code class="func">AtlasOfGroupRepresentationsInfo</code> (<a href="chap7.html#X7BEC94A6781E126E"><span class="RefLink">7.1-5</span></a>), see Section <a href="chap7.html#X81C5B5E78215169D"><span class="RefLink">7.2</span></a>. This function must take a path and return the <strong class="pkg">GAP</strong> object given by this file.</p>
</dd>
<dt><strong class="Mark"><code class="code">AddDescribingComponents</code> (for <code class="code">rep</code> only)</strong></dt>
<dd><p>This function takes two arguments, a record (that will be returned by <code class="func">AtlasGenerators</code> (<a href="chap3.html#X7D1CCCF8852DFF39"><span class="RefLink">3.5-3</span></a>), <code class="func">OneAtlasGeneratingSetInfo</code> (<a href="chap3.html#X841478AB7CD06D44"><span class="RefLink">3.5-6</span></a>), or <code class="func">AllAtlasGeneratingSetInfos</code> (<a href="chap3.html#X84C2D76482E60E42"><span class="RefLink">3.5-7</span></a>)) and the type record <var class="Arg">record</var>. It sets the components <code class="code">p</code>, <code class="code">dim</code>, <code class="code">id</code>, and <code class="code">ring</code> that are promised for return values of the abovementioned three functions.</p>
</dd>
<dt><strong class="Mark"><code class="code">DisplayGroup</code> (for <code class="code">rep</code> only)</strong></dt>
<dd><p>This defines the format of the lines printed by <code class="func">DisplayAtlasInfo</code> (<a href="chap3.html#X79DACFFA7E2D1A99"><span class="RefLink">3.5-1</span></a>) for a given group. The value must be a function that takes a list as returned by the function given in the component <code class="code">AddFileInfo</code>, and returns the string to be printed for the representation in question.</p>
</dd>
</dl>
<p><em>Optional components</em> of <var class="Arg">record</var> are</p>
<dl>
<dt><strong class="Mark"><code class="code">DisplayOverviewInfo</code></strong></dt>
<dd><p>This is used to introduce a new column in the output of <code class="func">DisplayAtlasInfo</code> (<a href="chap3.html#X79DACFFA7E2D1A99"><span class="RefLink">3.5-1</span></a>) when this is called without arguments or with a list of group names as its only argument. The value must be a list of length three, containing at its first position a string used as the header of the column, at its second position one of the strings <code class="code">"r"</code> or <code class="code">"l"</code>, denoting right or left aligned column entries, and at its third position a function that takes two arguments (a list of tables of contents of the <strong class="pkg">AtlasRep</strong> package and a group name), and returns a list of length two, containing the string to be printed as the column value and <code class="keyw">true</code> or <code class="keyw">false</code>, depending on whether private data is involved or not. (The default is <code class="keyw">fail</code>, indicating that no new column shall be printed.)</p>
</dd>
<dt><strong class="Mark"><code class="code">DisplayPRG</code> (for <code class="code">prg</code> only)</strong></dt>
<dd><p>This is used in <code class="func">DisplayAtlasInfo</code> (<a href="chap3.html#X79DACFFA7E2D1A99"><span class="RefLink">3.5-1</span></a>) for <strong class="pkg">ATLAS</strong> programs. The value must be a function that takes four arguments (a list of tables of contents to examine, a list containing the <strong class="pkg">GAP</strong> name and the <strong class="pkg">ATLAS</strong> name of the given group, a list of integers or <code class="keyw">true</code> for the required standardization, and a list of all available standardizations), and returns the list of lines (strings) to be printed as the information about the available programs of the current type and for the given group. (The default is to return an empty list.)</p>
</dd>
<dt><strong class="Mark"><code class="code">AccessGroupCondition</code> (for <code class="code">rep</code> only)</strong></dt>
<dd><p>This is used in <code class="func">DisplayAtlasInfo</code> (<a href="chap3.html#X79DACFFA7E2D1A99"><span class="RefLink">3.5-1</span></a>) and <code class="func">OneAtlasGeneratingSetInfo</code> (<a href="chap3.html#X841478AB7CD06D44"><span class="RefLink">3.5-6</span></a>). The value must be a function that takes two arguments (a list as returned by <code class="func">OneAtlasGeneratingSetInfo</code> (<a href="chap3.html#X841478AB7CD06D44"><span class="RefLink">3.5-6</span></a>), and a list of conditions), and returns <code class="keyw">true</code> or <code class="keyw">false</code>, depending on whether the first argument satisfies the conditions. (The default value is <code class="func">ReturnFalse</code> (<a href="../../../doc/ref/chap5.html#X7C131FB17D7518FC"><span class="RefLink">Reference: ReturnFalse</span></a>).)</p>
<p>The function must support conditions such as <code class="code">[ IsPermGroup, true ]</code> and <code class="code">[ NrMovedPoints, [ 5, 6 ] ]</code>, in general a list of functions followed by a prescribed value, a list of prescribed values, another (unary) function, or the string <code class="code">"minimal"</code>. For an overview of the interesting functions, see <code class="func">DisplayAtlasInfo</code> (<a href="chap3.html#X79DACFFA7E2D1A99"><span class="RefLink">3.5-1</span></a>).</p>
</dd>
<dt><strong class="Mark"><code class="code">AccessPRG</code> (for <code class="code">prg</code> only)</strong></dt>
<dd><p>This is used in <code class="func">AtlasProgram</code> (<a href="chap3.html#X801F2E657C8A79ED"><span class="RefLink">3.5-4</span></a>). The value must be a function that takes four arguments (the current table of contents, the group name, an integer or a list of integers or <code class="keyw">true</code> for the required standardization, and a list of conditions given by the optional arguments of <code class="func">AtlasProgram</code> (<a href="chap3.html#X801F2E657C8A79ED"><span class="RefLink">3.5-4</span></a>)), and returns either <code class="keyw">fail</code> or a list that together with the group name forms the identifier of a program that matches the conditions. (The default value is <code class="func">ReturnFail</code> (<a href="../../../doc/ref/chap5.html#X7A0994DE7C258E55"><span class="RefLink">Reference: ReturnFail</span></a>).)</p>
</dd>
<dt><strong class="Mark"><code class="code">AtlasProgram</code> (for <code class="code">prg</code> only)</strong></dt>
<dd><p>This is used in <code class="func">AtlasProgram</code> (<a href="chap3.html#X801F2E657C8A79ED"><span class="RefLink">3.5-4</span></a>) to create the result value from the identifier. (The default value is <code class="code">AtlasProgramDefault</code>, which works whenever the second entry of the identifier is the filename; this is not the case for example if the program is the composition of several programs.)</p>
</dd>
<dt><strong class="Mark"><code class="code">AtlasProgramInfo</code> (for <code class="code">prg</code> only)</strong></dt>
<dd><p>This is used in <code class="func">AtlasProgramInfo</code> (<a href="chap3.html#X83DFD8967E6BC831"><span class="RefLink">3.5-5</span></a>) to create the result value from the identifier. (The default value is <code class="code">AtlasProgramDefault</code>.)</p>
</dd>
<dt><strong class="Mark"><code class="code">TOCEntryString</code></strong></dt>
<dd><p>This is used in <code class="func">StringOfAtlasTableOfContents</code> (<a href="chap5.html#X81C5440983E47DBD"><span class="RefLink">5.1-3</span></a>). The value must be a function that takes two or three arguments (the name <var class="Arg">name</var> of the type, a list as returned by <code class="func">AGR.ParseFilenameFormat</code> (<a href="chap7.html#X8486CCB181FC99A3"><span class="RefLink">7.6-1</span></a>), and optionally a string that indicates the <q>remote</q> format) and returns a string that describes the appropriate data format. (The default value is <code class="code">TOCEntryStringDefault</code>.)</p>
</dd>
<dt><strong class="Mark"><code class="code">PostprocessFileInfo</code></strong></dt>
<dd><p>This is used in the construction of a table of contents for testing or rearranging the data of the current table of contents. The value must be a function that takes two arguments, the table of contents record and the record in it that belongs to one fixed group. (The default function does nothing.)</p>
</dd>
<dt><strong class="Mark"><code class="code">SortTOCEntries</code></strong></dt>
<dd><p>This is used in the construction of a table of contents for sorting the entries after they have been added and after the value of the component <code class="code">PostprocessFileInfo</code> has been called. The value must be a function that takes a list as returned by <code class="func">AGR.ParseFilenameFormat</code> (<a href="chap7.html#X8486CCB181FC99A3"><span class="RefLink">7.6-1</span></a>), and returns the sorting key. (There is no default value, which means that no sorting is needed.)</p>
</dd>
<dt><strong class="Mark"><code class="code">TestFileHeaders</code> (for <code class="code">rep</code> only)</strong></dt>
<dd><p>This is used in the function <code class="code">AGR.Test.FileHeaders</code>. The value must be a function that takes the same four arguments as <code class="func">AGR.FileContents</code> (<a href="chap7.html#X78AB92DB7C2CAB6E"><span class="RefLink">7.6-2</span></a>), except that the third argument is a list as returned by <code class="func">AGR.ParseFilenameFormat</code> (<a href="chap7.html#X8486CCB181FC99A3"><span class="RefLink">7.6-1</span></a>). (The default value is <code class="func">ReturnTrue</code> (<a href="../../../doc/ref/chap5.html#X7DB422A2876CCC4D"><span class="RefLink">Reference: ReturnTrue</span></a>).)</p>
</dd>
<dt><strong class="Mark"><code class="code">TestFiles</code> (for <code class="code">rep</code> only)</strong></dt>
<dd><p>This is used in the function <code class="code">AGR.Test.Files</code>. The format of the value and the default are the same as for the component <code class="code">TestFileHeaders</code>.</p>
</dd>
<dt><strong class="Mark"><code class="code">TestWords</code> (for <code class="code">prg</code> only)</strong></dt>
<dd><p>This is used in the function <code class="code">AGR.Test.Words</code>. The value must be a function that takes five arguments where the first four are the same arguments as for <code class="func">AGR.FileContents</code> (<a href="chap7.html#X78AB92DB7C2CAB6E"><span class="RefLink">7.6-2</span></a>), except that the fifth argument is <code class="keyw">true</code> or <code class="keyw">false</code>, indicating verbose mode or not.</p>
</dd>
</dl>
<p><a id="X7A86627B80980F61" name="X7A86627B80980F61"></a></p>
<h4>7.6 <span class="Heading">Filenames Used in the <strong class="pkg">AtlasRep</strong> Package</span></h4>
<p><strong class="pkg">AtlasRep</strong> expects that the filename of each data file describes the contents of the file. This section lists the definitions of the supported structures of filenames.</p>
<p>Each filename consists of two parts, separated by a minus sign <code class="code">-</code>. The first part is always of the form <span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span>, where the integer <span class="SimpleMath">i</span> denotes the <span class="SimpleMath">i</span>-th set of standard generators for the group <span class="SimpleMath">G</span>, say, with <strong class="pkg">ATLAS</strong>-file name <span class="SimpleMath">groupname</span> (see <a href="chap3.html#X81BF52FC7B8C08D4"><span class="RefLink">3.2</span></a>). The translations of the name <span class="SimpleMath">groupname</span> to the name(s) used within <strong class="pkg">GAP</strong> is given by the component <code class="code">GAPnames</code> of <code class="func">AtlasOfGroupRepresentationsInfo</code> (<a href="chap7.html#X7BEC94A6781E126E"><span class="RefLink">7.1-5</span></a>).</p>
<p>The names of files that contain straight line programs or straight line decisions have one of the following forms. In each of these cases, the suffix <code class="code">W</code><span class="SimpleMath">n</span> means that <span class="SimpleMath">n</span> is the version number of the program.</p>
<dl>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-cycW</code><span class="SimpleMath">n</span></strong></dt>
<dd><p>In this case, the file contains a straight line program that returns a list of representatives of generators of maximally cyclic subgroups of <span class="SimpleMath">G</span>. An example is <code class="code">Co1G1-cycW1</code>.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-cclsW</code><span class="SimpleMath">n</span></strong></dt>
<dd><p>In this case, the file contains a straight line program that returns a list of conjugacy class representatives of <span class="SimpleMath">G</span>. An example is <code class="code">RuG1-cclsW1</code>.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">cycW</code><span class="SimpleMath">n</span><code class="code">-cclsW</code><span class="SimpleMath">m</span></strong></dt>
<dd><p>In this case, the file contains a straight line program that takes the return value of the program in the file <span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-cycW</code><span class="SimpleMath">n</span> (see above), and returns a list of conjugacy class representatives of <span class="SimpleMath">G</span>. An example is <code class="code">M11G1cycW1-cclsW1</code>.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-max</code><span class="SimpleMath">k</span><code class="code">W</code><span class="SimpleMath">n</span></strong></dt>
<dd><p>In this case, the file contains a straight line program that takes generators of <span class="SimpleMath">G</span> w. r. t. the <span class="SimpleMath">i</span>-th set of standard generators, and returns a list of generators (in general <em>not</em> standard generators) for a subgroup <span class="SimpleMath">U</span> in the <span class="SimpleMath">k</span>-th class of maximal subgroups of <span class="SimpleMath">G</span>. An example is <code class="code">J1G1-max7W1</code>.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">max</code><span class="SimpleMath">k</span><code class="code">W</code><span class="SimpleMath">n</span><code class="code">-</code><span class="SimpleMath">subgroupname</span><code class="code">G</code><span class="SimpleMath">j</span><code class="code">W</code><span class="SimpleMath">m</span></strong></dt>
<dd><p>In this case, the file contains a straight line program that takes the return value of the program in the file <span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-max</code><span class="SimpleMath">k</span><code class="code">W</code><span class="SimpleMath">n</span> (see above), which are generators for a group <span class="SimpleMath">U</span>, say; <span class="SimpleMath">subgroupname</span> is a name for <span class="SimpleMath">U</span>, and the return value is a list of standard generators for <span class="SimpleMath">U</span>, w. r. t. the <span class="SimpleMath">j</span>-th set of standard generators. (Of course this implies that the groups in the <span class="SimpleMath">k</span>-th class of maximal subgroups of <span class="SimpleMath">G</span> are isomorphic to the group with name <span class="SimpleMath">subgroupname</span>.) An example is <code class="code">J1G1max1W1-L211G1W1</code>; the first class of maximal subgroups of the Janko group <span class="SimpleMath">J_1</span> consists of groups isomorphic to the linear group <span class="SimpleMath">L_2(11)</span>, for which standard generators are defined.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-a</code><span class="SimpleMath">outname</span><code class="code">W</code><span class="SimpleMath">n</span></strong></dt>
<dd><p>In this case, the file contains a straight line program that takes generators of <span class="SimpleMath">G</span> w. r. t. the <span class="SimpleMath">i</span>-th set of standard generators, and returns the list of their images under the outer automorphism <span class="SimpleMath">α</span> of <span class="SimpleMath">G</span> given by the name <span class="SimpleMath">outname</span>; if this name is empty then <span class="SimpleMath">α</span> is the unique nontrivial outer automorphism of <span class="SimpleMath">G</span>; if it is a positive integer <span class="SimpleMath">k</span> then <span class="SimpleMath">α</span> is a generator of the unique cyclic order <span class="SimpleMath">k</span> subgroup of the outer automorphism group of <span class="SimpleMath">G</span>; if it is of the form <code class="code">2_1</code> or <code class="code">2a</code>, <code class="code">4_2</code> or <code class="code">4b</code>, <code class="code">3_3</code> or <code class="code">3c</code> <span class="SimpleMath">...</span> then <span class="SimpleMath">α</span> generates the cyclic group of automorphisms induced on <span class="SimpleMath">G</span> by <span class="SimpleMath">G.2_1</span>, <span class="SimpleMath">G.4_2</span>, <span class="SimpleMath">G.3_3</span> <span class="SimpleMath">...</span>; finally, if it is of the form <span class="SimpleMath">k</span><code class="code">p</code><span class="SimpleMath">d</span>, with <span class="SimpleMath">k</span> one of the above forms and <span class="SimpleMath">d</span> an integer then <span class="SimpleMath">d</span> denotes the number of dashes appended to the automorphism described by <span class="SimpleMath">k</span>; if <span class="SimpleMath">d = 1</span> then <span class="SimpleMath">d</span> can be omitted. Examples are <code class="code">A5G1-aW1</code>, <code class="code">L34G1-a2_1W1</code>, <code class="code">U43G1-a2_3pW1</code>, and <code class="code">O8p3G1-a2_2p5W1</code>; these file names describe the outer order <span class="SimpleMath">2</span> automorphism of <span class="SimpleMath">A_5</span> (induced by the action of <span class="SimpleMath">S_5</span>) and the order <span class="SimpleMath">2</span> automorphisms of <span class="SimpleMath">L_3(4)</span>, <span class="SimpleMath">U_4(3)</span>, and <span class="SimpleMath">O_8^+(3)</span> induced by the actions of <span class="SimpleMath">L_3(4).2_1</span>, <span class="SimpleMath">U_4(3).2_2^'</span>, and <span class="SimpleMath">O_8^+(3).2_2^{'''''}</span>, respectively.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-ker</code><span class="SimpleMath">factgroupname</span><code class="code">W</code><span class="SimpleMath">n</span></strong></dt>
<dd><p>In this case, the file contains a straight line program that takes generators of <span class="SimpleMath">G</span> w. r. t. the <span class="SimpleMath">i</span>-th set of standard generators, and returns generators of the kernel of an epimorphism that maps <span class="SimpleMath">G</span> to a group with <strong class="pkg">ATLAS</strong>-file name <span class="SimpleMath">factgroupname</span>. An example is <code class="code">2A5G1-kerA5W1</code>.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-G</code><span class="SimpleMath">j</span><code class="code">W</code><span class="SimpleMath">n</span></strong></dt>
<dd><p>In this case, the file contains a straight line program that takes generators of <span class="SimpleMath">G</span> w. r. t. the <span class="SimpleMath">i</span>-th set of standard generators, and returns standard generators of <span class="SimpleMath">G</span> w. r. t. the <span class="SimpleMath">j</span>-th set of standard generators. An example is <code class="code">L35G1-G2W1</code>.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-check</code><span class="SimpleMath">n</span></strong></dt>
<dd><p>In this case, the file contains a straight line decision that takes generators of <span class="SimpleMath">G</span>, and returns <code class="keyw">true</code> if these generators are standard generators w. r. t. the <span class="SimpleMath">i</span>-th standardization, and <code class="keyw">false</code> otherwise.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-P</code><span class="SimpleMath">n</span></strong></dt>
<dd><p>In this case, the file contains a straight line decision that takes some group elements, and returns <code class="keyw">true</code> if these elements are standard generators for <span class="SimpleMath">G</span>, w. r. t. the <span class="SimpleMath">i</span>-th standardization, and <code class="keyw">false</code> otherwise.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-find</code><span class="SimpleMath">n</span></strong></dt>
<dd><p>In this case, the file contains a black box program that takes a group, and returns (if it is successful) a set of standard generators for <span class="SimpleMath">G</span>, w. r. t. the <span class="SimpleMath">i</span>-th standardization.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-X</code><span class="SimpleMath">descr</span><code class="code">W</code><span class="SimpleMath">n</span></strong></dt>
<dd><p>In this case, the file contains a straight line program that takes generators of <span class="SimpleMath">G</span> w. r. t. the <span class="SimpleMath">i</span>-th set of standard generators, and whose return value corresponds to <span class="SimpleMath">descr</span>. This format is used only in private extensions (see Chapter <a href="chap5.html#X7B0718A178BB10CA"><span class="RefLink">5</span></a>), such a script can be accessed with <span class="SimpleMath">descr</span> as the third argument of <code class="func">AtlasProgram</code> (<a href="chap3.html#X801F2E657C8A79ED"><span class="RefLink">3.5-4</span></a>).</p>
</dd>
</dl>
<p>The names of files that contain group generators have one of the following forms. In each of these cases, <span class="SimpleMath">id</span> is a (possibly empty) string that starts with a lowercase alphabet letter (see <code class="func">IsLowerAlphaChar</code> (<a href="../../../doc/ref/chap27.html#X854114A97BAFEAEA"><span class="RefLink">Reference: IsLowerAlphaChar</span></a>)), and <span class="SimpleMath">m</span> is a nonnegative integer, meaning that the generators are written w. r. t. the <span class="SimpleMath">m</span>-th basis (the meaning is defined by the <strong class="pkg">ATLAS</strong> developers).</p>
<dl>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-f</code><span class="SimpleMath">q</span><code class="code">r</code><span class="SimpleMath">dim</span><span class="SimpleMath">id</span><code class="code">B</code><span class="SimpleMath">m</span><code class="code">.m</code><span class="SimpleMath">nr</span></strong></dt>
<dd><p>a file in <strong class="pkg">MeatAxe</strong> text file format containing the <span class="SimpleMath">nr</span>-th generator of a matrix representation over the field with <span class="SimpleMath">q</span> elements, of dimension <span class="SimpleMath">dim</span>. An example is <code class="code">S5G1-f2r4aB0.m1</code>.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-p</code><span class="SimpleMath">n</span><span class="SimpleMath">id</span><code class="code">B</code><span class="SimpleMath">m</span><code class="code">.m</code><span class="SimpleMath">nr</span></strong></dt>
<dd><p>a file in <strong class="pkg">MeatAxe</strong> text file format containing the <span class="SimpleMath">nr</span>-th generator of a permutation representation on <span class="SimpleMath">n</span> points. An example is <code class="code">M11G1-p11B0.m1</code>.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-Ar</code><span class="SimpleMath">dim</span><span class="SimpleMath">id</span><code class="code">B</code><span class="SimpleMath">m</span><code class="code">.g</code></strong></dt>
<dd><p>a <strong class="pkg">GAP</strong> readable file containing all generators of a matrix representation of dimension <span class="SimpleMath">dim</span> over an algebraic number field not specified further. An example is <code class="code">A5G1-Ar3aB0.g</code>.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-Zr</code><span class="SimpleMath">dim</span><span class="SimpleMath">id</span><code class="code">B</code><span class="SimpleMath">m</span>.g</strong></dt>
<dd><p>a <strong class="pkg">GAP</strong> readable file containing all generators of a matrix representation over the integers, of dimension <span class="SimpleMath">dim</span>. An example is <code class="code">A5G1-Zr4B0.g</code>.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-Hr</code><span class="SimpleMath">dim</span><span class="SimpleMath">id</span><code class="code">B</code><span class="SimpleMath">m</span><code class="code">.g</code></strong></dt>
<dd><p>a <strong class="pkg">GAP</strong> readable file containing all generators of a matrix representation over a quaternion algebra over an algebraic number field, of dimension <span class="SimpleMath">dim</span>. An example is <code class="code">2A6G1-Hr2aB0.g</code>.</p>
</dd>
<dt><strong class="Mark"><span class="SimpleMath">groupname</span><code class="code">G</code><span class="SimpleMath">i</span><code class="code">-Z</code><span class="SimpleMath">n</span><code class="code">r</code><span class="SimpleMath">dim</span><span class="SimpleMath">id</span><code class="code">B</code><span class="SimpleMath">m</span><code class="code">.g</code></strong></dt>
<dd><p>a <strong class="pkg">GAP</strong> readable file containing all generators of a matrix representation of dimension <span class="SimpleMath">dim</span> over the ring of integers mod <span class="SimpleMath">n</span>. An example is <code class="code">2A8G1-Z4r4aB0.g</code>.</p>
</dd>
</dl>
<p><a id="X8486CCB181FC99A3" name="X8486CCB181FC99A3"></a></p>
<h5>7.6-1 AGR.ParseFilenameFormat</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AGR.ParseFilenameFormat</code>( <var class="Arg">string</var>, <var class="Arg">format</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: a list of strings and integers if <var class="Arg">string</var> matches <var class="Arg">format</var>, and <code class="keyw">fail</code> otherwise.</p>
<p>Let <var class="Arg">string</var> be a filename, and <var class="Arg">format</var> be a list <span class="SimpleMath">[ [ c_1, c_2, ..., c_n ], [ f_1, f_2, ..., f_n ] ]</span> such that each entry <span class="SimpleMath">c_i</span> is a list of strings and of functions that take a character as their argument and return <code class="file">true</code> or <code class="file">false</code>, and such that each entry <span class="SimpleMath">f_i</span> is a function for parsing a filename, such as the currently undocumented functions <code class="code">ParseForwards</code> and <code class="code">ParseBackwards</code>.</p>
<p><code class="func">AGR.ParseFilenameFormat</code> returns a list of strings and integers such that the concatenation of their <code class="func">String</code> (<a href="../../../doc/ref/chap27.html#X81FB5BE27903EC32"><span class="RefLink">Reference: String</span></a>) values yields <var class="Arg">string</var> if <var class="Arg">string</var> matches <var class="Arg">format</var>, and <code class="keyw">fail</code> otherwise. Matching is defined as follows. Splitting <var class="Arg">string</var> at each minus character (<code class="code">-</code>) yields <span class="SimpleMath">m</span> parts <span class="SimpleMath">s_1, s_2, ..., s_m</span>. The string <var class="Arg">string</var> matches <var class="Arg">format</var> if <span class="SimpleMath">s_i</span> matches the conditions in <span class="SimpleMath">c_i</span>, for <span class="SimpleMath">1 ≤ i ≤ n</span>, in the sense that applying <span class="SimpleMath">f_i</span> to <span class="SimpleMath">s_i</span> and <span class="SimpleMath">c_i</span> yields a non-<code class="keyw">fail</code> result.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">format:= [ [ [ IsChar, "G", IsDigitChar ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ "p", IsDigitChar, AGR.IsLowerAlphaOrDigitChar,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> "B", IsDigitChar, ".m", IsDigitChar ] ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ ParseBackwards, ParseForwards ] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AGR.ParseFilenameFormat( "A6G1-p10B0.m1", format );</span>
[ "A6", "G", 1, "p", 10, "", "B", 0, ".m", 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">AGR.ParseFilenameFormat( "A6G1-p15aB0.m1", format );</span>
[ "A6", "G", 1, "p", 15, "a", "B", 0, ".m", 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">AGR.ParseFilenameFormat( "A6G1-f2r16B0.m1", format );</span>
fail
</pre></div>
<p><a id="X78AB92DB7C2CAB6E" name="X78AB92DB7C2CAB6E"></a></p>
<h5>7.6-2 AGR.FileContents</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AGR.FileContents</code>( <var class="Arg">files</var>, <var class="Arg">type</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Returns: the <strong class="pkg">GAP</strong> object obtained from reading and interpreting the file(s) given by <var class="Arg">files</var>.</p>
<p>Let <var class="Arg">files</var> be a list of pairs of the form <code class="code">[ dirname, filename ]</code>, where <code class="code">dirname</code> and <code class="code">filename</code> are strings, and let <var class="Arg">type</var> be a data type (see <code class="func">AGR.DeclareDataType</code> (<a href="chap7.html#X836AA4EA8346BE5B"><span class="RefLink">7.5-1</span></a>)). Each <code class="code">dirname</code> must be one of <code class="code">"datagens"</code>, <code class="code">"dataword"</code>, or the <code class="code">dirid</code> value of a data extension (see <code class="func">AtlasOfGroupRepresentationsNotifyData</code> (<a href="chap5.html#X81B5FA0578257653"><span class="RefLink">5.1-1</span></a>)). If the contents of each of the files in question is accessible and their data belong to the data type <code class="code">type</code> then <code class="func">AGR.FileContents</code> returns the contents of the files; otherwise <code class="keyw">fail</code> is returned.</p>
<p>Note that if some file is already stored in the <var class="Arg">dirname</var> directory then <code class="func">AGR.FileContents</code> does <em>not</em> check whether the relevant table of contents actually contains <var class="Arg">filename</var>.</p>
<p><a id="X7CCA3DE97E756F01" name="X7CCA3DE97E756F01"></a></p>
<h4>7.7 <span class="Heading">The record component <code class="code">identifier</code> used by the <strong class="pkg">AtlasRep</strong> Package</span></h4>
<p>The functions <code class="func">AtlasGenerators</code> (<a href="chap3.html#X7D1CCCF8852DFF39"><span class="RefLink">3.5-3</span></a>), <code class="func">AtlasProgram</code> (<a href="chap3.html#X801F2E657C8A79ED"><span class="RefLink">3.5-4</span></a>), <code class="func">AtlasProgramInfo</code> (<a href="chap3.html#X83DFD8967E6BC831"><span class="RefLink">3.5-5</span></a>), <code class="func">OneAtlasGeneratingSetInfo</code> (<a href="chap3.html#X841478AB7CD06D44"><span class="RefLink">3.5-6</span></a>), and <code class="func">AllAtlasGeneratingSetInfos</code> (<a href="chap3.html#X84C2D76482E60E42"><span class="RefLink">3.5-7</span></a>) return records which have a component <code class="code">identifier</code>. The value of this component describes the record in the sense that one can reconstruct the whole record from it, and the <code class="code">identifier</code> value can be used as an input for <code class="func">AtlasGenerators</code> (<a href="chap3.html#X7D1CCCF8852DFF39"><span class="RefLink">3.5-3</span></a>), <code class="func">AtlasProgram</code> (<a href="chap3.html#X801F2E657C8A79ED"><span class="RefLink">3.5-4</span></a>), <code class="func">AtlasProgramInfo</code> (<a href="chap3.html#X83DFD8967E6BC831"><span class="RefLink">3.5-5</span></a>), <code class="func">AtlasGroup</code> (<a href="chap3.html#X80AABEE783363B70"><span class="RefLink">3.5-8</span></a>), and <code class="func">AtlasSubgroup</code> (<a href="chap3.html#X7A3E460C82B3D9A3"><span class="RefLink">3.5-9</span></a>).</p>
<p>The <code class="code">identifier</code> component has the following format.</p>
<ul>
<li><p>For records describing representations, it is a list of the form <code class="code">[ gapname, files, std, info ]</code>.</p>
</li>
<li><p>For records describing straight line programs and straight line decisions, it is a list of the form <code class="code">[ gapname, files, std ]</code>.</p>
</li>
</ul>
<p>Here <code class="code">gapname</code> is the <strong class="pkg">GAP</strong> name of the group in question, <code class="code">files</code> defines the data files, <code class="code">std</code> is the standardization of its generators, and <code class="code">info</code> is some information that depends on the type of the representation, for example the number of moved points in the case of a permutation representation.</p>
<p>The <code class="code">files</code> entry has one of the following formats:</p>
<ul>
<li><p>a string, in the case that exactly one file is needed that does not belong to a private extension; an example of such an <code class="code">identifier</code> value is <code class="code">[ "J1", "J1G1-cycW1", 1 ]</code></p>
</li>
<li><p>a list whose entries are strings (which refer to files from the core part of the database) and pairs of the form <code class="code">[ tocid, file ]</code> (which refer to files from the extension given by <code class="code">tocid</code>); examples of <code class="code">identifier</code> values are <code class="code">[ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ]</code>, <code class="code">[ "2.M12", [ [ "mfer", "2M12G1-cclsW1" ] ], 1 ]</code>, <code class="code">[ "2.M12", [ "M12G1-max1W1", [ "internal", "2M12G1-kerM12W1" ] ], 1 ]</code>, <code class="code">[ "2.M12", [ [ "mfer", "2M12G1-p24bB0.m1" ], [ "mfer", "2M12G1-p24bB0.m2" ] ], 1, 24 ]</code>.</p>
</li>
</ul>
<p>Up to version 1.5 of the <strong class="pkg">AtlasRep</strong> package, a different <code class="code">identifier</code> format was used for files from extensions of the database. Namely, the first entry of the list was a pair <code class="code">[ tocid, groupname ]</code>, and the second entry was either a string or a list of strings. Note that with that old format, it was not possible to describe a combination of several files from different sources (core part and extension, or different extensions). The function <code class="func">AtlasRepIdentifier</code> (<a href="chap7.html#X81685FC979BC3FB8"><span class="RefLink">7.7-1</span></a>) can be used to convert between the two formats.</p>
<p><a id="X81685FC979BC3FB8" name="X81685FC979BC3FB8"></a></p>
<h5>7.7-1 <span class="Heading">AtlasRepIdentifier</span></h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AtlasRepIdentifier</code>( <var class="Arg">oldid</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AtlasRepIdentifier</code>( <var class="Arg">id</var>, <var class="Arg">"old"</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>This function converts between the <q>old format</q> (the one used up to version 1.5.1 of the package) and the <q>new format</q> (the one used since version 2.0) of the <code class="code">identifier</code> component of the records returned by <strong class="pkg">AtlasRep</strong> functions. Note that the two formats differ only for <code class="code">identifier</code> components that describe data from non-core parts of the database.</p>
<p>If the only argument is a list <var class="Arg">oldid</var> that is an <code class="code">identifier</code> in old format then the function returns the corresponding <code class="code">identifier</code> in new format. If there are two arguments, a list <var class="Arg">id</var> that is an <code class="code">identifier</code> in new format and the string <var class="Arg">"old"</var>, then the function returns the corresponding <code class="code">identifier</code> in old format if this is possible, and <code class="keyw">fail</code> otherwise.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">id:= [ "A5", [ "A5G1-p5B0.m1", "A5G1-p5B0.m2" ], 1, 5 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AtlasRepIdentifier( id ) = id;</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">id:= [ "L2(8)", "L28G1-check1", 1, 1 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AtlasRepIdentifier( id ) = id;</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">oldid:= [ [ "priv", "C4" ], [ "C4G1-p4B0.m1" ], 1, 4 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">newid:= AtlasRepIdentifier( oldid );</span>
[ "C4", [ [ "priv", "C4G1-p4B0.m1" ] ], 1, 4 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">oldid = AtlasRepIdentifier( newid, "old" );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">oldid:= [ [ "priv", "C4" ], "C4G1-max1W1", 1 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">newid:= AtlasRepIdentifier( oldid );</span>
[ "C4", [ [ "priv", "C4G1-max1W1" ] ], 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">oldid = AtlasRepIdentifier( newid, "old" );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">oldid:= [ [ "priv", "C4" ], "C4G1-Ar1aB0.g", 1, 1 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">newid:= AtlasRepIdentifier( oldid );</span>
[ "C4", [ [ "priv", "C4G1-Ar1aB0.g" ] ], 1, 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">oldid = AtlasRepIdentifier( newid, "old" );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">oldid:= [ [ "priv", "C4" ], "C4G1-XtestW1", 1 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">newid:= AtlasRepIdentifier( oldid );</span>
[ "C4", [ [ "priv", "C4G1-XtestW1" ] ], 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">oldid = AtlasRepIdentifier( newid, "old" );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">oldid:= [ [ "mfer", "2.M12" ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ "2M12G1-p264aB0.m1", "2M12G1-p264aB0.m2" ], 1, 264 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">newid:= AtlasRepIdentifier( oldid );</span>
[ "2.M12",
[ [ "mfer", "2M12G1-p264aB0.m1" ], [ "mfer", "2M12G1-p264aB0.m2" ] ]
, 1, 264 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">oldid = AtlasRepIdentifier( newid, "old" );</span>
true
</pre></div>
<p><a id="X7B1DECF080AEB806" name="X7B1DECF080AEB806"></a></p>
<h4>7.8 <span class="Heading">The Tables of Contents of the <strong class="pkg">AtlasRep</strong> Package</span></h4>
<p>The list of <strong class="pkg">AtlasRep</strong> data is stored in several <em>tables of contents</em>, which are given essentially by JSON documents, one for the core data and one for each data extension in the sense of Chapter <a href="chap5.html#X7B0718A178BB10CA"><span class="RefLink">5</span></a>. The only exception are data extensions by locally available files in a given directory, where the contents of this directory itself describes the data in question. One can create such a JSON document for the contents of a given local data directory with the function <code class="func">StringOfAtlasTableOfContents</code> (<a href="chap5.html#X81C5440983E47DBD"><span class="RefLink">5.1-3</span></a>).</p>
<p>Here are the administrational functions that are called when a data extension gets notified with <code class="func">AtlasOfGroupRepresentationsNotifyData</code> (<a href="chap5.html#X81B5FA0578257653"><span class="RefLink">5.1-1</span></a>). In each case, <span class="SimpleMath">gapname</span> and <span class="SimpleMath">atlasname</span> denote the <strong class="pkg">GAP</strong> and <strong class="pkg">ATLAS</strong> name of the group in question (see Section <a href="chap3.html#X81BF52FC7B8C08D4"><span class="RefLink">3.2</span></a>), and <span class="SimpleMath">dirid</span> denotes the identifier of the data extension.</p>
<p>The following functions define group names, available representations, and straight line programs.</p>
<dl>
<dt><strong class="Mark"><code class="code">AGR.GNAN( </code><span class="SimpleMath">gapname, atlasname[, dirid]</span><code class="code"> )</code></strong></dt>
<dd><p>Called with two strings <span class="SimpleMath">gapname</span> (the <strong class="pkg">GAP</strong> name of the group) and <span class="SimpleMath">atlasname</span> (the <strong class="pkg">ATLAS</strong> name of the group), <code class="code">AGR.GNAN</code> stores the information in the list <code class="code">AtlasOfGroupRepresentationsInfo.GAPnames</code>, which defines the name mapping between the <strong class="pkg">ATLAS</strong> names and <strong class="pkg">GAP</strong> names of the groups.</p>
<p>An example of a valid call is <code class="code">AGR.GNAN("A5.2","S5")</code>.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.TOC( </code><span class="SimpleMath">typename, filename, crc[, dirid]</span><code class="code"> )</code></strong></dt>
<dd><p><code class="code">AGR.TOC</code> notifies an entry to the <code class="code">TableOfContents.( </code><span class="SimpleMath">dirid</span><code class="code"> )</code> component of <code class="func">AtlasOfGroupRepresentationsInfo</code> (<a href="chap7.html#X7BEC94A6781E126E"><span class="RefLink">7.1-5</span></a>). The string <span class="SimpleMath">typename</span> must be the name of the data type to which the entry belongs, the string <span class="SimpleMath">filename</span> must be the prefix of the data file(s), and <span class="SimpleMath">crc</span> must be a list that contains the checksums of the data files, which are either integers (see <code class="func">CrcFile</code> (<a href="../../../doc/ref/chap9.html#X8241CEAD80415BB9"><span class="RefLink">Reference: CrcFile</span></a>)) or strings (see <code class="code">HexSHA256</code>). In particular, the number of files that are described by the entry equals the length of <span class="SimpleMath">crc</span>.</p>
<p>The optional argument <span class="SimpleMath">dirid</span> is equal to the argument with the same name in the corresponding call of <code class="func">AtlasOfGroupRepresentationsNotifyData</code> (<a href="chap5.html#X81B5FA0578257653"><span class="RefLink">5.1-1</span></a>). If no <span class="SimpleMath">dirid</span> argument is given then the current value of <code class="code">AGR.DIRID</code> is taken as the default; this value is set automatically before a <code class="file">toc.json</code> file gets evaluated by <code class="func">AtlasOfGroupRepresentationsNotifyData</code> (<a href="chap5.html#X81B5FA0578257653"><span class="RefLink">5.1-1</span></a>), and is reset afterwards. If <code class="code">AGR.DIRID</code> is not bound and <span class="SimpleMath">dirid</span> is not given then this function has no effect.</p>
<p>An example of a valid call is <code class="code">AGR.TOC("perm","alt/A5/mtx/S5G1-p5B0.m", [-3581724,115937465])</code>.</p>
</dd>
</dl>
<p>The following functions add data about the groups and their standard generators. The function calls must be executed after the corresponding <code class="code">AGR.GNAN</code> calls.</p>
<dl>
<dt><strong class="Mark"><code class="code">AGR.GRS( </code><span class="SimpleMath">gapname, size[, dirid]</span><code class="code"> )</code></strong></dt>
<dd><p>The integer <span class="SimpleMath">size</span> is stored as the order of the group with <strong class="pkg">GAP</strong> name <span class="SimpleMath">gapname</span>, in <code class="code">AtlasOfGroupRepresentationsInfo.GAPnames</code>.</p>
<p>An example of a valid call is <code class="code">AGR.GRS("A5.2",120)</code>.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.MXN( </code><span class="SimpleMath">gapname, nrMaxes[, dirid]</span><code class="code"> )</code></strong></dt>
<dd><p>The integer <span class="SimpleMath">nrMaxes</span> is stored as the number of classes of maximal subgroups of the group with <strong class="pkg">GAP</strong> name <span class="SimpleMath">gapname</span>, in <code class="code">AtlasOfGroupRepresentationsInfo.GAPnames</code>.</p>
<p>An example of a valid call is <code class="code">AGR.MXN("A5.2",4)</code>.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.MXO( </code><span class="SimpleMath">gapname, sizesMaxes[, dirid]</span><code class="code"> )</code></strong></dt>
<dd><p>The list <span class="SimpleMath">sizesMaxes</span> of subgroup orders of the classes of maximal subgroups of the group with <strong class="pkg">GAP</strong> name <span class="SimpleMath">gapname</span> (not necessarily dense, in non-increasing order) is stored in <code class="code">AtlasOfGroupRepresentationsInfo.GAPnames</code>.</p>
<p>An example of a valid call is <code class="code">AGR.MXO("A5.2",[60,24,20,12])</code>.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.MXS( </code><span class="SimpleMath">gapname, structureMaxes[, dirid]</span><code class="code"> )</code></strong></dt>
<dd><p>The list <span class="SimpleMath">structureMaxes</span> of strings describing the structures of the maximal subgroups of the group with <strong class="pkg">GAP</strong> name <span class="SimpleMath">gapname</span> (not necessarily dense), is stored in <code class="code">AtlasOfGroupRepresentationsInfo.GAPnames</code>.</p>
<p>An example of a valid call is <code class="code">AGR.MXS("A5.2",["A5","S4","5:4","S3x2"])</code>.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.STDCOMP( </code><span class="SimpleMath">gapname, factorCompatibility[, dirid]</span><code class="code"> )</code></strong></dt>
<dd><p>The list <span class="SimpleMath">factorCompatibility</span> (with entries the standardization of the group with <strong class="pkg">GAP</strong> name <span class="SimpleMath">gapname</span> , the <strong class="pkg">GAP</strong> name of a factor group, the standardization of this factor group, and <code class="keyw">true</code> or <code class="keyw">false</code>, indicating whether mapping the standard generators for <span class="SimpleMath">gapname</span> to those of <span class="SimpleMath">factgapname</span> defines an epimorphism) is stored in <code class="code">AtlasOfGroupRepresentationsInfo.GAPnames</code>.</p>
<p>An example of a valid call is <code class="code">AGR.STDCOMP("2.A5.2",[1,"A5.2",1,true])</code>.</p>
</dd>
</dl>
<p>The following functions add data about representations or straight line programs that are already known. The function calls must be executed after the corresponding <code class="code">AGR.TOC</code> calls.</p>
<dl>
<dt><strong class="Mark"><code class="code">AGR.RNG( </code><span class="SimpleMath">repname, descr[, dirid]</span><code class="code"> )</code></strong></dt>
<dd><p>Called with two strings <span class="SimpleMath">repname</span> (denoting the name of a file containing the generators of a matrix representation over a ring that is not determined by the filename) and <span class="SimpleMath">descr</span> (describing this ring <span class="SimpleMath">R</span>, say), <code class="code">AGR.RNG</code> adds the triple <span class="SimpleMath">[ repname, descr, R ]</span> to the list stored in the <code class="code">ringinfo</code> component of <code class="func">AtlasOfGroupRepresentationsInfo</code> (<a href="chap7.html#X7BEC94A6781E126E"><span class="RefLink">7.1-5</span></a>).</p>
<p>An example of a valid call is <code class="code">AGR.RNG("A5G1-Ar3aB0","Field([Sqrt(5)])")</code>.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.TOCEXT( </code><span class="SimpleMath">atlasname, std, maxnr, files[, dirid]</span><code class="code"> )</code></strong></dt>
<dd><p>Called with <span class="SimpleMath">atlasname</span>, the positive integers <span class="SimpleMath">std</span> (the standardization) and <span class="SimpleMath">maxnr</span> (the number of the class of maximal subgroups), and the list <span class="SimpleMath">files</span> (of filenames of straight line programs for computing generators of the <span class="SimpleMath">maxnr</span>-th maximal subgroup, using a straight line program for a factor group plus perhaps some straight line program for computing kernel generators), <code class="code">AGR.TOCEXT</code> stores the information in <code class="code">AtlasOfGroupRepresentationsInfo.GAPnames</code>.</p>
<p>An example of a valid call is <code class="code">AGR.TOCEXT("2A5",1,3,["A5G1-max3W1"])</code>.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.API( </code><span class="SimpleMath">repname, info[, dirid]</span><code class="code"> )</code></strong></dt>
<dd><p>Called with the string <span class="SimpleMath">repname</span> (denoting the name of a permutation representation) and the list <span class="SimpleMath">info</span> (describing the point stabilizer of this representation), <code class="code">AGR.API</code> binds the component <span class="SimpleMath">repname</span> of the record <code class="code">AtlasOfGroupRepresentationsInfo.permrepinfo</code> to a record that describes the contents of <span class="SimpleMath">info</span>.</p>
<p><span class="SimpleMath">info</span> has the following entries.</p>
<ul>
<li><p>At position <span class="SimpleMath">1</span>, the transitivity is stored.</p>
</li>
<li><p>If the transitivity is zero then <span class="SimpleMath">info</span> has length two, and the second entry is the list of orbit lengths.</p>
</li>
<li><p>If the transitivity is positive then <span class="SimpleMath">info</span> has length four or five, and the second entry is the rank of the action.</p>
</li>
<li><p>If the transitivity is positive then the third entry is one of the strings <code class="code">"prim"</code>, <code class="code">"imprim"</code>, denoting primitivity or not.</p>
</li>
<li><p>If the transitivity is positive then the fourth entry is either the string <code class="code">"???"</code> or a string that describes the structure of the point stabilizer. If the third entry is <code class="code">"imprim"</code> then this description consists of a subgroup part and a maximal subgroup part, separated by <code class="code">" < "</code>.</p>
</li>
<li><p>If the third entry is <code class="code">"prim"</code> then the fifth entry is either the string <code class="code">"???"</code> or the number of the class of maximal subgroups that are the point stabilizers.</p>
</li>
</ul>
<p>An example of a valid call is <code class="code">AGR.API("A5G1-p5B0",[3,2,"prim","A4",1])</code>.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.CHAR( </code><span class="SimpleMath">gapname, repname, char, pos[, charname[, dirid]]</span><code class="code"> )</code></strong></dt>
<dd><p>Called with the strings <span class="SimpleMath">gapname</span> and <span class="SimpleMath">repname</span> (denoting the name of the representation), the integer <span class="SimpleMath">char</span> (the characteristic of the representation), and <span class="SimpleMath">pos</span> (the position or list of positions of the irreducible constituent(s)), <code class="code">AGR.CHAR</code> stores the information in <code class="code">AtlasOfGroupRepresentationsInfo.characterinfo</code>.</p>
<p>A string describing the character can be entered as <span class="SimpleMath">charname</span>.</p>
<p>If <span class="SimpleMath">dirid</span> is given but no <span class="SimpleMath">charname</span> is known then one can enter <code class="keyw">fail</code> as the fifth argument.</p>
<p>An example of a valid call is <code class="code">AGR.CHAR("M11","M11G1-p11B0",0,[1,2],"1a+10a")</code>.</p>
</dd>
</dl>
<p><a id="X79C5F2267ACCF52A" name="X79C5F2267ACCF52A"></a></p>
<h4>7.9 <span class="Heading">Sanity Checks for the <strong class="pkg">AtlasRep</strong> Package</span></h4>
<p>The file <code class="file">tst/testall.g</code> of the package contains <code class="func">Test</code> (<a href="../../../doc/ref/chap7.html#X87712F9D8732193C"><span class="RefLink">Reference: Test</span></a>) statements for checking whether the <strong class="pkg">AtlasRep</strong> functions behave as documented. One can run these tests by calling <code class="code">ReadPackage( "AtlasRep", "tst/testall.g" )</code>. The examples in the package manual form a part of the tests, they are collected in the file <code class="file">tst/docxpl.tst</code> of the package.</p>
<p>The remainder of this section deals with consistency checks of the data. The tests described in Section <a href="chap7.html#X86FDCF0B85496AE5"><span class="RefLink">7.9-1</span></a> can be used for data from any extension of the database (see Chapter <a href="chap5.html#X7B0718A178BB10CA"><span class="RefLink">5</span></a>), Section <a href="chap7.html#X7FBFA8D287B807D2"><span class="RefLink">7.9-2</span></a> lists tests which apply only to the core part of the database.</p>
<p>All these tests apply only to <em>locally</em> available files (see Section <a href="chap7.html#X7B1DECF080AEB806"><span class="RefLink">7.8</span></a>), no files are downloaded during the tests. Thus the required space and time for running these tests depend on the amount of locally available data.</p>
<p>Some of the tests compute and verify additional data, such as information about point stabilizers of permutation representations. In these cases, output lines starting with <code class="code">#E</code> are error messages that point to inconsistencies, whereas output lines starting with <code class="code">#I</code> inform about data that have been computed and were not yet stored, or about stored data that were not verified. These tests are experimental in the sense that they involve several heuristics. Depending on the data to which they are applied, it may happen that the tests run out of space or do not finish in acceptable time. Please inform the package maintainer if you run into such problems.</p>
<p><a id="X86FDCF0B85496AE5" name="X86FDCF0B85496AE5"></a></p>
<h5>7.9-1 <span class="Heading">Sanity Checks for a Table of Contents</span></h5>
<p>The following tests can be used to check the data that belong to a given part of the database (core data or extension). Each of these tests is given by a function with optional argument <span class="SimpleMath">tocid</span>, the identifying string that had been entered as the second argument of <code class="func">AtlasOfGroupRepresentationsNotifyData</code> (<a href="chap5.html#X81B5FA0578257653"><span class="RefLink">5.1-1</span></a>). The contents of the core part can be checked by entering <code class="code">"core"</code>, which is also the default for <span class="SimpleMath">tocid</span>. The function returns <code class="keyw">false</code> if an error occurs, otherwise <code class="keyw">true</code>. Currently the following tests of this kind are available. (For some of them, the global option <code class="code">TryToExtendData</code> can be entered in order to try the computation of not yet stored data.)</p>
<dl>
<dt><strong class="Mark"><code class="code">AGR.Test.GroupOrders()</code></strong></dt>
<dd><p>checks whether the group orders stored in the <code class="code">GAPnames</code> component of <code class="func">AtlasOfGroupRepresentationsInfo</code> (<a href="chap7.html#X7BEC94A6781E126E"><span class="RefLink">7.1-5</span></a>) coincide with the group orders computed from an <strong class="pkg">ATLAS</strong> permutation representation of degree up to <code class="code">AGR.Test.MaxTestDegree</code>, from the available character table or table of marks with the given name, or from the structure of the name, in the sense that splitting the name at the first dot (<code class="code">.</code>) or colon (<code class="code">:</code>) and applying the same criteria to derive the group order from the two parts may yield enough information.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.Words( [</code><span class="SimpleMath">tocid</span><code class="code">] )</code></strong></dt>
<dd><p>processes the straight line programs that belong to <span class="SimpleMath">tocid</span>, using the function stored in the <code class="code">TestWords</code> component of the data type in question.</p>
<p>The straight line programs for the cases listed in <code class="code">AGR.Test.HardCases.TestWords</code> are omitted.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.ClassScripts( [</code><span class="SimpleMath">tocid</span><code class="code">] )</code></strong></dt>
<dd><p>checks whether the straight line programs that belong to <span class="SimpleMath">tocid</span> and that compute representatives of certain conjugacy classes are consistent with information stored on the <strong class="pkg">GAP</strong> character table of the group in question, in the sense that the given class names really occur in the character table and that the element orders and centralizer orders for the classes are correct.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.CycToCcls( [</code><span class="SimpleMath">tocid</span><code class="code">][:TryToExtendData] )</code></strong></dt>
<dd><p>checks whether all straight line programs that belong to <span class="SimpleMath">tocid</span> and that compute class representatives from representatives of cyclic subgroups possess a corresponding straight line program (<em>anywhere</em> in the database) for computing representatives of cyclic subgroups.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.FileHeaders( [</code><span class="SimpleMath">tocid</span><code class="code">] )</code></strong></dt>
<dd><p>checks whether the <strong class="pkg">MeatAxe</strong> text files that belong to <span class="SimpleMath">tocid</span> have a header line that is consistent with the filename, and whether the contents of all <strong class="pkg">GAP</strong> format data files that belong to <span class="SimpleMath">tocid</span> is consistent with the filename.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.Files( [</code><span class="SimpleMath">tocid</span><code class="code">] )</code></strong></dt>
<dd><p>checks whether the <strong class="pkg">MeatAxe</strong> text files that belong to <span class="SimpleMath">tocid</span> can be read with <code class="func">ScanMeatAxeFile</code> (<a href="chap7.html#X83D5103780E1238F"><span class="RefLink">7.3-1</span></a>) such that the result is not <code class="keyw">fail</code>. The function does not check whether the first line of a <strong class="pkg">MeatAxe</strong> text file is consistent with the filename, since this can be tested with <code class="code">AGR.Test.FileHeaders</code>.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.BinaryFormat( [</code><span class="SimpleMath">tocid</span><code class="code">] )</code></strong></dt>
<dd><p>checks whether all <strong class="pkg">MeatAxe</strong> text files that belong to <span class="SimpleMath">tocid</span> satisfy that applying first <code class="func">CMtxBinaryFFMatOrPerm</code> (<a href="chap7.html#X8477AA668733255C"><span class="RefLink">7.3-4</span></a>) and then <code class="func">FFMatOrPermCMtxBinary</code> (<a href="chap7.html#X872FA00C7F791FBB"><span class="RefLink">7.3-5</span></a>) yields the same object.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.Primitivity( [</code><span class="SimpleMath">tocid</span><code class="code">][:TryToExtendData] )</code></strong></dt>
<dd><p>checks the stored primitivity information for the permutation representations that belong to <span class="SimpleMath">tocid</span>. That is, the number of orbits, in case of a transitive action the transitivity, the rank, the information about the point stabilizers are computed if possible, and compared with the stored information.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.Characters( [</code><span class="SimpleMath">tocid</span><code class="code">][:TryToExtendData] )</code></strong></dt>
<dd><p>checks the character information (that belongs to <span class="SimpleMath">tocid</span>) for the matrix and permutation representations.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.StdCompatibility( [</code><span class="SimpleMath">tocid</span><code class="code">][:TryToExtendData] )</code></strong></dt>
<dd><p>checks whether the information about the compatibility of standard generators of a group and its factor groups that is stored in the <code class="code">GAPnames</code> component of <code class="func">AtlasOfGroupRepresentationsInfo</code> (<a href="chap7.html#X7BEC94A6781E126E"><span class="RefLink">7.1-5</span></a>) and belongs to <span class="SimpleMath">tocid</span> coincides with computed values.</p>
<p>The following criterion is used for computing the value for a group <span class="SimpleMath">G</span>. Use the <strong class="pkg">GAP</strong> Character Table Library to determine factor groups <span class="SimpleMath">F</span> of <span class="SimpleMath">G</span> for which standard generators are defined and moreover a presentation in terms of these standard generators is known. Evaluate the relators of the presentation in the standard generators of <span class="SimpleMath">G</span>, and let <span class="SimpleMath">N</span> be the normal closure of these elements in <span class="SimpleMath">G</span>. Then mapping the standard generators of <span class="SimpleMath">F</span> to the <span class="SimpleMath">N</span>-cosets of the standard generators of <span class="SimpleMath">G</span> is an epimorphism. If <span class="SimpleMath">|G/N| = |F|</span> holds then <span class="SimpleMath">G/N</span> and <span class="SimpleMath">F</span> are isomorphic, and the standard generators of <span class="SimpleMath">G</span> and <span class="SimpleMath">F</span> are compatible in the sense that mapping the standard generators of <span class="SimpleMath">G</span> to their <span class="SimpleMath">N</span>-cosets yields standard generators of <span class="SimpleMath">F</span>.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.KernelGenerators( [</code><span class="SimpleMath">tocid</span><code class="code">][:TryToExtendData] )</code></strong></dt>
<dd><p>checks whether the straight line programs (that belong to <span class="SimpleMath">tocid</span>) for computing generators of kernels of natural epimorphisms between <strong class="pkg">ATLAS</strong> groups compute generators of normal subgroups of the right group orders. If it is known that the given standard generators of the given group are compatible with some standard generators of the factor group in question (see the section about <code class="code">AGR.Test.StdCompatibility</code>) then it is also checked whether evaluating the straight line program at these standard generators of the factor group yields only the identity.</p>
<p>Note that the verification of normal subgroups of matrix groups may be <em>very</em> time and space consuming if the package <strong class="pkg">recog</strong> <a href="chapBib.html#biBrecog">[NSA+18]</a> is not available.</p>
<p>The function also tries to <em>find</em> words for computing kernel generators of those epimorphisms for which no straight line programs are stored; the candidates are given by stored factor fusions between the character tables from the <strong class="pkg">GAP</strong> Character Table Library.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.MaxesOrders( [</code><span class="SimpleMath">tocid</span><code class="code">] )</code></strong></dt>
<dd><p>checks whether the orders of maximal subgroups stored in the component <code class="code">GAPnames</code> of <code class="func">AtlasOfGroupRepresentationsInfo</code> (<a href="chap7.html#X7BEC94A6781E126E"><span class="RefLink">7.1-5</span></a>) coincide with the orders computed from the restriction of an <strong class="pkg">ATLAS</strong> permutation representation of degree up to <code class="code">AGR.Test.MaxTestDegree</code> (using a straight line program that belongs to <span class="SimpleMath">tocid</span>), from the character table, or the table of marks with the given name, or from the information about maximal subgroups of the factor group modulo a normal subgroup that is contained in the Frattini subgroup.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.MaxesStructure()</code></strong></dt>
<dd><p>checks whether the names of maximal subgroups stored in the component <code class="code">GAPnames</code> of <code class="func">AtlasOfGroupRepresentationsInfo</code> (<a href="chap7.html#X7BEC94A6781E126E"><span class="RefLink">7.1-5</span></a>) coincide with the names computed from the <strong class="pkg">GAP</strong> character table with the given name.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.MaxesStandardization( [</code><span class="SimpleMath">tocid</span><code class="code">] )</code></strong></dt>
<dd><p>checks whether the straight line programs (that belong to <span class="SimpleMath">tocid</span>) for standardizing the generators of maximal subgroups are correct: If a semi-presentation is available for the maximal subgroup and the standardization in question then it is used, otherwise an explicit isomorphism is tried.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.CompatibleMaxes( [</code><span class="SimpleMath">tocid</span><code class="code">][:TryToExtendData] )</code></strong></dt>
<dd><p>checks whether the information about deriving straight line programs for restricting to subgroups from straight line programs that belong to a factor group coincide with computed values.</p>
<p>The following criterion is used for computing the value for a group <span class="SimpleMath">G</span>. If <span class="SimpleMath">F</span> is a factor group of <span class="SimpleMath">G</span> such that the standard generators of <span class="SimpleMath">G</span> and <span class="SimpleMath">F</span> are compatible (see the test function <code class="code">AGR.Test.StdCompatibility</code>) and if there are a presentation for <span class="SimpleMath">F</span> and a permutation representation of <span class="SimpleMath">G</span> then it is checked whether the <code class="code">"maxes"</code> type straight line programs for <span class="SimpleMath">F</span> can be used to compute generators for the maximal subgroups of <span class="SimpleMath">G</span>; if not then generators of the kernel of the natural epimorphism from <span class="SimpleMath">G</span> to <span class="SimpleMath">F</span>, must be added.</p>
</dd>
</dl>
<p><a id="X7FBFA8D287B807D2" name="X7FBFA8D287B807D2"></a></p>
<h5>7.9-2 <span class="Heading">Other Sanity Checks</span></h5>
<p>The tests described in this section are intended for checking data that do not belong to a particular part of the <strong class="pkg">AtlasRep</strong> database. Therefore <em>all</em> locally available data are used in these tests. Each of the tests is given by a function without arguments that returns <code class="keyw">false</code> if a contradiction was found during the test, and <code class="keyw">true</code> otherwise. Additionally, certain messages are printed when contradictions between stored and computed data are found, when stored data cannot be verified computationally, or when the computations yield improvements of the stored data. Currently the following tests of this kind are available.</p>
<dl>
<dt><strong class="Mark"><code class="code">AGR.Test.Standardization()</code></strong></dt>
<dd><p>checks whether all generating sets corresponding to the same set of standard generators have the same element orders; for the case that straight line programs for computing certain class representatives are available, also the orders of these representatives are checked w. r. t. all generating sets.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.StdTomLib()</code></strong></dt>
<dd><p>checks whether the standard generators are compatible with those that occur in the <strong class="pkg">TomLib</strong> package.</p>
</dd>
<dt><strong class="Mark"><code class="code">AGR.Test.MinimalDegrees()</code></strong></dt>
<dd><p>checks that the (permutation and matrix) representations available in the database do not have smaller degree than the minimum claimed in Section <a href="chap6.html#X87E1F08D80C9E069"><span class="RefLink">6.3</span></a>.</p>
</dd>
</dl>
<p>Finally, we reset the user preference and the info level which had been set at the beginning of Chapter <a href="chap2.html#X8171B3798425E183"><span class="RefLink">2</span></a>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetUserPreference( "AtlasRep", "DisplayFunction", origpref );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetInfoLevel( InfoAtlasRep, globallevel );</span>
</pre></div>
<div class="chlinkprevnextbot"> <a href="chap0.html">[Top of Book]</a> <a href="chap0.html#contents">[Contents]</a> <a href="chap6.html">[Previous Chapter]</a> <a href="chapBib.html">[Next Chapter]</a> </div>
<div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chap7.html">7</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
<hr />
<p class="foot">generated by <a href="https://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
</body>
</html>
|
