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
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
|
<?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>
<script type="text/javascript"
src="https://cdn.jsdelivr.net/npm/mathjax@2/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
<title>GAP (CTblLibXpls) - Chapter 1: Maintenance Issues for the GAP Character Table Library</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="chap1" onload="jscontent()">
<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0_mj.html">Top</a> <a href="chap1_mj.html">1</a> <a href="chap2_mj.html">2</a> <a href="chap3_mj.html">3</a> <a href="chap4_mj.html">4</a> <a href="chap5_mj.html">5</a> <a href="chap6_mj.html">6</a> <a href="chap7_mj.html">7</a> <a href="chap8_mj.html">8</a> <a href="chap9_mj.html">9</a> <a href="chap10_mj.html">10</a> <a href="chap11_mj.html">11</a> <a href="chapBib_mj.html">Bib</a> <a href="chapInd_mj.html">Ind</a> </div>
<div class="chlinkprevnexttop"> <a href="chap0_mj.html">[Top of Book]</a> <a href="chap0_mj.html#contents">[Contents]</a> <a href="chap0_mj.html">[Previous Chapter]</a> <a href="chap2_mj.html">[Next Chapter]</a> </div>
<p id="mathjaxlink" class="pcenter"><a href="chap1.html">[MathJax off]</a></p>
<p><a id="X8354C98179CDB193" name="X8354C98179CDB193"></a></p>
<div class="ChapSects"><a href="chap1_mj.html#X8354C98179CDB193">1 <span class="Heading">Maintenance Issues for the <strong class="pkg">GAP</strong> Character Table Library</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X7ECA800587320C2C">1.1 <span class="Heading">Disproving Possible Character Tables (November 2006)</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X795DCCEA7F4D187A">1.1-1 <span class="Heading">A Perfect Pseudo Character Table (November 2006)</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X80F0B4E07B0B2277">1.1-2 <span class="Heading">An Error in the Character Table of <span class="SimpleMath">\(E_6(2)\)</span> (March 2016)</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X7D7982CD87413F76">1.1-3 <span class="Heading">An Error in a Power Map of the Character Table of <span class="SimpleMath">\(2.F_4(2).2\)</span> (November 2015)</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X836E4B6184F32EF5">1.1-4 <span class="Heading">A Character Table with a Wrong Name (May 2017)</span></a>
</span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X8159D79C7F071B33">1.2 <span class="Heading">Some finite factor groups of perfect space groups (February 2014)</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X8710D4947AEB366F">1.2-1 <span class="Heading">Constructing the space groups in question</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X84E7FE70843422B0">1.2-2 <span class="Heading">Constructing the factor groups in question</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X79109A20873E76DA">1.2-3 <span class="Heading">Examples with point group <span class="SimpleMath">\(A_5\)</span></span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X83523D1E792F9E01">1.2-4 <span class="Heading">Examples with point group <span class="SimpleMath">\(L_3(2)\)</span></span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X7A01A9BC846BE39A">1.2-5 <span class="Heading">Example with point group SL<span class="SimpleMath">\(_2(7)\)</span></span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X7D3100B58093F37D">1.2-6 <span class="Heading">Example with point group <span class="SimpleMath">\(2^3.L_3(2)\)</span></span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X80800F3B7D6EF06C">1.2-7 <span class="Heading">Examples with point group <span class="SimpleMath">\(A_6\)</span></span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X7D43452C79B0EAE1">1.2-8 <span class="Heading">Examples with point group <span class="SimpleMath">\(L_2(8)\)</span></span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X8575CE147A9819BF">1.2-9 <span class="Heading">Example with point group <span class="SimpleMath">\(M_{11}\)</span></span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X7C0201B77DA1682A">1.2-10 <span class="Heading">Example with point group <span class="SimpleMath">\(U_3(3)\)</span></span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X85D9C329792E58F3">1.2-11 <span class="Heading">Examples with point group <span class="SimpleMath">\(U_4(2)\)</span></span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X8635EE0B78A66120">1.2-12 <span class="Heading">A remark on one of the example groups</span></a>
</span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X8448022280E82C52">1.3 <span class="Heading">Generality problems (December 2004/October 2015)</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X7D1A66C3844D09B1">1.3-1 <span class="Heading">Listing possible generality problems</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X80EB5D827A78975A">1.3-2 <span class="Heading">A generality problem concerning the group <span class="SimpleMath">\(J_3\)</span> (April 2015)</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X82C37532783168AA">1.3-3 <span class="Heading">A generality problem concerning the group <span class="SimpleMath">\(HN\)</span> (August 2022)</span></a>
</span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X7D8C6D1883C9CECA">1.4 <span class="Heading">Brauer Tables that can be derived from Known Tables</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X7DF018B77E722CA7">1.4-1 <span class="Heading">Brauer Tables via Construction Information</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X795419A287BD228E">1.4-2 <span class="Heading">Liftable Brauer Characters (May 2017)</span></a>
</span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap1_mj.html#X864EFF897A854F89">1.5 <span class="Heading">Information about certain subgroups of the Monster group</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X82C7A03684DD7C6E">1.5-1 <span class="Heading">The Monster group does not contain subgroups of the type <span class="SimpleMath">\(2.U_4(2)\)</span> (August 2023)</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X87EC0C48866D1BDE">1.5-2 <span class="Heading">Perfect central extensions of <span class="SimpleMath">\(L_3(4)\)</span> (August 2023)</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap1_mj.html#X7F605CA28441687F">1.5-3 <span class="Heading">The character table of <span class="SimpleMath">\((2 \times O_8^+(3)).S_4 \leq 2.B\)</span> (October 2023)</span></a>
</span>
</div></div>
</div>
<h3>1 <span class="Heading">Maintenance Issues for the <strong class="pkg">GAP</strong> Character Table Library</span></h3>
<p>This chapter collects examples of computations that arose in the context of maintaining the <strong class="pkg">GAP</strong> Character Table Library. The sections have been added when the issues in question arose; the dates of the additions are shown in the section titles.</p>
<p><a id="X7ECA800587320C2C" name="X7ECA800587320C2C"></a></p>
<h4>1.1 <span class="Heading">Disproving Possible Character Tables (November 2006)</span></h4>
<p>I do not know a necessary and sufficient criterion for checking whether a given matrix together with a list of power maps describes the character table of a finite group. Examples of <em>pseudo character tables</em> (tables which satisfy certain necessary conditions but for which actually no group exists) have been given in <a href="chapBib_mj.html#biBGag86">[Gag86]</a>. Another such example is described in Section <a href="chap2_mj.html#X7E0C603880157C4E"><span class="RefLink">2.4-17</span></a>. The tables in the <strong class="pkg">GAP</strong> Character Table Library satisfy the usual tests. However, there are table candidates for which these tests are not good enough. Another question would be whether a given character table belongs to the group for which it is claimed to belong, see Section <a href="chap1_mj.html#X836E4B6184F32EF5"><span class="RefLink">1.1-4</span></a> for an example.</p>
<p><a id="X795DCCEA7F4D187A" name="X795DCCEA7F4D187A"></a></p>
<h5>1.1-1 <span class="Heading">A Perfect Pseudo Character Table (November 2006)</span></h5>
<p>(This example arose from a discussion with Jack Schmidt.)</p>
<p>Up to version 1.1.3 of the <strong class="pkg">GAP</strong> Character Table Library, the table with identifier <code class="code">"P41/G1/L1/V4/ext2"</code> was not correct. The problem occurs already in the microfiches that are attached to <a href="chapBib_mj.html#biBHP89">[HP89]</a>.</p>
<p>In the following, we show that this table is not the character table of a finite group, using the <strong class="pkg">GAP</strong> library of perfect groups. Currently we do not know how to prove this inconsistency alone from the table.</p>
<p>We start with the construction of the inconsistent table; apart from a little editing, the following input equals the data formerly stored in the file <code class="file">data/ctoholpl.tbl</code> of the <strong class="pkg">GAP</strong> Character Table Library.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tbl:= rec(</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Identifier:= "P41/G1/L1/V4/ext2",</span>
<span class="GAPprompt">></span> <span class="GAPinput"> InfoText:= Concatenation( [</span>
<span class="GAPprompt">></span> <span class="GAPinput"> "origin: Hanrath library,\n",</span>
<span class="GAPprompt">></span> <span class="GAPinput"> "structure is 2^7.L2(8),\n",</span>
<span class="GAPprompt">></span> <span class="GAPinput"> "characters sorted with permutation (12,14,15,13)(19,20)" ] ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> UnderlyingCharacteristic:= 0,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> SizesCentralizers:= [64512,1024,1024,64512,64,64,64,64,128,128,64,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> 64,128,128,18,18,14,14,14,14,14,14,18,18,18,18,18,18],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> ComputedPowerMaps:= [,[1,1,1,1,2,3,3,2,3,2,2,1,3,2,16,16,20,20,22,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> 22,18,18,26,26,27,27,23,23],[1,2,3,4,5,6,7,8,9,10,11,12,13,14,4,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> 1,21,22,17,18,19,20,16,15,15,16,16,15],,,,[1,2,3,4,5,6,7,8,9,10,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> 11,12,13,14,15,16,4,1,4,1,4,1,26,25,28,27,23,24]],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Irr:= 0,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> AutomorphismsOfTable:= Group( [(23,26,27)(24,25,28),(9,13)(10,14),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> (17,19,21)(18,20,22)] ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> ConstructionInfoCharacterTable:= ["ConstructClifford",[[[1,2,3,4,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> 5,6,7,8,9],[1,7,8,3,9,2],[1,4,5,6,2],[1,2,2,2,2,2,2,2]],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [["L2(8)"],["Dihedral",18],["Dihedral",14],["2^3"]],[[[1,2,3,4],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [1,1,1,1],["elab",4,25]],[[1,2,3,4,4,4,4,4,4,4],[2,6,5,2,3,4,5,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> 6,7,8],["elab",10,17]],[[1,2],[3,4],[[1,1],[-1,1]]],[[1,3],[4,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> 2],[[1,1],[-1,1]]],[[1,3],[5,3],[[1,1],[-1,1]]],[[1,3],[6,4],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [[1,1],[-1,1]]],[[1,2],[7,2],[[1,1],[1,-1]]],[[1,2],[8,3],[[1,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> 1],[-1,1]]],[[1,2],[9,5],[[1,1],[1,-1]]]]]],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ConstructClifford( tbl, tbl.ConstructionInfoCharacterTable[2] );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ConvertToLibraryCharacterTableNC( tbl );;</span>
</pre></div>
<p>Suppose that there is a group <span class="SimpleMath">\(G\)</span>, say, with this table. Then <span class="SimpleMath">\(G\)</span> is perfect since the table has only one linear character.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( LinearCharacters( tbl ) );</span>
1
<span class="GAPprompt">gap></span> <span class="GAPinput">IsPerfectCharacterTable( tbl );</span>
true
</pre></div>
<p>The table satisfies the orthogonality relations, the structure constants are nonnegative integers, and symmetrizations of the irreducibles decompose into the irreducibles, with nonnegative integral coefficients.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">IsInternallyConsistent( tbl );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">irr:= Irr( tbl );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">test:= Concatenation( List( [ 2 .. 7 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> n -> Symmetrizations( tbl, irr, n ) ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Append( test, Set( Tensored( irr, irr ) ) );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fail in Decomposition( irr, test, "nonnegative" );</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">if ForAny( Tuples( [ 1 .. NrConjugacyClasses( tbl ) ], 3 ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> t -> not ClassMultiplicationCoefficient( tbl, t[1], t[2], t[3] )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> in NonnegativeIntegers ) then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Error( "contradiction" );</span>
<span class="GAPprompt">></span> <span class="GAPinput">fi;</span>
</pre></div>
<p>The <strong class="pkg">GAP</strong> Library of Perfect Groups contains representatives of the four isomorphism types of perfect groups of order <span class="SimpleMath">\(|G| = 64\,512\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">n:= Size( tbl );</span>
64512
<span class="GAPprompt">gap></span> <span class="GAPinput">NumberPerfectGroups( n );</span>
4
<span class="GAPprompt">gap></span> <span class="GAPinput">grps:= List( [ 1 .. 4 ], i -> PerfectGroup( IsPermGroup, n, i ) );</span>
[ L2(8) 2^6 E 2^1, L2(8) N 2^6 E 2^1 I, L2(8) N 2^6 E 2^1 II,
L2(8) N 2^6 E 2^1 III ]
</pre></div>
<p>If we believe that the classification of perfect groups of order <span class="SimpleMath">\(|G|\)</span> is correct then all we have to do is to show that none of the character tables of these four groups is equivalent to the given table.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tbls:= List( grps, CharacterTable );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">List( tbls,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> TransformingPermutationsCharacterTables( x, tbl ) );</span>
[ fail, fail, fail, fail ]
</pre></div>
<p>In fact, already the matrices of irreducible characters of the four groups do not fit to the given table.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">List( tbls,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> t -> TransformingPermutations( Irr( t ), Irr( tbl ) ) );</span>
[ fail, fail, fail, fail ]
</pre></div>
<p>Let us look closer at the tables in question. Each character table of a perfect group of order <span class="SimpleMath">\(64\,512\)</span> has exactly one irreducible character of degree <span class="SimpleMath">\(63\)</span> that takes exactly the values <span class="SimpleMath">\(-1\)</span>, <span class="SimpleMath">\(0\)</span>, <span class="SimpleMath">\(7\)</span>, and <span class="SimpleMath">\(63\)</span>; moreover, the value <span class="SimpleMath">\(7\)</span> occurs in exactly two classes.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">testchars:= List( tbls,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> t -> Filtered( Irr( t ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> x[1] = 63 and Set( x ) = [ -1, 0, 7, 63 ] ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">List( testchars, Length );</span>
[ 1, 1, 1, 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( testchars, l -> Number( l[1], x -> x = 7 ) );</span>
[ 2, 2, 2, 2 ]
</pre></div>
<p>(Another way to state this is that in each of the four tables <span class="SimpleMath">\(t\)</span> in question, there are ten preimage classes of the involution class in the simple factor group <span class="SimpleMath">\(L_2(8)\)</span>, there are eight preimage classes of this class in the factor group <span class="SimpleMath">\(2^6.L_2(8)\)</span>, and that the unique class in which an irreducible degree <span class="SimpleMath">\(63\)</span> character of this factor group takes the value <span class="SimpleMath">\(7\)</span> splits in <span class="SimpleMath">\(t\)</span>.)</p>
<p>In the erroneous table, however, there is only one class with the value <span class="SimpleMath">\(7\)</span> in this character.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">testchars:= List( [ tbl ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> t -> Filtered( Irr( t ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> x[1] = 63 and Set( x ) = [ -1, 0, 7, 63 ] ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">List( testchars, Length );</span>
[ 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( testchars, l -> Number( l[1], x -> x = 7 ) );</span>
[ 1 ]
</pre></div>
<p>This property can be checked easily for the displayed table stored in fiche <span class="SimpleMath">\(2\)</span>, row <span class="SimpleMath">\(4\)</span>, column <span class="SimpleMath">\(7\)</span> of <a href="chapBib_mj.html#biBHP89">[HP89]</a>, with the name <code class="code">6L1<>Z^7<>L2(8); V4; MOD 2</code>, and it turns out that this table is not correct.</p>
<p>Note that these microfiches contain <em>two</em> tables of order <span class="SimpleMath">\(64\,512\)</span>, and there were <em>three</em> tables of groups of that order in the <strong class="pkg">GAP</strong> Character Table Library that contain <code class="code">origin: Hanrath library</code> in their <code class="func">InfoText</code> (<a href="../../../doc/ref/chap12_mj.html#X871562FD7F982C12"><span class="RefLink">Reference: InfoText</span></a>) value. Besides the incorrect table, these library tables are the character tables of the groups <code class="code">PerfectGroup( 64512, 1 )</code> and <code class="code">PerfectGroup( 64512, 3 )</code>, respectively. (The matrices of irreducible characters of these tables are equivalent.)</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">Filtered( [ 1 .. 4 ], i -></span>
<span class="GAPprompt">></span> <span class="GAPinput"> TransformingPermutationsCharacterTables( tbls[i],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> CharacterTable( "P41/G1/L1/V1/ext2" ) ) <> fail );</span>
[ 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Filtered( [ 1 .. 4 ], i -></span>
<span class="GAPprompt">></span> <span class="GAPinput"> TransformingPermutationsCharacterTables( tbls[i],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> CharacterTable( "P41/G1/L1/V2/ext2" ) ) <> fail );</span>
[ 3 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">TransformingPermutations( Irr( tbls[1] ), Irr( tbls[3] ) ) <> fail;</span>
true
</pre></div>
<p>Since version 1.2 of the <strong class="pkg">GAP</strong> Character Table Library, the character table with the <code class="func">Identifier</code> (<a href="../../../doc/ref/chap70_mj.html#X810E53597B5BB4F8"><span class="RefLink">Reference: Identifier for tables of marks</span></a>) value <code class="code">"P41/G1/L1/V4/ext2"</code> corresponds to the group <code class="code">PerfectGroup( 64512, 4 )</code>. The choice of this group was somewhat arbitrary since the vector system <code class="code">V4</code> seems to be not defined in <a href="chapBib_mj.html#biBHP89">[HP89]</a>; anyhow, this group and the remaining perfect group, <code class="code">PerfectGroup( 64512, 2 )</code>, have equivalent matrices of irreducibles.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">Filtered( [ 1 .. 4 ], i -></span>
<span class="GAPprompt">></span> <span class="GAPinput"> TransformingPermutationsCharacterTables( tbls[i],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> CharacterTable( "P41/G1/L1/V4/ext2" ) ) <> fail );</span>
[ 4 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">TransformingPermutations( Irr( tbls[2] ), Irr( tbls[4] ) ) <> fail;</span>
true
</pre></div>
<p><a id="X80F0B4E07B0B2277" name="X80F0B4E07B0B2277"></a></p>
<h5>1.1-2 <span class="Heading">An Error in the Character Table of <span class="SimpleMath">\(E_6(2)\)</span> (March 2016)</span></h5>
<p>In March 2016, Bill Unger computed the character table of the simple group <span class="SimpleMath">\(E_6(2)\)</span> with Magma (see <a href="chapBib_mj.html#biBCP96">[CP96]</a>) and compared it with the table that was contained in the <strong class="pkg">GAP</strong> Character Table Library since 2000. It turned out that the two tables did not coincide.</p>
<p>The differences concern irrational character values on classes of element order <span class="SimpleMath">\(91\)</span> and power map values on these classes. (The character values and power maps fit to each other in both tables; thus it may be that the assumption of a wrong power has implied the wrong character values, or vice versa.) Specifically, the <span class="SimpleMath">\(11\)</span>th power map in the <strong class="pkg">GAP</strong> table fixed all elements of order <span class="SimpleMath">\(91\)</span>. Using the smallest matrix representation of <span class="SimpleMath">\(E_6(2)\)</span> over the field with two elements, one can easily find an element <span class="SimpleMath">\(g\)</span> of order <span class="SimpleMath">\(91\)</span>, and show that the characteristic polynomials of <span class="SimpleMath">\(g\)</span> and <span class="SimpleMath">\(g^{11}\)</span> differ. Hence these two elements cannot be conjugate in <span class="SimpleMath">\(E_6(2)\)</span>. In other words, the <strong class="pkg">GAP</strong> table was wrong.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= AtlasGroup( "E6(2)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">repeat x:= PseudoRandom( g ); until Order( x ) = 91;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">CharacteristicPolynomial( x ) = CharacteristicPolynomial( x^11 );</span>
false
</pre></div>
<p>The wrong <strong class="pkg">GAP</strong> table has been corrected in version 1.3.0 of the <strong class="pkg">GAP</strong> Character Table Library.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "E6(2)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ord91:= Positions( OrdersClassRepresentatives( t ), 91 );</span>
[ 163, 164, 165, 166, 167, 168 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PowerMap( t, 11 ){ ord91 };</span>
[ 167, 168, 163, 164, 165, 166 ]
</pre></div>
<p><a id="X7D7982CD87413F76" name="X7D7982CD87413F76"></a></p>
<h5>1.1-3 <span class="Heading">An Error in a Power Map of the Character Table of <span class="SimpleMath">\(2.F_4(2).2\)</span> (November 2015)</span></h5>
<p>As a part of the computations for <a href="chapBib_mj.html#biBBMO17">[BMO17]</a>, the character table of the group <span class="SimpleMath">\(2.F_4(2).2\)</span> was computed automatically from a representation of the group, using Magma (see <a href="chapBib_mj.html#biBCP96">[CP96]</a>). It turned out that the <span class="SimpleMath">\(2\)</span>-nd power map that had been stored on the library character table of <span class="SimpleMath">\(2.F_4(2).2\)</span> had been wrong.</p>
<p>In fact, this was the one and only case of a power map for an <strong class="pkg">Atlas</strong> group which was not determined by the character table, and the <code class="func">InfoText</code> (<a href="../../../doc/ref/chap12_mj.html#X871562FD7F982C12"><span class="RefLink">Reference: InfoText</span></a>) value of the character table had mentioned the two alternatives.</p>
<p>Note that the ambiguity is not present in the table of the factor group <span class="SimpleMath">\(F_4(2).2\)</span>, and only four faithful irreducible characters of <span class="SimpleMath">\(2.F_4(2).2\)</span> distinguish the four relevant conjugacy classes.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "2.F4(2).2" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">f:= CharacterTable( "F4(2).2" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">map:= PowerMap( t, 2 );</span>
[ 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 11, 11, 3, 3, 3, 5, 5, 5, 3, 6, 6, 5,
5, 7, 7, 5, 8, 7, 29, 29, 9, 9, 9, 9, 11, 11, 9, 9, 9, 9, 11, 11,
43, 43, 20, 20, 20, 14, 14, 13, 13, 20, 21, 24, 28, 28, 57, 57, 29,
29, 29, 29, 33, 33, 35, 37, 37, 37, 37, 33, 33, 37, 37, 35, 41, 41,
42, 42, 79, 79, 43, 43, 83, 83, 45, 45, 47, 47, 53, 53, 91, 91, 57,
57, 61, 61, 61, 98, 98, 70, 70, 63, 63, 81, 81, 83, 83, 1, 6, 7,
11, 16, 17, 24, 24, 21, 27, 27, 25, 26, 29, 41, 53, 53, 53, 46, 56,
56, 56, 56, 62, 75, 75, 78, 78, 77, 77, 79, 79, 86, 86, 85, 85, 88,
88, 88, 88, 95, 95, 96, 96 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PositionSublist( map, [ 86, 86, 85, 85 ] );</span>
140
<span class="GAPprompt">gap></span> <span class="GAPinput">OrdersClassRepresentatives( t ){ [ 140 .. 143 ] };</span>
[ 32, 32, 32, 32 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">SizesCentralizers( t ){ [ 140 .. 143 ] };</span>
[ 64, 64, 64, 64 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">GetFusionMap( t, f ){ [ 140 ..143 ] };</span>
[ 86, 86, 87, 87 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PowerMap( f, 2 ){ [ 86, 87 ] };</span>
[ 50, 50 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">pos:= PositionsProperty( Irr( t ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> x[1] <> x[2] and Length( Set( x{ [ 140 .. 143 ] } ) ) > 1 );</span>
[ 144, 145, 146, 147 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( pos, i -> Irr(t)[i]{ [ 140 .. 143 ] } );</span>
[ [ 2*E(16)-2*E(16)^7, -2*E(16)+2*E(16)^7, 2*E(16)^3-2*E(16)^5,
-2*E(16)^3+2*E(16)^5 ],
[ -2*E(16)+2*E(16)^7, 2*E(16)-2*E(16)^7, -2*E(16)^3+2*E(16)^5,
2*E(16)^3-2*E(16)^5 ],
[ -2*E(16)^3+2*E(16)^5, 2*E(16)^3-2*E(16)^5, 2*E(16)-2*E(16)^7,
-2*E(16)+2*E(16)^7 ],
[ 2*E(16)^3-2*E(16)^5, -2*E(16)^3+2*E(16)^5, -2*E(16)+2*E(16)^7,
2*E(16)-2*E(16)^7 ] ]
</pre></div>
<p>I had not found a suitable subgroup of <span class="SimpleMath">\(2.F_4(2).2\)</span> whose character table could be used to decide the question which of the two alternatives is the correct one.</p>
<p><a id="X836E4B6184F32EF5" name="X836E4B6184F32EF5"></a></p>
<h5>1.1-4 <span class="Heading">A Character Table with a Wrong Name (May 2017)</span></h5>
<p>(This example is much older.)</p>
<p>The character table that is shown in <a href="chapBib_mj.html#biBOst86">[Ost86, p. 126 f.]</a> is claimed to be the table of a Sylow <span class="SimpleMath">\(2\)</span> subgroup <span class="SimpleMath">\(P\)</span> of the sporadic simple Lyons group <span class="SimpleMath">\(Ly\)</span>. This table had been contained in the character table library of the <strong class="pkg">CAS</strong> system (see <a href="chapBib_mj.html#biBNPP84">[NPP84]</a>), which was one of the predecessors of <strong class="pkg">GAP</strong>.</p>
<p>It is easy to see that no subgroup of <span class="SimpleMath">\(Ly\)</span> can have this character table. Namely, the group of that table contains elements of order eight with centralizer order <span class="SimpleMath">\(2^6\)</span>, and this does not occur in <span class="SimpleMath">\(Ly\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tbl:= CharacterTable( "Ly" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">orders:= OrdersClassRepresentatives( tbl );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">order8:= Filtered( [ 1 .. Length( orders ) ], x -> orders[x] = 8 );</span>
[ 12, 13 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">SizesCentralizers( tbl ){ order8 } / 2^6;</span>
[ 15/2, 3/2 ]
</pre></div>
<p>The table of <span class="SimpleMath">\(P\)</span> has been computed in <a href="chapBib_mj.html#biBBre91">[Bre91]</a> with character theoretic methods. Nowadays it would be no problem to take a permutation representation of <span class="SimpleMath">\(Ly\)</span>, to compute its Sylow <span class="SimpleMath">\(2\)</span> subgroup, and use this group to compute its character table. However, the task is even easier if we assume that <span class="SimpleMath">\(Ly\)</span> has a subgroup of the structure <span class="SimpleMath">\(3.McL.2\)</span>. This subgroup is of odd index, hence it contains a conjugate of <span class="SimpleMath">\(P\)</span>. Clearly the Sylow <span class="SimpleMath">\(2\)</span> subgroups in the factor group <span class="SimpleMath">\(McL.2\)</span> are isomorphic with <span class="SimpleMath">\(P\)</span>. Thus we can start with a rather small permutation representation.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= AtlasGroup( "McL.2" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">NrMovedPoints( g );</span>
275
<span class="GAPprompt">gap></span> <span class="GAPinput">syl:= SylowSubgroup( g, 2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">pc:= Image( IsomorphismPcGroup( syl ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( pc );;</span>
</pre></div>
<p>The character table coincides with the one which is stored in the Character Table Library.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">IsRecord( TransformingPermutationsCharacterTables( t,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> CharacterTable( "LyN2" ) ) );</span>
true
</pre></div>
<p><a id="X8159D79C7F071B33" name="X8159D79C7F071B33"></a></p>
<h4>1.2 <span class="Heading">Some finite factor groups of perfect space groups (February 2014)</span></h4>
<p>If one wants to find a group to which a given character table from the <strong class="pkg">GAP</strong> Character Table Library belongs, one can try the function <code class="func">GroupInfoForCharacterTable</code> (<a href="..//doc/chap3_mj.html#X78DCD38B7D96D8A4"><span class="RefLink">CTblLib: GroupInfoForCharacterTable</span></a>). For a long time, this was not successful in the case of <span class="SimpleMath">\(16\)</span> character tables that had been computed by W. Hanrath (see Section "Ordinary and Brauer Tables in the <strong class="pkg">GAP</strong> Character Table Library" in the <strong class="pkg">CTblLib</strong> manual).</p>
<p>Using the information from <a href="chapBib_mj.html#biBHP89">[HP89]</a>, it is straightforward to construct such groups as factor groups of infinite groups. Since version 1.3.0 of the <strong class="pkg">CTblLib</strong> package, calling <code class="func">GroupInfoForCharacterTable</code> (<a href="..//doc/chap3_mj.html#X78DCD38B7D96D8A4"><span class="RefLink">CTblLib: GroupInfoForCharacterTable</span></a>) for the <span class="SimpleMath">\(16\)</span> library tables in question yields nonempty lists and thus allows one to access the results of these constructions, via the function <code class="code">CTblLib.FactorGroupOfPerfectSpaceGroup</code>. This is an undocumented auxiliary function that becomes available automatically when <code class="func">GroupInfoForCharacterTable</code> (<a href="..//doc/chap3_mj.html#X78DCD38B7D96D8A4"><span class="RefLink">CTblLib: GroupInfoForCharacterTable</span></a>) has been called for the first time.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">GroupInfoForCharacterTable( "A5" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">IsBound( CTblLib.FactorGroupOfPerfectSpaceGroup );</span>
true
</pre></div>
<p>Below we list the <span class="SimpleMath">\(16\)</span> group constructions. In each case, an epimorphism from the space group in question is defined by mapping the generators returned by by the function <code class="code">generatorsOfPerfectSpaceGroup</code> defined below to the generators stored in the attribute <code class="func">GeneratorsOfGroup</code> (<a href="../../../doc/ref/chap39_mj.html#X79C44528864044C5"><span class="RefLink">Reference: GeneratorsOfGroup</span></a>) of the group returned by <code class="code">CTblLib.FactorGroupOfPerfectSpaceGroup</code>.</p>
<p><a id="X8710D4947AEB366F" name="X8710D4947AEB366F"></a></p>
<h5>1.2-1 <span class="Heading">Constructing the space groups in question</span></h5>
<p>In <a href="chapBib_mj.html#biBHP89">[HP89]</a>, a space group <span class="SimpleMath">\(S\)</span> is described as a subgroup <span class="SimpleMath">\(\{ M(g, t); g \in P, t \in T \}\)</span> of GL<span class="SimpleMath">\((d+1, ℤ)\)</span>, where</p>
<p><div class="pcenter"><table> <tr> <td class="tdright"><span class="SimpleMath">M(g, t)</span></td> <td class="tdcenter"><span class="SimpleMath"> = </span></td> <td class="tdleft"> <table class="GAPDocTable"> <tr> <td class="tdright"><span class="SimpleMath">g</span></td> <td class="tdright"><span class="SimpleMath">0</span></td> </tr> <tr> <td class="tdright"><span class="SimpleMath">V(g)+t</span></td> <td class="tdright"><span class="SimpleMath">1</span></td> </tr> </table> </td> </tr> </table> </div></p>
<p>the <em>point group</em> <span class="SimpleMath">\(P\)</span> of <span class="SimpleMath">\(S\)</span> is a finite subgroup of GL<span class="SimpleMath">\((d, ℤ)\)</span>, the <em>translation lattice</em> <span class="SimpleMath">\(T\)</span> of <span class="SimpleMath">\(S\)</span> is a sublattice of <span class="SimpleMath">\(ℤ^d\)</span>, and the <em>vector system</em> <span class="SimpleMath">\(V\)</span> of <span class="SimpleMath">\(S\)</span> is a map from <span class="SimpleMath">\(P\)</span> to <span class="SimpleMath">\(ℤ^d\)</span>. Note that <span class="SimpleMath">\(V\)</span> maps the identity matrix <span class="SimpleMath">\(I \in\)</span> GL<span class="SimpleMath">\((d, ℤ)\)</span> to the zero vector, and <span class="SimpleMath">\(M(T):= \{ M(I, t); t \in T \}\)</span> is a normal subgroup of <span class="SimpleMath">\(S\)</span> that is isomorphic with <span class="SimpleMath">\(T\)</span>. More generally, <span class="SimpleMath">\(M(n T)\)</span> is a normal subgroup of <span class="SimpleMath">\(S\)</span>, for any positive integer <span class="SimpleMath">\(n\)</span>.</p>
<p>Specifically, <span class="SimpleMath">\(P\)</span> is given by generators <span class="SimpleMath">\(g_1, g_2, \ldots, g_k\)</span>, <span class="SimpleMath">\(T\)</span> is given by a <span class="SimpleMath">\(ℤ\)</span>-basis <span class="SimpleMath">\(B = \{ b_1, b_2, \ldots, b_d \}\)</span> of <span class="SimpleMath">\(T\)</span>, and <span class="SimpleMath">\(V\)</span> is given by the vectors <span class="SimpleMath">\(V(g_1), V(g_2), \ldots, V(g_k)\)</span>.</p>
<p>In the examples below, the matrix representation of <span class="SimpleMath">\(P\)</span> is irreducible, so we need just the following <span class="SimpleMath">\(k+1\)</span> elements to generate <span class="SimpleMath">\(S\)</span>:</p>
<p><div class="pcenter"> <table> <tr> <td class="tdleft"> <table class="GAPDocTable"> <tr> <td class="tdright"><span class="SimpleMath">g_1</span></td> <td class="tdright"><span class="SimpleMath">0</span></td> </tr> <tr> <td class="tdright"><span class="SimpleMath">V(g_1)</span></td> <td class="tdright"><span class="SimpleMath">1</span></td> </tr> </table> <td class="tdleft"> , </td> </td> <td class="tdleft"> <table class="GAPDocTable"> <tr> <td class="tdright"><span class="SimpleMath">g_2</span></td> <td class="tdright"><span class="SimpleMath">0</span></td> </tr> <tr> <td class="tdright"><span class="SimpleMath">V(g_2)</span></td> <td class="tdright"><span class="SimpleMath">1</span></td> </tr> </table> </td> <td class="tdleft"> , ..., </td> <td class="tdleft"> <table class="GAPDocTable"> <tr> <td class="tdright"><span class="SimpleMath">g_k</span></td> <td class="tdright"><span class="SimpleMath">0</span></td> </tr> <tr> <td class="tdright"><span class="SimpleMath">V(g_k)</span></td> <td class="tdright"><span class="SimpleMath">1</span></td> </tr> </table> </td> <td class="tdleft"> , </td> <td class="tdleft"> <table class="GAPDocTable"> <tr> <td class="tdright"><span class="SimpleMath">I</span></td> <td class="tdright"><span class="SimpleMath">0</span></td> </tr> <tr> <td class="tdright"><span class="SimpleMath">b_1</span></td> <td class="tdright"><span class="SimpleMath">1</span></td> </tr> </table> </td> <td class="tdleft"> . </td> </tr> </table> </div></p>
<p>These generators are returned by the function <code class="code">generatorsOfPerfectSpaceGroup</code>, when the inputs are <span class="SimpleMath">\([ g_1, g_2, \ldots, g_k ]\)</span>, <span class="SimpleMath">\([ V(g_1), V(g_2), \ldots, V(g_k) ]\)</span>, and <span class="SimpleMath">\(b_1\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">generatorsOfPerfectSpaceGroup:= function( Pgens, V, t )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> local d, result, i, m;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> d:= Length( Pgens[1] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> result:= [];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for i in [ 1 .. Length( Pgens ) ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> m:= IdentityMat( d+1 );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> m{ [ 1 .. d ] }{ [ 1 .. d ] }:= Pgens[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> m[ d+1 ]{ [ 1 .. d ] }:= V[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> result[i]:= m;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> m:= IdentityMat( d+1 );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> m[ d+1 ]{ [ 1 .. d ] }:= t;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( result, m );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return result;</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;;</span>
</pre></div>
<p><a id="X84E7FE70843422B0" name="X84E7FE70843422B0"></a></p>
<h5>1.2-2 <span class="Heading">Constructing the factor groups in question</span></h5>
<p>The space group <span class="SimpleMath">\(S\)</span> acts on <span class="SimpleMath">\(ℤ^d\)</span>, via <span class="SimpleMath">\(v \cdot M(g, t) = v g + V(g) + t\)</span>. A (not necessarily faithful) representation of <span class="SimpleMath">\(S/M(n T)\)</span> can be obtained from the corresponding action of <span class="SimpleMath">\(S\)</span> on <span class="SimpleMath">\(ℤ^d/(n ℤ^d)\)</span>, that is, by reducing the vectors modulo <span class="SimpleMath">\(n\)</span>. For the <strong class="pkg">GAP</strong> computations, we work instead with vectors of length <span class="SimpleMath">\(d+1\)</span>, extending each vector in <span class="SimpleMath">\(ℤ^d\)</span> by <span class="SimpleMath">\(1\)</span> in the last position, and acting on these vectors by right multiplicaton with elements of <span class="SimpleMath">\(S\)</span>. Multiplication followed by reduction modulo <span class="SimpleMath">\(n\)</span> is implemented by the action function returned by <code class="code">multiplicationModulo</code> when this is called with argument <span class="SimpleMath">\(n\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">multiplicationModulo:= n -> function( v, g )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return List( v * g, x -> x mod n ); end;;</span>
</pre></div>
<p>In some of the examples, the representation of <span class="SimpleMath">\(P\)</span> given in <a href="chapBib_mj.html#biBHP89">[HP89]</a> is the action on the factor of a permutation module modulo its trivial submodule. For that, we provide the function <code class="code">deletedPermutationMat</code>, cf. <a href="chapBib_mj.html#biBHP89">[HP89, p. 269]</a>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">deletedPermutationMat:= function( pi, n )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> local mat, j, i;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> mat:= PermutationMat( pi, n );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> mat:= mat{ [ 1 .. n-1 ] }{ [ 1 .. n-1 ] };</span>
<span class="GAPprompt">></span> <span class="GAPinput"> j:= n ^ pi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if j <> n then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for i in [ 1 .. n-1 ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> mat[i][j]:= -1;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return mat;</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;;</span>
</pre></div>
<p>After constructing permutation generators for the example groups, we verify that the groups fit to the character tables from the <strong class="pkg">GAP</strong> Character Table Library and to the permutation generators stored for the construction of the group via <code class="code">CTblLib.FactorGroupOfPerfectSpaceGroup</code>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup:= function( gens, id )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> local sm, act, stored, hom;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> sm:= SmallerDegreePermutationRepresentation( Group( gens ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> gens:= List( gens, x -> x^sm );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> act:= Images( sm );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if not IsRecord( TransformingPermutationsCharacterTables(</span>
<span class="GAPprompt">></span> <span class="GAPinput"> CharacterTable( act ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> CharacterTable( id ) ) ) then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return "wrong character table";</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> GroupInfoForCharacterTable( id );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> stored:= CTblLib.FactorGroupOfPerfectSpaceGroup( id );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> hom:= GroupHomomorphismByImages( stored, act,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> GeneratorsOfGroup( stored ), gens );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if hom = fail or not IsBijective( hom ) then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return "wrong group";</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return true;</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;;</span>
</pre></div>
<p><a id="X79109A20873E76DA" name="X79109A20873E76DA"></a></p>
<h5>1.2-3 <span class="Heading">Examples with point group <span class="SimpleMath">\(A_5\)</span></span></h5>
<p>There are two examples with <span class="SimpleMath">\(d = 5\)</span>. The generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 272]</a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">a:= deletedPermutationMat( (1,3)(2,4), 6 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">b:= deletedPermutationMat( (1,2,3)(4,5,6), 6 );;</span>
</pre></div>
<p>In both cases, the vector system is <span class="SimpleMath">\(V_2\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">v:= [ [ 2, 2, 0, 0, 1 ], 0 * b[1] ];;</span>
</pre></div>
<p>In the first example, the translation lattice is the sublattice <span class="SimpleMath">\(L = 2 L_1\)</span> of the full lattice <span class="SimpleMath">\(L_1 = ℤ^d\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= [ 2, 0, 0, 0, 0 ];;</span>
</pre></div>
<p>The library character table with identifier <code class="code">"P1/G2/L1/V2/ext4"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(4 L)\)</span>, so we compute the action on an orbit modulo <span class="SimpleMath">\(8\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fun:= multiplicationModulo( 8 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, [ 1, 0, 0, 0, 0, 1 ], fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P1/G2/L1/V2/ext4" );</span>
true
</pre></div>
<p>In the second example, the translation lattice is the sublattice <span class="SimpleMath">\(2 L_2\)</span> of <span class="SimpleMath">\(ℤ^d\)</span> where <span class="SimpleMath">\(L_2\)</span> has the following basis.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">bas:= [ [-1,-1, 1, 1, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1, 1,-1, 1, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 1, 1,-1,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 1,-1,-1, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1, 1, 1,-1, 1 ] ];;</span>
</pre></div>
<p>For the sake of simplicity, we rewrite the action of the point group to one on <span class="SimpleMath">\(L_2\)</span>, and we adjust also the vector system.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">B:= Basis( Rationals^Length( bas ), bas );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">abas:= List( bas, x -> Coefficients( B, x * a ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">bbas:= List( bas, x -> Coefficients( B, x * b ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">vbas:= List( v, x -> Coefficients( B, x ) );</span>
[ [ 3/2, 1, 2, 3/2, -1 ], [ 0, 0, 0, 0, 0 ] ]
</pre></div>
<p>In order to work with integral matrices (which is necessary because <code class="code">multiplicationModulo</code> uses <strong class="pkg">GAP</strong>'s <code class="code">mod</code> operator), we double both the vector system and the translation lattice.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">vbas:= vbas * 2;</span>
[ [ 3, 2, 4, 3, -2 ], [ 0, 0, 0, 0, 0 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= 2 * t;</span>
[ 4, 0, 0, 0, 0 ]
</pre></div>
<p>The library character table with identifier <code class="code">"P1/G2/L2/V2/ext4"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(8 L_2)\)</span>; since we have doubled the lattice, we compute the action on an orbit modulo <span class="SimpleMath">\(16\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ abas, bbas ], vbas, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fun:= multiplicationModulo( 16 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, [ 0, 0, 0, 0, 0, 1 ], fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P1/G2/L2/V2/ext4" );</span>
true
</pre></div>
<p><a id="X83523D1E792F9E01" name="X83523D1E792F9E01"></a></p>
<h5>1.2-4 <span class="Heading">Examples with point group <span class="SimpleMath">\(L_3(2)\)</span></span></h5>
<p>There are three examples with <span class="SimpleMath">\(d = 6\)</span> and one example with <span class="SimpleMath">\(d = 8\)</span>. The generators of the point group for the first three examples are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 290]</a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">a:= [ [ 0, 1, 0, 1, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 0, 1, 1, 1, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1,-1,-1,-1, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0,-1,-1,-1,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 1, 1, 1, 0, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 1, 0, 1, 0 ] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">b:= [ [-1, 0, 0, 0, 0,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0,-1, 0,-1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 1, 1, 1, 1, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 1, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1,-1,-1, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 0, 0, 0, 0, 0 ] ];;</span>
</pre></div>
<p>The first vector system is the trivial vector system <span class="SimpleMath">\(V_1\)</span> (that is, the space group <span class="SimpleMath">\(S\)</span> is a split extension of the point group and the translation lattice), and the translation lattice is the full lattice <span class="SimpleMath">\(L_1 = ℤ^d\)</span>.</p>
<p>The library character table with identifier <code class="code">"P11/G1/L1/V1/ext4"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(4 L_1)\)</span>, so we compute the action on an orbit modulo <span class="SimpleMath">\(4\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">v:= List( [ 1, 2 ], i -> 0 * a[1] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= [ 1, 0, 0, 0, 0, 0 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fun:= multiplicationModulo( 4 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">seed:= [ 1, 0, 0, 0, 0, 0, 1 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, seed, fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P11/G1/L1/V1/ext4" );</span>
true
</pre></div>
<p>The second vector system is <span class="SimpleMath">\(V_2\)</span>, and the translation lattice is <span class="SimpleMath">\(2 L_1\)</span>.</p>
<p>The library character table with identifier <code class="code">"P11/G1/L1/V2/ext4"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(8 L_1)\)</span>, so we compute the action on an orbit modulo <span class="SimpleMath">\(8\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">v:= [ [ 1, 0, 1, 0, 0, 0 ], 0 * a[1] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= [ 2, 0, 0, 0, 0, 0 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fun:= multiplicationModulo( 8 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, [ 1, 0, 0, 0, 0, 0, 1 ], fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P11/G1/L1/V2/ext4" );</span>
true
</pre></div>
<p>The third vector system is <span class="SimpleMath">\(V_3\)</span>, and the translation lattice is <span class="SimpleMath">\(2 L_1\)</span>.</p>
<p>The library character table with identifier <code class="code">"P11/G1/L1/V3/ext4"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(8 L_1)\)</span>, so we compute the action on an orbit modulo <span class="SimpleMath">\(8\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">v:= [ [ 0, 1, 0, 0, 1, 0 ], 0 * a[1] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= [ 2, 0, 0, 0, 0, 0 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fun:= multiplicationModulo( 8 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, [ 1, 0, 0, 0, 0, 0, 1 ], fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P11/G1/L1/V3/ext4" );</span>
true
</pre></div>
<p>The generators of the point group for the fourth example are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 293]</a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">a:= [ [ 1, 0, 0, 1, 0,-1, 0, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0,-1, 1, 0,-1, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 0, 0, 1, 0,-1, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0,-1, 0,-1, 0, 1, 1,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 0,-1, 1, 1,-1, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1,-1,-1, 0, 0, 0, 1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0,-1, 1, 0,-1, 1, 0,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 0,-1, 0, 0, 0, 0, 0 ] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">b:= [ [ 1, 0,-2, 0, 1,-1, 1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0,-1, 0, 0, 0, 0, 1,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 0,-1, 0, 1,-1, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1,-1, 1,-1,-1, 2, 0,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0,-1, 0, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0,-1, 0,-1,-1, 1, 1,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1,-1, 0, 0, 0, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 0, 0, 0, 0, 0, 0, 0 ] ];;</span>
</pre></div>
<p>The vector system is the trivial vector system <span class="SimpleMath">\(V_1\)</span>, and the translation lattice is the full lattice <span class="SimpleMath">\(L_1 = ℤ^d\)</span>.</p>
<p>The library character table with identifier <code class="code">"P11/G4/L1/V1/ext3"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(3 L_1)\)</span>, so we compute the action on an orbit modulo <span class="SimpleMath">\(3\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">v:= List( [ 1, 2 ], i -> 0 * a[1] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= [ 1, 0, 0, 0, 0, 0, 0, 0 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fun:= multiplicationModulo( 3 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">seed:= [ 1, 0, 0, 0, 0, 0, 0, 0, 1 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, seed, fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P11/G4/L1/V1/ext3" );</span>
true
</pre></div>
<p><a id="X7A01A9BC846BE39A" name="X7A01A9BC846BE39A"></a></p>
<h5>1.2-5 <span class="Heading">Example with point group SL<span class="SimpleMath">\(_2(7)\)</span></span></h5>
<p>There is one example with <span class="SimpleMath">\(d = 8\)</span>. The generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 295]</a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">a:= KroneckerProduct( IdentityMat( 4 ), [ [ 0, 1 ], [ -1, 0 ] ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">b:= [ [ 0,-1, 0, 0, 0, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 1, 0, 0, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1, 0, 0, 0, 0, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 0,-1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0,-1, 0, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 1, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 1, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 0, 0, 1 ] ];;</span>
</pre></div>
<p>The vector system is the trivial vector system <span class="SimpleMath">\(V_1\)</span>, and the translation lattice is the sublattice <span class="SimpleMath">\(L_2\)</span> of <span class="SimpleMath">\(ℤ^d\)</span> that has the following basis, which is called <span class="SimpleMath">\(B(2,8)\)</span> in <a href="chapBib_mj.html#biBHP89">[HP89, p. 269]</a>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">bas:= [ [ 1, 1, 0, 0, 0, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 1, 1, 0, 0, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 1, 1, 0, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 1, 1, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 1, 1, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 1, 1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 0, 1, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 0,-1, 1 ] ];;</span>
</pre></div>
<p>For the sake of simplicity, we rewrite the action to one on <span class="SimpleMath">\(L_2\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">B:= Basis( Rationals^Length( bas ), bas );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">abas:= List( bas, x -> Coefficients( B, x * a ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">bbas:= List( bas, x -> Coefficients( B, x * b ) );;</span>
</pre></div>
<p>The library character table with identifier <code class="code">"P12/G1/L2/V1/ext2"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(2 L_2)\)</span>. The action on an orbit modulo <span class="SimpleMath">\(2\)</span> is not faithful, its kernel contains the centre of SL<span class="SimpleMath">\((2,7)\)</span>. We can compute a faithful representation by acting on pairs: One entry is the usual vector and the other entry carries the action of the point group.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">v:= List( [ 1, 2 ], i -> 0 * a[1] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= [ 1, 0, 0, 0, 0, 0, 0, 0 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ abas, bbas ], v, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fun:= multiplicationModulo( 2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">funpairs:= function( pair, g )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return [ fun( pair[1], g ), pair[2] * g ];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> end;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">seed:= [ [ 1, 0, 0, 0, 0, 0, 0, 0, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 0, 0, 0, 0, 0, 0, 0, 0 ] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, seed, funpairs );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, funpairs ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P12/G1/L2/V1/ext2" );</span>
true
</pre></div>
<p><a id="X7D3100B58093F37D" name="X7D3100B58093F37D"></a></p>
<h5>1.2-6 <span class="Heading">Example with point group <span class="SimpleMath">\(2^3.L_3(2)\)</span></span></h5>
<p>There is one example with <span class="SimpleMath">\(d = 7\)</span>. The generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 297]</a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">a:= PermutationMat( (2,4)(5,7), 7 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">b:= PermutationMat( (1,3,2)(4,6,5), 7 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">c:= DiagonalMat( [ -1, -1, 1, 1, -1, -1, 1 ] );;</span>
</pre></div>
<p>The vector system is the trivial vector system <span class="SimpleMath">\(V_1\)</span>, and the translation lattice is the sublattice <span class="SimpleMath">\(L_2\)</span> of <span class="SimpleMath">\(ℤ^d\)</span> that has the following basis, which is called <span class="SimpleMath">\(B(2,7)\)</span> in <a href="chapBib_mj.html#biBHP89">[HP89, p. 269]</a>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">bas:= [ [ 1, 1, 0, 0, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 1, 1, 0, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 1, 1, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 1, 1, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 1, 1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 1, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0,-1, 1 ] ];;</span>
</pre></div>
<p>For the sake of simplicity, we rewrite the action to one on <span class="SimpleMath">\(L_2\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">B:= Basis( Rationals^Length( bas ), bas );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">abas:= List( bas, x -> Coefficients( B, x * a ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">bbas:= List( bas, x -> Coefficients( B, x * b ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cbas:= List( bas, x -> Coefficients( B, x * c ) );;</span>
</pre></div>
<p>The library character table with identifier <code class="code">"P13/G1/L2/V1/ext2"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(2 L_2)\)</span>, so we compute the action on an orbit modulo <span class="SimpleMath">\(2\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">v:= List( [ 1 .. 3 ], i -> 0 * a[1] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= [ 1, 0, 0, 0, 0, 0, 0 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ abas,bbas,cbas ], v, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fun:= multiplicationModulo( 2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, [ 1, 0, 0, 0, 0, 0, 0, 1 ], fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">act:= Action( g, orb, fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P13/G1/L2/V1/ext2" );</span>
true
</pre></div>
<p><a id="X80800F3B7D6EF06C" name="X80800F3B7D6EF06C"></a></p>
<h5>1.2-7 <span class="Heading">Examples with point group <span class="SimpleMath">\(A_6\)</span></span></h5>
<p>There are two examples with <span class="SimpleMath">\(d = 10\)</span>. In both cases, the generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 307]</a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">b:= [ [ 0,-1, 0, 0, 0, 0, 0, 0, 0, 0 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0,-1, 0, 0, 0, 0, 0 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">c:= [ [ 0, 0, 0, 0, 0, 0, 0,-1, 0, 0 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 0, 0,-1, 1,-1 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0,-1, 1, 0,-1, 0, 0 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0,-1, 1, 0, 0, 0, 0,-1, 0, 0 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 0, 0, 0, 0,-1 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 1,-1, 0, 0, 1 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 1,-1, 0, 0, 0, 0, 0, 1 ], </span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1, 0, 1, 0, 0,-1, 0, 0, 0, 0 ] ];;</span>
</pre></div>
<p>In both examples, the vector system is the trivial vector system <span class="SimpleMath">\(V_1\)</span>, and the translation lattices are the lattices <span class="SimpleMath">\(L_2\)</span> and <span class="SimpleMath">\(L_5\)</span>, respectively, which have the following bases.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">bas2:= [ [ 0, 1,-1, 0, 0, 0, 0, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 1,-1, 0, 0, 0, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 1,-1, 0, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 1,-1, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 1, 0,-1, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 0, 0, 1,-1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 0, 0, 0, 1,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 1, 0, 0, 0, 0, 0,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 1, 0, 0, 0, 0, 0, 1, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 ] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">bas5:= [ [ 0,-1, 1, 1,-1, 1, 1,-1,-1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 0,-1,-1,-1, 1, 1,-1,-1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 1, 1,-1, 1, 1,-1, 0, 1, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 1, 0,-1, 0,-1, 1,-1, 1,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1, 0,-1, 1, 1, 0,-1,-1, 1,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 1,-1, 1, 1,-1, 1, 1, 0,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1,-1, 1, 1, 0,-1,-1,-1,-1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1,-1, 0,-1, 1,-1, 1, 1, 0,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1, 1,-1, 1,-1, 0,-1, 1, 0,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1,-1,-1, 1, 1, 1, 0, 0,-1,-1 ] ];;</span>
</pre></div>
<p>For the sake of simplicity, we rewrite the action to actions on <span class="SimpleMath">\(L_2\)</span> and <span class="SimpleMath">\(L_5\)</span>, respectively.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">B2:= Basis( Rationals^Length( bas2 ), bas2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">bbas2:= List( bas2, x -> Coefficients( B2, x * b ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cbas2:= List( bas2, x -> Coefficients( B2, x * c ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">B5:= Basis( Rationals^Length( bas5 ), bas5 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">bbas5:= List( bas5, x -> Coefficients( B5, x * b ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cbas5:= List( bas5, x -> Coefficients( B5, x * c ) );;</span>
</pre></div>
<p>The library character table with identifier <code class="code">"P21/G3/L2/V1/ext2"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(2 L_2)\)</span>, so we compute the action on an orbit modulo <span class="SimpleMath">\(2\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">v:= List( [ 1, 2 ], i -> 0 * bbas2[1] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ bbas2, cbas2 ], v, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fun:= multiplicationModulo( 2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">seed:= [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, seed, fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P21/G3/L2/V1/ext2" );</span>
true
</pre></div>
<p>The library character table with identifier <code class="code">"P21/G3/L5/V1/ext2"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(2 L_5)\)</span>, so we compute the action on an orbit modulo <span class="SimpleMath">\(2\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ bbas5, cbas5 ], v, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, seed, fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P21/G3/L5/V1/ext2" );</span>
true
</pre></div>
<p><a id="X7D43452C79B0EAE1" name="X7D43452C79B0EAE1"></a></p>
<h5>1.2-8 <span class="Heading">Examples with point group <span class="SimpleMath">\(L_2(8)\)</span></span></h5>
<p>There are two examples with <span class="SimpleMath">\(d = 7\)</span>. In both cases, the generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 327]</a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">a:= [ [ 0,-1, 0, 1, 0,-1, 1],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0,-1, 0, 1,-1, 0],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0,-1, 1, 0, 0],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0,-1, 0, 0, 0],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 1,-1, 0, 0, 0],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0,-1, 1, 0,-1, 0, 0],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1,-1, 0, 1, 0,-1, 0] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">b:= [ [-1, 0, 1, 0,-1, 1, 0],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0,-1, 0, 1,-1, 0, 0],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0,-1, 1, 0, 0, 0],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0,-1, 0, 0, 0, 0],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 1,-1, 0, 0, 0, 0],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1, 1, 0,-1, 0, 0, 0],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1, 0, 1, 0,-1, 0, 1] ];;</span>
</pre></div>
<p>In both examples, the vector system is <span class="SimpleMath">\(V_2\)</span>. The translation lattice in the first example is the lattice <span class="SimpleMath">\(L = 3 ℤ^d\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">v:= [ [ 2, 1, 0, 0, 0, 1, 4 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 2, 0, 0, 0, 0, 0, 0 ] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= [ 3, 0, 0, 0, 0, 0, 0 ];;</span>
</pre></div>
<p>The library character table with identifier <code class="code">"P41/G1/L1/V3/ext3"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(3 L)\)</span>, so we compute the action on an orbit modulo <span class="SimpleMath">\(9\)</span>.</p>
<p>The orbits in this action are quite long. we choose a seed vector from the fixed space of an element of order <span class="SimpleMath">\(7\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">aa:= sgens[1];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">bb:= sgens[2];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">elm:= aa*bb;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Order( elm );</span>
7
<span class="GAPprompt">gap></span> <span class="GAPinput">fixed:= NullspaceMat( elm - aa^0 );</span>
[ [ 1, 1, 1, 1, 1, 1, 1, 0 ], [ -4, 1, 1, -5, -5, 2, 0, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">fun:= multiplicationModulo( 9 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">seed:= fun( fixed[2], aa^0 );</span>
[ 5, 1, 1, 4, 4, 2, 0, 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, seed, fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P41/G1/L1/V3/ext3" );</span>
true
</pre></div>
<p>The translation lattice in the second example is the lattice <span class="SimpleMath">\(L = 6 ℤ^d\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= [ 6, 0, 0, 0, 0, 0, 0 ];;</span>
</pre></div>
<p>The library character table with identifier <code class="code">"P41/G1/L1/V4/ext3"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(6 L)\)</span>, so we compute the action on an orbit modulo <span class="SimpleMath">\(18\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">fun:= multiplicationModulo( 18 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">seed:= fun( fixed[2], aa^0 );</span>
[ 14, 1, 1, 13, 13, 2, 0, 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, seed, fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P41/G1/L1/V4/ext3" );</span>
true
</pre></div>
<p><a id="X8575CE147A9819BF" name="X8575CE147A9819BF"></a></p>
<h5>1.2-9 <span class="Heading">Example with point group <span class="SimpleMath">\(M_{11}\)</span></span></h5>
<p>There is one example with <span class="SimpleMath">\(d = 10\)</span>. The generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 334]</a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">a:= deletedPermutationMat( (1,9)(3,5)(7,11)(8,10), 11 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">b:= deletedPermutationMat( (1,4,3,2)(5,8,7,6), 11 );;</span>
</pre></div>
<p>The vector system is <span class="SimpleMath">\(V_2\)</span>, and the translation lattice is <span class="SimpleMath">\(L = 2 ℤ^d\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">v:= [ 0 * a[1],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 ] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= [ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];;</span>
</pre></div>
<p>The library character table with identifier <code class="code">"P48/G1/L1/V2/ext2"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(2 L)\)</span>, so we compute the action on an orbit modulo <span class="SimpleMath">\(4\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fun:= multiplicationModulo( 4 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ], fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P48/G1/L1/V2/ext2" );</span>
true
</pre></div>
<p><a id="X7C0201B77DA1682A" name="X7C0201B77DA1682A"></a></p>
<h5>1.2-10 <span class="Heading">Example with point group <span class="SimpleMath">\(U_3(3)\)</span></span></h5>
<p>There is one example with <span class="SimpleMath">\(d = 7\)</span>. The generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 335]</a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">a:= [ [ 0, 0,-1, 1, 0,-1, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 0,-1, 1, 1,-1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 1,-1, 0, 1, 0,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 1, 0,-1, 1, 0,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1, 1, 1,-1, 0, 1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1, 0, 1,-1, 0, 0, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 0, 1 ] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">b:= [ [ 0, 0, 0, 0, 0, 0, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0,-1, 1, 0,-1, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 0,-1, 1, 1,-1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 1,-1, 0, 1, 0,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 1, 0,-1, 1, 0,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1, 1, 1,-1, 0, 1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [-1, 0, 1,-1, 0, 0, 1 ] ];;</span>
</pre></div>
<p>The vector system is <span class="SimpleMath">\(V_2\)</span>, and the translation lattice is <span class="SimpleMath">\(L = 3 ℤ^d\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">v:= [ [ 2, 1, 0, 0, 2, 1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> 0 * b[1] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= [ 3, 0, 0, 0, 0, 0, 0 ];;</span>
</pre></div>
<p>The library character table with identifier <code class="code">"P49/G1/L1/V2/ext3"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(3 L)\)</span>, so we compute the action on an orbit modulo <span class="SimpleMath">\(9\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fun:= multiplicationModulo( 9 );;</span>
</pre></div>
<p>The orbits in this action are quite long. we choose a seed vector from the fixed space of an element of order <span class="SimpleMath">\(12\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">aa:= sgens[1];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">bb:= sgens[2];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">elm:= aa*bb^4;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Order( elm );</span>
12
<span class="GAPprompt">gap></span> <span class="GAPinput">fixed:= NullspaceMat( elm - aa^0 );</span>
[ [ -1, -1, 1, 1, -1, -1, 1, 0 ], [ 0, -3, 1, 1, -1, -2, 0, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">seed:= fun( fixed[2], aa^0 );</span>
[ 0, 6, 1, 1, 8, 7, 0, 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, seed, fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P49/G1/L1/V2/ext3" );</span>
true
</pre></div>
<p><a id="X85D9C329792E58F3" name="X85D9C329792E58F3"></a></p>
<h5>1.2-11 <span class="Heading">Examples with point group <span class="SimpleMath">\(U_4(2)\)</span></span></h5>
<p>There are two examples with <span class="SimpleMath">\(d = 6\)</span>. In both cases, the generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 336]</a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">a:= [ [ 0, 1, 0,-1,-1, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 0,-1, 0, 1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0,-1, 0, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0,-1, 0, 0, 1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0, 0, 1 ] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">b:= [ [ 0,-1, 0, 1, 0,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 1, 0,-1,-1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 1, 1, 0,-1 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 0, 0, 0,-1, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 0, 1, 0, 0, 0, 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 1, 0, 0, 0, 0, 0 ] ];;</span>
</pre></div>
<p>In both examples, the vector system is the trivial vector system <span class="SimpleMath">\(V_1\)</span>, and the translation lattice is the full lattice <span class="SimpleMath">\(L_1 = ℤ^d\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">v:= List( [ 1, 2 ], i -> 0 * a[1] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= [ 1, 0, 0, 0, 0, 0 ];;</span>
</pre></div>
<p>The library character table with identifier <code class="code">"P50/G1/L1/V1/ext3"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(3 L_1)\)</span>, so we compute the action on an orbit modulo <span class="SimpleMath">\(3\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fun:= multiplicationModulo( 3 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, [ 1, 0, 0, 0, 0, 0, 1 ], fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P50/G1/L1/V1/ext3" );</span>
true
</pre></div>
<p>The library character table with identifier <code class="code">"P50/G1/L1/V1/ext4"</code> belongs to the factor group of <span class="SimpleMath">\(S\)</span> modulo the normal subgroup <span class="SimpleMath">\(M(4 L_1)\)</span>, so we compute the action on an orbit modulo <span class="SimpleMath">\(4\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= Group( sgens );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fun:= multiplicationModulo( 4 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">orb:= Orbit( g, [ 1, 0, 0, 0, 0, 0, 1 ], fun );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">verifyFactorGroup( permgens, "P50/G1/L1/V1/ext4" );</span>
true
</pre></div>
<p><a id="X8635EE0B78A66120" name="X8635EE0B78A66120"></a></p>
<h5>1.2-12 <span class="Heading">A remark on one of the example groups</span></h5>
<p>The (perfect) character table with identifier <code class="code">"P1/G2/L2/V2/ext4"</code> has the property that its character degrees are exactly the divisors of <span class="SimpleMath">\(60\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">degrees:= CharacterDegrees( CharacterTable( "P1/G2/L2/V2/ext4" ) );</span>
[ [ 1, 1 ], [ 2, 2 ], [ 3, 2 ], [ 4, 2 ], [ 5, 1 ], [ 6, 5 ],
[ 10, 4 ], [ 12, 4 ], [ 15, 20 ], [ 20, 2 ], [ 30, 29 ], [ 60, 8 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( degrees, x -> x[1] ) = DivisorsInt( 60 );</span>
true
</pre></div>
<p>There are nilpotent groups with the same set of character degrees, for example the direct product of four extraspecial groups of the orders <span class="SimpleMath">\(2^3\)</span>, <span class="SimpleMath">\(2^3\)</span>, <span class="SimpleMath">\(3^3\)</span>, and <span class="SimpleMath">\(5^3\)</span>, respectively. This phenomenon has been described in <a href="chapBib_mj.html#biBNR14">[NR14]</a>.</p>
<p><a id="X8448022280E82C52" name="X8448022280E82C52"></a></p>
<h4>1.3 <span class="Heading">Generality problems (December 2004/October 2015)</span></h4>
<p>The term "generality problem" is used for problems concerning consistent choices of conjugacy classes of Brauer tables for the same group, in different characteristics. The definition and some examples are given in <a href="chapBib_mj.html#biBJLPW95">[JLPW95, p. x]</a>.</p>
<p>Section <a href="chap1_mj.html#X7D1A66C3844D09B1"><span class="RefLink">1.3-1</span></a> shows how to detect generality problems and lists the known generality problems, and Section <a href="chap1_mj.html#X80EB5D827A78975A"><span class="RefLink">1.3-2</span></a> gives an example that actually arose.</p>
<p><a id="X7D1A66C3844D09B1" name="X7D1A66C3844D09B1"></a></p>
<h5>1.3-1 <span class="Heading">Listing possible generality problems</span></h5>
<p>We use the following idea for finding character tables which may involve generality problems. (The functions shown in this section are based on <strong class="pkg">GAP</strong> 3 code that was originally written by Jürgen Müller.)</p>
<p>If the <span class="SimpleMath">\(p\)</span>-modular Brauer table <span class="SimpleMath">\(mtbl\)</span>, say, of a group contributes to a generality problem then some choice of conjugacy classes is necessary in order to write down this table, in the sense that some symmetry of the corresponding ordinary table <span class="SimpleMath">\(tbl\)</span>, say, is broken in <span class="SimpleMath">\(mtbl\)</span>. This situation can be detected as follows. We assume that the class fusion from <span class="SimpleMath">\(mtbl\)</span> to <span class="SimpleMath">\(tbl\)</span> has been fixed. All possible class fusions are obtained as the orbit of this class fusion under the actions of table automorphisms of <span class="SimpleMath">\(tbl\)</span>, via mapping the images of the class fusion (with the function <code class="func">OnTuples</code> (<a href="../../../doc/ref/chap41_mj.html#X832CC5F87EEA4A7E"><span class="RefLink">Reference: OnTuples</span></a>)), and of the table automorphisms of <span class="SimpleMath">\(mtbl\)</span>, via permuting the preimages. The case of broken symmetries occurs if and only if this orbit splits into several orbits when only the action of the table automorphisms of <span class="SimpleMath">\(mtbl\)</span> is considered. Equivalently, symmetries are broken if and only if the orbit under table automorphisms of <span class="SimpleMath">\(mtbl\)</span> is not closed under the action of table automorphisms of <span class="SimpleMath">\(tbl\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">BrokenSymmetries:= function( ordtbl, modtbl )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> local taut, maut, triv, fus, orb;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> taut:= AutomorphismsOfTable( ordtbl );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> maut:= AutomorphismsOfTable( modtbl );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> triv:= TrivialSubgroup( taut );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fus:= GetFusionMap( modtbl, ordtbl );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> orb:= MakeImmutable( Set( OrbitFusions( maut, fus, triv ) ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return ForAny( GeneratorsOfGroup( taut ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> ForAny( orb,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fus -> not OnTuples( fus, x ) in orb ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;;</span>
</pre></div>
<p><em>Remark:</em> (Thanks to Klaus Lux for discussions on this topic.)</p>
<ul>
<li><p>It may happen that some symmetry <span class="SimpleMath">\(\sigma_m\)</span> of a Brauer table does not belong to a symmetry <span class="SimpleMath">\(\sigma_o\)</span> of the corresponding ordinary table, in the sense that permuting the preimage classes of a fusion <span class="SimpleMath">\(f\)</span> between the two tables with <span class="SimpleMath">\(\sigma_m\)</span> and permuting the image classes with <span class="SimpleMath">\(\sigma_o\)</span> yields <span class="SimpleMath">\(f\)</span>.</p>
<p>For example, consider the group <span class="SimpleMath">\(G = 2.A_6.2_1\)</span>, the double cover of the symmetric group <span class="SimpleMath">\(S_6\)</span> on six points. The <span class="SimpleMath">\(2\)</span>-modular Brauer table of <span class="SimpleMath">\(G\)</span>, which is essentially equal to that of <span class="SimpleMath">\(S_6\)</span>, has a table automorphism group order two, and the nonidentity element in it swaps the two classes of element order three. The automorphism group of the ordinary character table of <span class="SimpleMath">\(G\)</span>, however, fixes the two classes of element order three; note that exactly one of these classes possesses square roots in the "outer half" <span class="SimpleMath">\(G \setminus G'\)</span>.</p>
<p>Thus it is not sufficient to compare the orbit of the fixed class fusion under the automorphisms of the ordinary table with the orbit of the same fusion under the automorphisms of the Brauer table.</p>
</li>
</ul>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "2.A6.2_1" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">m:= t mod 2;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">GetFusionMap( m, t );</span>
[ 1, 4, 6, 9 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">AutomorphismsOfTable( t );</span>
Group([ (16,17), (14,15), (14,15)(16,17) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">AutomorphismsOfTable( m );</span>
Group([ (2,3) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( m );</span>
2.A6.2_1mod2
2 5 2 2 1
3 2 2 2 .
5 1 . . 1
1a 3a 3b 5a
2P 1a 3a 3b 5a
3P 1a 1a 1a 5a
5P 1a 3a 3b 1a
X.1 1 1 1 1
X.2 4 1 -2 -1
X.3 4 -2 1 -1
X.4 16 -2 -2 1
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( t );</span>
2.A6.2_1
2 5 5 4 2 2 2 2 3 1 1 4 4 3 2 2 2 2
3 2 2 . 2 2 2 2 . . . 1 1 . 1 1 1 1
5 1 1 . . . . . . 1 1 . . . . . . .
1a 2a 4a 3a 6a 3b 6b 8a 5a 10a 2b 4b 8b 6c 6d 12a 12b
2P 1a 1a 2a 3a 3a 3b 3b 4a 5a 5a 1a 2a 4a 3a 3a 6b 6b
3P 1a 2a 4a 1a 2a 1a 2a 8a 5a 10a 2b 4b 8b 2b 2b 4b 4b
5P 1a 2a 4a 3a 6a 3b 6b 8a 1a 2a 2b 4b 8b 6d 6c 12b 12a
X.1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
X.2 1 1 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1
X.3 5 5 1 2 2 -1 -1 -1 . . 3 -1 1 . . -1 -1
X.4 5 5 1 2 2 -1 -1 -1 . . -3 1 -1 . . 1 1
X.5 5 5 1 -1 -1 2 2 -1 . . -1 3 1 -1 -1 . .
X.6 5 5 1 -1 -1 2 2 -1 . . 1 -3 -1 1 1 . .
X.7 16 16 . -2 -2 -2 -2 . 1 1 . . . . . . .
X.8 9 9 1 . . . . 1 -1 -1 3 3 -1 . . . .
X.9 9 9 1 . . . . 1 -1 -1 -3 -3 1 . . . .
X.10 10 10 -2 1 1 1 1 . . . 2 -2 . -1 -1 1 1
X.11 10 10 -2 1 1 1 1 . . . -2 2 . 1 1 -1 -1
X.12 4 -4 . -2 2 1 -1 . -1 1 . . . . . B -B
X.13 4 -4 . -2 2 1 -1 . -1 1 . . . . . -B B
X.14 4 -4 . 1 -1 -2 2 . -1 1 . . . A -A . .
X.15 4 -4 . 1 -1 -2 2 . -1 1 . . . -A A . .
X.16 16 -16 . -2 2 -2 2 . 1 -1 . . . . . . .
X.17 20 -20 . 2 -2 2 -2 . . . . . . . . . .
A = E(3)-E(3)^2
= Sqrt(-3) = i3
B = -E(12)^7+E(12)^11
= Sqrt(3) = r3
</pre></div>
<p>When considering several characteristics in parallel, one argues as follows. The possible class fusions from a Brauer table <span class="SimpleMath">\(mtbl\)</span> to its ordinary table <span class="SimpleMath">\(tbl\)</span> are given by the orbit of a fixed class fusion under the action of the table automorphisms of <span class="SimpleMath">\(tbl\)</span>. If there are several orbits under the action of the automorphisms of <span class="SimpleMath">\(mtbl\)</span> then we choose one orbit. Due to this choice, only those table automorphisms of <span class="SimpleMath">\(tbl\)</span> are admissible for other characteristics that stabilize the chosen orbit. For the second characteristic, we take again the set of all class fusions from the Brauer table to <span class="SimpleMath">\(tbl\)</span>, and split it into orbits under the table automorphisms of the Brauer table. Now there are two possibilities. Either the action of the admissible subgroup of automorphisms of <span class="SimpleMath">\(tbl\)</span> joins these orbits into one orbit or not. In the former case, we choose again one of the orbits, replace the group of admissible automorphisms of <span class="SimpleMath">\(tbl\)</span> by the stabilizer of this orbit, and proceed with the next characteristic. In the latter case, we have found a generality problem, since we are not free to choose an arbitrary class fusion from the set of possibilities.</p>
<p>The following function returns the set of primes which may be involved in generality problems for the given ordinary character table. Note that the procedure sketched above does not tell which characteristics are actually involved or which classes are affected by the choices; for example, we could argue that one is always free to choose a fusion for the first characteristics, and that only the other ones cause problems. We return <em>all</em> those primes <span class="SimpleMath">\(p\)</span> for which broken symmetries between the <span class="SimpleMath">\(p\)</span>-modular table and the ordinary table have been detected.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">PrimesOfGeneralityProblems:= function( ordtbl )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> local consider, p, modtbl, taut, triv, admiss, fusion, maut,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> allfusions, orbits, orbit, reps;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # Find the primes for which symmetries are broken.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> consider:= [];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for p in Filtered( PrimeDivisors( Size( ordtbl ) ), IsPrimeInt ) do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> modtbl:= ordtbl mod p;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if modtbl <> fail and BrokenSymmetries( ordtbl, modtbl ) then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( consider, p );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # Compute the choices and detect generality problems.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> taut:= AutomorphismsOfTable( ordtbl );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> triv:= TrivialSubgroup( taut );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> admiss:= taut;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for p in consider do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> modtbl:= ordtbl mod p;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fusion:= GetFusionMap( modtbl, ordtbl );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> maut:= AutomorphismsOfTable( modtbl );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # - We need not apply the action of 'maut' here,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # since 'maut' will later be used to get representatives.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # - We need not apply all elements in 'taut' but only</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # representatives of left cosets of 'admiss' in 'taut',</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # since 'admiss' will later be used to get representatives.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # allfusions:= OrbitFusions( maut, fusion, taut );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> allfusions:= Set( RightTransversal( taut, admiss ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> OnTuples( fusion, x^-1 ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # For computing representatives, 'RepresentativesFusions' is not</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # suitable because 'allfusions' is in generally not closed</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # under the actions.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # reps:= RepresentativesFusions( maut, allfusions, admiss );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> orbits:= [];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> while not IsEmpty( allfusions ) do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> orbit:= OrbitFusions( maut, allfusions[1], admiss );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( orbits, orbit );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> SubtractSet( allfusions, orbit );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> reps:= List( orbits, x -> x[1] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if Length( reps ) = 1 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # Reduce the symmetries that are still available.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> admiss:= Stabilizer( admiss,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Set( OrbitFusions( maut, fusion, triv ) ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> OnSetsTuples );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # We have found a generality problem.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return consider;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # There is no generality problem for this table.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return [];</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;;</span>
</pre></div>
<p>Let us look at a small example, the <span class="SimpleMath">\(5\)</span>-modular character table of the group <span class="SimpleMath">\(2.A_5.2\)</span>. The irreducible characters of degree <span class="SimpleMath">\(2\)</span> have the values <span class="SimpleMath">\(\pm \sqrt{{-2}}\)</span> on the classes <code class="code">8a</code> and <code class="code">8b</code>, and the values <span class="SimpleMath">\(\pm \sqrt{{-3}}\)</span> on the classes <code class="code">6b</code> and <code class="code">6c</code>. When we define which of the two classes of element order <span class="SimpleMath">\(8\)</span> is called <code class="code">8a</code>, this will also define which class is called <code class="code">6b</code>. The ordinary character table does not relate the two pairs of classes, there are table automorphisms which interchange each pair independently. This symmetry is thus broken in the <span class="SimpleMath">\(5\)</span>-modular character table.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "2.A5.2" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">m:= t mod 5;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( m );</span>
2.A5.2mod5
2 4 4 3 2 2 2 3 3 2 2
3 1 1 . 1 1 1 . . 1 1
5 1 1 . . . . . . . .
1a 2a 4a 3a 6a 2b 8a 8b 6b 6c
2P 1a 1a 2a 3a 3a 1a 4a 4a 3a 3a
3P 1a 2a 4a 1a 2a 2b 8a 8b 2b 2b
5P 1a 2a 4a 3a 6a 2b 8b 8a 6c 6b
X.1 1 1 1 1 1 1 1 1 1 1
X.2 1 1 1 1 1 -1 -1 -1 -1 -1
X.3 3 3 -1 . . 1 -1 -1 -2 -2
X.4 3 3 -1 . . -1 1 1 2 2
X.5 5 5 1 -1 -1 1 -1 -1 1 1
X.6 5 5 1 -1 -1 -1 1 1 -1 -1
X.7 2 -2 . -1 1 . A -A B -B
X.8 2 -2 . -1 1 . -A A -B B
X.9 4 -4 . 1 -1 . . . B -B
X.10 4 -4 . 1 -1 . . . -B B
A = E(8)+E(8)^3
= Sqrt(-2) = i2
B = E(3)-E(3)^2
= Sqrt(-3) = i3
<span class="GAPprompt">gap></span> <span class="GAPinput">AutomorphismsOfTable( t );</span>
Group([ (11,12), (9,10) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">AutomorphismsOfTable( m );</span>
Group([ (7,8)(9,10) ])
<span class="GAPprompt">gap></span> <span class="GAPinput">GetFusionMap( m, t );</span>
[ 1, 2, 3, 4, 5, 8, 9, 10, 11, 12 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">BrokenSymmetries( t, m );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">BrokenSymmetries( t, t mod 2 );</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">BrokenSymmetries( t, t mod 3 );</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">PrimesOfGeneralityProblems( t );</span>
[ ]
</pre></div>
<p>Since no symmetry is broken in the <span class="SimpleMath">\(2\)</span>- and <span class="SimpleMath">\(3\)</span>-modular character tables of <span class="SimpleMath">\(G\)</span>, there is no generality problem in this case.</p>
<p>For an example of a generality problem, we look at the smallest Janko group <span class="SimpleMath">\(J_1\)</span>. As is mentioned in <a href="chapBib_mj.html#biBJLPW95">[JLPW95, p. x]</a>, the unique irreducible <span class="SimpleMath">\(11\)</span>-modular Brauer character of degree <span class="SimpleMath">\(7\)</span> distinguishes the two (algebraically conjugate) classes of element order <span class="SimpleMath">\(5\)</span>. Since also the unique irreducible <span class="SimpleMath">\(19\)</span>-modular Brauer character of degree <span class="SimpleMath">\(22\)</span> distinguishes these classes, we have to choose these classes consistently.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "J1" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">m:= t mod 11;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( m, rec( chars:= Filtered( Irr( m ), x -> x[1] = 7 ) ) );</span>
J1mod11
2 3 3 1 1 1 1 . 1 1 . . . . .
3 1 1 1 1 1 1 . . . 1 1 . . .
5 1 1 1 1 1 . . 1 1 1 1 . . .
7 1 . . . . . 1 . . . . . . .
11 1 . . . . . . . . . . . . .
19 1 . . . . . . . . . . 1 1 1
1a 2a 3a 5a 5b 6a 7a 10a 10b 15a 15b 19a 19b 19c
2P 1a 1a 3a 5b 5a 3a 7a 5b 5a 15b 15a 19b 19c 19a
3P 1a 2a 1a 5b 5a 2a 7a 10b 10a 5b 5a 19b 19c 19a
5P 1a 2a 3a 1a 1a 6a 7a 2a 2a 3a 3a 19b 19c 19a
7P 1a 2a 3a 5b 5a 6a 1a 10b 10a 15b 15a 19a 19b 19c
11P 1a 2a 3a 5a 5b 6a 7a 10a 10b 15a 15b 19a 19b 19c
19P 1a 2a 3a 5a 5b 6a 7a 10a 10b 15a 15b 1a 1a 1a
Y.1 7 -1 1 A *A -1 . B *B C *C D E F
A = E(5)+E(5)^4
= (-1+Sqrt(5))/2 = b5
B = -E(5)-2*E(5)^2-2*E(5)^3-E(5)^4
= (3+Sqrt(5))/2 = 2+b5
C = -2*E(5)-2*E(5)^4
= 1-Sqrt(5) = 1-r5
D = -E(19)-E(19)^2-E(19)^3-E(19)^5-E(19)^7-E(19)^8-E(19)^11-E(19)^12-E\
(19)^14-E(19)^16-E(19)^17-E(19)^18
E = -E(19)^2-E(19)^3-E(19)^4-E(19)^5-E(19)^6-E(19)^9-E(19)^10-E(19)^13\
-E(19)^14-E(19)^15-E(19)^16-E(19)^17
F = -E(19)-E(19)^4-E(19)^6-E(19)^7-E(19)^8-E(19)^9-E(19)^10-E(19)^11-E\
(19)^12-E(19)^13-E(19)^15-E(19)^18
<span class="GAPprompt">gap></span> <span class="GAPinput">m:= t mod 19;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( m, rec( chars:= Filtered( Irr( m ), x -> x[1] = 22 ) ) );</span>
J1mod19
2 3 3 1 1 1 1 . 1 1 . . .
3 1 1 1 1 1 1 . . . . 1 1
5 1 1 1 1 1 . . 1 1 . 1 1
7 1 . . . . . 1 . . . . .
11 1 . . . . . . . . 1 . .
19 1 . . . . . . . . . . .
1a 2a 3a 5a 5b 6a 7a 10a 10b 11a 15a 15b
2P 1a 1a 3a 5b 5a 3a 7a 5b 5a 11a 15b 15a
3P 1a 2a 1a 5b 5a 2a 7a 10b 10a 11a 5b 5a
5P 1a 2a 3a 1a 1a 6a 7a 2a 2a 11a 3a 3a
7P 1a 2a 3a 5b 5a 6a 1a 10b 10a 11a 15b 15a
11P 1a 2a 3a 5a 5b 6a 7a 10a 10b 1a 15a 15b
19P 1a 2a 3a 5a 5b 6a 7a 10a 10b 11a 15a 15b
Y.1 22 -2 1 A *A 1 1 -A -*A . B *B
A = E(5)+E(5)^4
= (-1+Sqrt(5))/2 = b5
B = -2*E(5)-2*E(5)^4
= 1-Sqrt(5) = 1-r5
</pre></div>
<p>Note that the degree <span class="SimpleMath">\(7\)</span> character above also distinguishes the three classes of element order <span class="SimpleMath">\(19\)</span>, and the same holds for the unique irreducible degree <span class="SimpleMath">\(31\)</span> character from characteristic <span class="SimpleMath">\(7\)</span>. Thus also the prime <span class="SimpleMath">\(7\)</span> occurs in the list of candidates for generality problems.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">PrimesOfGeneralityProblems( t );</span>
[ 7, 11, 19 ]
</pre></div>
<p>Finally, we list the candidates for generality problems from <strong class="pkg">GAP</strong>'s Character Table Library.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">list:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">isGeneralityProblem:= function( ordtbl )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> local res;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> res:= PrimesOfGeneralityProblems( ordtbl );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if res = [] then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return false;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( list, [ Identifier( ordtbl ), res ] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return true;</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AllCharacterTableNames( IsDuplicateTable, false,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> isGeneralityProblem, true );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PrintArray( SortedList( list ) );</span>
[ [ (2.A4x2.G2(4)).2, [ 2, 5, 7, 13 ] ],
[ (2^2x3).L3(4).2_1, [ 5, 7 ] ],
[ (2x12).L3(4), [ 2, 3, 7 ] ],
[ (4^2x3).L3(4), [ 2, 3, 7 ] ],
[ (7:3xHe):2, [ 5, 7, 17 ] ],
[ (A5xA12):2, [ 2, 3 ] ],
[ (D10xHN).2, [ 2, 3, 5, 7, 11, 19 ] ],
[ (S3x2.Fi22).2, [ 3, 11, 13 ] ],
[ 12.M22, [ 2, 5, 7, 11 ] ],
[ 12.M22.2, [ 2, 5, 7, 11 ] ],
[ 12_1.L3(4).2_1, [ 5, 7 ] ],
[ 12_2.L3(4), [ 2, 3, 7 ] ],
[ 12_2.L3(4).2_1, [ 3, 5, 7 ] ],
[ 12_2.L3(4).2_2, [ 2, 3, 7 ] ],
[ 12_2.L3(4).2_3, [ 2, 3, 7 ] ],
[ 2.(A4xG2(4)).2, [ 2, 5, 7, 13 ] ],
[ 2.2E6(2), [ 13, 19 ] ],
[ 2.2E6(2).2, [ 13, 19 ] ],
[ 2.A10, [ 5, 7 ] ],
[ 2.A11, [ 3, 5, 7 ] ],
[ 2.A11.2, [ 5, 7, 11 ] ],
[ 2.A12, [ 2, 3, 5, 7 ] ],
[ 2.A12.2, [ 5, 7, 11 ] ],
[ 2.A13, [ 2, 3, 5, 7, 11 ] ],
[ 2.A13.2, [ 5, 7, 13 ] ],
[ 2.Alt(14), [ 2, 3, 5, 7 ] ],
[ 2.Alt(15), [ 2, 5, 7 ] ],
[ 2.Alt(16), [ 2, 3, 5, 7 ] ],
[ 2.Alt(17), [ 2, 3, 5, 7 ] ],
[ 2.Alt(18), [ 2, 3, 5, 7 ] ],
[ 2.B, [ 17, 23 ] ],
[ 2.F4(2), [ 2, 7, 13, 17 ] ],
[ 2.Fi22.2, [ 11, 13 ] ],
[ 2.G2(4), [ 2, 7 ] ],
[ 2.G2(4).2, [ 5, 7, 13 ] ],
[ 2.HS, [ 3, 5, 7, 11 ] ],
[ 2.HS.2, [ 3, 11 ] ],
[ 2.L3(4).2_1, [ 5, 7 ] ],
[ 2.Ru, [ 5, 7, 13, 29 ] ],
[ 2.Suz, [ 2, 5, 11 ] ],
[ 2.Suz.2, [ 3, 7, 13 ] ],
[ 2.Sym(15), [ 3, 5, 7 ] ],
[ 2.Sym(16), [ 3, 5, 7 ] ],
[ 2.Sym(17), [ 3, 5, 7 ] ],
[ 2.Sym(18), [ 5, 7 ] ],
[ 2.Sz(8), [ 2, 5, 13 ] ],
[ 2^2.2E6(2), [ 13, 19 ] ],
[ 2^2.2E6(2).2, [ 13, 19 ] ],
[ 2^2.Fi22.2, [ 3, 11, 13 ] ],
[ 2^2.L3(4).2^2, [ 5, 7 ] ],
[ 2^2.L3(4).2_1, [ 5, 7 ] ],
[ 2^2.Sz(8), [ 2, 5, 13 ] ],
[ 2x2.F4(2), [ 2, 7, 13, 17 ] ],
[ 2x3.Fi22, [ 2, 3, 5 ] ],
[ 2x6.Fi22, [ 2, 3, 5 ] ],
[ 2x6.M22, [ 2, 5, 11 ] ],
[ 2xFi22.2, [ 11, 13 ] ],
[ 2xFi23, [ 3, 17, 23 ] ],
[ 3.Fi22, [ 2, 3, 5 ] ],
[ 3.Fi22.2, [ 2, 5, 11, 13 ] ],
[ 3.J3, [ 2, 17, 19 ] ],
[ 3.J3.2, [ 2, 5, 17, 19 ] ],
[ 3.L3(4).2_3, [ 2, 3, 7 ] ],
[ 3.L3(4).3.2_3, [ 2, 3, 7 ] ],
[ 3.L3(7).2, [ 3, 7, 19 ] ],
[ 3.L3(7).S3, [ 3, 7, 19 ] ],
[ 3.McL, [ 2, 5, 11 ] ],
[ 3.McL.2, [ 2, 3, 5, 11 ] ],
[ 3.ON, [ 3, 7, 11, 19, 31 ] ],
[ 3.ON.2, [ 3, 5, 7, 11, 19, 31 ] ],
[ 3.Suz.2, [ 2, 3, 13 ] ],
[ 3x2.F4(2), [ 2, 7, 13, 17 ] ],
[ 3x2.Fi22.2, [ 11, 13 ] ],
[ 3x2.G2(4), [ 2, 7 ] ],
[ 3xFi23, [ 3, 17, 23 ] ],
[ 3xJ1, [ 7, 11, 19 ] ],
[ 3xL3(7).2, [ 3, 7, 19 ] ],
[ 4.HS.2, [ 5, 7, 11 ] ],
[ 4.M22, [ 5, 7 ] ],
[ 4_1.L3(4).2_1, [ 5, 7 ] ],
[ 4_2.L3(4).2_1, [ 3, 5, 7 ] ],
[ 6.Fi22, [ 2, 3, 5 ] ],
[ 6.Fi22.2, [ 2, 5, 11, 13 ] ],
[ 6.L3(4).2_1, [ 5, 7 ] ],
[ 6.M22, [ 2, 5, 11 ] ],
[ 6.O7(3), [ 3, 5, 13 ] ],
[ 6.O7(3).2, [ 3, 5, 13 ] ],
[ 6.Suz, [ 2, 5, 11 ] ],
[ 6.Suz.2, [ 2, 3, 5, 7, 13 ] ],
[ 6x2.F4(2), [ 2, 7, 13, 17 ] ],
[ A12, [ 2, 3 ] ],
[ A14, [ 2, 5, 7 ] ],
[ A17, [ 2, 7 ] ],
[ A18, [ 2, 3, 5, 7 ] ],
[ B, [ 13, 17, 23, 31 ] ],
[ F3+, [ 17, 23, 29 ] ],
[ F3+.2, [ 17, 23, 29 ] ],
[ Fi22.2, [ 11, 13 ] ],
[ Fi23, [ 3, 17, 23 ] ],
[ HN, [ 2, 3, 11, 19 ] ],
[ HN.2, [ 5, 7, 11, 19 ] ],
[ He, [ 5, 17 ] ],
[ He.2, [ 5, 7, 17 ] ],
[ Isoclinic(12.M22.2), [ 2, 5, 7, 11 ] ],
[ Isoclinic(2.A11.2), [ 5, 7, 11 ] ],
[ Isoclinic(2.A12.2), [ 5, 7, 11 ] ],
[ Isoclinic(2.A13.2), [ 5, 7, 13 ] ],
[ Isoclinic(2.Fi22.2), [ 11, 13 ] ],
[ Isoclinic(2.G2(4).2), [ 5, 7, 13 ] ],
[ Isoclinic(2.HS.2), [ 3, 11 ] ],
[ Isoclinic(2.HSx2), [ 3, 5, 7, 11 ] ],
[ Isoclinic(2.L3(4).2_1), [ 5, 7 ] ],
[ Isoclinic(2.Suz.2), [ 3, 7, 13 ] ],
[ Isoclinic(4_1.L3(4).2_1), [ 5, 7 ] ],
[ Isoclinic(4_2.L3(4).2_1), [ 3, 5, 7 ] ],
[ Isoclinic(6.Fi22.2), [ 2, 5, 11, 13 ] ],
[ Isoclinic(6.L3(4).2_1), [ 5, 7 ] ],
[ Isoclinic(6.Suz.2), [ 2, 3, 5, 7, 13 ] ],
[ J1, [ 7, 11, 19 ] ],
[ J1x2, [ 7, 11, 19 ] ],
[ J3, [ 2, 17, 19 ] ],
[ J3.2, [ 2, 5, 17, 19 ] ],
[ L3(4).2_3, [ 3, 7 ] ],
[ L3(4).3.2_3, [ 2, 3, 7 ] ],
[ L3(7).2, [ 3, 7, 19 ] ],
[ L3(7).S3, [ 3, 7, 19 ] ],
[ L3(9).2_1, [ 3, 7, 13 ] ],
[ L5(2).2, [ 2, 7, 31 ] ],
[ Ly, [ 7, 37, 67 ] ],
[ M23, [ 2, 3, 23 ] ],
[ ON, [ 3, 7, 11, 19, 31 ] ],
[ ON.2, [ 3, 5, 7, 11, 19, 31 ] ],
[ Ru, [ 5, 7, 13, 29 ] ],
[ S3xFi22.2, [ 11, 13 ] ],
[ Suz.2, [ 3, 13 ] ] ]
</pre></div>
<p>Note that this list may become longer as new Brauer tables become available. (For example, the prime <span class="SimpleMath">\(2\)</span> was added to the entries for extensions of <span class="SimpleMath">\(F_4(2)\)</span> when the <span class="SimpleMath">\(2\)</span>-modular table of <span class="SimpleMath">\(F_4(2)\)</span> became available.)</p>
<p><a id="X80EB5D827A78975A" name="X80EB5D827A78975A"></a></p>
<h5>1.3-2 <span class="Heading">A generality problem concerning the group <span class="SimpleMath">\(J_3\)</span> (April 2015)</span></h5>
<p><a name="generality_problem_J3">In March 2015,</a> Klaus Lux reported an inconsistency in the character data of <strong class="pkg">GAP</strong>:</p>
<p>The sporadic simple Janko group <span class="SimpleMath">\(J_3\)</span> has a unique <span class="SimpleMath">\(19\)</span>-modular irreducible Brauer character of degree <span class="SimpleMath">\(110\)</span>. In the character table that is printed in the <strong class="pkg">Atlas</strong> of Brauer characters <a href="chapBib_mj.html#biBJLPW95">[JLPW95, p. 219]</a>, the Brauer character value on the class <code class="code">17A</code> is <span class="SimpleMath">\(b_{17}\)</span>. The <strong class="pkg">Atlas</strong> of Group Representations <a href="chapBib_mj.html#biBAGRv3">[WWT+]</a> provides a straight line program for computing class representatives of <span class="SimpleMath">\(J_3\)</span>. If we compute the Brauer character value in question, we do not get <span class="SimpleMath">\(b_{17}\)</span> but its algebraic conjugate, <span class="SimpleMath">\(-1-b_{17}\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "J3" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">m:= t mod 19;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= Filtered( Irr( m ), x -> x[1] = 110 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( cand );</span>
1
<span class="GAPprompt">gap></span> <span class="GAPinput">slp:= AtlasProgram( "J3", "classes" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">17a:= Position( slp.outputs, "17A" );</span>
18
<span class="GAPprompt">gap></span> <span class="GAPinput">info:= OneAtlasGeneratingSetInfo( "J3", Characteristic, 19,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Dimension, 110 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">gens:= AtlasGenerators( info );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">reps:= ResultOfStraightLineProgram( slp.program,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> gens.generators );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Quadratic( BrauerCharacterValue( reps[ 17a ] ) );</span>
rec( ATLAS := "-1-b17", a := -1, b := -1, d := 2,
display := "(-1-Sqrt(17))/2", root := 17 )
</pre></div>
<p>How shall we resolve this inconsistency, by replacing the straight line program or by swapping the classes <code class="code">17A</code> and <code class="code">17B</code> in the character table? Before we decide this, we look at related information.</p>
<p>The following table lists the <span class="SimpleMath">\(p\)</span>-modular irreducible characters of <span class="SimpleMath">\(J_3\)</span>, according to <a href="chapBib_mj.html#biBJLPW95">[JLPW95]</a>, that can be used to define which of the two classes of element order <span class="SimpleMath">\(17\)</span> shall be called <code class="code">17A</code>; a <span class="SimpleMath">\(+\)</span> sign in the last column of the table indicates that the representation is available in the <strong class="pkg">Atlas</strong> of Group Representations.</p>
<div class="pcenter"><table class="GAPDocTable">
<caption class="GAPDocTable"><b>Table: </b>Representations of <span class="SimpleMath">\(J_3\)</span> that may define <code class="code">17A</code></caption>
<tr>
<td class="tdright"><span class="SimpleMath">\(p\)</span></td>
<td class="tdright"><span class="SimpleMath">\(\varphi(1)\)</span></td>
<td class="tdright"><span class="SimpleMath">\(\varphi(\)</span><code class="code">17A</code><span class="SimpleMath">\()\)</span></td>
<td class="tdright"><span class="SimpleMath">\(\varphi(\)</span><code class="code">17B</code><span class="SimpleMath">\()\)</span></td>
<td class="tdcenter"><strong class="pkg">Atlas</strong>?</td>
</tr>
<tr>
<td class="tdright"><span class="SimpleMath">\(2\)</span></td>
<td class="tdright"><span class="SimpleMath">\(78\)</span></td>
<td class="tdright"><span class="SimpleMath">\(1-b_{17}\)</span></td>
<td class="tdright"><span class="SimpleMath">\(2+b_{17}\)</span></td>
<td class="tdcenter"><span class="SimpleMath">\(+\)</span></td>
</tr>
<tr>
<td class="tdright"><span class="SimpleMath">\(2\)</span></td>
<td class="tdright"><span class="SimpleMath">\(80\)</span></td>
<td class="tdright"><span class="SimpleMath">\(3-b_{17}\)</span></td>
<td class="tdright"><span class="SimpleMath">\(4+b_{17}\)</span></td>
<td class="tdcenter"><span class="SimpleMath">\(+\)</span></td>
</tr>
<tr>
<td class="tdright"><span class="SimpleMath">\(2\)</span></td>
<td class="tdright"><span class="SimpleMath">\(244\)</span></td>
<td class="tdright"><span class="SimpleMath">\(b_{17}-2\)</span></td>
<td class="tdright"><span class="SimpleMath">\(-3-b_{17}\)</span></td>
<td class="tdcenter"><span class="SimpleMath">\(+\)</span></td>
</tr>
<tr>
<td class="tdright"><span class="SimpleMath">\(2\)</span></td>
<td class="tdright"><span class="SimpleMath">\(966\)</span></td>
<td class="tdright"><span class="SimpleMath">\(r_{17}-3\)</span></td>
<td class="tdright"><span class="SimpleMath">\(-3-r_{17}\)</span></td>
<td class="tdcenter"><span class="SimpleMath">\(+\)</span></td>
</tr>
<tr>
<td class="tdright"><span class="SimpleMath">\(19\)</span></td>
<td class="tdright"><span class="SimpleMath">\(110\)</span></td>
<td class="tdright"><span class="SimpleMath">\(b_{17}\)</span></td>
<td class="tdright"><span class="SimpleMath">\(-1-b_{17}\)</span></td>
<td class="tdcenter"><span class="SimpleMath">\(+\)</span></td>
</tr>
<tr>
<td class="tdright"><span class="SimpleMath">\(19\)</span></td>
<td class="tdright"><span class="SimpleMath">\(214\)</span></td>
<td class="tdright"><span class="SimpleMath">\(1-b_{17}\)</span></td>
<td class="tdright"><span class="SimpleMath">\(2+b_{17}\)</span></td>
<td class="tdcenter"><span class="SimpleMath">\(+\)</span></td>
</tr>
<tr>
<td class="tdright"><span class="SimpleMath">\(19\)</span></td>
<td class="tdright"><span class="SimpleMath">\(706\)</span></td>
<td class="tdright"><span class="SimpleMath">\(-b_{17}\)</span></td>
<td class="tdright"><span class="SimpleMath">\(1+b_{17}\)</span></td>
<td class="tdcenter"><span class="SimpleMath">\(+\)</span></td>
</tr>
<tr>
<td class="tdright"><span class="SimpleMath">\(19\)</span></td>
<td class="tdright"><span class="SimpleMath">\(1214\)</span></td>
<td class="tdright"><span class="SimpleMath">\(-1+b_{17}\)</span></td>
<td class="tdright"><span class="SimpleMath">\(-2-b_{17}\)</span></td>
<td class="tdcenter"><span class="SimpleMath">\(-\)</span></td>
</tr>
</table><br />
</div>
<p>Note that the irreducible Brauer characters in characteristic <span class="SimpleMath">\(3\)</span> and <span class="SimpleMath">\(5\)</span> that distinguish the two classes <code class="code">17A</code> and <code class="code">17B</code> occur in pairs of Galois conjugate characters.</p>
<p>The following computations show that the given straight line program is compatible with the four characters in characteristic <span class="SimpleMath">\(2\)</span> but is not compatible with the three available characters in characteristic <span class="SimpleMath">\(19\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">table:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for pair in [ [ 2, [ 78, 80, 244, 966 ] ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ 19, [ 110, 214, 706 ] ] ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> p:= pair[1];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for d in pair[2] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> info:= OneAtlasGeneratingSetInfo( "J3", Characteristic, p,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Dimension, d );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> gens:= AtlasGenerators( info );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> reps:= ResultOfStraightLineProgram( slp.program,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> gens.generators );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> val:= BrauerCharacterValue( reps[ 17a ] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( table, [ p, d, Quadratic( val ).ATLAS,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Quadratic( StarCyc( val ) ).ATLAS ] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PrintArray( table );</span>
[ [ 2, 78, 1-b17, 2+b17 ],
[ 2, 80, 3-b17, 4+b17 ],
[ 2, 244, -2+b17, -3-b17 ],
[ 2, 966, -3+r17, -3-r17 ],
[ 19, 110, -1-b17, b17 ],
[ 19, 214, 2+b17, 1-b17 ],
[ 19, 706, 1+b17, -b17 ] ]
</pre></div>
<p>We see that the problem is an inconsistency between the <span class="SimpleMath">\(2\)</span>-modular and the <span class="SimpleMath">\(19\)</span>-modular character table of <span class="SimpleMath">\(J_3\)</span> in <a href="chapBib_mj.html#biBJLPW95">[JLPW95]</a>. In particular, changing the straight line program would not help to resolve the problem.</p>
<p>How shall we proceed in order to fix the problem? We can decide to keep the <span class="SimpleMath">\(19\)</span>-modular table of <span class="SimpleMath">\(J_3\)</span>, and to swap the two classes of element order <span class="SimpleMath">\(17\)</span> in the <span class="SimpleMath">\(2\)</span>-modular table; then also the straight line program has to be changed, and the classes of element orders <span class="SimpleMath">\(17\)</span> and <span class="SimpleMath">\(51\)</span> in the <span class="SimpleMath">\(2\)</span>-modular character table of the triple cover <span class="SimpleMath">\(3.J_3\)</span> of <span class="SimpleMath">\(J_3\)</span> have to be adjusted. Alternatively, we can keep the <span class="SimpleMath">\(2\)</span>-modular table of <span class="SimpleMath">\(J_3\)</span> and the straight line program, and adjust the conjugacy classes of element orders divisible by <span class="SimpleMath">\(17\)</span> in the <span class="SimpleMath">\(19\)</span>-modular character tables of <span class="SimpleMath">\(J_3\)</span>, <span class="SimpleMath">\(3.J_3\)</span>, <span class="SimpleMath">\(J_3.2\)</span>, and <span class="SimpleMath">\(3.J_3.2\)</span>.</p>
<p>We decide to change the <span class="SimpleMath">\(19\)</span>-modular character tables. Note that these character tables —or equivalently, the corresponding Brauer trees— have been described in <a href="chapBib_mj.html#biBHL89">[HL89]</a>, where explicit choices are mentioned that lead to the shown Brauer trees. Questions about the consistency with Brauer tables in other characteristic had not been an issue in this book. (Only the consistency of the Brauer trees among the <span class="SimpleMath">\(19\)</span>-blocks of <span class="SimpleMath">\(3.J_3\)</span> is mentioned.) In fact, the book mentions that the <span class="SimpleMath">\(19\)</span>-modular Brauer trees for <span class="SimpleMath">\(J_3\)</span> had been computed already by W. Feit. The inconsistency of Brauer character tables in different characteristic has apparently been overlooked when the data for <a href="chapBib_mj.html#biBJLPW95">[JLPW95]</a> have been put together, and had not been detected until now.</p>
<p><em>Remarks:</em></p>
<ul>
<li><p>Such a change of a Brauer table can in general affect the class fusions from and to this table. Note that Brauer tables may impose conditions on the choice of the fusion among possible fusions that are equivalent w. r. t. the table automorphisms of the ordinary table. In this particular case, in fact no class fusion had to be changed, see the sections <a href="chap9_mj.html#X7ACC7F588213D5D5"><span class="RefLink">9.6-1</span></a> and Section <a href="chap9_mj.html#X7DED4C437D479226"><span class="RefLink">9.6-3</span></a>.</p>
</li>
<li><p>The change of the character tables affects the decomposition matrices. Thus the PDF files containing the <span class="SimpleMath">\(19\)</span>-modular decomposition matrices had to be updated, see <span class="URL"><a href="http://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/dec/tex/J3/index.html">http://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/dec/tex/J3/index.html</a></span>.</p>
</li>
<li><p>Jürgen Müller has checked that the conjugacy classes of all Brauer tables of <span class="SimpleMath">\(J_3\)</span>, <span class="SimpleMath">\(3.J_3\)</span>, <span class="SimpleMath">\(J_3.2\)</span>, <span class="SimpleMath">\(3.J_3.2\)</span> are consistent after the fix described above.</p>
</li>
</ul>
<p><a id="X82C37532783168AA" name="X82C37532783168AA"></a></p>
<h5>1.3-3 <span class="Heading">A generality problem concerning the group <span class="SimpleMath">\(HN\)</span> (August 2022)</span></h5>
<p>The classes <code class="code">20A</code>, <code class="code">20B</code> of the Harada-Norton group <span class="SimpleMath">\(HN\)</span> in the <span class="SimpleMath">\(11\)</span>- and <span class="SimpleMath">\(19\)</span>-modular character tables are determined by unique Brauer characters that have different values on these classes. Once we have <em>defined</em> these classes in one characteristic, the two Brauer characters tell us how to <em>choose</em> them consistently in the other characteristic. Thus the question is whether the two Brauer tables are consistent w.r.t. this property or not.</p>
<p>(Note that this question can be answered independently of all other questions of this kind for <span class="SimpleMath">\(HN\)</span>, because the permutation that swaps exactly the classes <code class="code">20A</code> and <code class="code">20B</code> is a table automorphism of the ordinary character table of <span class="SimpleMath">\(HN\)</span>.)</p>
<p>We start with the ordinary character table of <span class="SimpleMath">\(HN\)</span>. There are exactly two ordinary irreducible characters that take different values on the classes <code class="code">20A</code>, <code class="code">20B</code>, these are <span class="SimpleMath">\(\chi_{51}\)</span> and <span class="SimpleMath">\(\chi_{52}\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "HN" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">pos20:= Positions( OrdersClassRepresentatives( t ), 20 );</span>
[ 39, 40, 41, 42, 43 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">diff:= Filtered( Irr( t ), x -> x[39] <> x[40] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">List( diff, x -> Position( Irr( t ), x ) );</span>
[ 51, 52 ]
</pre></div>
<p>These values are irrational and lie in the field that is generated by the square root of <span class="SimpleMath">\(5\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">List( diff, x -> List( x{ [ 1, 39, 40 ] },</span>
<span class="GAPprompt">></span> <span class="GAPinput"> CTblLib.StringOfAtlasIrrationality ) );</span>
[ [ "5103000", "2r5+1", "-2r5+1" ], [ "5103000", "-2r5+1", "2r5+1" ] ]
</pre></div>
<p>In each of the characteristics <span class="SimpleMath">\(p \in \{ 11, 19 \}\)</span>, the <span class="SimpleMath">\(p\)</span>-modular reductions of <span class="SimpleMath">\(\chi_{51}\)</span> and <span class="SimpleMath">\(\chi_{52}\)</span> decompose differently into irreducibles. Note that the Galois automorphism of the ordinary character table that maps <span class="SimpleMath">\(\sqrt{5}\)</span> to <span class="SimpleMath">\(-\sqrt{5}\)</span> does not live in the <span class="SimpleMath">\(11\)</span>- and <span class="SimpleMath">\(19\)</span>-modular Brauer tables.</p>
<p>For <span class="SimpleMath">\(p = 11\)</span>, the reduction of <span class="SimpleMath">\(\chi_{51}\)</span> is <span class="SimpleMath">\(\varphi_{40} + \varphi_{48}\)</span>, with <span class="SimpleMath">\(\varphi_{40}(1) = 1\,575\,176\)</span> and <span class="SimpleMath">\(\varphi_{48}(1) = 3\,527\,824\)</span>, and the reduction of <span class="SimpleMath">\(\chi_{52}\)</span> is <span class="SimpleMath">\(\varphi_{39} + \varphi_{49}\)</span>, with <span class="SimpleMath">\(\varphi_{39}(1) = 1\,361\,919\)</span> and <span class="SimpleMath">\(\varphi_{49}(1) = 3\,741\,081\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t11:= t mod 11;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">rest11:= RestrictedClassFunctions( diff, t11 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">dec11:= Decomposition( Irr( t11 ), rest11, "nonnegative" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">List( dec11, Set );</span>
[ [ 0, 1 ], [ 0, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( dec11, x -> Positions( x, 1 ) );</span>
[ [ 40, 48 ], [ 39, 49 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( Irr( t11 ){ [ 40, 48 ] }, x -> x[1] );</span>
[ 1575176, 3527824 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( Irr( t11 ){ [ 39, 49 ] }, x -> x[1] );</span>
[ 1361919, 3741081 ]
</pre></div>
<p>For <span class="SimpleMath">\(p = 19\)</span>, the reduction of <span class="SimpleMath">\(\chi_{51}\)</span> is <span class="SimpleMath">\(\varphi_{42} + \varphi_{45}\)</span>, with <span class="SimpleMath">\(\varphi_{42}(1) = 2\,125\,925\)</span> and <span class="SimpleMath">\(\varphi_{45}(1) = 2\,977\,075\)</span>, and the reduction of <span class="SimpleMath">\(\chi_{52}\)</span> is <span class="SimpleMath">\(\varphi_{33} + \varphi_{48}\)</span>, with <span class="SimpleMath">\(\varphi_{33}(1) = 1\,197\,330\)</span> and <span class="SimpleMath">\(\varphi_{48}(1) = 3\,905\,670\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t19:= t mod 19;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">rest19:= RestrictedClassFunctions( diff, t19 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">dec19:= Decomposition( Irr( t19 ), rest19, "nonnegative" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">List( dec19, Set );</span>
[ [ 0, 1 ], [ 0, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( dec19, x -> Positions( x, 1 ) );</span>
[ [ 42, 45 ], [ 33, 48 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( Irr( t19 ){ [ 42, 45 ] }, x -> x[1] );</span>
[ 2125925, 2977075 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( Irr( t19 ){ [ 33, 48 ] }, x -> x[1] );</span>
[ 1197330, 3905670 ]
</pre></div>
<p>The Frobenius-Schur indicators of all involved <span class="SimpleMath">\(p\)</span>-modular constituents are <span class="SimpleMath">\(+\)</span>. This implies that <span class="SimpleMath">\(\chi_{51}\)</span> reduces orthogonally stably modulo <span class="SimpleMath">\(11\)</span> but not orthogonally stably modulo <span class="SimpleMath">\(19\)</span>, whereas <span class="SimpleMath">\(\chi_{52}\)</span> reduces orthogonally stably modulo <span class="SimpleMath">\(19\)</span> but not orthogonally stably modulo <span class="SimpleMath">\(11\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">Indicator( t11, 2 ){ [ 39, 40, 48, 49 ] };</span>
[ 1, 1, 1, 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Indicator( t19, 2 ){ [ 33, 42, 45, 48 ] };</span>
[ 1, 1, 1, 1 ]
</pre></div>
<p>In version up to 1.3.4 of the character table library, this condition was not satisfied: The reduction of <span class="SimpleMath">\(\chi_{51}\)</span> modulo both <span class="SimpleMath">\(11\)</span> and <span class="SimpleMath">\(19\)</span> was orthogonally stable, and the reduction of <span class="SimpleMath">\(\chi_{52}\)</span> modulo both <span class="SimpleMath">\(11\)</span> and <span class="SimpleMath">\(19\)</span> was not orthogonally stable. However, this cannot happen, due to theoretical results about orthogonal discriminants of the involved characters. Thus we have found a way to decide the consistency of the classes <code class="code">20A</code> and <code class="code">20B</code> in characteristics <span class="SimpleMath">\(11\)</span> and <span class="SimpleMath">\(19\)</span>: Either the <span class="SimpleMath">\(11\)</span>-modular character table or the <span class="SimpleMath">\(19\)</span>-modular character table of <span class="SimpleMath">\(HN\)</span> had to be changed for version 1.3.5, by swapping the classes <code class="code">20A</code> and <code class="code">20B</code>.</p>
<p>We decided to change the <span class="SimpleMath">\(11\)</span>-modular table, because there are no other generality problems for <span class="SimpleMath">\(HN\)</span> involving the <span class="SimpleMath">\(19\)</span>-modular table, and hence we are sure that this table will not need to be changed because of new solutions to generality problems.</p>
<p>For <span class="SimpleMath">\(HN.2\)</span>, the situation is similar. There are additionally two classes of element order <span class="SimpleMath">\(40\)</span> that have to be swapped if <code class="code">20A</code> and <code class="code">20B</code> get swapped. Thus we have to change the <span class="SimpleMath">\(11\)</span>-modular table of <span class="SimpleMath">\(HN.2\)</span> accordingly.</p>
<p>Changes of this kind may affect also derived character tables in the library. In this case, the <span class="SimpleMath">\(11\)</span>-modular table with identifier <code class="code">"(D10xHN).2"</code> was changed as well. Note that this table is not stored explicitly in the data files, it gets constructed from ordinary and modular library tables via <code class="func">ConstructIndexTwoSubdirectProduct</code> (<a href="..//doc/chap5_mj.html#X8714D24B802DA949"><span class="RefLink">CTblLib: ConstructIndexTwoSubdirectProduct</span></a>).</p>
<p><a id="X7D8C6D1883C9CECA" name="X7D8C6D1883C9CECA"></a></p>
<h4>1.4 <span class="Heading">Brauer Tables that can be derived from Known Tables</span></h4>
<p>In a few situations, one can derive the <span class="SimpleMath">\(p\)</span>-modular Brauer character table of a group from known character theoretic information.</p>
<p>For quite some time, a method is available in <strong class="pkg">GAP</strong> that computes the Brauer characters of <span class="SimpleMath">\(p\)</span>-solvable groups (see <a href="../../../doc/ref/chap71_mj.html#X8476B25A79D7A7FC"><span class="RefLink">Reference: BrauerTable</span></a> and <a href="../../../doc/ref/chap71_mj.html#X7A0CBD1884276882"><span class="RefLink">Reference: IsPSolubleCharacterTable</span></a>).</p>
<p>The following sections list other situations where Brauer tables can be computed by <strong class="pkg">GAP</strong>.</p>
<p><a id="X7DF018B77E722CA7" name="X7DF018B77E722CA7"></a></p>
<h5>1.4-1 <span class="Heading">Brauer Tables via Construction Information</span></h5>
<p>If a given ordinary character table <span class="SimpleMath">\(t\)</span>, say, has been constructed from other ordinary character tables then <strong class="pkg">GAP</strong> may be able to create the <span class="SimpleMath">\(p\)</span>-modular Brauer table of <span class="SimpleMath">\(t\)</span> from the <span class="SimpleMath">\(p\)</span>-modular Brauer tables of the "ingredients". This happens currently in the following cases.</p>
<ul>
<li><p><span class="SimpleMath">\(t\)</span> has been constructed with <code class="func">CharacterTableDirectProduct</code> (<a href="../../../doc/ref/chap71_mj.html#X7BE1572D7BBC6AC8"><span class="RefLink">Reference: CharacterTableDirectProduct</span></a>), and <strong class="pkg">GAP</strong> can compute the <span class="SimpleMath">\(p\)</span>-modular Brauer tables of the direct factors.</p>
</li>
<li><p><span class="SimpleMath">\(t\)</span> has been constructed with <code class="func">CharacterTableIsoclinic</code> (<a href="../../../doc/ref/chap71_mj.html#X85BE46F784B83938"><span class="RefLink">Reference: CharacterTableIsoclinic</span></a>), and <strong class="pkg">GAP</strong> can compute the <span class="SimpleMath">\(p\)</span>-modular Brauer table of the table that is stored in <span class="SimpleMath">\(t\)</span> as the value of the attribute <code class="func">SourceOfIsoclinicTable</code> (<a href="../../../doc/ref/chap71_mj.html#X85BE46F784B83938"><span class="RefLink">Reference: SourceOfIsoclinicTable</span></a>).</p>
</li>
<li><p><span class="SimpleMath">\(t\)</span> has the attribute <code class="func">ConstructionInfoCharacterTable</code> (<a href="..//doc/chap3_mj.html#X851118377D1D6EC9"><span class="RefLink">CTblLib: ConstructionInfoCharacterTable</span></a>) set, the first entry of this list <span class="SimpleMath">\(l\)</span>, say, is one of the strings <code class="code">"ConstructGS3"</code> (see <a href="chap2_mj.html#X7CCABDDE864E6300"><span class="RefLink">2.3-2</span></a>), <code class="code">"ConstructIndexTwoSubdirectProduct"</code> (see <a href="chap2_mj.html#X788591D78451C024"><span class="RefLink">2.3-6</span></a>), <code class="code">"ConstructMGA"</code> (see <a href="chap2_mj.html#X82E75B6880EC9E6C"><span class="RefLink">2.3-1</span></a>), <code class="code">"ConstructPermuted"</code>, <code class="code">"ConstructV4G"</code> (see <a href="chap2_mj.html#X81464C4B8178C85A"><span class="RefLink">2.3-4</span></a>), and <strong class="pkg">GAP</strong> can construct the <span class="SimpleMath">\(p\)</span>-modular Brauer table(s) of the relevant ordinary character table(s), which are library tables whose names occur in <span class="SimpleMath">\(l\)</span>.</p>
</li>
</ul>
<p><a id="X795419A287BD228E" name="X795419A287BD228E"></a></p>
<h5>1.4-2 <span class="Heading">Liftable Brauer Characters (May 2017)</span></h5>
<p>Let <span class="SimpleMath">\(B\)</span> be a <span class="SimpleMath">\(p\)</span>-block of cyclic defect for the finite group <span class="SimpleMath">\(G\)</span>. It can be read off from the set Irr<span class="SimpleMath">\((B)\)</span> of ordinary irreducible characters of <span class="SimpleMath">\(B\)</span> whether all irreducible Brauer characters in <span class="SimpleMath">\(B\)</span> are restrictions of ordinary characters to the <span class="SimpleMath">\(p\)</span>-regular classes of <span class="SimpleMath">\(G\)</span>, as follows.</p>
<p>If <span class="SimpleMath">\(B\)</span> has only one irreducible Brauer character then all ordinary characters in <span class="SimpleMath">\(B\)</span> restrict to this Brauer character. So let us assume that <span class="SimpleMath">\(B\)</span> contains at least two irreducible Brauer characters, and consider the set <span class="SimpleMath">\(S\)</span>, say, of restrictions of Irr<span class="SimpleMath">\((B)\)</span> to the <span class="SimpleMath">\(p\)</span>-regular classes of <span class="SimpleMath">\(G\)</span>.</p>
<p>The block <span class="SimpleMath">\(B\)</span> contains exactly <span class="SimpleMath">\(|S| - 1\)</span> irreducible Brauer characters, and the decomposition of the characters in <span class="SimpleMath">\(S\)</span> into these Brauer characters is described by an <span class="SimpleMath">\(|S|\)</span> by <span class="SimpleMath">\(|S| - 1\)</span> matrix <span class="SimpleMath">\(M\)</span>, say, whose entries are zero and one, such that exactly two nonzero entries occur in each column. (See for example <a href="chapBib_mj.html#biBHL89">[HL89, Theorem 2.1.5]</a>, which refers to <a href="chapBib_mj.html#biBDad66">[Dad66]</a>.)</p>
<p>If all irreducible Brauer characters of <span class="SimpleMath">\(B\)</span> occur in <span class="SimpleMath">\(S\)</span> then the matrix <span class="SimpleMath">\(M\)</span> contains <span class="SimpleMath">\(|S| - 1\)</span> rows that contain exactly one nonzero entry, hence the remaining row consists only of <span class="SimpleMath">\(1\)</span>s. This means that the element of largest degree in <span class="SimpleMath">\(S\)</span> is equal to the sum of all other elements in <span class="SimpleMath">\(S\)</span>. Conversely, if the element of largest degree in <span class="SimpleMath">\(S\)</span> is equal to the sum of all other elements in <span class="SimpleMath">\(S\)</span> then the matrix <span class="SimpleMath">\(M\)</span> has the structure as stated above, hence all irreducible Brauer characters of <span class="SimpleMath">\(B\)</span> occur in <span class="SimpleMath">\(S\)</span>.</p>
<p>Alternatively, one could state that all irreducible Brauer characters of <span class="SimpleMath">\(B\)</span> are restricted ordinary characters if and only if the Brauer tree of <span class="SimpleMath">\(B\)</span> is a <em>star</em> (see <a href="chapBib_mj.html#biBHL89">[HL89, p. 2]</a>. If <span class="SimpleMath">\(B\)</span> contains at least two irreducible Brauer characters then this happens if and only if one of the types <span class="SimpleMath">\(\times\)</span> or <span class="SimpleMath">\(\circ\)</span> occurs for exactly one node in the Brauer graph of <span class="SimpleMath">\(B\)</span>, see <a href="chapBib_mj.html#biBHL89">[HL89, Lemma 2.1.13]</a>, and the distribution to types is determined by Irr<span class="SimpleMath">\((B)\)</span>.</p>
<p>The default method for <code class="func">BrauerTableOp</code> (<a href="../../../doc/ref/chap71_mj.html#X8476B25A79D7A7FC"><span class="RefLink">Reference: BrauerTableOp</span></a>) that is contained in the <strong class="pkg">GAP</strong> library has been extended in version 4.11 such that it checks whether the Sylow <span class="SimpleMath">\(p\)</span>-subgroups of the given group <span class="SimpleMath">\(G\)</span> are cyclic and, if yes, whether all <span class="SimpleMath">\(p\)</span>-blocks of <span class="SimpleMath">\(G\)</span> have the property discussed above. (This feature arose from a discussion with Klaus Lux.)</p>
<p>Examples where this method is successful for all blocks are the <span class="SimpleMath">\(p\)</span>-modular character tables of the groups PSL<span class="SimpleMath">\((2, q)\)</span>, where <span class="SimpleMath">\(p\)</span> is odd and does not divide <span class="SimpleMath">\(q\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( PSL( 2, 11 ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">modt:= t mod 5;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">modt <> fail;</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">InfoText( modt );</span>
"computed using that all Brauer characters lift to char. zero"
</pre></div>
<p>Another such example is the <span class="SimpleMath">\(5\)</span>-modular table of the Mathieu group <span class="SimpleMath">\(M_{11}\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">lib:= CharacterTable( "M11" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fromgroup:= CharacterTable( MathieuGroup( 11 ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">DecompositionMatrix( lib mod 5 );</span>
[ [ 1, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 1, 0, 0, 0, 0, 0, 0, 0 ],
[ 0, 0, 1, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
[ 0, 0, 0, 0, 1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 1, 0, 0 ], [ 1, 0, 0, 0, 1, 1, 1, 0, 0 ],
[ 0, 0, 0, 0, 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">fromgroup mod 5 <> fail;</span>
true
</pre></div>
<p>There are cases where all Brauer characters of a block lift to characteristic zero but the defect group of the block is not cyclic, thus the method cannot be used. An example is the <span class="SimpleMath">\(2\)</span>-modular table of the Mathieu group <span class="SimpleMath">\(M_{11}\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">DecompositionMatrix( lib mod 2 );</span>
[ [ 1, 0, 0, 0, 0 ], [ 0, 1, 0, 0, 0 ], [ 0, 1, 0, 0, 0 ],
[ 0, 1, 0, 0, 0 ], [ 1, 1, 0, 0, 0 ], [ 0, 0, 1, 0, 0 ],
[ 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, 1 ], [ 1, 0, 0, 0, 1 ],
[ 1, 1, 0, 0, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">fromgroup mod 2;</span>
fail
</pre></div>
<p><a id="X864EFF897A854F89" name="X864EFF897A854F89"></a></p>
<h4>1.5 <span class="Heading">Information about certain subgroups of the Monster group</span></h4>
<p><a id="X82C7A03684DD7C6E" name="X82C7A03684DD7C6E"></a></p>
<h5>1.5-1 <span class="Heading">The Monster group does not contain subgroups of the type <span class="SimpleMath">\(2.U_4(2)\)</span> (August 2023)</span></h5>
<p>In the context of a question about decomposition numbers of the sporadic simple Monster group <span class="SimpleMath">\(𝕄\)</span>, Benjamin Sambale was interested in possible embeddings of certain groups <span class="SimpleMath">\(G\)</span> into <span class="SimpleMath">\(𝕄\)</span> such that the decomposition matrices of <span class="SimpleMath">\(G\)</span> are known. For a given <span class="SimpleMath">\(G\)</span>, the first steps were to compute the possible class fusions of <span class="SimpleMath">\(G\)</span> in <span class="SimpleMath">\(𝕄\)</span> and then to check whether the corresponding embeddings would be interesting.</p>
<p>Apparently, calling <code class="func">PossibleClassFusions</code> (<a href="../../../doc/ref/chap73_mj.html#X7883271F7F26356E"><span class="RefLink">Reference: PossibleClassFusions</span></a>) with its default parameters often runs very long and requires a lot of space when <span class="SimpleMath">\(G\)</span> is a small group such as <span class="SimpleMath">\(2.U_4(2)\)</span>. We can do better by calling the function with the parameter <code class="code">decompose:= false</code>. This has the effect that one criterion is omitted that checks the decomposability of restricted characters of <span class="SimpleMath">\(𝕄\)</span> as an integral linear combination of characters of the subgroup. As a rule of thumb, if the number of classes of the subgroup is small compared to the number of classes of the group and if the result consists of many candidates then it might be faster to omit the decomposability criterion.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">s:= CharacterTable( "2.U4(2)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">m:= CharacterTable( "M" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sfusm:= PossibleClassFusions( s, m, rec( decompose:= false ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( sfusm );</span>
2332
</pre></div>
<p>Looking at the (many) candidates, we see that all map the central involution of <span class="SimpleMath">\(2.U_4(2)\)</span> to the class <code class="code">2B</code> of <span class="SimpleMath">\(𝕄\)</span>, thus any subgroup of the type <span class="SimpleMath">\(2.U_4(2)\)</span> lies inside the <code class="code">2B</code> normalizer in <span class="SimpleMath">\(𝕄\)</span>. We compute the possible class fusions into this subgroup.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">Set( List( sfusm, x -> x[2] ) );</span>
[ 3 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "MN2B" );</span>
CharacterTable( "2^1+24.Co1" )
<span class="GAPprompt">gap></span> <span class="GAPinput">sfust:= PossibleClassFusions( s, t, rec( decompose:= false ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( sfust );</span>
0
</pre></div>
<p>Thus we have shown that <span class="SimpleMath">\(𝕄\)</span> does not contain subgroups of the type <span class="SimpleMath">\(2.U_4(2)\)</span>.</p>
<p><a id="X87EC0C48866D1BDE" name="X87EC0C48866D1BDE"></a></p>
<h5>1.5-2 <span class="Heading">Perfect central extensions of <span class="SimpleMath">\(L_3(4)\)</span> (August 2023)</span></h5>
<p>There was <span class="URL"><a href="https://mathoverflow.net/questions/450255">the question in MathOverflow</a></span> which perfect central extensions of the simple group <span class="SimpleMath">\(G = L_3(4)\)</span> are subgroups of the sporadic simple Monster group <span class="SimpleMath">\(𝕄\)</span>.</p>
<p>First we get the list of perfect central extensions of <span class="SimpleMath">\(G\)</span> (asuming that their character tables are contained in the character table library).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">simp:= CharacterTable( "L3(4)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">extnames:= AllCharacterTableNames( Identifier,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> EndsWith(x, "L3(4)" ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ext:= List( extnames, CharacterTable );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ext:= Filtered( ext, x -> Length( ClassPositionsOfCentre( x ) ) =</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Size( x ) / Size( simp ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SortBy( ext, Size );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">names:= List( ext, Identifier );</span>
[ "L3(4)", "2.L3(4)", "3.L3(4)", "2^2.L3(4)", "4_1.L3(4)",
"4_2.L3(4)", "6.L3(4)", "(2x4).L3(4)", "(2^2x3).L3(4)",
"12_1.L3(4)", "12_2.L3(4)", "4^2.L3(4)", "(2x12).L3(4)",
"(4^2x3).L3(4)" ]
</pre></div>
<p>The fact that <span class="SimpleMath">\(G\)</span> is <em>not</em> isomorphic to a subgroup of <span class="SimpleMath">\(𝕄\)</span> is shown in <a href="chapBib_mj.html#biBHW08">[HW08]</a> (at the end of this paper).</p>
<p>And the following embeddings of central extensions of <span class="SimpleMath">\(G\)</span> in <span class="SimpleMath">\(𝕄\)</span> can be established using known subgroups of <span class="SimpleMath">\(𝕄\)</span>.</p>
<ul>
<li><p><span class="SimpleMath">\(2.G < 2.U_4(3) < 2^2.U_6(2) < Fi_{23} < 3.Fi_{24}' < 𝕄\)</span>.</p>
</li>
<li><p><span class="SimpleMath">\(2^2.G < He < 3.Fi_{24}' < 𝕄\)</span>.</p>
</li>
<li><p><span class="SimpleMath">\(6.G < 2.G_2(4) < 6.Suz < 3^{1+12}_+.2Suz < 𝕄\)</span>.</p>
</li>
</ul>
<p>Note that <span class="SimpleMath">\(G\)</span> is a subgroup of <span class="SimpleMath">\(U_4(3)\)</span> but not of <span class="SimpleMath">\(2.U_4(3)\)</span>, <span class="SimpleMath">\(3.G\)</span> is a subgroup of <span class="SimpleMath">\(G_2(4)\)</span> but not of <span class="SimpleMath">\(2.G_2(4)\)</span>, and <span class="SimpleMath">\(G_2(4)\)</span> is a subgroup of <span class="SimpleMath">\(Suz\)</span> but not of <span class="SimpleMath">\(2.Suz\)</span>. The positive statements follow from <a href="chapBib_mj.html#biBCCN85">[CCN+85, pp. 52, 97, 131]</a> and the negative ones from the following computations.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( PossibleClassFusions( CharacterTable( "L3(4)" ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> CharacterTable( "2.U4(3)" ) ) );</span>
0
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( PossibleClassFusions( CharacterTable( "3.L3(4)" ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> CharacterTable( "2.G2(4)" ) ) );</span>
0
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( PossibleClassFusions( CharacterTable( "G2(4)" ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> CharacterTable( "2.Suz" ) ) );</span>
0
</pre></div>
<p>The group <span class="SimpleMath">\(3.G\)</span> centralizes an element of order three. If <span class="SimpleMath">\(3.G\)</span> is a subgroup of <span class="SimpleMath">\(𝕄\)</span> then it is contained in a <code class="code">3A</code> centralizer (of the structure <span class="SimpleMath">\(3.Fi_{24}'\)</span>), a <code class="code">3B</code> centralizer (of the structure <span class="SimpleMath">\(3^{1+12}_+.2Suz\)</span>) or a <code class="code">3C</code> centralizer (of the structure <span class="SimpleMath">\(3 \times Th\)</span>). Clearly the case <span class="SimpleMath">\(3C\)</span> cannot occur, and <code class="code">3B</code> is excluded by the fact that no class fusion between <span class="SimpleMath">\(3.G\)</span> and the <span class="SimpleMath">\(3B\)</span> normalizer <span class="SimpleMath">\(3^{1+12}_+.2Suz.2\)</span> is possible.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "MN3B" );</span>
CharacterTable( "3^(1+12).2.Suz.2" )
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( PossibleClassFusions( CharacterTable( "3.L3(4)" ), t ) );</span>
0
</pre></div>
<p>If <span class="SimpleMath">\(3.G\)</span> is contained in the <code class="code">3A</code> centralizer then this embedding induces one of <span class="SimpleMath">\(G\)</span> into some maximal subgroup of <span class="SimpleMath">\(Fi_{24}'\)</span>. Using the known character tables of these maximal subgroups in GAP's character table library, one shows that only <span class="SimpleMath">\(Fi_{23}\)</span> admits a class fusion, but this subgroup lifts to <span class="SimpleMath">\(3 \times Fi_{23}\)</span> in <span class="SimpleMath">\(3.Fi_{24}'\)</span> and thus cannot lead to a subgroup of type <span class="SimpleMath">\(3.G\)</span>..</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">mx:= List( Maxes( CharacterTable( "Fi24'" ) ), CharacterTable );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">s:= CharacterTable( "L3(4)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Filtered( mx, x -> Length( PossibleClassFusions( s, x ) ) > 0 );</span>
[ CharacterTable( "Fi23" ) ]
</pre></div>
<p>The other candidates <span class="SimpleMath">\(m.G\)</span> contain at least one central involution. If <span class="SimpleMath">\(m.G\)</span> is a subgroup of <span class="SimpleMath">\(𝕄\)</span> then it is contained in a <code class="code">2A</code> centralizer (of the structure <span class="SimpleMath">\(2.B\)</span>) or a <code class="code">2B</code> centralizer (of the structure <code class="code">2^{1+24}_+.Co_1</code>). Again we use <code class="func">PossibleClassFusions</code> (<a href="../../../doc/ref/chap73_mj.html#X7883271F7F26356E"><span class="RefLink">Reference: PossibleClassFusions</span></a>) to list all candidates for the class fusion, but here we prescribe the central involution of the <code class="code">2A</code> or <code class="code">2B</code> centralizer as an image of one central involution in <span class="SimpleMath">\(m.G\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">done:= [ "L3(4)", "2.L3(4)", "3.L3(4)", "2^2.L3(4)", "6.L3(4)" ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">names:= Filtered( names, x -> not x in done );</span>
[ "4_1.L3(4)", "4_2.L3(4)", "(2x4).L3(4)", "(2^2x3).L3(4)",
"12_1.L3(4)", "12_2.L3(4)", "4^2.L3(4)", "(2x12).L3(4)",
"(4^2x3).L3(4)" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">invcent:= List( [ "MN2A", "MN2B" ], CharacterTable );</span>
[ CharacterTable( "2.B" ), CharacterTable( "2^1+24.Co1" ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">ForAll( invcent, x -> ClassPositionsOfCentre( x ) = [ 1, 2 ] );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ords:= "dummy";; # Avoid a message about an unbound variable ...</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for name in names do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> s:= CharacterTable( name );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> ords:= OrdersClassRepresentatives( s );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> invpos:= Filtered( ClassPositionsOfCentre( s ), i -> ords[i] = 2 );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for i in invpos do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for t in invcent do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> init:= InitFusion( s, t );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if init = fail then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> continue;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> init[i]:= 2;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fus:= PossibleClassFusions( s, t, rec( fusionmap:= init,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> decompose:= false ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if fus <> [] then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( cand, [ s, t, i, fus ] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">List( cand, x -> x{ [ 1 .. 3 ] } );</span>
[ [ CharacterTable( "4_1.L3(4)" ), CharacterTable( "2^1+24.Co1" ), 3 ]
, [ CharacterTable( "(2x4).L3(4)" ), CharacterTable( "2.B" ), 2 ],
[ CharacterTable( "(2x4).L3(4)" ), CharacterTable( "2.B" ), 3 ] ]
</pre></div>
<p>(Note that we have called <code class="func">PossibleClassFusions</code> (<a href="../../../doc/ref/chap73_mj.html#X7883271F7F26356E"><span class="RefLink">Reference: PossibleClassFusions</span></a>) with the option <code class="code">decompose:= false</code>, in order to save space and time. See Section <a href="chap1_mj.html#X82C7A03684DD7C6E"><span class="RefLink">1.5-1</span></a> for more details.)</p>
<p>Concerning the candidate <span class="SimpleMath">\((2 \times 4).G\)</span>, we see that only fusions are possible for which the central involution in question is mapped to a <code class="code">2A</code> element of <span class="SimpleMath">\(𝕄\)</span>. Since we get candidates only for two out of the three central involutions, we see that <span class="SimpleMath">\((2 \times 4).G\)</span> does not embed into <span class="SimpleMath">\(𝕄\)</span>.</p>
<p>Thus it turns out that exactly one group <span class="SimpleMath">\(m.G\)</span> cannot be excluded this way. Namely, these character-theoretical criteria leave the possibility that <span class="SimpleMath">\(4_1.G\)</span> may occur as a subgroup of <span class="SimpleMath">\(2^{1+24}_+.Co_1\)</span>.</p>
<p>Moreover, we see that if this happens then the centre <span class="SimpleMath">\(C\)</span> of <span class="SimpleMath">\(4_1.G\)</span> lies inside the normal subgroup <span class="SimpleMath">\(N = 2^{1+24}_+\)</span>. The centralizer of <span class="SimpleMath">\(C\)</span> in <span class="SimpleMath">\(N\)</span> has order <span class="SimpleMath">\(2^{24}\)</span>, and the centralizer of <span class="SimpleMath">\(C\)</span> in <span class="SimpleMath">\(2^{1+24}_+.Co_1\)</span> has order <span class="SimpleMath">\(2^{24} \cdot |Co_3|\)</span>. We see that <span class="SimpleMath">\(4_1.G\)</span>, if it exists as a subgroup of <span class="SimpleMath">\(2^{1+24}_+.Co_1\)</span>, must lie inside the subgroup <span class="SimpleMath">\([2^{24}].Co_3\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">s:= cand[1][1];</span>
CharacterTable( "4_1.L3(4)" )
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= cand[1][2];</span>
CharacterTable( "2^1+24.Co1" )
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= cand[1][4];</span>
[ [ 1, 5, 2, 5, 9, 8, 23, 27, 24, 27, 49, 49, 50, 50, 70, 74, 71, 74,
70, 74, 71, 74, 114, 119, 115, 119, 114, 119, 115, 119 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">ClassPositionsOfCentre( s );</span>
[ 1, 2, 3, 4 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">5 in ClassPositionsOfPCore( t, 2 );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">siz:= SizesCentralizers( t )[5] / 2^24;</span>
495766656000
<span class="GAPprompt">gap></span> <span class="GAPinput">mx:= Filtered( List( Maxes( CharacterTable( "Co1" ) ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> CharacterTable ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> Size( x ) mod siz = 0 );</span>
[ CharacterTable( "Co3" ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Size( mx[1] ) = siz;</span>
true
</pre></div>
<p>I do not see a character-theoretic argument that could disprove the existence of such an <span class="SimpleMath">\(4_1.G\)</span> type subgroup.</p>
<p><a id="X7F605CA28441687F" name="X7F605CA28441687F"></a></p>
<h5>1.5-3 <span class="Heading">The character table of <span class="SimpleMath">\((2 \times O_8^+(3)).S_4 \leq 2.B\)</span> (October 2023)</span></h5>
<p>Consider a maximal subgroup <span class="SimpleMath">\(H\)</span> of type <span class="SimpleMath">\((3^2:2 \times O_8^+(3)).S_4\)</span> in the sporadic simple Monster group. The character table of <span class="SimpleMath">\(H\)</span> has been contributed by Tim Burness. We can view <span class="SimpleMath">\(H\)</span> as <span class="SimpleMath">\(O_8^+(3).(3^2:2S_4) = O_8^+(3).F\)</span>. The character table of <span class="SimpleMath">\(H\)</span> determines that of <span class="SimpleMath">\(F\)</span>, and this table determines the isomorphism type of <span class="SimpleMath">\(F\)</span> as <code class="code">SmallGroup( 432, 734 )</code>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tblH:= CharacterTable( "(3^2:2xO8+(3)).S4" );</span>
CharacterTable( "(3^2:2xO8+(3)).S4" )
<span class="GAPprompt">gap></span> <span class="GAPinput">N:= ClassPositionsOfSolvableResiduum( tblH );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">tblF:= tblH / N;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Size( tblF );</span>
432
<span class="GAPprompt">gap></span> <span class="GAPinput">known:= NamesOfEquivalentLibraryCharacterTables( tblF );</span>
[ "3^2.2.S4", "M12M7" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Filtered( GroupInfoForCharacterTable( known[1] ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> x[1] = "SmallGroup" );</span>
[ [ "SmallGroup", [ 432, 734 ] ] ]
</pre></div>
<p>(Note that the precomputed <code class="func">GroupInfoForCharacterTable</code> (<a href="..//doc/chap3_mj.html#X78DCD38B7D96D8A4"><span class="RefLink">CTblLib: GroupInfoForCharacterTable</span></a>) information about <strong class="pkg">GAP</strong> library character tables means that exactly one isomorphism type of groups fits to the character table of <span class="SimpleMath">\(F\)</span>.)</p>
<p>We compute that <span class="SimpleMath">\(O_3(F) \cong 3^2\)</span> has complements in <span class="SimpleMath">\(F\)</span>, thus <span class="SimpleMath">\(H\)</span> has a subgroup <span class="SimpleMath">\(V\)</span> of the type <span class="SimpleMath">\(O_8^+(3).2S_4\)</span>, which is a complement of <span class="SimpleMath">\(O_3(H)\)</span> in <span class="SimpleMath">\(H\)</span>, thus <span class="SimpleMath">\(V\)</span> is isomorphic with <span class="SimpleMath">\(H / O_3(H)\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G:= SmallGroup( 432, 734 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">P:= PCore( G, 3 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( ComplementClassesRepresentatives( G, P ) );</span>
1
</pre></div>
<p>We can derive the character table of <span class="SimpleMath">\(V\)</span> from that of <span class="SimpleMath">\(H\)</span>, and compute that the group structure of <span class="SimpleMath">\(V\)</span> is <span class="SimpleMath">\((2 \times O_8^+(3)).S_4\)</span>. For that, we consider the element orders of the unique normal subgroup of order <span class="SimpleMath">\(2 |O_8^+(3)|\)</span> in <span class="SimpleMath">\(V\)</span>. If this normal subgroup would not be isomorphic with <span class="SimpleMath">\(2 \times O_8^+(3)\)</span> then it would have one of the structures <span class="SimpleMath">\(O_8^+(3).2_1\)</span> or <span class="SimpleMath">\(O_8^+(3).2_2\)</span>, but then it would contain elements of the orders <span class="SimpleMath">\(24\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tblV:= tblH / ClassPositionsOfPCore( tblH, 3 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ord:= 2 * Size( tblH ) / Size( tblF );</span>
9904359628800
<span class="GAPprompt">gap></span> <span class="GAPinput">classes:= SizesConjugacyClasses( tblV );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">2N:= Filtered( ClassPositionsOfNormalSubgroups( tblV ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> l -> Sum( classes{ l } ) = ord );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( 2N );</span>
1
<span class="GAPprompt">gap></span> <span class="GAPinput">Set( OrdersClassRepresentatives( tblV ){ 2N[1] } );</span>
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 18, 20, 26, 30 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Set( OrdersClassRepresentatives( CharacterTable( "O8+(3)" ) ) );</span>
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 18, 20 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Set( OrdersClassRepresentatives( CharacterTable( "O8+(3).2_1" ) ) );</span>
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 18, 20, 24, 26, 28,
30, 36, 40 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Set( OrdersClassRepresentatives( CharacterTable( "O8+(3).2_2" ) ) );</span>
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 18, 20, 24, 26, 28,
30, 36 ]
</pre></div>
<p>The class fusion of <span class="SimpleMath">\(V\)</span> into the Monster group shows that <span class="SimpleMath">\(V\)</span> centralizes a <code class="code">2A</code> element in the Monster, hence <span class="SimpleMath">\(V\)</span> is a subgroup of a maximal subgroup of the type <span class="SimpleMath">\(2.B\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tblM:= CharacterTable( "M" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">VfusM:= PossibleClassFusions( tblV, tblM );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( VfusM );</span>
4
<span class="GAPprompt">gap></span> <span class="GAPinput">ZV:= ClassPositionsOfCentre( tblV );</span>
[ 1, 2 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Set( List( VfusM, l -> l{ ZV } ) );</span>
[ [ 1, 2 ] ]
</pre></div>
<p>From the list of maximal subgroups of <span class="SimpleMath">\(B\)</span>, we see that either <span class="SimpleMath">\(V\)</span> is contained in the preimage of <span class="SimpleMath">\(Fi_{23}\)</span> under the natural epimorphism from <span class="SimpleMath">\(2.B\)</span> to <span class="SimpleMath">\(B\)</span>, or <span class="SimpleMath">\(V\)</span> is equal to the preimage of <span class="SimpleMath">\(O_8^+(3).S_4\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tblB:= CharacterTable( "B" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">mxB:= List( Maxes( tblB ), CharacterTable );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= Filtered( mxB, s -> Size( s ) mod ( Size( tblV ) / 2 ) = 0 );</span>
[ CharacterTable( "Fi23" ), CharacterTable( "O8+(3).S4" ) ]
</pre></div>
<p>The former possibility is excluded from the fact that the factor of <span class="SimpleMath">\(V\)</span> by its center does not admit a class fusion into <span class="SimpleMath">\(Fi_{23}\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( PossibleClassFusions( tblV / ZV, CharacterTable( "Fi23" ) ) );</span>
0
</pre></div>
<p>We conclude that <span class="SimpleMath">\(V\)</span> is a maximal subgroup of <span class="SimpleMath">\(2.B\)</span>.</p>
<p>Thus we have used the character table of <span class="SimpleMath">\(H\)</span> to construct the character table of a maximal subgroup of <span class="SimpleMath">\(2.B\)</span>, with very little effort.</p>
<p>This table is meanwhile available in the table library, with the identifier <code class="code">"(2xO8+(3)).S4"</code>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">lib:= CharacterTable( "(2xO8+(3)).S4" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">TransformingPermutationsCharacterTables( tblV, lib ) <> fail;</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">Irr( lib ) = Irr( tblV );</span>
true
</pre></div>
<p>In order to add the table to the library, we have to provide also the class fusions from <span class="SimpleMath">\(V\)</span> to <span class="SimpleMath">\(2.B\)</span>, to the maximal subgroup <span class="SimpleMath">\((2 \times O_8^+(3)).S_4\)</span> of <span class="SimpleMath">\(B\)</span>, and to the maximal subgroup <span class="SimpleMath">\((3^2:2 \times O_8^+(3)).S_4\)</span> of <span class="SimpleMath">\(M\)</span>, such that the compositions of fusions from <span class="SimpleMath">\(V\)</span> to <span class="SimpleMath">\(B\)</span> via <span class="SimpleMath">\(O_8^+(3).S_4\)</span> and <span class="SimpleMath">\(2.B\)</span> are compatible, <span class="SimpleMath">\(\ldots\)</span></p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tblU:= CharacterTable( "O8+(3).S4" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">tbl2B:= CharacterTable( "2.B" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">CompositionMaps( GetFusionMap( tblU, tblB ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> GetFusionMap( lib, tblU ) ) =</span>
<span class="GAPprompt">></span> <span class="GAPinput"> CompositionMaps( GetFusionMap( tbl2B, tblB ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> GetFusionMap( lib, tbl2B ) );</span>
true
</pre></div>
<p><span class="SimpleMath">\(\ldots\)</span> and that the compositions of fusions from <span class="SimpleMath">\(V\)</span> to <span class="SimpleMath">\(M\)</span> via <span class="SimpleMath">\((3^2:2 \times O_8^+(3)).S_4\)</span> and <span class="SimpleMath">\(2.B\)</span> are compatible.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tblH:= CharacterTable( "(3^2:2xO8+(3)).S4" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">CompositionMaps( GetFusionMap( tblH, tblM ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> GetFusionMap( lib, tblH ) ) =</span>
<span class="GAPprompt">></span> <span class="GAPinput"> CompositionMaps( GetFusionMap( tbl2B, tblM ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> GetFusionMap( lib, tbl2B ) );</span>
true
</pre></div>
<div class="chlinkprevnextbot"> <a href="chap0_mj.html">[Top of Book]</a> <a href="chap0_mj.html#contents">[Contents]</a> <a href="chap0_mj.html">[Previous Chapter]</a> <a href="chap2_mj.html">[Next Chapter]</a> </div>
<div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0_mj.html">Top</a> <a href="chap1_mj.html">1</a> <a href="chap2_mj.html">2</a> <a href="chap3_mj.html">3</a> <a href="chap4_mj.html">4</a> <a href="chap5_mj.html">5</a> <a href="chap6_mj.html">6</a> <a href="chap7_mj.html">7</a> <a href="chap8_mj.html">8</a> <a href="chap9_mj.html">9</a> <a href="chap10_mj.html">10</a> <a href="chap11_mj.html">11</a> <a href="chapBib_mj.html">Bib</a> <a href="chapInd_mj.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>
|
