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
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737
2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952
2953
2954
2955
2956
2957
2958
2959
2960
2961
2962
2963
2964
2965
2966
2967
2968
2969
2970
2971
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992
2993
2994
2995
2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
3014
3015
3016
3017
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031
3032
3033
3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110
3111
3112
3113
3114
3115
3116
3117
3118
3119
3120
3121
3122
3123
3124
3125
3126
3127
3128
3129
3130
3131
3132
3133
3134
3135
3136
3137
3138
3139
3140
3141
3142
3143
3144
3145
3146
3147
3148
3149
3150
3151
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163
3164
3165
3166
3167
3168
3169
3170
3171
3172
3173
3174
3175
3176
3177
3178
|
<?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 8: Permutation Characters in GAP</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="chap8" 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="chap7_mj.html">[Previous Chapter]</a> <a href="chap9_mj.html">[Next Chapter]</a> </div>
<p id="mathjaxlink" class="pcenter"><a href="chap8.html">[MathJax off]</a></p>
<p><a id="X7A7EEBE9858333E1" name="X7A7EEBE9858333E1"></a></p>
<div class="ChapSects"><a href="chap8_mj.html#X7A7EEBE9858333E1">8 <span class="Heading">Permutation Characters in <strong class="pkg">GAP</strong></span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X86A1325B82E5AECD">8.1 <span class="Heading">Some Computations with <span class="SimpleMath">\(M_{24}\)</span></span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X79C9051F805851DB">8.2 <span class="Heading">All Possible Permutation Characters of <span class="SimpleMath">\(M_{11}\)</span></span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X81A5FC968782CFC3">8.3 <span class="Heading">The Action of <span class="SimpleMath">\(U_6(2)\)</span> on the Cosets of <span class="SimpleMath">\(M_{22}\)</span></span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X7EE1811C8496C428">8.4 <span class="Heading">Degree <span class="SimpleMath">\(20\,736\)</span> Permutation Characters of <span class="SimpleMath">\(U_6(2)\)</span></span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X7DC6A6E785A347C8">8.5 <span class="Heading">Degree <span class="SimpleMath">\(57\,572\,775\)</span> Permutation Characters of <span class="SimpleMath">\(O_8^+(3)\)</span></span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X792D2C2380591D8D">8.6 <span class="Heading">The Action of <span class="SimpleMath">\(O_7(3).2\)</span> on the Cosets of <span class="SimpleMath">\(2^7.S_7\)</span></span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X875B361C8512939F">8.7 <span class="Heading">The Action of <span class="SimpleMath">\(O_8^+(3).2_1\)</span> on the Cosets of <span class="SimpleMath">\(2^7.A_8\)</span></span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X7B1DFAF98182CFF4">8.8 <span class="Heading">The Action of <span class="SimpleMath">\(S_4(4).4\)</span> on the Cosets of <span class="SimpleMath">\(5^2.[2^5]\)</span></span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X7F04F0C684AA8B30">8.9 <span class="Heading">The Action of <span class="SimpleMath">\(Co_1\)</span> on the Cosets of Involution Centralizers</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X8230719D8538384B">8.10 <span class="Heading">The Multiplicity Free Permutation Characters of <span class="SimpleMath">\(G_2(3)\)</span></span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X7E3E326C7CB0E2CD">8.11 <span class="Heading">Degree <span class="SimpleMath">\(11\,200\)</span> Permutation Characters of <span class="SimpleMath">\(O_8^+(2)\)</span></span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X7D8572E68194CBB9">8.12 <span class="Heading">A Proof of Nonexistence of a Certain Subgroup</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X8068E9DA7CD03BF2">8.13 <span class="Heading">A Permutation Character of the Lyons group</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X87D6C1A67CC7EE0A">8.14 <span class="Heading">Identifying two subgroups of Aut<span class="SimpleMath">\((U_3(5))\)</span> (October 2001)</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X793669787CF73A55">8.15 <span class="Heading">A Permutation Character of Aut<span class="SimpleMath">\((O_8^+(2))\)</span> (October 2001)</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X8337F3C682B6BE63">8.16 <span class="Heading">Four Primitive Permutation Characters of the Monster Group</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap8_mj.html#X78A8A1248336DD26">8.16-1 <span class="Heading">The Subgroup <span class="SimpleMath">\(2^2.2^{11}.2^{22}.(S_3 \times M_{24})\)</span>
(June 2009)</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap8_mj.html#X79E9247182B20474">8.16-2 <span class="Heading">The Subgroup <span class="SimpleMath">\(2^3.2^6.2^{12}.2^{18}.(L_3(2) \times 3.S_6)\)</span>
(September 2009)</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap8_mj.html#X7BC36C597E542DEE">8.16-3 <span class="Heading">The Subgroup <span class="SimpleMath">\(2^5.2^{10}.2^{20}.(S_3 \times L_5(2))\)</span>
(October 2009)</span></a>
</span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap8_mj.html#X7F2ABD3E7AFF5F6E">8.16-4 <span class="Heading">The Subgroup <span class="SimpleMath">\(2^{{10+16}}.O_{10}^+(2)\)</span> (November 2009)</span></a>
</span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X87D11B097D95D027">8.17 <span class="Heading">A permutation character of the Baby Monster (June 2012)</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X86827FA97D27F3A2">8.18 <span class="Heading">A permutation character of <span class="SimpleMath">\(2.B\)</span> (October 2017)</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap8_mj.html#X849F0EA6807C9B19">8.19 <span class="Heading">Generation of sporadic simple groups by <span class="SimpleMath">\(\pi\)</span>- and <span class="SimpleMath">\(\pi'\)</span>-subgroups (December 2021)</span></a>
</span>
</div>
</div>
<h3>8 <span class="Heading">Permutation Characters in <strong class="pkg">GAP</strong></span></h3>
<p>Date: April 17th, 1999</p>
<p>This is a loose collection of examples of computations with permutation characters and possible permutation characters in the <strong class="pkg">GAP</strong> system <a href="chapBib_mj.html#biBGAP">[GAP21]</a>. We mainly use the <strong class="pkg">GAP</strong> implementation of the algorithms to compute possible permutation characters that are described in <a href="chapBib_mj.html#biBBP98copy">[BP98]</a>, and information from the Atlas of Finite Groups <a href="chapBib_mj.html#biBCCN85">[CCN+85]</a>. A <em>possible permutation character</em> of a finite group <span class="SimpleMath">\(G\)</span> is a character satisfying the conditions listed in Section "Possible Permutation Characters" of the <strong class="pkg">GAP</strong> Reference Manual.</p>
<ul>
<li><p>Sections <a href="chap8_mj.html#X87D6C1A67CC7EE0A"><span class="RefLink">8.14</span></a> and <a href="chap8_mj.html#X793669787CF73A55"><span class="RefLink">8.15</span></a> were added in October 2001.</p>
</li>
<li><p>Section <a href="chap8_mj.html#X78A8A1248336DD26"><span class="RefLink">8.16-1</span></a> was added in June 2009.</p>
</li>
<li><p>Section <a href="chap8_mj.html#X79E9247182B20474"><span class="RefLink">8.16-2</span></a> was added in September 2009.</p>
</li>
<li><p>Section <a href="chap8_mj.html#X7BC36C597E542DEE"><span class="RefLink">8.16-3</span></a> was added in October 2009.</p>
</li>
<li><p>Section <a href="chap8_mj.html#X7F2ABD3E7AFF5F6E"><span class="RefLink">8.16-4</span></a> was added in November 2009.</p>
</li>
<li><p>Section <a href="chap8_mj.html#X87D11B097D95D027"><span class="RefLink">8.17</span></a> was added in June 2012.</p>
</li>
<li><p>Section <a href="chap8_mj.html#X86827FA97D27F3A2"><span class="RefLink">8.18</span></a> was added in October 2017.</p>
</li>
<li><p>Section <a href="chap8_mj.html#X849F0EA6807C9B19"><span class="RefLink">8.19</span></a> was added in December 2021.</p>
</li>
</ul>
<p>In the following, the <strong class="pkg">GAP</strong> Character Table Library <a href="chapBib_mj.html#biBCTblLib">[Bre24]</a> will be used frequently.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">LoadPackage( "ctbllib", "1.2", false );</span>
true
</pre></div>
<p><a id="X86A1325B82E5AECD" name="X86A1325B82E5AECD"></a></p>
<h4>8.1 <span class="Heading">Some Computations with <span class="SimpleMath">\(M_{24}\)</span></span></h4>
<p>We start with the sporadic simple Mathieu group <span class="SimpleMath">\(G = M_{24}\)</span> in its natural action on <span class="SimpleMath">\(24\)</span> points.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= MathieuGroup( 24 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( g, "m24" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Size( g ); IsSimple( g ); NrMovedPoints( g );</span>
244823040
true
24
</pre></div>
<p>The conjugacy classes that are computed for a group can be ordered differently in different <strong class="pkg">GAP</strong> sessions. In order to make the output shown in the following examples stable, we first sort the conjugacy classes of <span class="SimpleMath">\(G\)</span> for our purposes.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">ccl:= AttributeValueNotSet( ConjugacyClasses, g );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">HasConjugacyClasses( g );</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">invariants:= List( ccl, c -> [ Order( Representative( c ) ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Size( c ), Size( ConjugacyClass( g, Representative( c )^2 ) ) ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SortParallel( invariants, ccl );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetConjugacyClasses( g, ccl );</span>
</pre></div>
<p>The permutation character <code class="code">pi</code> of <span class="SimpleMath">\(G\)</span> corresponding to the action on the moved points is constructed. This action is <span class="SimpleMath">\(5\)</span>-transitive.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">NrConjugacyClasses( g );</span>
26
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= NaturalCharacter( g );</span>
Character( CharacterTable( m24 ),
[ 24, 8, 0, 6, 0, 0, 4, 0, 4, 2, 0, 3, 3, 2, 0, 2, 0, 0, 1, 1, 1, 1,
0, 0, 1, 1 ] )
<span class="GAPprompt">gap></span> <span class="GAPinput">IsTransitive( pi ); Transitivity( pi );</span>
true
5
<span class="GAPprompt">gap></span> <span class="GAPinput">SetIdentifier( CharacterTable( g ), "M24table" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( pi );</span>
M24table
2 10 10 9 3 3 7 7 5 2 3 3 1 1 4 2 . 2 2 1
3 3 1 1 3 2 1 . 1 1 1 1 1 1 . . . 1 1 .
5 1 . 1 1 . . . . 1 . . . . . 1 . . . .
7 1 1 . . 1 . . . . . . 1 1 . . . . . 1
11 1 . . . . . . . . . . . . . . 1 . . .
23 1 . . . . . . . . . . . . . . . . . .
1a 2a 2b 3a 3b 4a 4b 4c 5a 6a 6b 7a 7b 8a 10a 11a 12a 12b 14a
Y.1 24 8 . 6 . . 4 . 4 2 . 3 3 2 . 2 . . 1
2 1 . . . . . .
3 . 1 1 1 1 . .
5 . 1 1 . . . .
7 1 . . 1 1 . .
11 . . . . . . .
23 . . . . . 1 1
14b 15a 15b 21a 21b 23a 23b
Y.1 1 1 1 . . 1 1
</pre></div>
<p>(We have set the <code class="func">Identifier</code> (<a href="..//doc/chap3_mj.html#X860F49407882658F"><span class="RefLink">CTblLib: IdentifierOfMainTable</span></a>) value of the character table because otherwise some default identifier would be chosen, which depends on the <strong class="pkg">GAP</strong> session.)</p>
<p><code class="code">pi</code> determines the permutation characters of the <span class="SimpleMath">\(G\)</span>-actions on related sets, for example <code class="code">piop</code> on the set of ordered and <code class="code">piup</code> on the set of unordered pairs of points.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">piop:= pi * pi;</span>
Character( CharacterTable( m24 ),
[ 576, 64, 0, 36, 0, 0, 16, 0, 16, 4, 0, 9, 9, 4, 0, 4, 0, 0, 1, 1,
1, 1, 0, 0, 1, 1 ] )
<span class="GAPprompt">gap></span> <span class="GAPinput">IsTransitive( piop );</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">piup:= SymmetricParts( UnderlyingCharacterTable(pi), [ pi ], 2 )[1];</span>
Character( CharacterTable( m24 ),
[ 300, 44, 12, 21, 0, 4, 12, 0, 10, 5, 0, 6, 6, 4, 2, 3, 0, 1, 2, 2,
1, 1, 0, 0, 1, 1 ] )
<span class="GAPprompt">gap></span> <span class="GAPinput">IsTransitive( piup );</span>
false
</pre></div>
<p>Clearly the action on unordered pairs is not transitive, since the pairs <span class="SimpleMath">\([ i, i ]\)</span> form an orbit of their own. There are exactly two <span class="SimpleMath">\(G\)</span>-orbits on the unordered pairs, hence the <span class="SimpleMath">\(G\)</span>-action on <span class="SimpleMath">\(2\)</span>-sets of points is transitive.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">ScalarProduct( piup, TrivialCharacter( g ) );</span>
2
<span class="GAPprompt">gap></span> <span class="GAPinput">comb:= Combinations( [ 1 .. 24 ], 2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">hom:= ActionHomomorphism( g, comb, OnSets );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">pihom:= NaturalCharacter( hom );</span>
Character( CharacterTable( m24 ),
[ 276, 36, 12, 15, 0, 4, 8, 0, 6, 3, 0, 3, 3, 2, 2, 1, 0, 1, 1, 1,
0, 0, 0, 0, 0, 0 ] )
<span class="GAPprompt">gap></span> <span class="GAPinput">Transitivity( pihom );</span>
1
</pre></div>
<p>In terms of characters, the permutation character <code class="code">pihom</code> is the difference of <code class="code">piup</code> and <code class="code">pi</code> . Note that <strong class="pkg">GAP</strong> does not know that this difference is in fact a character; in general this question is not easy to decide without knowing the irreducible characters of <span class="SimpleMath">\(G\)</span>, and up to now <strong class="pkg">GAP</strong> has not computed the irreducibles.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">pi2s:= piup - pi;</span>
VirtualCharacter( CharacterTable( m24 ),
[ 276, 36, 12, 15, 0, 4, 8, 0, 6, 3, 0, 3, 3, 2, 2, 1, 0, 1, 1, 1,
0, 0, 0, 0, 0, 0 ] )
<span class="GAPprompt">gap></span> <span class="GAPinput">pi2s = pihom;</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">HasIrr( g ); HasIrr( CharacterTable( g ) );</span>
false
false
</pre></div>
<p>The point stabilizer in the action on <span class="SimpleMath">\(2\)</span>-sets is in fact a maximal subgroup of <span class="SimpleMath">\(G\)</span>, which is isomorphic to the automorphism group <span class="SimpleMath">\(M_{22}:2\)</span> of the Mathieu group <span class="SimpleMath">\(M_{22}\)</span>. Thus this permutation action is primitive. But we cannot apply <code class="func">IsPrimitive</code> (<a href="../../../doc/ref/chap41_mj.html#X84C19AD68247B760"><span class="RefLink">Reference: IsPrimitive</span></a>) to the character <code class="code">pihom</code> for getting this answer because primitivity of characters is defined in a different way, cf. <code class="func">IsPrimitiveCharacter</code> (<a href="../../../doc/ref/chap75_mj.html#X7BC72ECE822D4245"><span class="RefLink">Reference: IsPrimitiveCharacter</span></a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">IsPrimitive( g, comb, OnSets );</span>
true
</pre></div>
<p>We could also have computed the transitive permutation character of degree <span class="SimpleMath">\(276\)</span> using the <strong class="pkg">GAP</strong> Character Table Library instead of the group <span class="SimpleMath">\(G\)</span>, since the character tables of <span class="SimpleMath">\(G\)</span> and all its maximal subgroups are available, together with the class fusions of the maximal subgroups into <span class="SimpleMath">\(G\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tbl:= CharacterTable( "M24" );</span>
CharacterTable( "M24" )
<span class="GAPprompt">gap></span> <span class="GAPinput">maxes:= Maxes( tbl );</span>
[ "M23", "M22.2", "2^4:a8", "M12.2", "2^6:3.s6", "L3(4).3.2_2",
"2^6:(psl(3,2)xs3)", "L2(23)", "L3(2)" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">s:= CharacterTable( maxes[2] );</span>
CharacterTable( "M22.2" )
<span class="GAPprompt">gap></span> <span class="GAPinput">TrivialCharacter( s )^tbl;</span>
Character( CharacterTable( "M24" ),
[ 276, 36, 12, 15, 0, 4, 8, 0, 6, 3, 0, 3, 3, 2, 2, 1, 1, 0, 1, 1,
0, 0, 0, 0, 0, 0 ] )
</pre></div>
<p>Note that the sequence of conjugacy classes in the library table of <span class="SimpleMath">\(G\)</span> does in general not agree with the succession computed for the group.</p>
<p><a id="X79C9051F805851DB" name="X79C9051F805851DB"></a></p>
<h4>8.2 <span class="Heading">All Possible Permutation Characters of <span class="SimpleMath">\(M_{11}\)</span></span></h4>
<p>We compute all possible permutation characters of the Mathieu group <span class="SimpleMath">\(M_{11}\)</span>, using the three different strategies available in <strong class="pkg">GAP</strong>. First we try the algorithm that enumerates all candidates via solving a system of inequalities, which is described in <a href="chapBib_mj.html#biBBP98copy">[BP98, Section 3.2]</a>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">m11:= CharacterTable( "M11" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetName( m11, "m11" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= PermChars( m11 );</span>
[ Character( m11, [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ), Character( m11,
[ 11, 3, 2, 3, 1, 0, 1, 1, 0, 0 ] ), Character( m11,
[ 12, 4, 3, 0, 2, 1, 0, 0, 1, 1 ] ), Character( m11,
[ 22, 6, 4, 2, 2, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 55, 7, 1, 3, 0, 1, 1, 1, 0, 0 ] ), Character( m11,
[ 66, 10, 3, 2, 1, 1, 0, 0, 0, 0 ] ), Character( m11,
[ 110, 6, 2, 2, 0, 0, 2, 2, 0, 0 ] ), Character( m11,
[ 110, 6, 2, 6, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 110, 14, 2, 2, 0, 2, 0, 0, 0, 0 ] ), Character( m11,
[ 132, 12, 6, 0, 2, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 144, 0, 0, 0, 4, 0, 0, 0, 1, 1 ] ), Character( m11,
[ 165, 13, 3, 1, 0, 1, 1, 1, 0, 0 ] ), Character( m11,
[ 220, 4, 4, 0, 0, 4, 0, 0, 0, 0 ] ), Character( m11,
[ 220, 12, 4, 4, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 220, 20, 4, 0, 0, 2, 0, 0, 0, 0 ] ), Character( m11,
[ 330, 2, 6, 2, 0, 2, 0, 0, 0, 0 ] ), Character( m11,
[ 330, 18, 6, 2, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 396, 12, 0, 4, 1, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 440, 8, 8, 0, 0, 2, 0, 0, 0, 0 ] ), Character( m11,
[ 440, 24, 8, 0, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 495, 15, 0, 3, 0, 0, 1, 1, 0, 0 ] ), Character( m11,
[ 660, 4, 3, 4, 0, 1, 0, 0, 0, 0 ] ), Character( m11,
[ 660, 12, 3, 0, 0, 3, 0, 0, 0, 0 ] ), Character( m11,
[ 660, 12, 12, 0, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 660, 28, 3, 0, 0, 1, 0, 0, 0, 0 ] ), Character( m11,
[ 720, 0, 0, 0, 0, 0, 0, 0, 5, 5 ] ), Character( m11,
[ 792, 24, 0, 0, 2, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 880, 0, 16, 0, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 990, 6, 0, 2, 0, 0, 2, 2, 0, 0 ] ), Character( m11,
[ 990, 6, 0, 6, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 990, 30, 0, 2, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 1320, 8, 6, 0, 0, 2, 0, 0, 0, 0 ] ), Character( m11,
[ 1320, 24, 6, 0, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 1584, 0, 0, 0, 4, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 1980, 12, 0, 4, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 1980, 36, 0, 0, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 2640, 0, 12, 0, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 3960, 24, 0, 0, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
[ 7920, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( perms );</span>
39
</pre></div>
<p>Next we try the improved combinatorial approach that is sketched at the end of Section 3.2 in <a href="chapBib_mj.html#biBBP98copy">[BP98]</a>. We get the same characters, except that they may be ordered in a different way; thus we compare the ordered lists.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">degrees:= DivisorsInt( Size( m11 ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">perms2:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for d in degrees do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Append( perms2, PermChars( m11, d ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Set( perms ) = Set( perms2 );</span>
true
</pre></div>
<p>Finally, we try the algorithm that is based on Gaussian elimination and that is described in <a href="chapBib_mj.html#biBBP98copy">[BP98, Section 3.3]</a>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">perms3:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for d in degrees do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Append( perms3, PermChars( m11, rec( torso:= [ d ] ) ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Set( perms ) = Set( perms3 );</span>
true
</pre></div>
<p><strong class="pkg">GAP</strong> provides two more functions to test properties of permutation characters. The first one yields no new information in our case, but the second excludes one possible permutation character; note that <code class="code">TestPerm5</code> needs a <span class="SimpleMath">\(p\)</span>-modular Brauer table, and the <strong class="pkg">GAP</strong> character table library contains all Brauer tables of <span class="SimpleMath">\(M_{11}\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">newperms:= TestPerm4( m11, perms );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">newperms = perms;</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">newperms:= TestPerm5( m11, perms, m11 mod 11 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">newperms = perms;</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">Difference( perms, newperms );</span>
[ Character( m11, [ 220, 4, 4, 0, 0, 4, 0, 0, 0, 0 ] ) ]
</pre></div>
<p><strong class="pkg">GAP</strong> knows the table of marks of <span class="SimpleMath">\(M_{11}\)</span>, from which the permutation characters can be extracted. It turns out that <span class="SimpleMath">\(M_{11}\)</span> has <span class="SimpleMath">\(39\)</span> conjugacy classes of subgroups but only <span class="SimpleMath">\(36\)</span> different permutation characters, so three candidates computed above are in fact not permutation characters.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tom:= TableOfMarks( "M11" );</span>
TableOfMarks( "M11" )
<span class="GAPprompt">gap></span> <span class="GAPinput">trueperms:= PermCharsTom( m11, tom );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( trueperms ); Length( Set( trueperms ) );</span>
39
36
<span class="GAPprompt">gap></span> <span class="GAPinput">Difference( perms, trueperms );</span>
[ Character( m11, [ 220, 4, 4, 0, 0, 4, 0, 0, 0, 0 ] ),
Character( m11, [ 660, 4, 3, 4, 0, 1, 0, 0, 0, 0 ] ),
Character( m11, [ 660, 12, 3, 0, 0, 3, 0, 0, 0, 0 ] ) ]
</pre></div>
<p><a id="X81A5FC968782CFC3" name="X81A5FC968782CFC3"></a></p>
<h4>8.3 <span class="Heading">The Action of <span class="SimpleMath">\(U_6(2)\)</span> on the Cosets of <span class="SimpleMath">\(M_{22}\)</span></span></h4>
<p>We are interested in the permutation character of <span class="SimpleMath">\(U_6(2)\)</span> (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 115]</a>) that corresponds to the action on the cosets of a <span class="SimpleMath">\(M_{22}\)</span> subgroup (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 39]</a>). The character tables of both the group and the point stabilizer are available in the <strong class="pkg">GAP</strong> character table library, so we can compute class fusion and permutation character directly; note that if the class fusion is not stored on the table of the subgroup, in general one will not get a unique fusion but only a list of candidates for the fusion.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">u62:= CharacterTable( "U6(2)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">m22:= CharacterTable( "M22" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= PossibleClassFusions( m22, u62 );</span>
[ [ 1, 3, 7, 10, 14, 15, 22, 24, 24, 26, 33, 34 ],
[ 1, 3, 7, 10, 14, 15, 22, 24, 24, 26, 34, 33 ],
[ 1, 3, 7, 11, 14, 15, 22, 24, 24, 27, 33, 34 ],
[ 1, 3, 7, 11, 14, 15, 22, 24, 24, 27, 34, 33 ],
[ 1, 3, 7, 12, 14, 15, 22, 24, 24, 28, 33, 34 ],
[ 1, 3, 7, 12, 14, 15, 22, 24, 24, 28, 34, 33 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">RepresentativesFusions( m22, fus, u62 );</span>
[ [ 1, 3, 7, 10, 14, 15, 22, 24, 24, 26, 33, 34 ] ]
</pre></div>
<p>We see that there are six possible class fusions that are equivalent under table automorphisms of <span class="SimpleMath">\(U_6(2)\)</span> and <span class="SimpleMath">\(M22\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= Set( fus,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> Induced( m22, u62, [ TrivialCharacter( m22 ) ], x )[1] );</span>
[ Character( CharacterTable( "U6(2)" ),
[ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 0, 0, 48, 0, 16, 6, 0, 0, 0, 0,
0, 0, 6, 0, 2, 0, 0, 0, 4, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0 ] ), Character( CharacterTable( "U6(2)" ),
[ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 0, 48, 0, 0, 16, 6, 0, 0, 0, 0,
0, 0, 6, 0, 2, 0, 0, 4, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0 ] ), Character( CharacterTable( "U6(2)" ),
[ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 48, 0, 0, 0, 16, 6, 0, 0, 0, 0,
0, 0, 6, 0, 2, 0, 4, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( u62, cand ).ATLAS;</span>
[ "1a+22a+252a+616a+1155c+1386a+8064a+9240c",
"1a+22a+252a+616a+1155b+1386a+8064a+9240b",
"1a+22a+252a+616a+1155a+1386a+8064a+9240a" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">aut:= AutomorphismsOfTable( u62 );; Size( aut );</span>
24
<span class="GAPprompt">gap></span> <span class="GAPinput">elms:= Filtered( Elements( aut ), x -> Order( x ) = 3 );</span>
[ (10,11,12)(26,27,28)(40,41,42), (10,12,11)(26,28,27)(40,42,41) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Position( cand, Permuted( cand[1], elms[1] ) );</span>
3
<span class="GAPprompt">gap></span> <span class="GAPinput">Position( cand, Permuted( cand[3], elms[1] ) );</span>
2
</pre></div>
<p>The six fusions induce three different characters, they are conjugate under the action of the unique subgroup of order <span class="SimpleMath">\(3\)</span> in the group of table automorphisms of <span class="SimpleMath">\(U_6(2)\)</span>. The table automorphisms of order <span class="SimpleMath">\(3\)</span> are induced by group automorphisms of <span class="SimpleMath">\(U_6(2)\)</span> (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 120]</a>). As can be seen from the list of maximal subgroups of <span class="SimpleMath">\(U_6(2)\)</span> in <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 115]</a>, the three induced characters are in fact permutation characters which belong to the three classes of maximal subgroups of type <span class="SimpleMath">\(M_{22}\)</span> in <span class="SimpleMath">\(U_6(2)\)</span>, which are permuted by an outer automorphism of order 3. Now we want to compute the extension of the above permutation character to the group <span class="SimpleMath">\(U_6(2).2\)</span>, which corresponds to the action of this group on the cosets of a <span class="SimpleMath">\(M_{22}.2\)</span> subgroup.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">u622:= CharacterTable( "U6(2).2" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">m222:= CharacterTable( "M22.2" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= PossibleClassFusions( m222, u622 );</span>
[ [ 1, 3, 7, 10, 13, 14, 20, 22, 22, 24, 29, 38, 39, 42, 41, 46, 50,
53, 58, 59, 59 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= Induced( m222, u622, [ TrivialCharacter( m222 ) ], fus[1] );</span>
[ Character( CharacterTable( "U6(2).2" ),
[ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 48, 0, 0, 16, 6, 0, 0, 0, 0, 0,
6, 0, 2, 0, 4, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1080, 72,
0, 48, 8, 0, 0, 0, 18, 0, 0, 0, 8, 0, 0, 2, 0, 0, 0, 0, 2, 2,
0, 0, 0, 0, 0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( u622, cand ).ATLAS;</span>
[ "1a+22a+252a+616a+1155a+1386a+8064a+9240a" ]
</pre></div>
<p>We see that for the embedding of <span class="SimpleMath">\(M_{22}.2\)</span> into <span class="SimpleMath">\(U_6(2).2\)</span>, the class fusion is unique, so we get a unique extension of one of the above permutation characters. This implies that exactly one class of maximal subgroups of type <span class="SimpleMath">\(M_{22}\)</span> extends to <span class="SimpleMath">\(M_{22}.2\)</span> in a given group <span class="SimpleMath">\(U_6(2).2\)</span>.</p>
<p><a id="X7EE1811C8496C428" name="X7EE1811C8496C428"></a></p>
<h4>8.4 <span class="Heading">Degree <span class="SimpleMath">\(20\,736\)</span> Permutation Characters of <span class="SimpleMath">\(U_6(2)\)</span></span></h4>
<p>Now we show an alternative way to compute the characters dealt with in the previous example. This works also if the character table of the point stabilizer is not available. In this situation we can compute all those characters that have certain properties of permutation characters. Of course this may take much longer than the above computations, which needed only a few seconds. (The following calculations may need several hours, depending on the computer used.)</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= PermChars( u62, rec( torso := [ 20736 ] ) );</span>
[ Character( CharacterTable( "U6(2)" ),
[ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 0, 0, 48, 0, 16, 6, 0, 0, 0,
0, 0, 0, 6, 0, 2, 0, 0, 0, 4, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0 ] ), Character( CharacterTable( "U6(2)" ),
[ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 0, 48, 0, 0, 16, 6, 0, 0, 0,
0, 0, 0, 6, 0, 2, 0, 0, 4, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0 ] ), Character( CharacterTable( "U6(2)" ),
[ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 48, 0, 0, 0, 16, 6, 0, 0, 0,
0, 0, 0, 6, 0, 2, 0, 4, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0 ] ) ]
</pre></div>
<p>For the next step, that is, the computation of the extension of the permutation character to <span class="SimpleMath">\(U_6(2).2\)</span>, we may use the above information, since the values on the inner classes are prescribed. The question which of the three candidates for <span class="SimpleMath">\(U_6(2)\)</span> extends to <span class="SimpleMath">\(U_6(2).2\)</span> depends on the choice of the class fusion of <span class="SimpleMath">\(U_6(2)\)</span> into <span class="SimpleMath">\(U_6(2).2\)</span>. With respect to the class fusion that is stored on the <strong class="pkg">GAP</strong> library table, the third candidate extends, as can be seen from the fact that this one is invariant under the permutation of conjugacy classes of <span class="SimpleMath">\(U_6(2)\)</span> that is induced by the action of the chosen supergroup <span class="SimpleMath">\(U_6(2).2\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">u622:= CharacterTable( "U6(2).2" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">inv:= InverseMap( GetFusionMap( u62, u622 ) );</span>
[ 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 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">ext:= List( cand, x -> CompositionMaps( x, inv ) );</span>
[ [ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 0, [ 0, 48 ], 0, 16, 6, 0, 0,
0, 0, 0, 6, 0, 2, 0, 0, [ 0, 4 ], 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
0, 0 ],
[ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 0, [ 0, 48 ], 0, 16, 6, 0, 0,
0, 0, 0, 6, 0, 2, 0, 0, [ 0, 4 ], 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
0, 0 ],
[ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 48, 0, 0, 16, 6, 0, 0, 0, 0, 0,
6, 0, 2, 0, 4, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= PermChars( u622, rec( torso:= ext[3] ) );</span>
[ Character( CharacterTable( "U6(2).2" ),
[ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 48, 0, 0, 16, 6, 0, 0, 0, 0,
0, 6, 0, 2, 0, 4, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1080,
72, 0, 48, 8, 0, 0, 0, 18, 0, 0, 0, 8, 0, 0, 2, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0 ] ) ]
</pre></div>
<p><a id="X7DC6A6E785A347C8" name="X7DC6A6E785A347C8"></a></p>
<h4>8.5 <span class="Heading">Degree <span class="SimpleMath">\(57\,572\,775\)</span> Permutation Characters of <span class="SimpleMath">\(O_8^+(3)\)</span></span></h4>
<p>The group <span class="SimpleMath">\(O_8^+(3)\)</span> (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 140]</a>) contains a subgroup of type <span class="SimpleMath">\(2^{{3+6}}.L_3(2)\)</span>, which extends to a maximal subgroup <span class="SimpleMath">\(U\)</span> in <span class="SimpleMath">\(O_8^+(3).3\)</span>. For the computation of the permutation character, we cannot use explicit induction since the table of <span class="SimpleMath">\(U\)</span> is not available in the <strong class="pkg">GAP</strong> table library. Since <span class="SimpleMath">\(U \cap O_8^+(3)\)</span> is contained in a <span class="SimpleMath">\(O_8^+(2)\)</span> subgroup of <span class="SimpleMath">\(O_8^+(3)\)</span>, we can try to find the permutation character of <span class="SimpleMath">\(O_8^+(2)\)</span> corresponding to the action on the cosets of <span class="SimpleMath">\(U \cap O_8^+(3)\)</span>, and then induce this character to <span class="SimpleMath">\(O_8^+(3)\)</span>. This kind of computations becomes more difficult with increasing degree, so we try to reduce the problem further. In fact, the <span class="SimpleMath">\(2^{{3+6}}.L_3(2)\)</span> group is contained in a <span class="SimpleMath">\(2^6:A_8\)</span> subgroup of <span class="SimpleMath">\(O_8^+(2)\)</span>, in which the index is only <span class="SimpleMath">\(15\)</span>; the unique possible permutation character of this degree can be read off immediately. Induction to <span class="SimpleMath">\(O_8^+(3)\)</span> through the chain of subgroups is possible provided the class fusions are available. There are <span class="SimpleMath">\(24\)</span> possible fusions from <span class="SimpleMath">\(O_8^+(2)\)</span> into <span class="SimpleMath">\(O_8^+(3)\)</span>, which are all equivalent w.r.t. table automorphisms of <span class="SimpleMath">\(O_8^+(3)\)</span>. If we later want to consider the extension of the permutation character in question to <span class="SimpleMath">\(O_8^+(3).3\)</span> then we have to choose a fusion of an <span class="SimpleMath">\(O_8^+(2)\)</span> subgroup that does <em>not</em> extend to <span class="SimpleMath">\(O_8^+(2).3\)</span>. But if for example our question is just whether the resulting permutation character is multiplicity-free then this can be decided already from the permutation character of <span class="SimpleMath">\(O_8^+(3)\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">o8p3:= CharacterTable("O8+(3)");;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Size( o8p3 ) / (2^9*168);</span>
57572775
<span class="GAPprompt">gap></span> <span class="GAPinput">o8p2:= CharacterTable( "O8+(2)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= PossibleClassFusions( o8p2, o8p3 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( fus );</span>
24
<span class="GAPprompt">gap></span> <span class="GAPinput">rep:= RepresentativesFusions( o8p2, fus, o8p3 );</span>
[ [ 1, 5, 2, 3, 4, 5, 7, 8, 12, 16, 17, 19, 23, 20, 21, 22, 23, 24,
25, 26, 37, 38, 42, 31, 32, 36, 49, 52, 51, 50, 43, 44, 45, 53,
55, 56, 57, 71, 71, 71, 72, 73, 74, 78, 79, 83, 88, 89, 90, 94,
100, 101, 105 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= rep[1];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Size( o8p2 ) / (2^9*168);</span>
2025
<span class="GAPprompt">gap></span> <span class="GAPinput">sub:= CharacterTable( "2^6:A8" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">subfus:= GetFusionMap( sub, o8p2 );</span>
[ 1, 3, 2, 2, 4, 5, 6, 13, 3, 6, 12, 13, 14, 7, 21, 24, 11, 30, 29,
31, 13, 17, 15, 16, 14, 17, 36, 37, 18, 41, 24, 44, 48, 28, 33, 32,
34, 35, 35, 51, 51 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= CompositionMaps( fus, subfus );</span>
[ 1, 2, 5, 5, 3, 4, 5, 23, 2, 5, 19, 23, 20, 7, 37, 31, 17, 50, 51,
43, 23, 23, 21, 22, 20, 23, 56, 57, 24, 72, 31, 78, 89, 52, 45, 44,
53, 55, 55, 100, 100 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Size( sub ) / (2^9*168);</span>
15
<span class="GAPprompt">gap></span> <span class="GAPinput">List( Irr( sub ), Degree );</span>
[ 1, 7, 14, 20, 21, 21, 21, 28, 35, 45, 45, 56, 64, 70, 28, 28, 35,
35, 35, 35, 70, 70, 70, 70, 140, 140, 140, 140, 140, 210, 210, 252,
252, 280, 280, 315, 315, 315, 315, 420, 448 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= PermChars( sub, 15 );</span>
[ Character( CharacterTable( "2^6:A8" ),
[ 15, 15, 15, 7, 7, 7, 7, 7, 3, 3, 3, 3, 3, 0, 0, 0, 3, 3, 3, 3, 3,
3, 3, 3, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">ind:= Induced( sub, o8p3, cand, fus );</span>
[ Character( CharacterTable( "O8+(3)" ),
[ 57572775, 59535, 59535, 59535, 3591, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 2187, 0, 27, 135, 135, 135, 243, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 27, 27, 0, 0, 0, 0, 27,
27, 27, 27, 0, 8, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">o8p33:= CharacterTable( "O8+(3).3" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">inv:= InverseMap( GetFusionMap( o8p3, o8p33 ) );</span>
[ 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 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">ext:= CompositionMaps( ind[1], inv );</span>
[ 57572775, 59535, 3591, 0, 0, 0, 0, 0, 2187, 0, 27, 135, 243, 0, 0,
0, 0, 0, 0, 0, 27, 0, 0, 27, 27, 0, 8, 1, 1, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= PermChars( o8p33, rec( torso:= ext ) );</span>
[ Character( CharacterTable( "O8+(3).3" ),
[ 57572775, 59535, 3591, 0, 0, 0, 0, 0, 2187, 0, 27, 135, 243, 0,
0, 0, 0, 0, 0, 0, 27, 0, 0, 27, 27, 0, 8, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3159,
3159, 243, 243, 39, 39, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3,
3, 3, 3, 0, 0, 0, 0, 0, 0, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( o8p33, perms ).ATLAS;</span>
[ "1a+780aabb+2457a+2808abc+9450aaabbcc+18200abcdddef+24192a+54600a^{5\
}b+70200aabb+87360ab+139776a^{5}+147420a^{4}b^{4}+163800ab+184275aabc+\
199017aa+218700a+245700a+291200aef+332800a^{4}b^{5}c^{5}+491400aaabcd+\
531441a^{5}b^{4}c^{4}+552825a^{4}+568620aabb+698880a^{4}b^{4}+716800aa\
abbccdddeeff+786240aabb+873600aa+998400aa+1257984a^{6}+1397760aa" ]
</pre></div>
<p><a id="X792D2C2380591D8D" name="X792D2C2380591D8D"></a></p>
<h4>8.6 <span class="Heading">The Action of <span class="SimpleMath">\(O_7(3).2\)</span> on the Cosets of <span class="SimpleMath">\(2^7.S_7\)</span></span></h4>
<p>We want to know whether the permutation character of <span class="SimpleMath">\(O_7(3).2\)</span> (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 108]</a>) on the cosets of its maximal subgroup <span class="SimpleMath">\(U\)</span> of type <span class="SimpleMath">\(2^7.S_7\)</span> is multiplicity-free. As in the previous examples, first we try to compute the permutation character of the simple group <span class="SimpleMath">\(O_7(3)\)</span>. It turns out that the direct computation of all candidates from the degree is very time consuming. But we can use for example the additional information provided by the fact that <span class="SimpleMath">\(U\)</span> contains an <span class="SimpleMath">\(A_7\)</span> subgroup. We compute the possible class fusions.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">o73:= CharacterTable( "O7(3)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">a7:= CharacterTable( "A7" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= PossibleClassFusions( a7, o73 );</span>
[ [ 1, 3, 6, 10, 15, 16, 24, 33, 33 ],
[ 1, 3, 7, 10, 15, 16, 22, 33, 33 ] ]
</pre></div>
<p>We cannot decide easily which fusion is the right one, but already the fact that no other fusions are possible gives us some information about impossible constituents of the permutation character we want to compute.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">ind:= List( fus,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> Induced( a7, o73, [ TrivialCharacter( a7 ) ], x )[1] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">mat:= MatScalarProducts( o73, Irr( o73 ), ind );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sum:= Sum( mat );</span>
[ 2, 6, 2, 0, 8, 6, 2, 4, 4, 8, 3, 0, 4, 4, 9, 3, 5, 0, 0, 9, 0, 10,
5, 6, 15, 1, 12, 1, 15, 7, 2, 4, 14, 16, 0, 12, 12, 7, 8, 8, 14,
12, 12, 14, 6, 6, 20, 16, 12, 12, 12, 10, 10, 12, 12, 8, 12, 6 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">const:= Filtered( [ 1 .. Length( sum ) ], x -> sum[x] <> 0 );</span>
[ 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 20, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( const );</span>
52
<span class="GAPprompt">gap></span> <span class="GAPinput">const:= Irr( o73 ){ const };;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">rat:= RationalizedMat( const );;</span>
</pre></div>
<p>But much more can be deduced from the fact that certain zeros of the permutation character can be predicted.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">names:= ClassNames( o73 );</span>
[ "1a", "2a", "2b", "2c", "3a", "3b", "3c", "3d", "3e", "3f", "3g",
"4a", "4b", "4c", "4d", "5a", "6a", "6b", "6c", "6d", "6e", "6f",
"6g", "6h", "6i", "6j", "6k", "6l", "6m", "6n", "6o", "6p", "7a",
"8a", "8b", "9a", "9b", "9c", "9d", "10a", "10b", "12a", "12b",
"12c", "12d", "12e", "12f", "12g", "12h", "13a", "13b", "14a",
"15a", "18a", "18b", "18c", "18d", "20a" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( fus, x -> names{ x } );</span>
[ [ "1a", "2b", "3b", "3f", "4d", "5a", "6h", "7a", "7a" ],
[ "1a", "2b", "3c", "3f", "4d", "5a", "6f", "7a", "7a" ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">torso:= [ 28431 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">zeros:= [ 5, 8, 9, 11, 17, 20, 23, 28, 29, 32, 36, 37, 38,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> 43, 46, 47, 48, 53, 54, 55, 56, 57, 58 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">names{ zeros };</span>
[ "3a", "3d", "3e", "3g", "6a", "6d", "6g", "6l", "6m", "6p", "9a",
"9b", "9c", "12b", "12e", "12f", "12g", "15a", "18a", "18b", "18c",
"18d", "20a" ]
</pre></div>
<p>Every order <span class="SimpleMath">\(3\)</span> element of <span class="SimpleMath">\(U\)</span> lies in an <span class="SimpleMath">\(A_7\)</span> subgroup of <span class="SimpleMath">\(U\)</span>, so among the classes of element order <span class="SimpleMath">\(3\)</span>, at most the classes <code class="code">3B</code>, <code class="code">3C</code>, and <code class="code">3F</code> can have nonzero permutation character values. The excluded classes of element order <span class="SimpleMath">\(6\)</span> are the square roots of the excluded order <span class="SimpleMath">\(3\)</span> elements, likewise the given classes of element orders <span class="SimpleMath">\(9\)</span>, <span class="SimpleMath">\(12\)</span>, and <span class="SimpleMath">\(18\)</span> are excluded. The character value on <code class="code">20A</code> must be zero because <span class="SimpleMath">\(U\)</span> does not contain elements of this order. So we enter the additional information about these zeros.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">for i in zeros do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> torso[i]:= 0;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">torso;</span>
[ 28431,,,, 0,,, 0, 0,, 0,,,,,, 0,,, 0,,, 0,,,,, 0, 0,,, 0,,,, 0, 0,
0,,,,, 0,,, 0, 0, 0,,,,, 0, 0, 0, 0, 0, 0 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= PermChars( o73, rec( torso:= torso, chars:= rat ) );</span>
[ Character( CharacterTable( "O7(3)" ),
[ 28431, 567, 567, 111, 0, 0, 243, 0, 0, 81, 0, 15, 3, 27, 15, 6,
0, 0, 27, 0, 3, 27, 0, 0, 0, 3, 9, 0, 0, 3, 3, 0, 4, 1, 1, 0,
0, 0, 0, 2, 2, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( o73, perms ).ATLAS;</span>
[ "1a+78a+168a+182a+260ab+1092a+2457a+2730a+4095b+5460a+11648a" ]
</pre></div>
<p>We see that this character is already multiplicity free, so this holds also for its extension to <span class="SimpleMath">\(O_7(3).2\)</span>, and we need not compute this extension. (Of course we could compute it in the same way as in the examples above.)</p>
<p><a id="X875B361C8512939F" name="X875B361C8512939F"></a></p>
<h4>8.7 <span class="Heading">The Action of <span class="SimpleMath">\(O_8^+(3).2_1\)</span> on the Cosets of <span class="SimpleMath">\(2^7.A_8\)</span></span></h4>
<p>We are interested in the permutation character of <span class="SimpleMath">\(O_8^+(3).2_1\)</span> that corresponds to the action on the cosets of a subgroup of type <span class="SimpleMath">\(2^7.A_8\)</span>. The intersection of the point stabilizer with the simple group <span class="SimpleMath">\(O_8^+(3)\)</span> is of type <span class="SimpleMath">\(2^6.A_8\)</span>. First we compute the class fusion of these groups, modulo problems with ambiguities due to table automorphisms.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">o8p3:= CharacterTable( "O8+(3)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">o8p2:= CharacterTable( "O8+(2)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= PossibleClassFusions( o8p2, o8p3 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">NamesOfFusionSources( o8p2 );</span>
[ "A9", "2^8:O8+(2)", "(D10xD10).2^2", "(3x3^3:S3):2",
"(3x3^(1+2)+:2A4).2", "2^(3+3+3).L3(2)", "NRS(O8+(2),2^(3+3+3)_a)",
"NRS(O8+(2),2^(3+3+3)_b)", "O8+(2)N2", "O8+(2)M2", "O8+(2)M3",
"O8+(2)M5", "O8+(2)M6", "O8+(2)M8", "O8+(2)M9", "(3xU4(2)):2",
"O8+(2)M11", "O8+(2)M12", "2^(1+8)_+:(S3xS3xS3)", "3^4:2^3.S4(a)",
"(A5xA5):2^2", "O8+(2)M16", "O8+(2)M17", "2^(1+8)+.O8+(2)", "7:6",
"(A5xD10).2", "(D10xA5).2", "O8+(2)N5C", "2^6:A8", "2.O8+(2)",
"2^2.O8+(2)", "S6(2)" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">sub:= CharacterTable( "2^6:A8" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">subfus:= GetFusionMap( sub, o8p2 );</span>
[ 1, 3, 2, 2, 4, 5, 6, 13, 3, 6, 12, 13, 14, 7, 21, 24, 11, 30, 29,
31, 13, 17, 15, 16, 14, 17, 36, 37, 18, 41, 24, 44, 48, 28, 33, 32,
34, 35, 35, 51, 51 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= List( fus, x -> CompositionMaps( x, subfus ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= Set( fus );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( fus );</span>
24
</pre></div>
<p>The ambiguities due to Galois automorphisms disappear when we are looking for the permutation characters induced by the fusions.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">ind:= List( fus, x -> Induced( sub, o8p3,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ TrivialCharacter( sub ) ], x )[1] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ind:= Set( ind );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( ind );</span>
6
</pre></div>
<p>Now we try to extend the candidates to <span class="SimpleMath">\(O_8^+(3).2_1\)</span>; the choice of the fusion of <span class="SimpleMath">\(O_8^+(3)\)</span> into <span class="SimpleMath">\(O_8^+(3).2_1\)</span> determines which of the candidates may extend.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">o8p32:= CharacterTable( "O8+(3).2_1" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= GetFusionMap( o8p3, o8p32 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ext:= List( ind, x -> CompositionMaps( x, InverseMap( fus ) ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ext:= Filtered( ext, x -> ForAll( x, IsInt ) );</span>
[ [ 3838185, 17577, 8505, 8505, 873, 0, 0, 0, 0, 6561, 0, 0, 729, 0,
9, 105, 45, 45, 105, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 189, 0, 0,
0, 9, 9, 27, 27, 0, 0, 27, 9, 0, 8, 1, 1, 0, 0, 0, 0, 0, 0, 0,
0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0 ],
[ 3838185, 17577, 8505, 8505, 873, 0, 6561, 0, 0, 0, 0, 0, 729, 0,
9, 105, 45, 45, 105, 30, 0, 0, 0, 0, 0, 0, 189, 0, 0, 0, 9, 0,
0, 0, 9, 27, 27, 0, 0, 9, 27, 0, 8, 1, 1, 0, 0, 0, 0, 0, 0, 0,
0, 2, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0,
0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ]
</pre></div>
<p>We compute the extensions of the first candidate; the other belongs to another class of subgroups, which is the image under an outer automorphism.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= PermChars( o8p32, rec( torso:= ext[1] ) );</span>
[ Character( CharacterTable( "O8+(3).2_1" ),
[ 3838185, 17577, 8505, 8505, 873, 0, 0, 0, 0, 6561, 0, 0, 729, 0,
9, 105, 45, 45, 105, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 189, 0, 0,
0, 9, 9, 27, 27, 0, 0, 27, 9, 0, 8, 1, 1, 0, 0, 0, 0, 0, 0, 0,
0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 3159, 1575, 567, 63, 87,
15, 0, 0, 45, 0, 81, 9, 27, 0, 0, 3, 3, 3, 3, 5, 5, 0, 0, 0, 4,
0, 0, 27, 0, 9, 0, 0, 15, 0, 3, 0, 0, 2, 0, 0, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( o8p32, perms ).ATLAS;</span>
[ "1a+260abc+520ab+819a+2808b+9450aab+18200a+23400ac+29120b+36400aab+4\
6592abce+49140d+66339a+98280ab+163800a+189540d+232960d+332800ab+368550\
a+419328a+531441ab" ]
</pre></div>
<p>Now we repeat the calculations for <span class="SimpleMath">\(O_8^+(3).2_2\)</span> instead of <span class="SimpleMath">\(O_8^+(3).2_1\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">o8p32:= CharacterTable( "O8+(3).2_2" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= GetFusionMap( o8p3, o8p32 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ext:= List( ind, x -> CompositionMaps( x, InverseMap( fus ) ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ext:= Filtered( ext, x -> ForAll( x, IsInt ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= PermChars( o8p32, rec( torso:= ext[1] ) );</span>
[ Character( CharacterTable( "O8+(3).2_2" ),
[ 3838185, 17577, 8505, 873, 0, 0, 0, 6561, 0, 0, 0, 0, 729, 0, 9,
105, 45, 105, 30, 0, 0, 0, 0, 0, 0, 189, 0, 0, 0, 9, 0, 9, 27,
0, 0, 0, 27, 27, 9, 0, 8, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0,
0, 6, 0, 0, 0, 0, 0, 0, 0, 199017, 2025, 297, 441, 73, 9, 0,
1215, 0, 0, 0, 0, 0, 81, 0, 0, 0, 0, 27, 27, 0, 1, 9, 12, 0, 0,
45, 0, 0, 1, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0,
0, 0, 0, 0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( o8p32, perms ).ATLAS;</span>
[ "1a+260aac+520ab+819a+2808a+9450aaa+18200accee+23400ac+29120a+36400a\
+46592aa+49140c+66339a+93184a+98280ab+163800a+184275ac+189540c+232960c\
+332800aa+419328a+531441aa" ]
</pre></div>
<p>We might be interested in the extension to <span class="SimpleMath">\(O_8^+(3).(2^2)_{122}\)</span>. It is clear that this cannot be multiplicity free because of the multiplicity <code class="code">9450aaa</code> in the character induced from <span class="SimpleMath">\(O_8^+(3).2_2\)</span>. We could put the extensions to the index two subgroups together, but it is simpler (and not expensive) to run the same program as above.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">o8p322:= CharacterTable( "O8+(3).(2^2)_{122}" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= GetFusionMap( o8p32, o8p322 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ext:= List( perms, x -> CompositionMaps( x, InverseMap( fus ) ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ext:= Filtered( ext, x -> ForAll( x, IsInt ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= PermChars( o8p322, rec( torso:= ext[1] ) );</span>
[ Character( CharacterTable( "O8+(3).(2^2)_{122}" ),
[ 3838185, 17577, 8505, 873, 0, 0, 0, 6561, 0, 0, 729, 0, 9, 105,
45, 105, 30, 0, 0, 0, 0, 0, 0, 189, 0, 0, 9, 9, 27, 0, 0, 27,
9, 0, 8, 1, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 9, 0, 0,
0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 3159, 1575,
567, 63, 87, 15, 0, 0, 45, 0, 81, 9, 27, 0, 0, 3, 3, 3, 5, 0,
0, 4, 0, 0, 27, 0, 9, 0, 0, 15, 0, 3, 0, 0, 2, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 199017, 2025, 297, 441, 73, 9, 0,
1215, 0, 0, 0, 0, 81, 0, 0, 0, 27, 27, 0, 1, 9, 12, 0, 0, 45,
0, 0, 1, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 0, 0, 0, 0,
0, 28431, 1647, 135, 63, 87, 39, 0, 0, 243, 27, 0, 0, 81, 63,
0, 0, 0, 9, 0, 3, 3, 6, 2, 0, 0, 0, 9, 0, 0, 3, 3, 3, 0, 4, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( o8p322, perms ).ATLAS;</span>
[ "1a+260ace+819a+1040a+2808c+9450aac+18200a+23400ae+29120c+36400aac+4\
6592ac+49140g+66339a+93184a+163800b+189540g+196560a+232960g+332800ac+3\
68550a+419328a+531441ac" ]
</pre></div>
<p><a id="X7B1DFAF98182CFF4" name="X7B1DFAF98182CFF4"></a></p>
<h4>8.8 <span class="Heading">The Action of <span class="SimpleMath">\(S_4(4).4\)</span> on the Cosets of <span class="SimpleMath">\(5^2.[2^5]\)</span></span></h4>
<p>We want to know whether the permutation character corresponding to the action of <span class="SimpleMath">\(S_4(4).4\)</span> (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 44]</a>) on the cosets of its maximal subgroup of type <span class="SimpleMath">\(5^2:[2^5]\)</span> is multiplicity free. The library names of subgroups for which the class fusions are stored are listed as value of the attribute <code class="func">NamesOfFusionSources</code> (<a href="../../../doc/ref/chap73_mj.html#X7F6569D5786A9D49"><span class="RefLink">Reference: NamesOfFusionSources</span></a>), and for groups whose isomorphism type is not determined by the name this is the recommended way to find out whether the table of the subgroup is contained in the <strong class="pkg">GAP</strong> library and known to belong to this group. (It might be that a table with such a name is contained in the library but belongs to another group, and it may also be that the table of the group is contained in the library --with any name-- but it is not known that this group is isomorphic to a subgroup of <span class="SimpleMath">\(S_4(4).4\)</span>.)</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">s444:= CharacterTable( "S4(4).4" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">NamesOfFusionSources( s444 );</span>
[ "(L3(2)xS4(4):2).2", "S4(4)", "S4(4).2" ]
</pre></div>
<p>So we cannot simply fetch the table of the subgroup. As in the previous examples, we compute the possible permutation characters.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= PermChars( s444,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> rec( torso:= [ Size( s444 ) / ( 5^2*2^5 ) ] ) );</span>
[ Character( CharacterTable( "S4(4).4" ),
[ 4896, 384, 96, 0, 16, 32, 36, 16, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ),
Character( CharacterTable( "S4(4).4" ),
[ 4896, 192, 32, 0, 0, 8, 6, 1, 0, 2, 0, 0, 36, 0, 12, 0, 0, 0, 1,
0, 6, 6, 2, 2, 0, 0, 0, 0, 1, 1 ] ),
Character( CharacterTable( "S4(4).4" ),
[ 4896, 240, 64, 0, 8, 8, 36, 16, 0, 0, 0, 0, 0, 12, 8, 0, 4, 4, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ) ]
</pre></div>
<p>So there are three candidates. None of them is multiplicity free, so we need not decide which of the candidates actually belongs to the group <span class="SimpleMath">\(5^2:[2^5]\)</span> we have in mind.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( s444, perms ).ATLAS;</span>
[ "1abcd+50abcd+153abcd+170a^{4}b^{4}+680aabb",
"1a+50ac+153a+170aab+256a+680abb+816a+1020a",
"1ac+50ac+68a+153abcd+170aabbb+204a+680abb+1020a" ]
</pre></div>
<p>(If we would be interested which candidate is the right one, we could for example look at the intersection with <span class="SimpleMath">\(S_4(4)\)</span>, and hope for a contradiction to the fact that the group must lie in a <span class="SimpleMath">\((A_5 \times A_5):2\)</span> subgroup.)</p>
<p><a id="X7F04F0C684AA8B30" name="X7F04F0C684AA8B30"></a></p>
<h4>8.9 <span class="Heading">The Action of <span class="SimpleMath">\(Co_1\)</span> on the Cosets of Involution Centralizers</span></h4>
<p>We compute the permutation characters of the sporadic simple Conway group <span class="SimpleMath">\(Co_1\)</span> (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 180]</a>) corresponding to the actions on the cosets of involution centralizers. Equivalently, we are interested in the action of <span class="SimpleMath">\(Co_1\)</span> on conjugacy classes of involutions. These characters can be computed as follows. First we take the table of <span class="SimpleMath">\(Co_1\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "Co1" );</span>
CharacterTable( "Co1" )
</pre></div>
<p>The centralizer of each <code class="code">2A</code> element is a maximal subgroup of <span class="SimpleMath">\(Co_1\)</span>. This group is also contained in the table library. So we can compute the permutation character by explicit induction, and the decomposition in irreducibles is computed with the command <code class="func">PermCharInfo</code> (<a href="../../../doc/ref/chap72_mj.html#X8477004C7A31D28C"><span class="RefLink">Reference: PermCharInfo</span></a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">s:= CharacterTable( Maxes( t )[5] );</span>
CharacterTable( "2^(1+8)+.O8+(2)" )
<span class="GAPprompt">gap></span> <span class="GAPinput">ind:= Induced( s, t, [ TrivialCharacter( s ) ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( t, ind ).ATLAS;</span>
[ "1a+299a+17250a+27300a+80730a+313950a+644644a+2816856a+5494125a+1243\
2420a+24794000a" ]
</pre></div>
<p>The centralizer of a <code class="code">2B</code> element is not maximal. First we compute which maximal subgroup can contain it. The character tables of all maximal subgroups of <span class="SimpleMath">\(Co_1\)</span> are contained in the <strong class="pkg">GAP</strong>'s table library, so we may take these tables and look at the group orders.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">centorder:= SizesCentralizers( t )[3];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">maxes:= List( Maxes( t ), CharacterTable );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= Filtered( maxes, x -> Size( x ) mod centorder = 0 );</span>
[ CharacterTable( "(A4xG2(4)):2" ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">u:= cand[1];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">index:= Size( u ) / centorder;</span>
3
</pre></div>
<p>So there is a unique class of maximal subgroups containing the centralizer of a <code class="code">2B</code> element, as a subgroup of index <span class="SimpleMath">\(3\)</span>. We compute the unique permutation character of degree <span class="SimpleMath">\(3\)</span> of this group, and induce this character to <span class="SimpleMath">\(G\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">subperm:= PermChars( u, rec( degree := index, bounds := false ) );</span>
[ Character( CharacterTable( "(A4xG2(4)):2" ),
[ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">subperm = PermChars( u, rec( torso := [ 3 ] ) );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">ind:= Induced( u, t, subperm );</span>
[ Character( CharacterTable( "Co1" ),
[ 2065694400, 181440, 119408, 38016, 2779920, 0, 0, 378, 30240,
864, 0, 720, 316, 80, 2520, 30, 0, 6480, 1508, 0, 0, 0, 0, 0,
38, 18, 105, 0, 600, 120, 56, 24, 0, 12, 0, 0, 0, 120, 48, 18,
0, 0, 6, 0, 360, 144, 108, 0, 0, 10, 0, 0, 0, 0, 0, 4, 2, 3, 9,
0, 0, 15, 3, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
12, 8, 0, 6, 0, 0, 3, 0, 1, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 3,
0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( t, ind ).ATLAS;</span>
[ "1a+1771a+8855a+27300aa+313950a+345345a+644644aa+871884aaa+1771000a+\
2055625a+4100096a+7628985a+9669660a+12432420aa+21528000aa+23244375a+24\
174150aa+24794000a+31574400aa+40370176a+60435375a+85250880aa+100725625\
a+106142400a+150732800a+184184000a+185912496a+207491625a+299710125a+30\
2176875a" ]
</pre></div>
<p>Finally, we try the same for the centralizer of a <code class="code">2C</code> element.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">centorder:= SizesCentralizers( t )[4];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= Filtered( maxes, x -> Size( x ) mod centorder = 0 );</span>
[ CharacterTable( "Co2" ), CharacterTable( "2^11:M24" ) ]
</pre></div>
<p>The group order excludes all except two classes of maximal subgroups. But the <code class="code">2C</code> centralizer cannot lie in <span class="SimpleMath">\(Co_2\)</span> because the involution centralizers in <span class="SimpleMath">\(Co_2\)</span> are too small.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">u:= cand[1];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">GetFusionMap( u, t );</span>
[ 1, 2, 2, 4, 7, 6, 9, 11, 11, 10, 11, 12, 14, 17, 16, 21, 23, 20,
22, 22, 24, 28, 30, 33, 31, 32, 33, 33, 37, 42, 41, 43, 44, 48, 52,
49, 53, 55, 53, 52, 54, 60, 60, 60, 64, 65, 65, 67, 66, 70, 73, 72,
78, 79, 84, 85, 87, 92, 93, 93 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">centorder;</span>
389283840
<span class="GAPprompt">gap></span> <span class="GAPinput">SizesCentralizers( u )[4];</span>
1474560
</pre></div>
<p>So we try the second candidate.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">u:= cand[2];</span>
CharacterTable( "2^11:M24" )
<span class="GAPprompt">gap></span> <span class="GAPinput">index:= Size( u ) / centorder;</span>
1288
<span class="GAPprompt">gap></span> <span class="GAPinput">subperm:= PermChars( u, rec( torso := [ index ] ) );</span>
[ Character( CharacterTable( "2^11:M24" ),
[ 1288, 1288, 1288, 56, 56, 56, 56, 56, 56, 48, 48, 48, 48, 48, 10,
10, 10, 10, 7, 7, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 3, 3, 3, 2, 2, 2, 2, 2, 2, 3, 3, 3, 0, 0, 0, 0, 2, 2, 2,
2, 3, 3, 3, 1, 1, 2, 2, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">subperm = PermChars( u, rec( degree:= index, bounds := false ) );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">ind:= Induced( u, t, subperm );</span>
[ Character( CharacterTable( "Co1" ),
[ 10680579000, 1988280, 196560, 94744, 0, 17010, 0, 945, 7560,
3432, 2280, 1728, 252, 308, 0, 225, 0, 0, 0, 270, 0, 306, 0,
46, 45, 25, 0, 0, 120, 32, 12, 52, 36, 36, 0, 0, 0, 0, 0, 45,
15, 0, 9, 3, 0, 0, 0, 0, 18, 0, 30, 0, 6, 18, 0, 3, 5, 0, 0, 0,
0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 3, 0, 0, 0, 0, 1, 0, 0, 0, 0,
6, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( t, ind ).ATLAS;</span>
[ "1a+17250aa+27300a+80730aa+644644aaa+871884a+1821600a+2055625aaa+281\
6856a+5494125a^{4}+12432420aa+16347825aa+23244375a+24174150aa+24667500\
aa+24794000aaa+31574400a+40370176a+55255200a+66602250a^{4}+83720000aa+\
85250880aaa+91547820aa+106142400a+150732800a+184184000aaa+185912496aaa\
+185955000aaa+207491625aaa+215547904aa+241741500aaa+247235625a+2578576\
00aa+259008750a+280280000a+302176875a+326956500a+387317700a+402902500a\
+464257024a+469945476b+502078500a+503513010a+504627200a+522161640a" ]
</pre></div>
<p><a id="X8230719D8538384B" name="X8230719D8538384B"></a></p>
<h4>8.10 <span class="Heading">The Multiplicity Free Permutation Characters of <span class="SimpleMath">\(G_2(3)\)</span></span></h4>
<p>We compute the multiplicity free possible permutation characters of <span class="SimpleMath">\(G_2(3)\)</span> (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 60]</a>). For each divisor <span class="SimpleMath">\(d\)</span> of the group order, we compute all those possible permutation characters of degree <span class="SimpleMath">\(d\)</span> of <span class="SimpleMath">\(G\)</span> for which each irreducible constituent occurs with multiplicity at most <span class="SimpleMath">\(1\)</span>; this is done by prescribing the <code class="code">maxmult</code> component of the second argument of <code class="func">PermChars</code> (<a href="../../../doc/ref/chap72_mj.html#X7D02541482C196A6"><span class="RefLink">Reference: PermChars</span></a>) to be the list with <span class="SimpleMath">\(1\)</span> at each position.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "G2(3)" );</span>
CharacterTable( "G2(3)" )
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "G2(3)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">n:= Length( RationalizedMat( Irr( t ) ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">maxmult:= List( [ 1 .. n ], i -> 1 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">divs:= DivisorsInt( Size( t ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for d in divs do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Append( perms,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> PermChars( t, rec( bounds := false,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> degree := d,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> maxmult := maxmult ) ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( perms );</span>
42
<span class="GAPprompt">gap></span> <span class="GAPinput">List( perms, Degree );</span>
[ 1, 351, 351, 364, 364, 378, 378, 546, 546, 546, 546, 546, 702, 702,
728, 728, 1092, 1092, 1092, 1092, 1092, 1092, 1092, 1092, 1456,
1456, 1638, 1638, 2184, 2184, 2457, 2457, 2457, 2457, 3159, 3276,
3276, 3276, 3276, 4368, 6552, 6552 ]
</pre></div>
<p>For finding out which of these candidates are really permutation characters, we could inspect them piece by piece, using the information in <a href="chapBib_mj.html#biBCCN85">[CCN+85]</a>. For example, the candidates of degrees <span class="SimpleMath">\(351\)</span>, <span class="SimpleMath">\(364\)</span>, and <span class="SimpleMath">\(378\)</span> are induced from the trivial characters of maximal subgroups of <span class="SimpleMath">\(G\)</span>, whereas the candidates of degree <span class="SimpleMath">\(546\)</span> are not permutation characters.</p>
<p>Since the table of marks of <span class="SimpleMath">\(G\)</span> is available in <strong class="pkg">GAP</strong>, we can extract all permutation characters from the table of marks, and then filter out the multiplicity free ones.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tom:= TableOfMarks( "G2(3)" );</span>
TableOfMarks( "G2(3)" )
<span class="GAPprompt">gap></span> <span class="GAPinput">tbl:= CharacterTable( "G2(3)" );</span>
CharacterTable( "G2(3)" )
<span class="GAPprompt">gap></span> <span class="GAPinput">permstom:= PermCharsTom( tbl, tom );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( permstom );</span>
433
<span class="GAPprompt">gap></span> <span class="GAPinput">multfree:= Intersection( perms, permstom );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( multfree );</span>
15
<span class="GAPprompt">gap></span> <span class="GAPinput">List( multfree, Degree );</span>
[ 1, 351, 351, 364, 364, 378, 378, 702, 702, 728, 728, 1092, 1092,
2184, 2184 ]
</pre></div>
<p><a id="X7E3E326C7CB0E2CD" name="X7E3E326C7CB0E2CD"></a></p>
<h4>8.11 <span class="Heading">Degree <span class="SimpleMath">\(11\,200\)</span> Permutation Characters of <span class="SimpleMath">\(O_8^+(2)\)</span></span></h4>
<p>We compute the primitive permutation characters of degree <span class="SimpleMath">\(11\,200\)</span> of <span class="SimpleMath">\(O_8^+(2)\)</span> and <span class="SimpleMath">\(O_8^+(2).2\)</span> (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 85]</a>). The character table of the maximal subgroup of type <span class="SimpleMath">\(3^4:2^3.S_4\)</span> in <span class="SimpleMath">\(O_8^+(2)\)</span> is not available in the <strong class="pkg">GAP</strong> table library. But the group extends to a wreath product of <span class="SimpleMath">\(S_3\)</span> and <span class="SimpleMath">\(S_4\)</span> in the group <span class="SimpleMath">\(O_8^+(2).2\)</span>, and the table of this wreath product can be constructed easily.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tbl2:= CharacterTable("O8+(2).2");;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">s3:= CharacterTable( "Symmetric", 3 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">s:= CharacterTableWreathSymmetric( s3, 4 );</span>
CharacterTable( "Sym(3)wrS4" )
</pre></div>
<p>The permutation character <code class="code">pi</code> of <span class="SimpleMath">\(O_8^+(2).2\)</span> can thus be computed by explicit induction, and the character of <span class="SimpleMath">\(O_8^+(2)\)</span> is obtained by restriction of <code class="code">pi</code>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= PossibleClassFusions( s, tbl2 );</span>
[ [ 1, 41, 6, 3, 48, 9, 42, 19, 51, 8, 5, 50, 24, 49, 7, 2, 44, 22,
42, 12, 53, 17, 58, 21, 5, 47, 26, 50, 37, 52, 23, 60, 18, 4,
46, 25, 14, 61, 20, 9, 53, 30, 51, 26, 64, 8, 52, 31, 13, 56,
38 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= Induced( s, tbl2, [ TrivialCharacter( s ) ], fus[1] )[1];</span>
Character( CharacterTable( "O8+(2).2" ),
[ 11200, 256, 160, 160, 80, 40, 40, 76, 13, 0, 0, 8, 8, 4, 0, 0, 16,
16, 4, 4, 4, 1, 1, 1, 1, 5, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 2, 2, 0,
0, 1120, 96, 0, 16, 0, 16, 8, 10, 4, 6, 7, 12, 3, 0, 0, 2, 0, 4, 0,
1, 1, 0, 0, 1, 0, 0, 0 ] )
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( tbl2, pi ).ATLAS;</span>
[ "1a+84a+168a+175a+300a+700c+972a+1400a+3200a+4200b" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">tbl:= CharacterTable( "O8+(2)" );</span>
CharacterTable( "O8+(2)" )
<span class="GAPprompt">gap></span> <span class="GAPinput">rest:= RestrictedClassFunction( pi, tbl );</span>
Character( CharacterTable( "O8+(2)" ),
[ 11200, 256, 160, 160, 160, 80, 40, 40, 40, 76, 13, 0, 0, 8, 8, 8,
4, 0, 0, 0, 16, 16, 16, 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 5, 0, 0, 0,
1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0 ] )
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( tbl, rest ).ATLAS;</span>
[ "1a+84abc+175a+300a+700bcd+972a+3200a+4200a" ]
</pre></div>
<p><a id="X7D8572E68194CBB9" name="X7D8572E68194CBB9"></a></p>
<h4>8.12 <span class="Heading">A Proof of Nonexistence of a Certain Subgroup</span></h4>
<p>We prove that the sporadic simple Mathieu group <span class="SimpleMath">\(G = M_{22}\)</span> (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 39]</a>) has no subgroup of index <span class="SimpleMath">\(56\)</span>. In <a href="chapBib_mj.html#biBIsa76">[Isa76]</a>, remark after Theorem 5.18, this is stated as an example of the case that a character may be a possible permutation character but not a permutation character. Let us consider the possible permutation character of degree <span class="SimpleMath">\(56\)</span> of <span class="SimpleMath">\(G\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tbl:= CharacterTable( "M22" );</span>
CharacterTable( "M22" )
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= PermChars( tbl, rec( torso:= [ 56 ] ) );</span>
[ Character( CharacterTable( "M22" ),
[ 56, 8, 2, 4, 0, 1, 2, 0, 0, 2, 1, 1 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= perms[1];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Norm( pi );</span>
2
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( tbl, rec( chars:= perms ) );</span>
M22
2 7 7 2 5 4 . 2 . . 3 . .
3 2 1 2 . . . 1 . . . . .
5 1 . . . . 1 . . . . . .
7 1 . . . . . . 1 1 . . .
11 1 . . . . . . . . . 1 1
1a 2a 3a 4a 4b 5a 6a 7a 7b 8a 11a 11b
2P 1a 1a 3a 2a 2a 5a 3a 7a 7b 4a 11b 11a
3P 1a 2a 1a 4a 4b 5a 2a 7b 7a 8a 11a 11b
5P 1a 2a 3a 4a 4b 1a 6a 7b 7a 8a 11a 11b
7P 1a 2a 3a 4a 4b 5a 6a 1a 1a 8a 11b 11a
11P 1a 2a 3a 4a 4b 5a 6a 7a 7b 8a 1a 1a
Y.1 56 8 2 4 . 1 2 . . 2 1 1
</pre></div>
<p>Suppose that <code class="code">pi</code> is a permutation character of <span class="SimpleMath">\(G\)</span>. Since <span class="SimpleMath">\(G\)</span> is <span class="SimpleMath">\(2\)</span>-transitive on the <span class="SimpleMath">\(56\)</span> cosets of the point stabilizer <span class="SimpleMath">\(S\)</span>, this stabilizer is transitive on <span class="SimpleMath">\(55\)</span> points, and thus <span class="SimpleMath">\(G\)</span> has a subgroup <span class="SimpleMath">\(U\)</span> of index <span class="SimpleMath">\(56 \cdot 55 = 3080\)</span>. We compute the possible permutation character of this degree.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= PermChars( tbl, rec( torso:= [ 56 * 55 ] ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( perms );</span>
16
</pre></div>
<p><span class="SimpleMath">\(U\)</span> is contained in <span class="SimpleMath">\(S\)</span>, so only those candidates must be considered that vanish on all classes where <code class="code">pi</code> vanishes. Furthermore, the index of <span class="SimpleMath">\(U\)</span> in <span class="SimpleMath">\(S\)</span> is odd, so the Sylow <span class="SimpleMath">\(2\)</span> subgroups of <span class="SimpleMath">\(U\)</span> and <span class="SimpleMath">\(S\)</span> are isomorphic; <span class="SimpleMath">\(S\)</span> contains elements of order <span class="SimpleMath">\(8\)</span>, hence also <span class="SimpleMath">\(U\)</span> does.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">OrdersClassRepresentatives( tbl );</span>
[ 1, 2, 3, 4, 4, 5, 6, 7, 7, 8, 11, 11 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= Filtered( perms, x -> x[5] = 0 and x[10] <> 0 );</span>
[ Character( CharacterTable( "M22" ),
[ 3080, 56, 2, 12, 0, 0, 2, 0, 0, 2, 0, 0 ] ),
Character( CharacterTable( "M22" ),
[ 3080, 8, 2, 8, 0, 0, 2, 0, 0, 4, 0, 0 ] ),
Character( CharacterTable( "M22" ),
[ 3080, 24, 11, 4, 0, 0, 3, 0, 0, 2, 0, 0 ] ),
Character( CharacterTable( "M22" ),
[ 3080, 24, 20, 4, 0, 0, 0, 0, 0, 2, 0, 0 ] ) ]
</pre></div>
<p>For getting an overview of the distribution of the elements of <span class="SimpleMath">\(U\)</span> to the conjugacy classes of <span class="SimpleMath">\(G\)</span>, we use the output of <code class="func">PermCharInfo</code> (<a href="../../../doc/ref/chap72_mj.html#X8477004C7A31D28C"><span class="RefLink">Reference: PermCharInfo</span></a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">infoperms:= PermCharInfo( tbl, perms );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( tbl, infoperms.display );</span>
M22
2 7 7 2 5 2 3
3 2 1 2 . 1 .
5 1 . . . . .
7 1 . . . . .
11 1 . . . . .
1a 2a 3a 4a 6a 8a
2P 1a 1a 3a 2a 3a 4a
3P 1a 2a 1a 4a 2a 8a
5P 1a 2a 3a 4a 6a 8a
7P 1a 2a 3a 4a 6a 8a
11P 1a 2a 3a 4a 6a 8a
I.1 3080 56 2 12 2 2
I.2 1 21 8 54 24 36
I.3 1 3 4 9 12 18
I.4 3080 8 2 8 2 4
I.5 1 3 8 36 24 72
I.6 1 3 4 9 12 18
I.7 3080 24 11 4 3 2
I.8 1 9 44 18 36 36
I.9 1 3 4 9 12 18
I.10 3080 24 20 4 . 2
I.11 1 9 80 18 . 36
I.12 1 3 4 9 12 18
</pre></div>
<p>We have four candidates. For each the above list shows first the character values, then the cardinality of the intersection of <span class="SimpleMath">\(U\)</span> with the classes, and then lower bounds for the lengths of <span class="SimpleMath">\(U\)</span>-conjugacy classes of these elements. Only those classes of <span class="SimpleMath">\(G\)</span> are shown that contain elements of <span class="SimpleMath">\(U\)</span> for at least one of the characters.</p>
<p>If the first two candidates are permutation characters corresponding to <span class="SimpleMath">\(U\)</span> then <span class="SimpleMath">\(U\)</span> contains exactly <span class="SimpleMath">\(8\)</span> elements of order <span class="SimpleMath">\(3\)</span> and thus <span class="SimpleMath">\(U\)</span> has a normal Sylow <span class="SimpleMath">\(3\)</span> subgroup <span class="SimpleMath">\(P\)</span>. But the order of <span class="SimpleMath">\(N_G(P)\)</span> is bounded by <span class="SimpleMath">\(72\)</span>, which can be shown as follows. The only elements in <span class="SimpleMath">\(G\)</span> with centralizer order divisible by <span class="SimpleMath">\(9\)</span> are of order <span class="SimpleMath">\(1\)</span> or <span class="SimpleMath">\(3\)</span>, so <span class="SimpleMath">\(P\)</span> is self-centralizing in <span class="SimpleMath">\(G\)</span>. The factor <span class="SimpleMath">\(N_G(P)/C_G(P)\)</span> is isomorphic with a subgroup of Aut<span class="SimpleMath">\((G) \cong GL(2,3)\)</span> which has order divisible by <span class="SimpleMath">\(16\)</span>, hence the order of <span class="SimpleMath">\(N_G(P)\)</span> divides <span class="SimpleMath">\(144\)</span>. Now note that <span class="SimpleMath">\([ G : N_G(P) ] \equiv 1 \pmod{3}\)</span> by Sylow's Theorem, and <span class="SimpleMath">\(|G|/144 = 3\,080 \equiv -1 \pmod{3}\)</span>. Thus the first two candidates are not permutation characters.</p>
<p>If the last two candidates are permutation characters corresponding to <span class="SimpleMath">\(U\)</span> then <span class="SimpleMath">\(U\)</span> has self-normalizing Sylow subgroups. This is because the index of a Sylow <span class="SimpleMath">\(2\)</span> normalizer in <span class="SimpleMath">\(G\)</span> is odd and divides <span class="SimpleMath">\(9\)</span>, and if it is smaller than <span class="SimpleMath">\(9\)</span> then <span class="SimpleMath">\(U\)</span> contains at most <span class="SimpleMath">\(3 \cdot 15 + 1\)</span> elements of <span class="SimpleMath">\(2\)</span> power order; the index of a Sylow <span class="SimpleMath">\(3\)</span> normalizer in <span class="SimpleMath">\(G\)</span> is congruent to <span class="SimpleMath">\(1\)</span> modulo <span class="SimpleMath">\(3\)</span> and divides <span class="SimpleMath">\(16\)</span>, and if it is smaller than <span class="SimpleMath">\(16\)</span> then <span class="SimpleMath">\(U\)</span> contains at most <span class="SimpleMath">\(4 \cdot 8\)</span> elements of order <span class="SimpleMath">\(3\)</span>.</p>
<p>But since <span class="SimpleMath">\(U\)</span> is solvable and not a <span class="SimpleMath">\(p\)</span>-group, not all its Sylow subgroups can be self-normalizing; note that <span class="SimpleMath">\(U\)</span> has a proper normal subgroup <span class="SimpleMath">\(N\)</span> containing a Sylow <span class="SimpleMath">\(p\)</span> subgroup <span class="SimpleMath">\(P\)</span> of <span class="SimpleMath">\(U\)</span> for a prime divisor <span class="SimpleMath">\(p\)</span> of <span class="SimpleMath">\(|U|\)</span>, and <span class="SimpleMath">\(U = N \cdot N_U(P)\)</span> holds by the Frattini argument (see <a href="chapBib_mj.html#biBHup67">[Hup67, Satz I.7.8]</a>).</p>
<p><a id="X8068E9DA7CD03BF2" name="X8068E9DA7CD03BF2"></a></p>
<h4>8.13 <span class="Heading">A Permutation Character of the Lyons group</span></h4>
<p>Let <span class="SimpleMath">\(G\)</span> be a maximal subgroup with structure <span class="SimpleMath">\(3^{{2+4}}:2A_5.D_8\)</span> in the sporadic simple Lyons group <span class="SimpleMath">\(Ly\)</span>. We want to compute the permutation character <span class="SimpleMath">\(1_G^{Ly}\)</span>. (This construction has been explained in <a href="chapBib_mj.html#biBBP98copy">[BP98, Section 4.2]</a>, without showing explicit <strong class="pkg">GAP</strong> code.)</p>
<p>In the representation of <span class="SimpleMath">\(Ly\)</span> as automorphism group of the rank <span class="SimpleMath">\(5\)</span> graph <code class="code">B</code> with <span class="SimpleMath">\(9\,606\,125\)</span> points (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 174]</a>), <span class="SimpleMath">\(G\)</span> is the stabilizer of an edge. A group <span class="SimpleMath">\(S\)</span> with structure <span class="SimpleMath">\(3.McL.2\)</span> is the point stabilizer. So the two point stabilizer <span class="SimpleMath">\(U = S \cap G\)</span> is a subgroup of index <span class="SimpleMath">\(2\)</span> in <span class="SimpleMath">\(G\)</span>. The index of <span class="SimpleMath">\(U\)</span> in <span class="SimpleMath">\(S\)</span> is <span class="SimpleMath">\(15\,400\)</span>, and according to the list of maximal subgroups of <span class="SimpleMath">\(McL.2\)</span> (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 100]</a>), the group <span class="SimpleMath">\(U\)</span> is isomorphic to the preimage in <span class="SimpleMath">\(3.McL.2\)</span> of a subgroup <span class="SimpleMath">\(H\)</span> of <span class="SimpleMath">\(McL.2\)</span> with structure <span class="SimpleMath">\(3_+^{{1+4}}:4S_5\)</span>.</p>
<p>Using the improved combinatorial method described in <a href="chapBib_mj.html#biBBP98copy">[BP98, Section 3.2]</a>, all possible permutation characters of degree <span class="SimpleMath">\(15\,400\)</span> for the group <span class="SimpleMath">\(McL\)</span> are computed. (The method of <a href="chapBib_mj.html#biBBP98copy">[BP98, Section 3.3]</a> is slower but also needs only a few seconds.)</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">ly:= CharacterTable( "Ly" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">mcl:= CharacterTable( "McL" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">mcl2:= CharacterTable( "McL.2" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">3mcl2:= CharacterTable( "3.McL.2" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= PermChars( mcl, rec( degree:= 15400 ) );</span>
[ Character( CharacterTable( "McL" ),
[ 15400, 56, 91, 10, 12, 25, 0, 11, 2, 0, 0, 2, 1, 1, 1, 0, 0, 3,
0, 0, 1, 1, 1, 1 ] ), Character( CharacterTable( "McL" ),
[ 15400, 280, 10, 37, 20, 0, 5, 10, 1, 0, 0, 2, 1, 1, 0, 0, 0, 2,
0, 0, 0, 0, 0, 0 ] ) ]
</pre></div>
<p>We get two characters, corresponding to the two classes of maximal subgroups of index <span class="SimpleMath">\(15\,400\)</span> in <span class="SimpleMath">\(McL\)</span>. The permutation character <span class="SimpleMath">\(\pi = 1_{{H \cap McL}}^{McL}\)</span> is the one with nonzero value on the class <code class="code">10A</code>, since the subgroup of structure <span class="SimpleMath">\(2S_5\)</span> in <span class="SimpleMath">\(H \cap McL\)</span> contains elements of order <span class="SimpleMath">\(10\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">ord10:= Filtered( [ 1 .. NrConjugacyClasses( mcl ) ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> i -> OrdersClassRepresentatives( mcl )[i] = 10 );</span>
[ 15 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( perms, pi -> pi[ ord10[1] ] );</span>
[ 1, 0 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= perms[1];</span>
Character( CharacterTable( "McL" ),
[ 15400, 56, 91, 10, 12, 25, 0, 11, 2, 0, 0, 2, 1, 1, 1, 0, 0, 3, 0,
0, 1, 1, 1, 1 ] )
</pre></div>
<p>The character <span class="SimpleMath">\(1_H^{McL.2}\)</span> is an extension of <span class="SimpleMath">\(\pi\)</span>, so we can use the method of <a href="chapBib_mj.html#biBBP98copy">[BP98, Section 3.3]</a> to compute all possible permutation characters for the group <span class="SimpleMath">\(McL.2\)</span> that have the values of <span class="SimpleMath">\(\pi\)</span> on the classes of <span class="SimpleMath">\(McL\)</span>. We find that the extension of <span class="SimpleMath">\(\pi\)</span> to a permutation character of <span class="SimpleMath">\(McL.2\)</span> is unique. Regarded as a character of <span class="SimpleMath">\(3.McL.2\)</span>, this character is equal to <span class="SimpleMath">\(1_U^S\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">map:= InverseMap( GetFusionMap( mcl, mcl2 ) );</span>
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, [ 10, 11 ], 12, [ 13, 14 ], 15, 16, 17,
18, [ 19, 20 ], [ 21, 22 ], [ 23, 24 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">torso:= CompositionMaps( pi, map );</span>
[ 15400, 56, 91, 10, 12, 25, 0, 11, 2, 0, 2, 1, 1, 0, 0, 3, 0, 1, 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= PermChars( mcl2, rec( torso:= torso ) );</span>
[ Character( CharacterTable( "McL.2" ),
[ 15400, 56, 91, 10, 12, 25, 0, 11, 2, 0, 2, 1, 1, 0, 0, 3, 0, 1,
1, 110, 26, 2, 4, 0, 0, 5, 2, 1, 1, 0, 0, 1, 1 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= Inflated( perms[1], 3mcl2 );</span>
Character( CharacterTable( "3.McL.2" ),
[ 15400, 15400, 56, 56, 91, 91, 10, 12, 12, 25, 25, 0, 0, 11, 11, 2,
2, 0, 0, 0, 2, 2, 1, 1, 1, 0, 0, 0, 0, 3, 3, 0, 0, 0, 1, 1, 1, 1,
1, 1, 110, 26, 2, 4, 0, 0, 5, 2, 1, 1, 0, 0, 1, 1 ] )
</pre></div>
<p>The fusion of conjugacy classes of <span class="SimpleMath">\(S\)</span> in <span class="SimpleMath">\(Ly\)</span> can be computed from the character tables of <span class="SimpleMath">\(S\)</span> and <span class="SimpleMath">\(Ly\)</span> given in <a href="chapBib_mj.html#biBCCN85">[CCN+85]</a>, it is unique up to Galois automorphisms of the table of <span class="SimpleMath">\(Ly\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= PossibleClassFusions( 3mcl2, ly );; Length( fus );</span>
4
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= AutomorphismsOfTable( ly );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">OrbitLengths( g, fus, OnTuples ); </span>
[ 4 ]
</pre></div>
<p>Now we can induce <span class="SimpleMath">\(1_U^S\)</span> to <span class="SimpleMath">\(Ly\)</span>, which yields <span class="SimpleMath">\((1_U^S)^{Ly} = 1_U^{Ly}\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= Induced( 3mcl2, ly, [ pi ], fus[1] )[1];</span>
Character( CharacterTable( "Ly" ),
[ 147934325000, 286440, 1416800, 1082, 784, 12500, 0, 672, 42, 24,
0, 40, 0, 2, 20, 0, 0, 0, 64, 10, 0, 50, 2, 0, 0, 4, 0, 0, 0, 0, 4,
0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] )
</pre></div>
<p>All elements of odd order in <span class="SimpleMath">\(G\)</span> are contained in <span class="SimpleMath">\(U\)</span>, for such an element <span class="SimpleMath">\(g\)</span> we have</p>
<p class="center">\[
1_G^{Ly}(g) = |C_{Ly}(g)| / |G| \cdot |G \cap Cl_{Ly}(g)|
= |C_{Ly}(g)| / (2 \cdot |U|) \cdot |U \cap Cl_{Ly}(g)|
= 1/2 \cdot 1_U^{Ly}(g) \ ,
\]</p>
<p>so we can prescribe the values of <span class="SimpleMath">\(1_G^{Ly}\)</span> on all classes of odd element order. For elements <span class="SimpleMath">\(g\)</span> of even order we have the weaker condition <span class="SimpleMath">\(U\cap Cl_{Ly}(g) \subseteq G \cap Cl_{Ly}(g)\)</span> and thus <span class="SimpleMath">\(1_G^{Ly}(g) \geq 1/2 \cdot 1_U^{Ly}(g)\)</span>, which gives lower bounds for the value of <span class="SimpleMath">\(1_G^{Ly}\)</span> on the remaining classes.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">orders:= OrdersClassRepresentatives( ly );</span>
[ 1, 2, 3, 3, 4, 5, 5, 6, 6, 6, 7, 8, 8, 9, 10, 10, 11, 11, 12, 12,
14, 15, 15, 15, 18, 20, 21, 21, 22, 22, 24, 24, 24, 25, 28, 30, 30,
31, 31, 31, 31, 31, 33, 33, 37, 37, 40, 40, 42, 42, 67, 67, 67 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">torso:= [];; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for i in [ 1 .. Length( orders ) ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if orders[i] mod 2 = 1 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> torso[i]:= pi[i]/2;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">torso;</span>
[ 73967162500,, 708400, 541,, 6250, 0,,,, 0,,, 1,,, 0, 0,,,, 25, 1, 0,
,, 0, 0,,,,,, 0,,,, 0, 0, 0, 0, 0, 0, 0, 0, 0,,,,, 0, 0, 0 ]
</pre></div>
<p>Exactly one possible permutation character of <span class="SimpleMath">\(Ly\)</span> satisfies these conditions.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= PermChars( ly, rec( torso:= torso ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( perms );</span>
43
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= Filtered( perms, cand -> ForAll( [ 1 .. Length( orders ) ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> i -> cand[i] >= pi[i] / 2 ) );</span>
[ Character( CharacterTable( "Ly" ),
[ 73967162500, 204820, 708400, 541, 392, 6250, 0, 1456, 61, 25, 0,
22, 10, 1, 10, 0, 0, 0, 32, 5, 0, 25, 1, 0, 1, 2, 0, 0, 0, 0,
4, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0,
0, 0 ] ) ]
</pre></div>
<p>(The permutation character <span class="SimpleMath">\(1_G^{Ly}\)</span> was used in the proof that the character <span class="SimpleMath">\(\chi_{37}\)</span> of <span class="SimpleMath">\(Ly\)</span> (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 175]</a>) occurs with multiplicity at least 2 in each character of <span class="SimpleMath">\(Ly\)</span> that is induced from a proper subgroup of <span class="SimpleMath">\(Ly\)</span>.)</p>
<p><a id="X87D6C1A67CC7EE0A" name="X87D6C1A67CC7EE0A"></a></p>
<h4>8.14 <span class="Heading">Identifying two subgroups of Aut<span class="SimpleMath">\((U_3(5))\)</span> (October 2001)</span></h4>
<p>According to the Atlas of Finite Groups <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 34]</a>, the group Aut<span class="SimpleMath">\((U_3(5))\)</span> has two classes of maximal subgroups of order <span class="SimpleMath">\(2^4 \cdot 3^3\)</span>, which have the structures <span class="SimpleMath">\(3^2 \colon 2S_4\)</span> and <span class="SimpleMath">\(6^2 \colon D_{12}\)</span>, respectively.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tbl:= CharacterTable( "U3(5).3.2" );</span>
CharacterTable( "U3(5).3.2" )
<span class="GAPprompt">gap></span> <span class="GAPinput">deg:= Size( tbl ) / ( 2^4*3^3 );</span>
1750
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= PermChars( tbl, rec( torso:= [ deg ] ) );</span>
[ Character( CharacterTable( "U3(5).3.2" ),
[ 1750, 70, 13, 2, 0, 0, 1, 0, 0, 0, 10, 7, 10, 4, 2, 0, 0, 0, 0,
0, 0, 30, 10, 3, 0, 0, 1, 0, 0 ] ),
Character( CharacterTable( "U3(5).3.2" ),
[ 1750, 30, 4, 6, 0, 0, 0, 0, 0, 0, 40, 7, 0, 6, 0, 0, 0, 0, 0, 0,
0, 20, 0, 2, 2, 0, 0, 0, 0 ] ) ]
</pre></div>
<p>Now the question is which character belongs to which subgroup. We see that the first character vanishes on the classes of element order <span class="SimpleMath">\(8\)</span> and the second does not, so only the first one can be the permutation character induced from <span class="SimpleMath">\(6^2 \colon D_{12}\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">ord8:= Filtered( [ 1 .. NrConjugacyClasses( tbl ) ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> i -> OrdersClassRepresentatives( tbl )[i] = 8 );</span>
[ 9, 25 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( pi, x -> x{ ord8 } );</span>
[ [ 0, 0 ], [ 0, 2 ] ]
</pre></div>
<p>Thus the question is whether the second candidate is really a permutation character. Since none of the two candidates vanishes on any outer coset of <span class="SimpleMath">\(U_3(5)\)</span> in Aut<span class="SimpleMath">\((U_3(5))\)</span>, the point stabilizers are extensions of groups of order <span class="SimpleMath">\(2^3 \cdot 3^2\)</span> in <span class="SimpleMath">\(U_3(5)\)</span>. The restrictions of the candidates to <span class="SimpleMath">\(U_3(5)\)</span> are different, so we can try to answer the question using information about this group.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">subtbl:= CharacterTable( "U3(5)" );</span>
CharacterTable( "U3(5)" )
<span class="GAPprompt">gap></span> <span class="GAPinput">rest:= RestrictedClassFunctions( pi, subtbl );</span>
[ Character( CharacterTable( "U3(5)" ),
[ 1750, 70, 13, 2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ] ),
Character( CharacterTable( "U3(5)" ),
[ 1750, 30, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ) ]
</pre></div>
<p>The intersection of the <span class="SimpleMath">\(3^2 \colon 2S_4\)</span> subgroup with <span class="SimpleMath">\(U_3(5)\)</span> lies inside the maximal subgroup of type <span class="SimpleMath">\(M_{10}\)</span>, which does not contain elements of order<span class="SimpleMath">\(6\)</span>. Only the second character has this property.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">ord6:= Filtered( [ 1 .. NrConjugacyClasses( subtbl ) ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> i -> OrdersClassRepresentatives( subtbl )[i] = 6 );</span>
[ 9 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( rest, x -> x{ ord6 } );</span>
[ [ 1 ], [ 0 ] ]
</pre></div>
<p>In order to establish the two characters as permutation characters, we could also compute the permutation characters of the degree in question directly from the table of marks of <span class="SimpleMath">\(U_3(5)\)</span>, which is contained in the <strong class="pkg">GAP</strong> library of tables of marks.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">tom:= TableOfMarks( "U3(5)" );</span>
TableOfMarks( "U3(5)" )
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= PermCharsTom( subtbl, tom );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Set( Filtered( perms, x -> x[1] = deg ) ) = Set( rest );</span>
true
</pre></div>
<p>We were mainly interested in the multiplicities of irreducible characters in these characters. The action of Aut<span class="SimpleMath">\((U_3(5)\)</span> on the cosets of <span class="SimpleMath">\(3^2 \colon 2S_4\)</span> turns out to be multiplicity-free whereas that on the cosets of <span class="SimpleMath">\(6^2 \colon D_{12}\)</span> is not.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( tbl, pi ).ATLAS;</span>
[ "1a+21a+42a+84aac+105a+125a+126a+250a+252a+288bc",
"1a+42a+84ac+105ab+125a+126a+250a+252b+288bc" ]
</pre></div>
<p>It should be noted that the restrictions of the multiplicity-free character to the subgroups <span class="SimpleMath">\(U_3(5).2\)</span> and <span class="SimpleMath">\(U_3(5).3\)</span> of Aut<span class="SimpleMath">\((U_3(5)\)</span> are not multiplicity-free.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">subtbl2:= CharacterTable( "U3(5).2" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">rest2:= RestrictedClassFunctions( pi, subtbl2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( subtbl2, rest2 ).ATLAS;</span>
[ "1a+21aab+28aa+56aa+84a+105a+125aab+126aab+288aa",
"1a+21ab+28a+56a+84a+105ab+125aab+126a+252a+288aa" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">subtbl3:= CharacterTable( "U3(5).3" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">rest3:= RestrictedClassFunctions( pi, subtbl3 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( subtbl3, rest3 ).ATLAS;</span>
[ "1a+21abc+84aab+105a+125abc+126abc+144bcef",
"1a+21bc+84ab+105aa+125abc+126adg+144bcef" ]
</pre></div>
<p><a id="X793669787CF73A55" name="X793669787CF73A55"></a></p>
<h4>8.15 <span class="Heading">A Permutation Character of Aut<span class="SimpleMath">\((O_8^+(2))\)</span> (October 2001)</span></h4>
<p>According to the Atlas of Finite Groups <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 85]</a>, the group <span class="SimpleMath">\(G =\)</span> Aut<span class="SimpleMath">\((O_8^+(2))\)</span> has a class of maximal subgroups of order <span class="SimpleMath">\(2^{13} \cdot 3^2\)</span>, thus the index of these subgroups in <span class="SimpleMath">\(G\)</span> is <span class="SimpleMath">\(3^4 \cdot 5^2 \cdot 7\)</span>. The intersection of these subgroups with <span class="SimpleMath">\(H = O_8^+(2)\)</span> lie inside maximal subgroups of type <span class="SimpleMath">\(2^6 \colon A_8\)</span>. We want to show that the permutation character of the action of <span class="SimpleMath">\(G\)</span> on the cosets of these subgroups is not multiplicity-free.</p>
<p>Since the table of marks for <span class="SimpleMath">\(H\)</span> is available in <strong class="pkg">GAP</strong>, but not that for <span class="SimpleMath">\(G\)</span>, we first compute the <span class="SimpleMath">\(H\)</span>-permutation characters of the intersections with <span class="SimpleMath">\(H\)</span> of index <span class="SimpleMath">\(3^4 \cdot 5^2 \cdot 7 = 14\,175\)</span> subgroups in <span class="SimpleMath">\(G\)</span>.</p>
<p>(Note that these intersections have order <span class="SimpleMath">\(2^{12} \cdot 3\)</span> because subgroups of order <span class="SimpleMath">\(2^{12} \cdot 3^2\)</span> are contained in <span class="SimpleMath">\(O_8^+(2).2\)</span> and hence are not maximal in <span class="SimpleMath">\(G\)</span>.)</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "O8+(2).3.2" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">s:= CharacterTable( "O8+(2)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">tom:= TableOfMarks( s );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= PermCharsTom( s, tom );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">deg:= 3^4*5^2*7;</span>
14175
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= Filtered( perms, x -> x[1] = deg );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( perms );</span>
4
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( Set( perms ) );</span>
1
</pre></div>
<p>We see that there are four classes of subgroups <span class="SimpleMath">\(S\)</span> in <span class="SimpleMath">\(H\)</span> that may belong to maximal subgroups of the desired index in <span class="SimpleMath">\(G\)</span>, and that the permutation characters are equal. They lead to such groups if they extend to <span class="SimpleMath">\(G\)</span>, so we compute the possible permutation characters of <span class="SimpleMath">\(G\)</span> that extend these characters.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= PossibleClassFusions( s, t );</span>
[ [ 1, 2, 3, 3, 3, 4, 5, 5, 5, 6, 7, 8, 9, 10, 10, 10, 11, 12, 12,
12, 13, 13, 13, 14, 14, 14, 15, 16, 16, 16, 17, 17, 17, 18, 19,
20, 21, 22, 22, 22, 23, 23, 23, 24, 24, 24, 25, 26, 26, 26, 27,
27, 27 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= fus[1];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">inv:= InverseMap( fus );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">comp:= CompositionMaps( perms[1], inv );</span>
[ 14175, 1215, 375, 79, 0, 0, 27, 27, 99, 15, 7, 0, 0, 0, 0, 9, 3, 1,
0, 1, 1, 0, 0, 0, 0, 0, 0 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">ext:= PermChars( t, rec( torso:= comp ) );</span>
[ Character( CharacterTable( "O8+(2).3.2" ),
[ 14175, 1215, 375, 79, 0, 0, 27, 27, 99, 15, 7, 0, 0, 0, 0, 9, 3,
1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 63, 9, 15, 7, 1, 0, 3, 3, 3, 1,
0, 0, 1, 1, 945, 129, 45, 69, 21, 25, 13, 0, 0, 0, 9, 0, 3, 3,
7, 1, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PermCharInfo( t, ext[1] ).ATLAS;</span>
[ "1a+50b+100a+252bb+300b+700b+972bb+1400a+1944a+3200b+4032b" ]
</pre></div>
<p>Thus we get one permutation character of <span class="SimpleMath">\(G\)</span> which is not multiplicity-free.</p>
<p><a id="X8337F3C682B6BE63" name="X8337F3C682B6BE63"></a></p>
<h4>8.16 <span class="Heading">Four Primitive Permutation Characters of the Monster Group</span></h4>
<p>In this section, we compute four primitive permutation characters <span class="SimpleMath">\(1_H^M\)</span> of the sporadic simple Monster group <span class="SimpleMath">\(M\)</span>, using the following strategy.</p>
<p>Let <span class="SimpleMath">\(E\)</span> be an elementary abelian <span class="SimpleMath">\(2\)</span>-subgroup of <span class="SimpleMath">\(M\)</span>, and <span class="SimpleMath">\(H = N_M(E)\)</span>. For an involution <span class="SimpleMath">\(z \in E\)</span>, let <span class="SimpleMath">\(G = C_M(z)\)</span> and <span class="SimpleMath">\(U = G \cap H = C_H(z)\)</span> and <span class="SimpleMath">\(V = C_H(E)\)</span>, a normal subgroup of <span class="SimpleMath">\(H\)</span>. According to the Atlas of Finite Groups <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 234]</a>, <span class="SimpleMath">\(G\)</span> has the structure <span class="SimpleMath">\(2.B\)</span> if <span class="SimpleMath">\(z\)</span> is in the class <code class="code">2A</code> of <span class="SimpleMath">\(M\)</span>, and <span class="SimpleMath">\(G\)</span> has the structure <span class="SimpleMath">\(2^{{1+24}}_+.Co_1\)</span> if <span class="SimpleMath">\(z\)</span> is in the class <code class="code">2B</code> of <span class="SimpleMath">\(M\)</span>. In the latter case, let <span class="SimpleMath">\(N\)</span> denote the extraspecial normal subgroup of order <span class="SimpleMath">\(2^{25}\)</span> in <span class="SimpleMath">\(G\)</span>. It will turn out that in our situation, <span class="SimpleMath">\(U\)</span> contains <span class="SimpleMath">\(N\)</span>.</p>
<p>We want to compute many values of <span class="SimpleMath">\(1_H^M\)</span> from the knowledge of permutation characters <span class="SimpleMath">\(1_X^M\)</span>, for suitable subgroups <span class="SimpleMath">\(X\)</span> with the property <span class="SimpleMath">\(V \leq X \leq U\)</span>, and then use the <strong class="pkg">GAP</strong> function <code class="func">PermChars</code> (<a href="../../../doc/ref/chap72_mj.html#X7D02541482C196A6"><span class="RefLink">Reference: PermChars</span></a>) for computing all those possible permutation characters of <span class="SimpleMath">\(M\)</span> that take the known values; if there is a unique solution then this is the desired character <span class="SimpleMath">\(1_H^M\)</span>.</p>
<p>(In the year 2023, the character tables of three of the four maximal subgroups <span class="SimpleMath">\(H\)</span> in question became available, since then one can compute the permutation characters directly by first computing the possible class fusions to <span class="SimpleMath">\(M\)</span> and then inducing the trivial character of <span class="SimpleMath">\(H\)</span> to <span class="SimpleMath">\(M\)</span>. We get the same results this way, see below.)</p>
<p><center> <img src="ctblpope01.png" alt="setup: some subgroups of G"/> </center></p>
<p>Why does this approach have a chance to be successful? Currently we do not have representations for the subgroups <span class="SimpleMath">\(H\)</span> in question, but the character tables of the involution centralizers <span class="SimpleMath">\(G\)</span> in <span class="SimpleMath">\(M\)</span> are available, and also either the character tables of <span class="SimpleMath">\(X/V\)</span> for the interesting subgroups <span class="SimpleMath">\(X\)</span> are known or we have enough information to compute the characters <span class="SimpleMath">\(1_X^G\)</span>.</p>
<p>And how do we compute certain values of <span class="SimpleMath">\(1_H^M\)</span>? Suppose that <span class="SimpleMath">\(C\)</span> is a union of classes of <span class="SimpleMath">\(M\)</span> and <span class="SimpleMath">\(I\)</span> is an index set such that <span class="SimpleMath">\((1_H)_{{C \cap H}} = (\sum_{{i \in I}} c_i 1_{{X_i}}^H)_{{C \cap H}}\)</span> holds for suitable rational numbers <span class="SimpleMath">\(c_i\)</span>.</p>
<p>The right hand side of this equality lives in <span class="SimpleMath">\(H/V\)</span>, provided that <span class="SimpleMath">\(C\)</span> "behaves well" w.r.t. factoring out the normal subgroup <span class="SimpleMath">\(V\)</span> of <span class="SimpleMath">\(H\)</span>, i. e., if there is a set of classes in <span class="SimpleMath">\(H/V\)</span> whose preimages in <span class="SimpleMath">\(H\)</span> form the set <span class="SimpleMath">\(H \cap C\)</span>. For example, <span class="SimpleMath">\(C\)</span> may be the set of all those elements in <span class="SimpleMath">\(M\)</span> whose order is not divisible by a particular prime <span class="SimpleMath">\(p\)</span> that divides <span class="SimpleMath">\(|H|\)</span> but not <span class="SimpleMath">\(|U|\)</span>.</p>
<p>Under these conditions, we have <span class="SimpleMath">\((1_H^M)_{C} = ((\sum_{{i \in I}} c_i 1_{{X_i}}^G)^M)_{C}\)</span>, and we interpret the right hand side as follows: If <span class="SimpleMath">\(X_i\)</span> contains <span class="SimpleMath">\(N\)</span> then <span class="SimpleMath">\(1_{{X_i}}^G\)</span> can be identified with <span class="SimpleMath">\(1_{{X_i/N}}^{{G/N}}\)</span>. If <span class="SimpleMath">\(X_i\)</span> contains at least <span class="SimpleMath">\(Z\)</span> then <span class="SimpleMath">\(1_{{X_i}}^G\)</span> can be identified with <span class="SimpleMath">\(1_{{X_i/Z}}^{{G/Z}}\)</span>. As mentioned above, we have good chances to compute these characters. So the main task in each of the following sections is to find, for a suitable set <span class="SimpleMath">\(C\)</span> of classes, a linear combination of permutation characters of <span class="SimpleMath">\(H/V\)</span> whose restriction to <span class="SimpleMath">\((C \cap H) / V\)</span> is constant and nonzero.</p>
<p><a id="X78A8A1248336DD26" name="X78A8A1248336DD26"></a></p>
<h5>8.16-1 <span class="Heading">The Subgroup <span class="SimpleMath">\(2^2.2^{11}.2^{22}.(S_3 \times M_{24})\)</span>
(June 2009)</span></h5>
<p>According to the Atlas of Finite Groups <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 234]</a>, the Monster group <span class="SimpleMath">\(M\)</span> has a class of maximal subgroups <span class="SimpleMath">\(H\)</span> of the type <span class="SimpleMath">\(2^2.2^{11}.2^{22}.(S_3 \times M_{24})\)</span>. Currently the character table of <span class="SimpleMath">\(H\)</span> and the class fusion into <span class="SimpleMath">\(M\)</span> are not available in <strong class="pkg">GAP</strong>. We are interested in the permutation character <span class="SimpleMath">\(1_H^G\)</span>, and we will compute it without this information.</p>
<p>The subgroup <span class="SimpleMath">\(H\)</span> normalizes a Klein four group <span class="SimpleMath">\(E\)</span> whose involutions lie in the class <code class="code">2B</code>. We fix an involution <span class="SimpleMath">\(z\)</span> in <span class="SimpleMath">\(E\)</span>, and set <span class="SimpleMath">\(G = C_M(z)\)</span>, <span class="SimpleMath">\(U = C_H(z)\)</span>, and <span class="SimpleMath">\(V = C_H(E)\)</span>. Further, let <span class="SimpleMath">\(N\)</span> be the extraspecial normal subgroup of order <span class="SimpleMath">\(2^{25}\)</span> in <span class="SimpleMath">\(G\)</span>.</p>
<p>So <span class="SimpleMath">\(G\)</span> has the structure <span class="SimpleMath">\(2^{{1+24}}_+.Co_1\)</span>, and <span class="SimpleMath">\(U\)</span> has index three in <span class="SimpleMath">\(H\)</span>. The order of <span class="SimpleMath">\(N U / N\)</span> is a multiple of <span class="SimpleMath">\(2^{{2+11+22-25}} \cdot 2 \cdot |M_{24}|\)</span>, and <span class="SimpleMath">\(N U / N\)</span> occurs as a subgroup of <span class="SimpleMath">\(G / N \cong Co_1\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">co1:= CharacterTable( "Co1" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">order:= 2^(2+11+22-25) * 2 * Size( CharacterTable( "M24" ) );</span>
501397585920
<span class="GAPprompt">gap></span> <span class="GAPinput">maxes:= List( Maxes( co1 ), CharacterTable );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">filt:= Filtered( maxes, t -> Size( t ) mod order = 0 );</span>
[ CharacterTable( "2^11:M24" ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( filt, t -> Size( t ) / order );</span>
[ 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">k:= filt[1];;</span>
</pre></div>
<p>The list of maximal subgroups of <span class="SimpleMath">\(Co_1\)</span> (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 183]</a>) tells us that <span class="SimpleMath">\(NU / N\)</span> is a maximal subgroup <span class="SimpleMath">\(K\)</span> of <span class="SimpleMath">\(Co_1\)</span> and has the structure <span class="SimpleMath">\(2^{11}:M_{24}\)</span>. In particular, <span class="SimpleMath">\(U\)</span> contains <span class="SimpleMath">\(N\)</span> and thus <span class="SimpleMath">\(U/N \cong K\)</span>.</p>
<p>Let <span class="SimpleMath">\(C = \{ g \in M; 3 \nmid |g|\)</span> or <span class="SimpleMath">\(1_V^M(g^3) = 0 \}\)</span>.</p>
<p>Then <span class="SimpleMath">\((1_H)_{{C \cap H}} = (1_U^H - 1/3 1_V^H)_{{C \cap H}}\)</span> holds, as we can see from computations with <span class="SimpleMath">\(H/V \cong S_3\)</span>, as follows.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">f:= CharacterTable( "Symmetric", 3 );</span>
CharacterTable( "Sym(3)" )
<span class="GAPprompt">gap></span> <span class="GAPinput">OrdersClassRepresentatives( f );</span>
[ 1, 2, 3 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">deg3:= PermChars( f, 3 );</span>
[ Character( CharacterTable( "Sym(3)" ), [ 3, 1, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">deg6:= PermChars( f, 6 );</span>
[ Character( CharacterTable( "Sym(3)" ), [ 6, 0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">deg3[1] - 1/3 * deg6[1];</span>
ClassFunction( CharacterTable( "Sym(3)" ), [ 1, 1, 0 ] )
</pre></div>
<p>The character table of <span class="SimpleMath">\(G\)</span> is available in <strong class="pkg">GAP</strong>, so we can compute the permutation character <span class="SimpleMath">\(\pi = 1_U^G\)</span> by computing the primitive permutation character <span class="SimpleMath">\(1_K^{{Co_1}}\)</span>, identifying it with <span class="SimpleMath">\(1_{{U/N}}^{{G/N}}\)</span>, and then inflating this character to <span class="SimpleMath">\(G\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">m:= CharacterTable( "M" );</span>
CharacterTable( "M" )
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= CharacterTable( "MC2B" );</span>
CharacterTable( "2^1+24.Co1" )
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= RestrictedClassFunction( TrivialCharacter( k )^co1, g );;</span>
</pre></div>
<p>Next we consider the permutation character <span class="SimpleMath">\(\phi = 1_V^G\)</span>. The group <span class="SimpleMath">\(V\)</span> does not contain <span class="SimpleMath">\(N\)</span> because <span class="SimpleMath">\(K\)</span> is perfect. But <span class="SimpleMath">\(V\)</span> contains <span class="SimpleMath">\(Z\)</span> because otherwise <span class="SimpleMath">\(U\)</span> would be a direct product of <span class="SimpleMath">\(V\)</span> and <span class="SimpleMath">\(Z\)</span>, which would imply that <span class="SimpleMath">\(N\)</span> would be a direct product of <span class="SimpleMath">\(V \cap N\)</span> and <span class="SimpleMath">\(Z\)</span>. So we can regard <span class="SimpleMath">\(\phi\)</span> as the inflation of <span class="SimpleMath">\(1_{{V/Z}}^{{G/Z}}\)</span> from <span class="SimpleMath">\(G/Z\)</span> to <span class="SimpleMath">\(G\)</span>, i. e., we can perform the computations with the character table of the factor group <span class="SimpleMath">\(G/Z\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">zclasses:= ClassPositionsOfCentre( g );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">gmodz:= g / zclasses;</span>
CharacterTable( "2^1+24.Co1/[ 1, 2 ]" )
<span class="GAPprompt">gap></span> <span class="GAPinput">invmap:= InverseMap( GetFusionMap( g, gmodz ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">pibar:= CompositionMaps( pi, invmap );;</span>
</pre></div>
<p>Since <span class="SimpleMath">\(\phi(g) = [G:V] \cdot |g^G \cap V| / |g^G|\)</span> holds for <span class="SimpleMath">\(g \in G\)</span>, and since <span class="SimpleMath">\(g^G \cap V \subseteq g^G \cap VN\)</span>, with equality if <span class="SimpleMath">\(g\)</span> has odd order, we get <span class="SimpleMath">\(\phi(g) = 2 \cdot \pi(g)\)</span> if <span class="SimpleMath">\(g\)</span> has odd order, and <span class="SimpleMath">\(\phi(g) = 0\)</span> if <span class="SimpleMath">\(\pi(g) = 0\)</span>.</p>
<p>We want to compute the possible permutation characters with these values.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">factorders:= OrdersClassRepresentatives( gmodz );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">phibar:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for i in [ 1 .. NrConjugacyClasses( gmodz ) ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if factorders[i] mod 2 = 1 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> phibar[i]:= 2 * pibar[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif pibar[i] = 0 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> phibar[i]:= 0;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= PermChars( gmodz, rec( torso:= phibar ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( cand );</span>
1
</pre></div>
<p>Now we know <span class="SimpleMath">\(\pi^M = 1_U^M\)</span> and <span class="SimpleMath">\(\phi^M = 1_V^M\)</span>, so we can write down <span class="SimpleMath">\((1_H^M)_{C}\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">phi:= RestrictedClassFunction( cand[1], g )^m;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= pi^m;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= ShallowCopy( pi - 1/3 * phi );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">morders:= OrdersClassRepresentatives( m );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for i in [ 1 .. Length( morders ) ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if morders[i] mod 3 = 0 and phi[ PowerMap( m, 3 )[i] ] <> 0 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Unbind( cand[i] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
</pre></div>
<p>We claim that <span class="SimpleMath">\(1_H^M(g) \geq \pi^M(g) - 1/3 \psi^M(g)\)</span> for all <span class="SimpleMath">\(g \in M\)</span>. In order to see this, let <span class="SimpleMath">\(H'\)</span> denote the index two subgroup of <span class="SimpleMath">\(H\)</span>, and let <span class="SimpleMath">\(g \in M\)</span>. Since <span class="SimpleMath">\(H\)</span> is the disjoint union of <span class="SimpleMath">\(V\)</span>, <span class="SimpleMath">\(H' \setminus V\)</span>, and three <span class="SimpleMath">\(H\)</span>-conjugates of <span class="SimpleMath">\(U \setminus V\)</span>, we get</p>
<p><div class="pcenter"><table> <tr> <td class="tdright"><span class="SimpleMath">1_H^M(g)</span></td> <td class="tdcenter"><span class="SimpleMath">=</span></td> <td class="tdleft"><span class="SimpleMath">[M:H] ⋅ |g^M ∩ H| / |g^M|</span></td> </tr> <tr> <td class="tdcenter"><span class="SimpleMath"> </span></td> <td class="tdcenter"><span class="SimpleMath">=</span></td> <td class="tdcenter"><span class="SimpleMath">[M:H] ⋅ ( |g^M ∩ V| + 3 |g^M ∩ U \ V| + |g^M ∩ H' \ V| ) / |g^M|</span></td> </tr> <tr> <td class="tdcenter"><span class="SimpleMath"> </span></td> <td class="tdcenter"><span class="SimpleMath">=</span></td> <td class="tdcenter"><span class="SimpleMath">[M:H] ⋅ ( 3 |g^M ∩ U| - 2 |g^M ∩ V| + |g^M ∩ H' \ V| ) / |g^M|</span></td> </tr> <tr> <td class="tdcenter"><span class="SimpleMath"> </span></td> <td class="tdcenter"><span class="SimpleMath">=</span></td> <td class="tdcenter"><span class="SimpleMath">1_U^M(g) - 1/3 ⋅ 1_V^G(g) + [M:H] ⋅ |g^M ∩ H' \ V| / |g^M| .</span></td> </tr> </table> </div></p>
<p>Possible constituents of <span class="SimpleMath">\(1_H^M\)</span> are those rational irreducible characters of <span class="SimpleMath">\(M\)</span> that are constituents of <span class="SimpleMath">\(\pi^M\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">constit:= Filtered( RationalizedMat( Irr( m ) ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> chi -> ScalarProduct( m, chi, pi ) <> 0 );;</span>
</pre></div>
<p>Now we compute the possible permutation characters that have the prescribed values, are compatible with the given lower bounds for values, and have only constituents in the given list.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= PermChars( m,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> rec( torso:= cand, chars:= constit,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> lower:= ShallowCopy( pi - 1/3 * phi ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> normalsubgroup:= [ 1 .. NrConjugacyClasses( m ) ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> nonfaithful:= TrivialCharacter( m ) ) );</span>
[ Character( CharacterTable( "M" ),
[ 16009115629875684006343550944921875, 7774182899642733721875,
120168544413337875, 4436049512692980, 215448838605,
131873639625, 760550656275, 110042727795, 943894035, 568854195,
1851609375, 0, 4680311220, 405405, 78624756, 14467005, 178605,
248265, 874650, 0, 76995, 591163, 224055, 34955, 29539, 20727,
0, 0, 375375, 15775, 0, 0, 0, 495, 116532, 3645, 62316, 1017,
11268, 357, 1701, 45, 117, 705, 0, 0, 4410, 1498, 0, 3780, 810,
0, 0, 83, 135, 31, 0, 0, 0, 0, 0, 0, 0, 255, 195, 0, 215, 0, 0,
210, 0, 42, 0, 35, 15, 1, 1, 160, 48, 9, 92, 25, 9, 9, 5, 1,
21, 0, 0, 0, 0, 0, 98, 74, 42, 0, 0, 0, 120, 76, 10, 0, 0, 0,
0, 0, 1, 1, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 3, 0,
0, 0, 18, 0, 10, 0, 3, 3, 0, 1, 1, 1, 1, 0, 0, 2, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0, 0, 0, 6, 12, 0, 0, 2, 0, 0, 0, 2, 0, 0, 1, 1,
0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0 ] ) ]
</pre></div>
<p>There is only one candidate, so we have found the permutation character.</p>
<p>The character table of <span class="SimpleMath">\(H\)</span> is available since 2023. We can compute the permutation character directly from this table.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">h:= CharacterTable( "2^(2+11+22).(M24xS3)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= PossibleClassFusions( h, m );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand = Set( fus, map -> InducedClassFunctionsByFusionMap( h, m,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ TrivialCharacter( h ) ], map )[1] );</span>
true
</pre></div>
<p><a id="X79E9247182B20474" name="X79E9247182B20474"></a></p>
<h5>8.16-2 <span class="Heading">The Subgroup <span class="SimpleMath">\(2^3.2^6.2^{12}.2^{18}.(L_3(2) \times 3.S_6)\)</span>
(September 2009)</span></h5>
<p>According to the Atlas of Finite Groups <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 234]</a>, the Monster group <span class="SimpleMath">\(M\)</span> has a class of maximal subgroups <span class="SimpleMath">\(H\)</span> of the type <span class="SimpleMath">\(2^3.2^6.2^{12}.2^{18}.(L_3(2) \times 3.S_6)\)</span>. Currently the character table of <span class="SimpleMath">\(H\)</span> and the class fusion into <span class="SimpleMath">\(M\)</span> are not available in <strong class="pkg">GAP</strong>. We are interested in the permutation character <span class="SimpleMath">\(1_H^G\)</span>, and we will compute it without this information.</p>
<p>The subgroup <span class="SimpleMath">\(H\)</span> normalizes an elementary abelian group <span class="SimpleMath">\(E\)</span> of order eight whose involutions lie in the class <code class="code">2B</code>. We fix an involution <span class="SimpleMath">\(z\)</span> in <span class="SimpleMath">\(E\)</span>, and set <span class="SimpleMath">\(G = C_M(z)\)</span>, <span class="SimpleMath">\(U = C_H(z)\)</span>, and <span class="SimpleMath">\(V = C_H(E)\)</span>. Further, let <span class="SimpleMath">\(N\)</span> be the extraspecial normal subgroup of order <span class="SimpleMath">\(2^{25}\)</span> in <span class="SimpleMath">\(G\)</span>.</p>
<p>So <span class="SimpleMath">\(G\)</span> has the structure <span class="SimpleMath">\(2^{{1+24}}_+.Co_1\)</span>, and <span class="SimpleMath">\(U\)</span> has index seven in <span class="SimpleMath">\(H\)</span>. The order of <span class="SimpleMath">\(N U / N\)</span> is a multiple of <span class="SimpleMath">\(2^{{3+6+12+18-25}} \cdot |L_3(2)| \cdot |3.S_6| / 7\)</span>, and <span class="SimpleMath">\(N U / N\)</span> occurs as a subgroup of <span class="SimpleMath">\(G / N \cong Co_1\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">co1:= CharacterTable( "Co1" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">order:= 2^(3+6+12+18-25) * 168 * 3 * Factorial( 6 ) / 7;</span>
849346560
<span class="GAPprompt">gap></span> <span class="GAPinput">maxes:= List( Maxes( co1 ), CharacterTable );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">filt:= Filtered( maxes, t -> Size( t ) mod order = 0 );</span>
[ CharacterTable( "2^(1+8)+.O8+(2)" ),
CharacterTable( "2^(4+12).(S3x3S6)" ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( filt, t -> Size( t ) / order );</span>
[ 105, 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">o8p2:= CharacterTable( "O8+(2)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PermChars( o8p2, rec( torso:= [ 105 ] ) );</span>
[ ]
<span class="GAPprompt">gap></span> <span class="GAPinput">k:= filt[2];;</span>
</pre></div>
<p>The list of maximal subgroups of <span class="SimpleMath">\(Co_1\)</span> (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 183]</a>) tells us that <span class="SimpleMath">\(NU / N\)</span> is a maximal subgroup <span class="SimpleMath">\(K\)</span> of <span class="SimpleMath">\(Co_1\)</span> and has the structure <span class="SimpleMath">\(2^{{4+12}}.(S_3 \times 3.S_6)\)</span>. (Note that the group <span class="SimpleMath">\(O_8^+(2)\)</span> has no proper subgroup of index <span class="SimpleMath">\(105\)</span>.) In particular, <span class="SimpleMath">\(U\)</span> contains <span class="SimpleMath">\(N\)</span> and thus <span class="SimpleMath">\(U/N \cong K\)</span>.</p>
<p>Let <span class="SimpleMath">\(C\)</span> be the set of elements in <span class="SimpleMath">\(M\)</span> whose order is not divisible by <span class="SimpleMath">\(7\)</span>. Then <span class="SimpleMath">\((1_H)_{{C \cap H}} = (1_U^H - 1/3 1_{VN}^H + 1/21 1_V^H)_{{C \cap H}}\)</span> holds, as we can see from computations with <span class="SimpleMath">\(H/V \cong L_3(2)\)</span>, as follows.</p>
<p>So S4, V4, 1 suffice! --></p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">f:= CharacterTable( "L3(2)" );</span>
CharacterTable( "L3(2)" )
<span class="GAPprompt">gap></span> <span class="GAPinput">OrdersClassRepresentatives( f );</span>
[ 1, 2, 3, 4, 7, 7 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">deg7:= PermChars( f, 7 );</span>
[ Character( CharacterTable( "L3(2)" ), [ 7, 3, 1, 1, 0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">deg42:= PermChars( f, 42 );</span>
[ Character( CharacterTable( "L3(2)" ), [ 42, 2, 0, 2, 0, 0 ] ),
Character( CharacterTable( "L3(2)" ), [ 42, 6, 0, 0, 0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">deg168:= PermChars( f, 168 );</span>
[ Character( CharacterTable( "L3(2)" ), [ 168, 0, 0, 0, 0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">deg7[1] - 1/3 * deg42[2] + 1/21 * deg168[1];</span>
ClassFunction( CharacterTable( "L3(2)" ), [ 1, 1, 1, 1, 0, 0 ] )
</pre></div>
<p>(Note that <span class="SimpleMath">\(VN/V\)</span> is a Klein four group, and there is only one transitive permutation character of <span class="SimpleMath">\(L_3(2)\)</span> that is induced from such subgroups.)</p>
<p>The character table of <span class="SimpleMath">\(G\)</span> is available in <strong class="pkg">GAP</strong>, so we can compute the permutation character <span class="SimpleMath">\(\pi = 1_U^G\)</span> by computing the primitive permutation character <span class="SimpleMath">\(1_K^{{Co_1}}\)</span>, identifying it with <span class="SimpleMath">\(1_{{U/N}}^{{G/N}}\)</span>, and then inflating this character to <span class="SimpleMath">\(G\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">m:= CharacterTable( "M" );</span>
CharacterTable( "M" )
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= CharacterTable( "MC2B" );</span>
CharacterTable( "2^1+24.Co1" )
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= RestrictedClassFunction( TrivialCharacter( k )^co1, g );;</span>
</pre></div>
<p>The permutation character <span class="SimpleMath">\(\psi = 1_{VN}^G\)</span> can be computed as the inflation of <span class="SimpleMath">\(1_{{VN/N}}^{{G/N}} = (1_{{VN/N}}^{{U/N}})^{{G/N}}\)</span>, where <span class="SimpleMath">\(1_{{VN/N}}^{{U/N}}\)</span> is a character of <span class="SimpleMath">\(K\)</span> that can be identified with the regular permutation character of <span class="SimpleMath">\(U/VN \cong S_3\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">nsg:= ClassPositionsOfNormalSubgroups( k );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">nsgsizes:= List( nsg, x -> Sum( SizesConjugacyClasses( k ){ x } ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">nn:= nsg[ Position( nsgsizes, Size( k ) / 6 ) ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">psi:= 0 * [ 1 .. NrConjugacyClasses( k ) ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for i in nn do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> psi[i]:= 6;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">psi:= InducedClassFunction( k, psi, co1 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">psi:= RestrictedClassFunction( psi, g );;</span>
</pre></div>
<p>Next we consider the permutation character <span class="SimpleMath">\(\phi = 1_V^G\)</span>. The group <span class="SimpleMath">\(V\)</span> does not contain <span class="SimpleMath">\(N\)</span> because <span class="SimpleMath">\(K\)</span> does not have a factor group of the type <span class="SimpleMath">\(S_4\)</span>. But <span class="SimpleMath">\(V\)</span> contains <span class="SimpleMath">\(Z\)</span> because <span class="SimpleMath">\(U/V\)</span> is centerless. So we can regard <span class="SimpleMath">\(\phi\)</span> as the inflation of <span class="SimpleMath">\(1_{{V/Z}}^{{G/Z}}\)</span> from <span class="SimpleMath">\(G/Z\)</span> to <span class="SimpleMath">\(G\)</span>, i. e., we can perform the computations with the character table of the factor group <span class="SimpleMath">\(G/Z\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">zclasses:= ClassPositionsOfCentre( g );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">gmodz:= g / zclasses;</span>
CharacterTable( "2^1+24.Co1/[ 1, 2 ]" )
<span class="GAPprompt">gap></span> <span class="GAPinput">invmap:= InverseMap( GetFusionMap( g, gmodz ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">psibar:= CompositionMaps( psi, invmap );;</span>
</pre></div>
<p>Since <span class="SimpleMath">\(\phi(g) = [G:V] \cdot |g^G \cap V| / |g^G|\)</span> holds for <span class="SimpleMath">\(g \in G\)</span>, and since <span class="SimpleMath">\(g^G \cap V \subseteq g^G \cap VN\)</span>, with equality if <span class="SimpleMath">\(g\)</span> has odd order, we get <span class="SimpleMath">\(\phi(g) = 4 \cdot \psi(g)\)</span> if <span class="SimpleMath">\(g\)</span> has odd order, and <span class="SimpleMath">\(\phi(g) = 0\)</span> if <span class="SimpleMath">\(\psi(g) = 0\)</span>.</p>
<p>We want to compute the possible permutation characters with these values. This is easier if we "go down" from <span class="SimpleMath">\(VN\)</span> to <span class="SimpleMath">\(V\)</span> in two steps.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">factorders:= OrdersClassRepresentatives( gmodz );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">phibar:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">upperphibar:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for i in [ 1 .. NrConjugacyClasses( gmodz ) ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if factorders[i] mod 2 = 1 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> phibar[i]:= 2 * psibar[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif psibar[i] = 0 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> phibar[i]:= 0;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> upperphibar[i]:= 2 * psibar[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= PermChars( gmodz, rec( torso:= phibar,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> upper:= upperphibar,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> normalsubgroup:= [ 1 .. NrConjugacyClasses( gmodz ) ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> nonfaithful:= TrivialCharacter( gmodz ) ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( cand );</span>
3
</pre></div>
<p>One of the candidates computed in this first step is excluded by the fact that it is induced from a subgroup that contains <span class="SimpleMath">\(N/Z\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">nn:= First( ClassPositionsOfNormalSubgroups( gmodz ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> Sum( SizesConjugacyClasses( gmodz ){x} ) = 2^24 );</span>
[ 1 .. 4 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">cont:= PermCharInfo( gmodz, cand ).contained;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= cand{ Filtered( [ 1 .. Length( cand ) ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> i -> Sum( cont[i]{ nn } ) < 2^24 ) };;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( cand );</span>
2
</pre></div>
<p>Now we run the second step. After excluding the candidates that cannot be induced from subgroups whose intersection with <span class="SimpleMath">\(N/Z\)</span> has index four in <span class="SimpleMath">\(N/Z\)</span>, we get four solutions.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">poss:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for v in cand do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> phibar:= [];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> upperphibar:= [];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for i in [ 1 .. NrConjugacyClasses( gmodz ) ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if factorders[i] mod 2 = 1 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> phibar[i]:= 2 * v[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif v[i] = 0 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> phibar[i]:= 0;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> upperphibar[i]:= 2 * v[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Append( poss, PermChars( gmodz, rec( torso:= phibar,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> upper:= upperphibar,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> normalsubgroup:= [ 1 .. NrConjugacyClasses( gmodz ) ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> nonfaithful:= TrivialCharacter( gmodz ) ) ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( poss );</span>
6
<span class="GAPprompt">gap></span> <span class="GAPinput">cont:= PermCharInfo( gmodz, poss ).contained;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">poss:= poss{ Filtered( [ 1 .. Length( poss ) ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> i -> Sum( cont[i]{ nn } ) < 2^23 ) };;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( poss );</span>
4
<span class="GAPprompt">gap></span> <span class="GAPinput">phicand:= RestrictedClassFunctions( poss, g );;</span>
</pre></div>
<p>Since we have several candidates for <span class="SimpleMath">\(1_V^G\)</span>, we form the linear combinations for all these candidates.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">phicand:= RestrictedClassFunctions( poss, g );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">phicand:= InducedClassFunctions( phicand, m );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">psi:= psi^m;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= pi^m;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= List( phicand,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> phi -> ShallowCopy( pi - 1/3 * psi + 1/21 * phi ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">morders:= OrdersClassRepresentatives( m );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for x in cand do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for i in [ 1 .. Length( morders ) ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if morders[i] mod 7 = 0 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Unbind( x[i] );</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>
</pre></div>
<p>Exactly one of the candidates has only integral values.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= Filtered( cand, x -> ForAll( x, IsInt ) );</span>
[ [ 4050306254358548053604918389065234375, 148844831270071996434375,
2815847622206994375, 14567365753025085, 3447181417680,
659368198125, 3520153823175, 548464353255, 5706077895,
3056566695, 264515625, 0, 19572895485, 6486480, 186109245,
61410960, 758160, 688365,,, 172503, 1264351, 376155, 137935,
99127, 52731, 0, 0, 119625, 3625, 0, 0, 0, 0, 402813, 29160,
185301, 2781, 21069, 1932, 4212, 360, 576, 1125, 0, 0,,,, 2160,
810, 0, 0, 111, 179, 43, 0, 0, 0, 0, 0, 0, 0, 185, 105, 0, 65,
0, 0,,,,, 0, 0, 0, 0, 337, 105, 36, 157, 37, 18, 18, 16, 4, 21,
0, 0, 0, 0, 0,,,,, 0, 0, 60, 40, 10, 0, 0, 0, 0, 0, 1, 1, 0, 0,
0,,, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 1, 0, 0, 0,,,,, 0, 0, 0, 0,
0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0,,,, 0, 0, 0, 6, 8, 0, 0, 2,
0, 0, 0, 0, 0, 0, 0, 0,,, 0, 0, 0, 0, 0,,,, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,, 0 ] ]
</pre></div>
<p>Possible constituents of <span class="SimpleMath">\(1_H^M\)</span> are those rational irreducible characters of <span class="SimpleMath">\(M\)</span> that are constituents of <span class="SimpleMath">\(\pi^M\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">constit:= Filtered( RationalizedMat( Irr( m ) ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> chi -> ScalarProduct( m, chi, pi ) <> 0 );;</span>
</pre></div>
<p>Now we compute the possible permutation characters that have the prescribed values and have only constituents in the given list.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= PermChars( m, rec( torso:= cand[1], chars:= constit ) );</span>
[ Character( CharacterTable( "M" ),
[ 4050306254358548053604918389065234375, 148844831270071996434375,
2815847622206994375, 14567365753025085, 3447181417680,
659368198125, 3520153823175, 548464353255, 5706077895,
3056566695, 264515625, 0, 19572895485, 6486480, 186109245,
61410960, 758160, 688365, 58310, 0, 172503, 1264351, 376155,
137935, 99127, 52731, 0, 0, 119625, 3625, 0, 0, 0, 0, 402813,
29160, 185301, 2781, 21069, 1932, 4212, 360, 576, 1125, 0, 0,
1302, 294, 0, 2160, 810, 0, 0, 111, 179, 43, 0, 0, 0, 0, 0, 0,
0, 185, 105, 0, 65, 0, 0, 224, 0, 14, 0, 0, 0, 0, 0, 337, 105,
36, 157, 37, 18, 18, 16, 4, 21, 0, 0, 0, 0, 0, 70, 38, 14, 0,
0, 0, 60, 40, 10, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 10, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 5, 1, 0, 0, 0, 24, 0, 6, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 6, 8, 0, 0, 2,
0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 4, 0, 2, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0 ] ) ]
</pre></div>
<p>There is only one candidate, so we have found the permutation character.</p>
<p>The character table of <span class="SimpleMath">\(H\)</span> is available since 2023. We can compute the permutation character directly from this table. (The class fusion from <span class="SimpleMath">\(H\)</span> to <span class="SimpleMath">\(M\)</span> is unique up to table automorphisms, but its computation is a bit tricky, thus we do not compute this fusion here.)</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">h:= CharacterTable( "2^[39].(L3(2)x3.S6)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand[1] = TrivialCharacter( h )^m;</span>
true
</pre></div>
<p><a id="X7BC36C597E542DEE" name="X7BC36C597E542DEE"></a></p>
<h5>8.16-3 <span class="Heading">The Subgroup <span class="SimpleMath">\(2^5.2^{10}.2^{20}.(S_3 \times L_5(2))\)</span>
(October 2009)</span></h5>
<p>According to the Atlas of Finite Groups <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 234]</a>, the Monster group <span class="SimpleMath">\(M\)</span> has a class of maximal subgroups <span class="SimpleMath">\(H\)</span> of the type <span class="SimpleMath">\(2^5.2^{10}.2^{20}.(S_3 \times L_5(2))\)</span>. Currently the character table of <span class="SimpleMath">\(H\)</span> and the class fusion into <span class="SimpleMath">\(M\)</span> are not available in <strong class="pkg">GAP</strong>. We are interested in the permutation character <span class="SimpleMath">\(1_H^G\)</span>, and we will compute it without this information.</p>
<p>The subgroup <span class="SimpleMath">\(H\)</span> normalizes an elementary abelian group <span class="SimpleMath">\(E\)</span> of order <span class="SimpleMath">\(32\)</span> whose involutions lie in the class <code class="code">2B</code>. We fix an involution <span class="SimpleMath">\(z\)</span> in <span class="SimpleMath">\(E\)</span>, and set <span class="SimpleMath">\(G = C_M(z)\)</span>, <span class="SimpleMath">\(U = C_H(z)\)</span>, and <span class="SimpleMath">\(V = C_H(E)\)</span>. Further, let <span class="SimpleMath">\(N\)</span> be the extraspecial normal subgroup of order <span class="SimpleMath">\(2^{25}\)</span> in <span class="SimpleMath">\(G\)</span>.</p>
<p>So <span class="SimpleMath">\(G\)</span> has the structure <span class="SimpleMath">\(2^{{1+24}}_+.Co_1\)</span>, and <span class="SimpleMath">\(U\)</span> has index <span class="SimpleMath">\(31\)</span> in <span class="SimpleMath">\(H\)</span>. The order of <span class="SimpleMath">\(N U / N\)</span> is a multiple of <span class="SimpleMath">\(2^{{5+10+20-25}} \cdot |L_5(2)| \cdot |S_3| / 31\)</span>, and <span class="SimpleMath">\(N U / N\)</span> occurs as a subgroup of <span class="SimpleMath">\(G / N \cong Co_1\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">co1:= CharacterTable( "Co1" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">order:= 2^35*Size( CharacterTable( "L5(2)" ) )*6 / 2^25 / 31;</span>
1981808640
<span class="GAPprompt">gap></span> <span class="GAPinput">maxes:= List( Maxes( co1 ), CharacterTable );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">filt:= Filtered( maxes, t -> Size( t ) mod order = 0 );</span>
[ CharacterTable( "2^11:M24" ), CharacterTable( "2^(1+8)+.O8+(2)" ),
CharacterTable( "2^(2+12):(A8xS3)" ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( filt, t -> Size( t ) / order );</span>
[ 253, 45, 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">m24:= CharacterTable( "M24" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= PermChars( m24, rec( torso:=[ 253 ] ) );</span>
[ Character( CharacterTable( "M24" ),
[ 253, 29, 13, 10, 1, 5, 5, 1, 3, 2, 1, 1, 1, 1, 3, 0, 2, 1, 1, 1,
0, 0, 1, 1, 0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">TestPerm5( m24, cand, m24 mod 11 );</span>
[ ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PermChars( CharacterTable( "O8+(2)" ), rec( torso:=[ 45 ] ) );</span>
[ ]
<span class="GAPprompt">gap></span> <span class="GAPinput">k:= filt[3];;</span>
</pre></div>
<p>The list of maximal subgroups of <span class="SimpleMath">\(Co_1\)</span> (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 183]</a>) tells us that <span class="SimpleMath">\(NU / N\)</span> is a maximal subgroup <span class="SimpleMath">\(K\)</span> of <span class="SimpleMath">\(Co_1\)</span> and has the structure <span class="SimpleMath">\(2^{{2+12}}.(A_8 \times S_3)\)</span>. (Note that the group <span class="SimpleMath">\(M_{24}\)</span> has no proper subgroup of index <span class="SimpleMath">\(253\)</span>, which is shown above using the <span class="SimpleMath">\(11\)</span>-modular Brauer table of <span class="SimpleMath">\(M_{24}\)</span>. Furthermore, the group <span class="SimpleMath">\(O_8^+(2)\)</span> has no subgroup of index <span class="SimpleMath">\(45\)</span>.) In particular, <span class="SimpleMath">\(U\)</span> contains <span class="SimpleMath">\(N\)</span> and thus <span class="SimpleMath">\(U/N \cong K\)</span>.</p>
<p>Let <span class="SimpleMath">\(C\)</span> be the set of elements in <span class="SimpleMath">\(M\)</span> whose order is not divisible by <span class="SimpleMath">\(31\)</span> or <span class="SimpleMath">\(21\)</span>. We want to find an index set <span class="SimpleMath">\(I\)</span> and subgroups <span class="SimpleMath">\(X_i\)</span>, for <span class="SimpleMath">\(i \in I\)</span>, with the property that <span class="SimpleMath">\(V \leq X_i \leq U\)</span> and</p>
<p class="center">\[
(1_H)_{{C \cap H}} = \left( \sum_{{i \in I}} c_i 1_{{X_i}}^H \right)_{{C \cap H}}
\]</p>
<p>holds for suitable rational integers <span class="SimpleMath">\(c_i\)</span>. Let <span class="SimpleMath">\(W\)</span> be the full preimage of the elementary normal subgroup of order <span class="SimpleMath">\(16\)</span> in <span class="SimpleMath">\(U/V \cong 2^4.A_8\)</span> under the natural epimorphism from <span class="SimpleMath">\(U\)</span> to <span class="SimpleMath">\(U/V\)</span>, and set <span class="SimpleMath">\(I_1 = \{ i \in I; W \leq X_i \}\)</span> and <span class="SimpleMath">\(I_2 = I \setminus I_1\)</span>.</p>
<p>Using the known table of marks of <span class="SimpleMath">\(U/V\)</span>, we will find a solution such that <span class="SimpleMath">\([W:(W \cap X_i)] = 2\)</span> for all <span class="SimpleMath">\(i \in I_2\)</span>. First we compute the permutation characters <span class="SimpleMath">\(1_S^{{U/V}}\)</span> for all subgroups <span class="SimpleMath">\(S\)</span> of <span class="SimpleMath">\(U/V\)</span> that contain <span class="SimpleMath">\(W/V\)</span>, and induce them to <span class="SimpleMath">\(H/V\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">subtbl:= CharacterTable( "2^4:A8" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">subtom:= TableOfMarks( subtbl );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">perms:= PermCharsTom( subtbl, subtom );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">nsg:= ClassPositionsOfNormalSubgroups( subtbl );</span>
[ [ 1 ], [ 1, 2 ], [ 1 .. 25 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">above:= Filtered( perms, x -> x[1] = x[2] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">tbl:= CharacterTable( "L5(2)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">above:= Set( Induced( subtbl, tbl, above ) );;</span>
</pre></div>
<p>Next we compute the permutation characters <span class="SimpleMath">\(1_S^{{U/V}}\)</span> for all subgroups <span class="SimpleMath">\(S\)</span> of <span class="SimpleMath">\(U/V\)</span> whose intersection with <span class="SimpleMath">\(W/V\)</span> has index two in <span class="SimpleMath">\(W/V\)</span>. Afterwards we exclude certain subgroups that would slow down later computations, and induce also these characters to <span class="SimpleMath">\(H/V\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">index2:= Filtered( perms,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> Sum( PermCharInfo( subtbl, [x] ).contained[1]{ [1,2] } ) = 8 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">index2:= Filtered( index2, x -> not x[1] in [ 630, 840, 1260, 1680 ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">index2:= Set( Induced( subtbl, tbl, index2 ) );;</span>
</pre></div>
<p>Now we induce the permutation characters to <span class="SimpleMath">\(H/V\)</span>, and compute the coefficients of a linear combination as desired.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">orders:= OrdersClassRepresentatives( tbl );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">goodclasses:= Filtered( [ 1 .. NrConjugacyClasses( tbl ) ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> i -> not orders[i] in [ 21, 31 ] );</span>
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">matrix:= List( Concatenation( above, index2 ), x -> x{ goodclasses } );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">sol:= SolutionMat( matrix,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> ListWithIdenticalEntries( Length( goodclasses ), 1 ) );</span>
[ 692/651, 57/217, -78/217, -26/217, 0, 74/651, 11/217, 0, 3/217,
151/651, 0, 22/651, 0, 0, 0, -11/217, 0, 0, 0, 0, 0, 0, 0, 0,
-115/651, 0, -3/31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -34/93,
-11/651, 0, 2/21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1/31, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">nonzero:= Filtered( [ 1 .. Length( sol ) ], i -> sol[i] <> 0 );</span>
[ 1, 2, 3, 4, 6, 7, 9, 10, 12, 16, 25, 27, 106, 107, 109, 120 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">sol:= sol{ nonzero };;</span>
</pre></div>
<p>Now we transfer this linear combination to the character tables which are given in our situation.</p>
<p>Those constituents that are induced from subgroups of <span class="SimpleMath">\(H\)</span> above <span class="SimpleMath">\(W\)</span> can be identified uniquely via their degrees and their values distribution; we compute these characters in the character table of <span class="SimpleMath">\(U/W\)</span> obtained as a factor table of the character table of <span class="SimpleMath">\(U/N\)</span>, lift them back to <span class="SimpleMath">\(U/N\)</span>, induce them to <span class="SimpleMath">\(G/N\)</span>, inflate them to <span class="SimpleMath">\(G\)</span>, and then induce them fo <span class="SimpleMath">\(M\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">a8degrees:= List( above{ Filtered( nonzero,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> x <= Length( above ) ) },</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> x[1] ) / 31;</span>
[ 1, 8, 15, 28, 56, 56, 70, 105, 120, 168, 336, 336 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">a8tbl:= subtbl / [ 1, 2 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">invtoa8:= InverseMap( GetFusionMap( subtbl, a8tbl ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">nsg:= ClassPositionsOfNormalSubgroups( k );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">nn:= First( nsg, x -> Sum( SizesConjugacyClasses( k ){ x } ) = 6*2^14 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">a8tbl_other:= k / nn;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= CharacterTable( "MC2B" );</span>
CharacterTable( "2^1+24.Co1" )
<span class="GAPprompt">gap></span> <span class="GAPinput">constit:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for i in [ 1 .. Length( a8degrees ) ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> cand:= PermChars( a8tbl_other, rec( torso:= [ a8degrees[i] ] ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> filt:= Filtered( perms, x -> x^tbl = above[ nonzero[i] ] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> filt:= List( filt, x -> CompositionMaps( x, invtoa8 ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> cand:= Filtered( cand,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> ForAny( filt, y -> Collected( x ) = Collected(y) ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( constit, List( Induced( Restricted( Induced(</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Restricted( cand, k ), co1 ), g ), m ), ValuesOfClassFunction ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">List( constit, Length );</span>
[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]
</pre></div>
<p>Dealing with the remaining constituents is more involved. For a permutation character <span class="SimpleMath">\(1_{{X/V}}^{{U/V}}\)</span>, we compute <span class="SimpleMath">\(1_{{WX/V}}^{{U/V}}\)</span>, a character whose degree is half as large and which can be regarded as a character of <span class="SimpleMath">\(U/W\)</span>. This character can be treated like the ones above: We lift it to <span class="SimpleMath">\(U/N\)</span>, induce it to <span class="SimpleMath">\(G/N\)</span>, and inflate it to <span class="SimpleMath">\(G/Z(G)\)</span>; let this character be <span class="SimpleMath">\(1_Y^{{G/Z(G)}}\)</span>, for some subgroup <span class="SimpleMath">\(Y\)</span>. Then we compute the possible permutation characters of <span class="SimpleMath">\(G/Z(G)\)</span> that can be induced from a subgroup of index two inside <span class="SimpleMath">\(Y\)</span>, inflate these characters to <span class="SimpleMath">\(G\)</span> and then induce them to <span class="SimpleMath">\(M\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">downdegrees:= List( index2{ Filtered( nonzero,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> x > Length( above ) )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> - Length( above ) },</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> x[1] ) / 31;</span>
[ 30, 210, 210, 1920 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">f:= g / ClassPositionsOfCentre( g );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">forders:= OrdersClassRepresentatives( f );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">inv:= InverseMap( GetFusionMap( g, f ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for j in [ 1 .. Length( downdegrees ) ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> chars:= [];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> cand:= PermChars( a8tbl_other, rec( torso:= [ downdegrees[j]/2 ] ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> filt:= Filtered( perms, x -> x^tbl = index2[ nonzero[</span>
<span class="GAPprompt">></span> <span class="GAPinput"> j + Length( a8degrees ) ] - Length( above ) ] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> filt:= Induced( subtbl, a8tbl, filt,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> GetFusionMap( subtbl, a8tbl ));</span>
<span class="GAPprompt">></span> <span class="GAPinput"> cand:= Filtered( cand, x -> ForAny( filt,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> y -> Collected( x ) = Collected( y ) ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> cand:= Restricted( Induced( Restricted( cand, k ), co1 ), g );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for chi in cand do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> cchi:= CompositionMaps( chi, inv );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> upper:= [];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> pphi:= [];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for i in [ 1 .. NrConjugacyClasses( f ) ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if forders[i] mod 2 = 1 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> pphi[i]:= 2 * cchi[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif cchi[i] = 0 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> pphi[i]:= 0;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> upper[i]:= 2* cchi[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Append( chars, PermChars( f, rec( torso:= ShallowCopy( pphi ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> upper:= upper,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> normalsubgroup:= [ 1 .. 4 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> nonfaithful:= cchi ) ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( constit, List( Induced( Restricted( chars, g ), m ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> ValuesOfClassFunction ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">List( constit, Length );</span>
[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 10, 10, 2 ]
</pre></div>
<p>Now we form the possible linear combinations.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= List( Cartesian( constit ), l -> sol * l );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">m:= CharacterTable( "M" );</span>
CharacterTable( "M" )
<span class="GAPprompt">gap></span> <span class="GAPinput">morders:= OrdersClassRepresentatives( m );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for x in cand do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for i in [ 1 .. Length( morders ) ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if morders[i] mod 31 = 0 or morders[i] mod 21 = 0 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Unbind( x[i] );</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>
</pre></div>
<p>Exactly one of the candidates has only integral values.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= Filtered( cand, x -> ForAll( x, IsInt ) );</span>
[ [ 391965121389536908413379198941796875, 23914487292951376996875,
474163138042468875, 9500455925885925, 646346515815,
334363486275, 954161764875, 147339103275, 1481392395,
1313281515, 0, 8203125, 9827885925, 1216215, 91556325, 9388791,
115911, 587331, 874650, 0, 79515, 581955, 336375, 104371,
62331, 36855, 0, 0, 0, 0, 28125, 525, 1125, 0, 188325, 16767,
88965, 2403, 9477, 1155, 891, 207, 351, 627, 0, 0, 4410, 1498,
0, 0, 0, 30, 150, 91, 151, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 125,
0, 5, 5,,,,, 0, 0, 0, 0, 141, 45, 27, 61, 27, 9, 9, 7, 3, 15,
0, 0, 0, 0, 0, 98, 74, 42, 0, 0, 30, 0, 0, 0, 6, 6, 6,,, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,,,,, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0,
0, 0, 2, 2, 0, 2,,, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,,,, 0,
0, 0, 0, 0, 0,,, 0, 0, 0, 0, 0, 0,, 0, 0, 0 ] ]
</pre></div>
<p>Now we compute the possible permutation characters that have the prescribed values.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= PermChars( m, rec( torso:= cand[1] ) );</span>
[ Character( CharacterTable( "M" ),
[ 391965121389536908413379198941796875, 23914487292951376996875,
474163138042468875, 9500455925885925, 646346515815,
334363486275, 954161764875, 147339103275, 1481392395,
1313281515, 0, 8203125, 9827885925, 1216215, 91556325, 9388791,
115911, 587331, 874650, 0, 79515, 581955, 336375, 104371,
62331, 36855, 0, 0, 0, 0, 28125, 525, 1125, 0, 188325, 16767,
88965, 2403, 9477, 1155, 891, 207, 351, 627, 0, 0, 4410, 1498,
0, 0, 0, 30, 150, 91, 151, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 125,
0, 5, 5, 210, 0, 42, 0, 0, 0, 0, 0, 141, 45, 27, 61, 27, 9, 9,
7, 3, 15, 0, 0, 0, 0, 0, 98, 74, 42, 0, 0, 30, 0, 0, 0, 6, 6,
6, 3, 3, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 0, 18, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 2, 3, 3, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0 ] ) ]
</pre></div>
<p>There is only one candidate, so we have found the permutation character.</p>
<p><a id="X7F2ABD3E7AFF5F6E" name="X7F2ABD3E7AFF5F6E"></a></p>
<h5>8.16-4 <span class="Heading">The Subgroup <span class="SimpleMath">\(2^{{10+16}}.O_{10}^+(2)\)</span> (November 2009)</span></h5>
<p>According to the Atlas of Finite Groups <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 234]</a>, the Monster group <span class="SimpleMath">\(M\)</span> has a class of maximal subgroups <span class="SimpleMath">\(H\)</span> of the type <span class="SimpleMath">\(2^{{10+16}}.O_{10}^+(2)\)</span>. Currently the character table of <span class="SimpleMath">\(H\)</span> and the class fusion into <span class="SimpleMath">\(M\)</span> are not available in <strong class="pkg">GAP</strong>. We are interested in the permutation character <span class="SimpleMath">\(1_H^M\)</span>, and we will compute it without this information.</p>
<p>The subgroup <span class="SimpleMath">\(H\)</span> normalizes an elementary abelian group <span class="SimpleMath">\(E\)</span> of order <span class="SimpleMath">\(2^{10}\)</span> which contains <span class="SimpleMath">\(496\)</span> involutions in the class <code class="code">2A</code> and <span class="SimpleMath">\(527\)</span> involutions in the class <code class="code">2B</code>. Let <span class="SimpleMath">\(V\)</span> denote the normal subgroup of order <span class="SimpleMath">\(2^{26}\)</span> in <span class="SimpleMath">\(H\)</span>, and set <span class="SimpleMath">\(\bar{H} = H/N\)</span>. Since the smallest two indices of maximal subgroups of <span class="SimpleMath">\(\bar{H}\)</span> are <span class="SimpleMath">\(496\)</span> and <span class="SimpleMath">\(527\)</span>, respectively, <span class="SimpleMath">\(H\)</span> acts transitively on both the <code class="code">2A</code> and the <code class="code">2B</code> involutions in <span class="SimpleMath">\(E\)</span>, and the centralizers of these involutions contain <span class="SimpleMath">\(V\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">Hbar:= CharacterTable( "O10+(2)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">U_Abar:= CharacterTable( "O10+(2)M1" );</span>
CharacterTable( "S8(2)" )
<span class="GAPprompt">gap></span> <span class="GAPinput">Index( Hbar, U_Abar );</span>
496
<span class="GAPprompt">gap></span> <span class="GAPinput">U_Bbar:= CharacterTable( "O10+(2)M2" );</span>
CharacterTable( "2^8:O8+(2)" )
<span class="GAPprompt">gap></span> <span class="GAPinput">Index( Hbar, U_Bbar );</span>
527
</pre></div>
<p>We fix a <code class="code">2A</code> involution <span class="SimpleMath">\(z_A\)</span> in <span class="SimpleMath">\(E\)</span>, and set <span class="SimpleMath">\(G_A = C_M(z_A)\)</span> and <span class="SimpleMath">\(U_A = C_H(z_A)\)</span>. So <span class="SimpleMath">\(G_A\)</span> has the structure <span class="SimpleMath">\(2.B\)</span> and <span class="SimpleMath">\(U_A\)</span> has the structure <span class="SimpleMath">\(2^{{10+16}}.S_8(2)\)</span>. From the list of maximal subgroups of <span class="SimpleMath">\(B\)</span> we see that the image of <span class="SimpleMath">\(G_A\)</span> under the natural epimorphism from <span class="SimpleMath">\(G_A\)</span> to <span class="SimpleMath">\(B\)</span> is a maximal subgroup of <span class="SimpleMath">\(B\)</span> and has the structure <span class="SimpleMath">\(2^{{9+16}}.S_8(2)\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">b:= CharacterTable( "B" );</span>
CharacterTable( "B" )
<span class="GAPprompt">gap></span> <span class="GAPinput">Horder:= 2^26 * Size( Hbar );</span>
1577011055923770163200
<span class="GAPprompt">gap></span> <span class="GAPinput">order:= Horder / ( 2 * 496 );</span>
1589728887019929600
<span class="GAPprompt">gap></span> <span class="GAPinput">maxes:= List( Maxes( b ), CharacterTable );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">filt:= Filtered( maxes, t -> Size( t ) mod order = 0 );</span>
[ CharacterTable( "2^(9+16).S8(2)" ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( filt, t -> Size( t ) / order );</span>
[ 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">u1:= filt[1];</span>
CharacterTable( "2^(9+16).S8(2)" )
</pre></div>
<p>Analogously, we fix a <code class="code">2B</code> involution <span class="SimpleMath">\(z_B\)</span> in <span class="SimpleMath">\(E\)</span>, and set <span class="SimpleMath">\(G_B = C_M(z_B)\)</span> and <span class="SimpleMath">\(U_B = C_H(z_B)\)</span>, Further, let <span class="SimpleMath">\(N\)</span> be the extraspecial normal subgroup of order <span class="SimpleMath">\(2^{25}\)</span> in <span class="SimpleMath">\(G_B\)</span>. So <span class="SimpleMath">\(G_B\)</span> has the structure <span class="SimpleMath">\(2^{{1+24}}_+.Co_1\)</span>, and <span class="SimpleMath">\(U_B\)</span> has index <span class="SimpleMath">\(527\)</span> in <span class="SimpleMath">\(G_B\)</span>. From the list of maximal subgroups of <span class="SimpleMath">\(Co_1\)</span> we see that the image of <span class="SimpleMath">\(U_B\)</span> under the natural epimorphism from <span class="SimpleMath">\(G_B\)</span> to <span class="SimpleMath">\(Co_1\)</span> is a maximal subgroup of <span class="SimpleMath">\(Co_1\)</span> and has the structure <span class="SimpleMath">\(2^{{1+8}}_+.O_8^+(2)\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">co1:= CharacterTable( "Co1" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">order:= Horder / ( 2^25 * 527 );</span>
89181388800
<span class="GAPprompt">gap></span> <span class="GAPinput">maxes:= List( Maxes( co1 ), CharacterTable );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">filt:= Filtered( maxes, t -> Size( t ) mod order = 0 );</span>
[ CharacterTable( "2^(1+8)+.O8+(2)" ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( filt, t -> Size( t ) / order );</span>
[ 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">u2:= filt[1];</span>
CharacterTable( "2^(1+8)+.O8+(2)" )
</pre></div>
<p>First we compute the permutation characters <span class="SimpleMath">\(\pi_A = 1_{{U_A}}^M\)</span> and <span class="SimpleMath">\(\pi_B = 1_{{U_B}}^M\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">m:= CharacterTable( "M" );</span>
CharacterTable( "M" )
<span class="GAPprompt">gap></span> <span class="GAPinput">2b:= CharacterTable( "MC2A" );</span>
CharacterTable( "2.B" )
<span class="GAPprompt">gap></span> <span class="GAPinput">mm:= CharacterTable( "MC2B" );</span>
CharacterTable( "2^1+24.Co1" )
<span class="GAPprompt">gap></span> <span class="GAPinput">pi_A:= RestrictedClassFunction( TrivialCharacter( u1 )^b, 2b )^m;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">pi_B:= RestrictedClassFunction( TrivialCharacter( u2 )^co1, mm )^m;;</span>
</pre></div>
<p>The degree of <span class="SimpleMath">\(1_H^M\)</span> is of course known.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">torso:= [ Size( m ) / Horder ];</span>
[ 512372707698741056749515292734375 ]
</pre></div>
<p>Next we compute some zero values of <span class="SimpleMath">\(1_H^M\)</span>, using the following conditions.</p>
<ul>
<li><p>For <span class="SimpleMath">\(g \in M\)</span>, if <span class="SimpleMath">\(|g|\)</span> does not divide <span class="SimpleMath">\(|H|\)</span> or if <span class="SimpleMath">\(|g|\)</span> is not the product of an element order in <span class="SimpleMath">\(H/V\)</span> and a <span class="SimpleMath">\(2\)</span>-power. (In fact we could use that the exponent of <span class="SimpleMath">\(V\)</span> is <span class="SimpleMath">\(4\)</span>, but this would not improve the result.)</p>
</li>
<li><p>Let <span class="SimpleMath">\(U \leq H \leq G\)</span>, and let <span class="SimpleMath">\(p\)</span> be a prime that does not divide <span class="SimpleMath">\([H:U]\)</span>. Then <span class="SimpleMath">\(U\)</span> contains a Sylow <span class="SimpleMath">\(p\)</span> subgroup of <span class="SimpleMath">\(H\)</span>, so each element of order <span class="SimpleMath">\(p\)</span> in <span class="SimpleMath">\(H\)</span> is conjugate in <span class="SimpleMath">\(H\)</span> to an element in <span class="SimpleMath">\(U\)</span>. For <span class="SimpleMath">\(g \in G\)</span>, <span class="SimpleMath">\(g = g_p h\)</span>, where the order of <span class="SimpleMath">\(g_p\)</span> is a power of <span class="SimpleMath">\(p\)</span> such that <span class="SimpleMath">\(1_U^G(g_p) = 0\)</span> holds, we have <span class="SimpleMath">\(1_H^G(g) = 0\)</span>. We apply this to <span class="SimpleMath">\(U \in \{ U_A, U_B \}\)</span>.</p>
</li>
</ul>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">morders:= OrdersClassRepresentatives( m );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">2parts:= Union( [ 1 ], Filtered( Set( morders ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> IsPrimePowerInt( x ) and IsEvenInt( x ) ) );</span>
[ 1, 2, 4, 8, 16, 32 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">factorders:= Set( OrdersClassRepresentatives( Hbar ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">primes_A:= Filtered( PrimeDivisors( Horder ), p -> 496 mod p <> 0 );</span>
[ 3, 5, 7, 17 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">primes_B:= Filtered( PrimeDivisors( Horder ), p -> 527 mod p <> 0 );</span>
[ 2, 3, 5, 7 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">primes:= Union( primes_A, primes_B );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">n:= NrConjugacyClasses( m );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for i in [ 1 .. n ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if Horder mod morders[i] <> 0 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> torso[i]:= 0;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif ForAll( factorders, x -> not morders[i] / x in 2parts ) then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> torso[i]:= 0;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for p in primes do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if morders[i] mod p = 0 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> pprime:= morders[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> while pprime mod p = 0 do pprime:= pprime / p; od;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> pos:= PowerMap( m, pprime )[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if p in primes_A and pi_A[ pos ] = 0 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> torso[i]:= 0;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif p in primes_B and pi_B[ pos ] = 0 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> torso[i]:= 0;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</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"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput">od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">torso;</span>
[ 512372707698741056749515292734375,,,,, 0,,,,,,,,,,,, 0,, 0,,,,,,,,,,
,,,, 0,,,, 0,,,,,, 0, 0, 0,,, 0,,,, 0,,,,,,,,,, 0,,,,,,,, 0, 0, 0,
0, 0, 0, 0,,,,, 0,,,,, 0, 0, 0, 0, 0, 0,,,, 0, 0,,,,, 0,,,,,,, 0, 0,
, 0, 0,,,,, 0, 0, 0, 0, 0,,,,, 0,, 0, 0, 0, 0, 0,, 0, 0, 0, 0, 0, 0,
, 0,, 0, 0, 0, 0,, 0, 0, 0, 0, 0,,,,,, 0,,, 0, 0,, 0, 0, 0, 0, 0,
0, 0, 0, 0,, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0 ]
</pre></div>
<p>Now we want to compute as many nonzero values of <span class="SimpleMath">\(1_H^M\)</span> as possible, using the same approach as in the previous sections. For that, we first compute several permutation characters <span class="SimpleMath">\(1_X^M\)</span>, for subgroups <span class="SimpleMath">\(X\)</span> with the property <span class="SimpleMath">\(V < X < U_A\)</span> or <span class="SimpleMath">\(V < X < U_B\)</span>. Then we find several subsets <span class="SimpleMath">\(C\)</span> of <span class="SimpleMath">\(M\)</span>, each being a union of conjugacy classes of <span class="SimpleMath">\(M\)</span> such that <span class="SimpleMath">\((1_H)_{{C \cap H}}\)</span> is a linear combination of the characters <span class="SimpleMath">\(1_X^H\)</span>, restricted to <span class="SimpleMath">\(C \cap H\)</span>. This yields the values of <span class="SimpleMath">\(1_H^M\)</span> on the classes in <span class="SimpleMath">\(C\)</span>.</p>
<p>The actual computations are performed with the characters <span class="SimpleMath">\(1_{{X/V}}^{{H/V}}\)</span>. So we build two parallel lists <code class="code">cand</code> and <code class="code">candbar</code> of permutation characters of <span class="SimpleMath">\(M\)</span> and of <span class="SimpleMath">\(H/V\)</span>, respectively. For that, we write two small <strong class="pkg">GAP</strong> functions:</p>
<ul>
<li><p>In the function <code class="code">AddSubgroupOfS82</code>, we choose a subgroup <span class="SimpleMath">\(Y\)</span> of <span class="SimpleMath">\(S_8(2) \cong U_A/V\)</span>, compute <span class="SimpleMath">\(1_Y^{{U_A/V}}\)</span>, inflate it to a character of <span class="SimpleMath">\(U_A\)</span>, induce this character to <span class="SimpleMath">\(B\)</span>, inflate the result to <span class="SimpleMath">\(G_A\)</span>, and finally induce this character to <span class="SimpleMath">\(M\)</span>.</p>
</li>
<li><p>In the function <code class="code">AddSubgroupOfO8p2</code>, we choose a subgroup <span class="SimpleMath">\(Y\)</span> of the factor group <span class="SimpleMath">\(F \cong O_8^+(2)\)</span> of <span class="SimpleMath">\(U_B/N\)</span>, compute <span class="SimpleMath">\(1_Y^F\)</span>, inflate it to a character of <span class="SimpleMath">\(U_B/N\)</span>, induce this to a character of <span class="SimpleMath">\(G_B/N \cong Co_1\)</span>, inflate this to a character of <span class="SimpleMath">\(G_B\)</span>, and finally induce this character to <span class="SimpleMath">\(M\)</span>.</p>
<p>One difficulty in this case is that choosing a subgroup <span class="SimpleMath">\(X/V\)</span> of <span class="SimpleMath">\(H/V\)</span> involves fixing the class fusion into <span class="SimpleMath">\(H/V\)</span>, but it is not clear which is a compatible class fusion of the corresponding subgroup <span class="SimpleMath">\(X\)</span> into <span class="SimpleMath">\(M\)</span>; therefore, each entry of <code class="code">cand</code> is in fact not the permutation character of <span class="SimpleMath">\(M\)</span> in question but a list of possibilities.</p>
</li>
</ul>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= [ [ pi_A ], [ pi_B ] ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">candbar:= [ TrivialCharacter( U_Abar )^Hbar,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> TrivialCharacter( U_Bbar )^Hbar ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AddSubgroupOfS82:= function( subname )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> local psis82;</span>
<span class="GAPprompt">></span> <span class="GAPinput"></span>
<span class="GAPprompt">></span> <span class="GAPinput"> psis82:= TrivialCharacter( CharacterTable( subname ) )^U_Abar;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( cand, [ Restricted( Restricted( psis82, u1 )^b, 2b )^m ] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( candbar, psis82 ^ Hbar );</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">tt1:= CharacterTable( "O8+(2)" );</span>
CharacterTable( "O8+(2)" )
<span class="GAPprompt">gap></span> <span class="GAPinput">AddSubgroupOfO8p2:= function( subname )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> local psi, list, char;</span>
<span class="GAPprompt">></span> <span class="GAPinput"></span>
<span class="GAPprompt">></span> <span class="GAPinput"> psi:= TrivialCharacter( CharacterTable( subname ) )^tt1;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> list:= [];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for char in Orbit( AutomorphismsOfTable( tt1 ), psi, Permuted ) do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> AddSet( list, Restricted( Restricted( char, u2 ) ^ co1, mm ) ^ m );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( cand, list );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( candbar, Restricted( psi, U_Bbar ) ^ Hbar );</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;;</span>
</pre></div>
<p>Now we choose the subgroups that will turn out to be sufficient for our computations.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">AddSubgroupOfS82( "O8+(2).2" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AddSubgroupOfO8p2( "S6(2)" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AddSubgroupOfS82( "O8-(2).2" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AddSubgroupOfS82( "A10.2" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AddSubgroupOfS82( "S4(4).2" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AddSubgroupOfS82( "L2(17)" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AddSubgroupOfO8p2( "A9" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AddSubgroupOfO8p2( "2^6:A8" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AddSubgroupOfO8p2( "(3xU4(2)):2" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AddSubgroupOfO8p2( "(A5xA5):2^2" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">AddSubgroupOfS82( "S8(2)M4" );</span>
</pre></div>
<p>In the case of <span class="SimpleMath">\(A_5 < S_8(2)\)</span>, the function <code class="code">AddSubgroupOfS82</code> does not work because there are several class fusions of <span class="SimpleMath">\(A_5\)</span> into <span class="SimpleMath">\(S_8(2)\)</span>. We choose one fusion; the fact that it really describes an embedding of an <span class="SimpleMath">\(A_5\)</span> type subgroup of <span class="SimpleMath">\(S_8(2)\)</span> can be checked using the function <code class="func">NrPolyhedralSubgroups</code> (<a href="../../../doc/ref/chap71_mj.html#X83AE05BF8085B3C8"><span class="RefLink">Reference: NrPolyhedralSubgroups</span></a>).</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">a5:= CharacterTable( "A5" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= PossibleClassFusions( a5, U_Abar )[1];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">NrPolyhedralSubgroups( U_Abar, fus[2], fus[3], fus[4] );</span>
rec( number := 548352, type := "A5" )
<span class="GAPprompt">gap></span> <span class="GAPinput">psis82:= Induced( a5, U_Abar, [ TrivialCharacter( a5 ) ], fus )[1];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Add( cand, [ Restricted( Restricted( psis82, u1 )^b, 2b )^m ] );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Add( candbar, psis82 ^ Hbar );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">List( cand, Length );</span>
[ 1, 1, 1, 2, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1 ]
</pre></div>
<p>The following function takes a condition on conjugacy classes in terms of their element orders, which gives a set <span class="SimpleMath">\(C\)</span> of elements in <span class="SimpleMath">\(M\)</span>. It forms the corresponding set of elements in <span class="SimpleMath">\(H/V\)</span> and tries to express the restriction of <span class="SimpleMath">\(1_{{H/V}}\)</span> as a linear combination of the characters <span class="SimpleMath">\(1_X^{{H/V}}\)</span> that are stored in the list <code class="code">candbar</code>. If this works and if the corresponding linear combination of the candidates in <code class="code">cand</code> is unique, the newly found values of <span class="SimpleMath">\(1_H^M\)</span> are entered into the list <code class="code">torso</code>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">Hbarorders:= OrdersClassRepresentatives( Hbar );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">TryCondition:= function( cond )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> local pos, sol, lincomb, oldknown, i;</span>
<span class="GAPprompt">></span> <span class="GAPinput"></span>
<span class="GAPprompt">></span> <span class="GAPinput"> pos:= Filtered( [ 1 .. Length( Hbarorders ) ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> i -> cond( Hbarorders[i] ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> sol:= SolutionMat( candbar{[1..Length(candbar)]}{ pos },</span>
<span class="GAPprompt">></span> <span class="GAPinput"> ListWithIdenticalEntries( Length( pos ), 1 ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if sol = fail then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return "no solution";</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"></span>
<span class="GAPprompt">></span> <span class="GAPinput"> pos:= Filtered( [ 1 .. Length( morders) ], i -> cond( morders[i] ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> lincomb:= Filtered( Set( Cartesian( cand ), x -> sol * x ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> ForAll( pos, i -> IsPosInt( x[i] ) or x[i] = 0 ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if Length( lincomb ) <> 1 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return "solution is not unique";</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"></span>
<span class="GAPprompt">></span> <span class="GAPinput"> lincomb:= lincomb[1];;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> oldknown:= Number( torso );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for i in pos do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if IsBound( torso[i] ) then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if torso[i] <> lincomb[i] then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Error( "contradiction of new and known value at position ", i );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif not IsInt( lincomb[i] ) or lincomb[i] < 0 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Error( "new value at position ", i, " is not a nonneg. integer" );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> torso[i]:= lincomb[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return Concatenation( "now ", String( Number( torso ) ), " values (",</span>
<span class="GAPprompt">></span> <span class="GAPinput"> String( Number( torso ) - oldknown ), " new)" );</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;;</span>
</pre></div>
<p>This procedure makes sense only if the elements of <span class="SimpleMath">\(H\)</span> that satisfy the condition are contained in the full preimage of the classes of <span class="SimpleMath">\(H/V\)</span> that satisfy the condition. Note that this is in fact the case for the conditions used below. This is clear for condition concerning only <em>odd</em> element orders, because <span class="SimpleMath">\(V\)</span> is a <span class="SimpleMath">\(2\)</span>-group. Also the set of all elements of the orders <span class="SimpleMath">\(9\)</span>, <span class="SimpleMath">\(18\)</span>, and <span class="SimpleMath">\(36\)</span> is such a "closed" set, since <span class="SimpleMath">\(M\)</span> has no elements of order <span class="SimpleMath">\(72\)</span>. Finally, the set of all elements of the orders <span class="SimpleMath">\(1\)</span>, <span class="SimpleMath">\(2\)</span>, and <span class="SimpleMath">\(4\)</span> in <span class="SimpleMath">\(H\)</span> is admissible because it is contained in the preimage of the set of all elements of these orders in <span class="SimpleMath">\(H/V\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">TryCondition( x -> x mod 7 = 0 and x mod 3 <> 0 );</span>
"now 99 values (7 new)"
<span class="GAPprompt">gap></span> <span class="GAPinput">TryCondition( x -> x mod 17 = 0 and x mod 3 <> 0 );</span>
"now 102 values (3 new)"
<span class="GAPprompt">gap></span> <span class="GAPinput">TryCondition( x -> x mod 5 = 0 and x mod 3 <> 0 );</span>
"now 119 values (17 new)"
<span class="GAPprompt">gap></span> <span class="GAPinput">TryCondition( x -> 4 mod x = 0 );</span>
"now 125 values (6 new)"
<span class="GAPprompt">gap></span> <span class="GAPinput">TryCondition( x -> 9 mod x = 0 );</span>
"now 129 values (4 new)"
<span class="GAPprompt">gap></span> <span class="GAPinput">TryCondition( x -> x in [ 9, 18, 36 ] );</span>
"now 138 values (9 new)"
</pre></div>
<p>Possible constituents of <span class="SimpleMath">\(1_H^M\)</span> are those rational irreducible characters of <span class="SimpleMath">\(M\)</span> that are constituents of <span class="SimpleMath">\(\pi^M\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">constit:= Filtered( RationalizedMat( Irr( m ) ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> ScalarProduct( m, x, pi_A ) <> 0</span>
<span class="GAPprompt">></span> <span class="GAPinput"> and ScalarProduct( m, x, pi_B ) <> 0 );;</span>
</pre></div>
<p>For the missing values, we can provide at least lower bounds, using that <span class="SimpleMath">\(U \leq H \leq G\)</span> implies <span class="SimpleMath">\(1_H^G(g) \geq 1_U^G(g) / [H:U] = [G:H] \cdot 1_U^G(g) / 1_U^G(1)\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">lower:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Hindex:= Size( m ) / Horder;</span>
512372707698741056749515292734375
<span class="GAPprompt">gap></span> <span class="GAPinput">for i in [ 1 .. NrConjugacyClasses( m ) ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> lower[i]:= Maximum( pi_A[i] / ( pi_A[1] / Hindex ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> pi_B[i] / ( pi_B[1] / Hindex ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if not IsInt( lower[i] ) then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> lower[i]:= Int( lower[i] + 1 );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput">od;</span>
</pre></div>
<p>Now we compute the possible permutation characters that have the prescribed values, are compatible with the given lower bounds for values, and have only constituents in the given list.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand:= PermChars( m, rec( torso:= torso, chars:= constit,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> lower:= lower, normalsubgroup:= [ 1 .. NrConjugacyClasses( m ) ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> nonfaithful:= TrivialCharacter( m ) ) );</span>
[ Character( CharacterTable( "M" ),
[ 512372707698741056749515292734375, 405589064025344574375,
29628786742129575, 658201521662685, 215448838605, 0,
121971774375, 28098354375, 335229607, 108472455, 164587500,
4921875, 2487507165, 2567565, 26157789, 6593805, 398925, 0,
437325, 0, 44983, 234399, 90675, 21391, 41111, 12915, 6561,
6561, 177100, 7660, 6875, 315, 275, 0, 113373, 17901, 57213, 0,
4957, 1197, 909, 301, 397, 0, 0, 0, 3885, 525, 0, 2835, 90, 45,
0, 103, 67, 43, 28, 81, 189, 9, 9, 9, 0, 540, 300, 175, 20, 15,
7, 420, 0, 0, 0, 0, 0, 0, 0, 165, 61, 37, 37, 0, 9, 9, 13, 5,
0, 0, 0, 0, 0, 0, 77, 45, 13, 0, 0, 45, 115, 19, 10, 0, 5, 5,
9, 9, 1, 1, 0, 0, 4, 0, 0, 9, 9, 3, 1, 0, 0, 0, 0, 0, 0, 4, 1,
1, 0, 24, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 1, 0, 4, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 3, 3, 1, 1, 2, 0, 3, 3, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0 ] ) ]
</pre></div>
<p>There is only one candidate, so we have found the permutation character.</p>
<p>The character table of <span class="SimpleMath">\(H\)</span> is available since 2023. We can compute the permutation character directly from this table.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">h:= CharacterTable( "2^(10+16).O10+(2)" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fus:= PossibleClassFusions( h, m );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">cand = Set( fus, map -> InducedClassFunctionsByFusionMap( h, m,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ TrivialCharacter( h ) ], map )[1] );</span>
true
</pre></div>
<p><a id="X87D11B097D95D027" name="X87D11B097D95D027"></a></p>
<h4>8.17 <span class="Heading">A permutation character of the Baby Monster (June 2012)</span></h4>
<p>We compute the character of the Baby Monster that is induced from the trivial character of a Sylow <span class="SimpleMath">\(2\)</span>-subgroup. (Gabriel Navarro had asked me how <strong class="pkg">GAP</strong> can compute this character.) We start with the computation of those transitive permutation characters of the symmetric group on five points that have degree <span class="SimpleMath">\(15\)</span>. Note that the function <code class="func">PermChars</code> (<a href="../../../doc/ref/chap72_mj.html#X7D02541482C196A6"><span class="RefLink">Reference: PermChars</span></a>) computes in general only candidates, but here we are sure that the result consists of permutation characters because it is unique.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "S5" );</span>
CharacterTable( "A5.2" )
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= PermChars( t, rec( torso:= [ 15 ] ) );</span>
[ Character( CharacterTable( "A5.2" ), [ 15, 3, 0, 0, 3, 1, 0 ] ) ]
</pre></div>
<p>Next, we regard this character as a character of the group <span class="SimpleMath">\(2^5:S_5\)</span> that occurs as a maximal subgroup of index <span class="SimpleMath">\(231\)</span> in <span class="SimpleMath">\(M_{22}:2\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">m222:= CharacterTable( "M22.2" );</span>
CharacterTable( "M22.2" )
<span class="GAPprompt">gap></span> <span class="GAPinput">mx:= List( Maxes( m222 ), CharacterTable );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">mx:= Filtered( mx, x -> Size( m222 ) / Size( x ) = 231 );</span>
[ CharacterTable( "M22.2M4" ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= pi[1]{ GetFusionMap( mx[1], t ) };</span>
[ 15, 15, 3, 3, 3, 0, 0, 3, 3, 1, 1, 0, 15, 15, 3, 3, 3, 0, 0, 3, 3,
1, 1, 0 ]
</pre></div>
<p>We induce this character to <span class="SimpleMath">\(M_{22}:2\)</span>. (Note that this is the character that is induced from the trivial character of a Sylow <span class="SimpleMath">\(2\)</span>-subgroup of <span class="SimpleMath">\(M_{22}:2\)</span>.)</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= InducedClassFunction( mx[1], pi, m222 );</span>
ClassFunction( CharacterTable( "M22.2" ),
[ 3465, 105, 0, 9, 5, 0, 0, 0, 0, 1, 0, 189, 45, 9, 13, 0, 1, 0, 0,
0, 0 ] )
</pre></div>
<p>Next, we regard this character as a character of the group <span class="SimpleMath">\(2^{10}:M_{22}:2\)</span> that occurs as a maximal subgroup of index <span class="SimpleMath">\(46575\)</span> in <span class="SimpleMath">\(Co_2\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">co2:= CharacterTable( "Co2" );</span>
CharacterTable( "Co2" )
<span class="GAPprompt">gap></span> <span class="GAPinput">mx:= List( Maxes( co2 ), CharacterTable );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">mx:= Filtered( mx, x -> Size( co2 ) / Size( x ) = 46575 );</span>
[ CharacterTable( "2^10:m22:2" ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= pi{ GetFusionMap( mx[1], m222 ) };</span>
[ 3465, 3465, 3465, 3465, 105, 105, 105, 105, 105, 105, 105, 105, 0,
0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 1, 1, 0, 189, 189, 189, 189, 189, 189, 45, 45, 45, 45,
9, 9, 9, 9, 13, 13, 13, 13, 13, 13, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0 ]
</pre></div>
<p>We induce this character to <span class="SimpleMath">\(Co_2\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= InducedClassFunction( mx[1], pi, co2 );</span>
ClassFunction( CharacterTable( "Co2" ),
[ 161382375, 626535, 162855, 27495, 0, 0, 6615, 3975, 2727, 855,
567, 975, 115, 0, 0, 0, 0, 0, 0, 0, 0, 0, 63, 51, 19, 27, 35, 7, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0 ] )
</pre></div>
<p>Next, we regard this character as a character of the group <span class="SimpleMath">\(2^{{1+22}}.Co_2\)</span> that occurs as a maximal subgroup of index <span class="SimpleMath">\(11707448673375\)</span> in the Baby Monster.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">b:= CharacterTable( "B" );</span>
CharacterTable( "B" )
<span class="GAPprompt">gap></span> <span class="GAPinput">mx:= List( Maxes( b ), CharacterTable );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">mx:= Filtered( mx, x -> Size( b ) / Size( x ) = 11707448673375 );</span>
[ CharacterTable( "2^(1+22).Co2" ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= pi{ GetFusionMap( mx[1], co2 ) };;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">pi[1];</span>
161382375
</pre></div>
<p>We induce this character to the Baby Monster.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= InducedClassFunction( mx[1], pi, b );</span>
ClassFunction( CharacterTable( "B" ),
[ 1889375872099856765625, 2609385408855225, 62316674429625,
207818526825, 268788490425, 0, 0, 13052741625, 7537207545,
128298681, 270580905, 46366425, 74315385, 35633385, 3937689,
201825, 1233225, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 713097,
241425, 320625, 88521, 275265, 57705, 19305, 20089, 9441, 6489,
2577, 1825, 5345, 753, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
273, 417, 105, 97, 185, 33, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] )
</pre></div>
<p><a id="X86827FA97D27F3A2" name="X86827FA97D27F3A2"></a></p>
<h4>8.18 <span class="Heading">A permutation character of <span class="SimpleMath">\(2.B\)</span> (October 2017)</span></h4>
<p>We compute the character of the double cover <span class="SimpleMath">\(2.B\)</span> of the Baby Monster that is induced from the trivial character of a subgroup <span class="SimpleMath">\(U\)</span> of the structure <span class="SimpleMath">\(2^{1+22}.McL\)</span>.</p>
<p>This subgroup occurs as the intersection of two conjugates of <span class="SimpleMath">\(2.B\)</span> inside the Monster group <span class="SimpleMath">\(M\)</span>. More precisely, we consider <span class="SimpleMath">\(2.B\)</span> as the centralizer of an involution <span class="SimpleMath">\(a\)</span> in <span class="SimpleMath">\(M\)</span>, and we are interested in the permutation action of <span class="SimpleMath">\(M\)</span> on the cosets of <span class="SimpleMath">\(2.B\)</span> (or, equivalently, on the conjugacy class in <span class="SimpleMath">\(M\)</span> of this involution). The restriction of this action to <span class="SimpleMath">\(2.B\)</span> has nine orbits. One of them has point stabilizer <span class="SimpleMath">\(U\)</span>.</p>
<p>Background information can be found in <a href="chapBib_mj.html#biBGMS89">[GJMS89]</a>. The decomposition into the nine orbits appears in Definition (3.4.9) on p 587, and our orbit is characterized in Table VII (on p. 582) by the facts that its points <span class="SimpleMath">\(c\)</span> have order <span class="SimpleMath">\(4\)</span> and the squares of <span class="SimpleMath">\(a c\)</span> lie in the class <code class="code">2B</code> of <span class="SimpleMath">\(M\)</span>. This implies that <span class="SimpleMath">\(a\)</span> and <span class="SimpleMath">\(c\)</span> do not commute, hence <span class="SimpleMath">\(a\)</span> does not lie in <span class="SimpleMath">\(U\)</span>.</p>
<p>From this description, we know that <span class="SimpleMath">\(U\)</span> is a subgroup of a maximal subgroup of the type <span class="SimpleMath">\(2^{2+22}.Co_2\)</span> in <span class="SimpleMath">\(2.B\)</span>, and the group <span class="SimpleMath">\(\langle U, a \rangle\)</span> has the type <span class="SimpleMath">\(2^{2+22}.McL\)</span>.</p>
<p>Thus we can proceed in two steps. First we induce the trivial character of <span class="SimpleMath">\(\langle U, a \rangle\)</span> to <span class="SimpleMath">\(2.B\)</span>. Then we use the variant of the <strong class="pkg">GAP</strong> function <code class="func">PermChars</code> (<a href="../../../doc/ref/chap72_mj.html#X7D02541482C196A6"><span class="RefLink">Reference: PermChars</span></a>) that allows us to prescribe the permutation character of the closure with a normal subgroup, which is <span class="SimpleMath">\(\langle a \rangle\)</span> in our case.</p>
<p>The first step can be performed by inducing the trivial character of <span class="SimpleMath">\(McL\)</span> to <span class="SimpleMath">\(Co_2\)</span>, <span class="SimpleMath">\(\ldots\)</span></p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">mcl:= CharacterTable( "McL" );</span>
CharacterTable( "McL" )
<span class="GAPprompt">gap></span> <span class="GAPinput">co2:= CharacterTable( "Co2" );</span>
CharacterTable( "Co2" )
<span class="GAPprompt">gap></span> <span class="GAPinput">ind:= Induced( mcl, co2, [ TrivialCharacter( mcl ) ] )[1];</span>
Character( CharacterTable( "Co2" ),
[ 47104, 0, 1024, 0, 16, 160, 0, 0, 0, 0, 64, 0, 0, 4, 24, 16, 0, 0,
0, 16, 0, 8, 0, 0, 0, 0, 0, 8, 4, 4, 0, 0, 2, 0, 0, 0, 0, 0, 0, 4,
0, 0, 2, 2, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 ] )
</pre></div>
<p><span class="SimpleMath">\(\ldots\)</span> regarding this character as a character of <span class="SimpleMath">\(2^{1+22}.Co_2\)</span>, <span class="SimpleMath">\(\ldots\)</span></p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">m:= CharacterTable( "BM2" );</span>
CharacterTable( "2^(1+22).Co2" )
<span class="GAPprompt">gap></span> <span class="GAPinput">infl:= ind{ GetFusionMap( m, co2 ) };</span>
[ 47104, 47104, 47104, 47104, 47104, 47104, 47104, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024,
1024, 1024, 1024, 1024, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 16, 16, 16, 16, 160, 160, 160, 160, 160, 160, 160, 160,
160, 160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 4, 4, 4, 24, 24, 24, 24, 24, 24, 24, 24, 16, 16, 16,
16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8,
8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 4,
4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4,
4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1 ]
</pre></div>
<p><span class="SimpleMath">\(\ldots\)</span> inducing this character to <span class="SimpleMath">\(B\)</span>, <span class="SimpleMath">\(\ldots\)</span></p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">b:= CharacterTable( "B" );</span>
CharacterTable( "B" )
<span class="GAPprompt">gap></span> <span class="GAPinput">ind:= Induced( m, b, [ infl ] )[1];</span>
ClassFunction( CharacterTable( "B" ),
[ 551467662310656000, 186911262720, 272993634304, 0, 634521600,
194594400, 69984, 8495104, 17465344, 129024, 276480, 2073600,
16384, 798720, 46080, 0, 5120, 138600, 1000, 110880, 252000,
112480, 432, 12960, 0, 1312, 8352, 864, 432, 0, 2520, 0, 2880,
2880, 3072, 2880, 0, 0, 256, 64, 1152, 576, 640, 192, 96, 0, 108,
2520, 744, 0, 104, 120, 40, 30, 160, 16, 1120, 1024, 0, 0, 96, 288,
64, 144, 0, 96, 0, 108, 16, 48, 0, 32, 12, 0, 0, 0, 168, 0, 104,
48, 0, 4, 0, 0, 0, 0, 32, 16, 8, 8, 0, 24, 12, 4, 0, 0, 0, 0, 24,
4, 24, 24, 0, 0, 0, 0, 4, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 8, 0, 16, 8, 4, 0, 0, 0, 0, 0, 4, 2,
2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] )
</pre></div>
<p><span class="SimpleMath">\(\ldots\)</span> and regarding the result as a character of <span class="SimpleMath">\(2.B\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">2b:= CharacterTable( "2.B" );</span>
CharacterTable( "2.B" )
<span class="GAPprompt">gap></span> <span class="GAPinput">infl:= ind{ GetFusionMap( 2b, b ) };</span>
[ 551467662310656000, 551467662310656000, 186911262720, 272993634304,
272993634304, 0, 634521600, 194594400, 194594400, 69984, 69984,
8495104, 17465344, 129024, 276480, 2073600, 2073600, 16384, 798720,
46080, 0, 5120, 138600, 138600, 1000, 1000, 110880, 252000, 112480,
112480, 432, 12960, 0, 1312, 1312, 8352, 864, 864, 432, 0, 2520,
2520, 0, 2880, 2880, 3072, 2880, 0, 0, 256, 64, 1152, 576, 576,
640, 192, 96, 0, 0, 108, 108, 2520, 744, 744, 0, 104, 104, 120, 40,
40, 30, 30, 160, 16, 1120, 1024, 0, 0, 0, 96, 288, 64, 144, 144, 0,
96, 0, 108, 108, 16, 48, 0, 32, 12, 12, 0, 0, 0, 0, 168, 0, 104,
104, 48, 0, 0, 4, 4, 0, 0, 0, 0, 32, 16, 8, 8, 8, 0, 0, 24, 12, 4,
4, 0, 0, 0, 0, 0, 0, 24, 4, 24, 24, 0, 0, 0, 0, 0, 4, 0, 0, 0, 6,
6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0,
0, 0, 0, 0, 0, 0, 8, 0, 16, 8, 4, 4, 0, 0, 0, 0, 0, 0, 4, 4, 2, 2,
2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
</pre></div>
<p>Now we have the character <span class="SimpleMath">\(\psi\)</span> that represents the "nonfaithful half" of the desired permutation character. We have to "fill it up" with faithful characters of <span class="SimpleMath">\(2.B\)</span> of total degree <span class="SimpleMath">\(\psi(1)\)</span> such that the sum with <span class="SimpleMath">\(\psi\)</span> can be a permutation character of <span class="SimpleMath">\(2.B\)</span>.</p>
<p>The <strong class="pkg">GAP</strong> function <code class="func">PermChars</code> (<a href="../../../doc/ref/chap72_mj.html#X7D02541482C196A6"><span class="RefLink">Reference: PermChars</span></a>) is designed for this situation. We specify the normal subgroup <span class="SimpleMath">\(N = \langle a \rangle\)</span> by listing the positions of its conjugacy classes in the character table of <span class="SimpleMath">\(2.B\)</span>, we enter the known permutation character <span class="SimpleMath">\(1_{{UN}}^{{2.B}}\)</span>, and of course we specify the degree of the possible permutation characters.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">centre:= ClassPositionsOfCentre( 2b );</span>
[ 1, 2 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">pi:= PermChars( 2b, rec( torso:= [ 2 * infl[1], 0 ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> normalsubgroup:= centre,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> nonfaithful:= infl ) );</span>
[ Character( CharacterTable( "2.B" ),
[ 1102935324621312000, 0, 186911262720, 541790208000, 4197060608,
0, 634521600, 389188800, 0, 139968, 0, 8495104, 17465344,
129024, 276480, 4026240, 120960, 16384, 798720, 46080, 0, 5120,
277200, 0, 2000, 0, 110880, 252000, 190080, 34880, 432, 12960,
0, 2592, 32, 8352, 1728, 0, 432, 0, 5040, 0, 0, 2880, 2880,
3072, 2880, 0, 0, 256, 64, 1152, 1008, 144, 640, 192, 96, 0, 0,
216, 0, 2520, 960, 528, 0, 200, 8, 120, 80, 0, 60, 0, 160, 16,
1120, 1024, 0, 0, 0, 96, 288, 64, 216, 72, 0, 96, 0, 216, 0,
16, 48, 0, 32, 24, 0, 0, 0, 0, 0, 168, 0, 160, 48, 48, 0, 0, 8,
0, 0, 0, 0, 0, 32, 16, 8, 12, 4, 0, 0, 24, 12, 0, 8, 0, 0, 0,
0, 0, 0, 24, 4, 24, 24, 0, 0, 0, 0, 0, 4, 0, 0, 0, 6, 6, 8, 4,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 8, 0, 16, 8, 8, 0, 0, 0, 0, 0, 0, 0, 8, 0, 2, 2, 2,
2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">MatScalarProducts( 2b, Irr( 2b ), pi );</span>
[ [ 1, 1, 2, 1, 2, 0, 2, 3, 2, 0, 0, 1, 4, 1, 2, 0, 3, 2, 0, 2, 0, 0,
2, 2, 0, 0, 2, 3, 1, 5, 0, 4, 3, 2, 0, 0, 3, 2, 0, 6, 4, 0, 1,
1, 0, 0, 0, 0, 3, 0, 1, 0, 0, 5, 0, 5, 2, 0, 0, 2, 0, 0, 4, 1,
0, 2, 0, 4, 2, 4, 4, 3, 0, 2, 4, 2, 4, 0, 3, 0, 3, 2, 5, 0, 1,
0, 3, 1, 0, 1, 1, 2, 5, 3, 1, 1, 4, 5, 1, 1, 0, 3, 0, 0, 3, 2,
1, 1, 2, 1, 1, 4, 0, 3, 2, 3, 1, 3, 0, 1, 3, 0, 2, 2, 1, 3, 3,
0, 0, 2, 0, 0, 0, 0, 3, 0, 3, 3, 3, 1, 0, 3, 0, 4, 0, 1, 0, 0,
2, 0, 0, 2, 0, 0, 2, 1, 1, 0, 0, 0, 0, 1, 2, 1, 1, 1, 0, 1, 1,
1, 1, 1, 1, 0, 2, 1, 1, 3, 3, 0, 0, 0, 1, 1, 1, 1, 2, 3, 2, 0,
0, 2, 2, 4, 3, 5, 2, 4, 0, 0, 0, 0, 5, 2, 0, 0, 0, 1, 1, 0, 0,
0, 0, 0, 0, 7, 0, 0, 1, 7, 7, 0, 0, 0, 1, 6, 4, 5, 0, 0, 3, 0,
0, 0, 0, 0, 4, 1, 1, 3, 8, 3, 2, 2, 5, 0, 1 ] ]
</pre></div>
<p>We are lucky: There is a unique solution, and its computation is quite fast.</p>
<p><a id="X849F0EA6807C9B19" name="X849F0EA6807C9B19"></a></p>
<h4>8.19 <span class="Heading">Generation of sporadic simple groups by <span class="SimpleMath">\(\pi\)</span>- and <span class="SimpleMath">\(\pi'\)</span>-subgroups (December 2021)</span></h4>
<p>This section shows the computations that are needed in order to show the following statements from <a href="chapBib_mj.html#biBBG21">[BG]</a>.</p>
<p><em>Proposition 2.2</em>: Let <span class="SimpleMath">\(S\)</span> be a sporadic simple group and let <span class="SimpleMath">\(P\)</span> be a Sylow <span class="SimpleMath">\(2\)</span>-subgroup of <span class="SimpleMath">\(S\)</span>. If <span class="SimpleMath">\(1 \neq x \in S\)</span>, then <span class="SimpleMath">\(S = \langle P, x^g \rangle\)</span> for some <span class="SimpleMath">\(g \in S\)</span>.</p>
<p><em>Theorem 7.1</em>: Let <span class="SimpleMath">\(S\)</span> be a sporadic simple group and let <span class="SimpleMath">\(p \leq q\)</span> be primes each dividing <span class="SimpleMath">\(|S|\)</span>. Then <span class="SimpleMath">\(S\)</span> can be generated by a Sylow <span class="SimpleMath">\(p\)</span>-subgroup and a Sylow <span class="SimpleMath">\(q\)</span>-subgroup.</p>
<p>A stronger version of Theorem 7.1: Let <span class="SimpleMath">\(S\)</span> be a sporadic simple group, <span class="SimpleMath">\(p\)</span> be a prime dividing <span class="SimpleMath">\(|S|\)</span>, and <span class="SimpleMath">\(P\)</span> be a Sylow <span class="SimpleMath">\(p\)</span>-subgroup of <span class="SimpleMath">\(S\)</span>. If <span class="SimpleMath">\(1 \neq x \in S\)</span>, then <span class="SimpleMath">\(S = \langle P, x^g \rangle\)</span> for some <span class="SimpleMath">\(g \in S\)</span>.</p>
<p>First we show <a href="chapBib_mj.html#biBBG21">[BG, Proposition 2.2]</a>. Let <span class="SimpleMath">\(S\)</span> be a sporadic simple group, fix a Sylow <span class="SimpleMath">\(2\)</span>-subgroup <span class="SimpleMath">\(P\)</span> of <span class="SimpleMath">\(S\)</span>, and let <span class="SimpleMath">\(x\)</span> be a nonidentity element in <span class="SimpleMath">\(S\)</span>. We use known information about maximal subgroups of <span class="SimpleMath">\(S\)</span> to show that <span class="SimpleMath">\(x^S\)</span> is not a subset of the union of those maximal subgroups in <span class="SimpleMath">\(S\)</span> that contain <span class="SimpleMath">\(P\)</span>.</p>
<p>Let <span class="SimpleMath">\(M\)</span> be a maximal subgroup of <span class="SimpleMath">\(S\)</span> with the property <span class="SimpleMath">\(P \leq M\)</span>. The number of <span class="SimpleMath">\(S\)</span>-conjugates of <span class="SimpleMath">\(M\)</span> that contain <span class="SimpleMath">\(P\)</span> is equal to <span class="SimpleMath">\(|N_S(P)|/|N_M(P)| \leq [N_S(P):P]\)</span>, thus these subgroups can contain at most <span class="SimpleMath">\([N_S(P):P] |x^S \cap M|\)</span> elements from the class <span class="SimpleMath">\(x^S\)</span>.</p>
<p>Thus the number of elements in <span class="SimpleMath">\(x^S\)</span> that generate a proper subgroup of <span class="SimpleMath">\(S\)</span> together with <span class="SimpleMath">\(P\)</span> is bounded from above by <span class="SimpleMath">\([N_S(P):P] \sum_M |x^S \cap M|\)</span>, where the sum is taken over representatives <span class="SimpleMath">\(M\)</span> of conjugacy classes of maximal subgroups of odd index in <span class="SimpleMath">\(S\)</span>.</p>
<p>Let <span class="SimpleMath">\(1_M^S\)</span> denote the permutation character of the action of <span class="SimpleMath">\(S\)</span> on the cosets of <span class="SimpleMath">\(M\)</span>. We have <span class="SimpleMath">\(|x^S \cap M| = |x^S| 1_M^S(x) / 1_M^S(1)\)</span>. Hence we are done when we show that</p>
<p class="center">\[
[N_S(P):P] \sum_M 1_M^S(x) / 1_M^S(1) < 1
\]</p>
<p>holds.</p>
<p>The numbers <span class="SimpleMath">\([N_S(P):P]\)</span> can be read off from <a href="chapBib_mj.html#biBWil98">[Wil98, Table I]</a>. Here we use the fact that the character table of the Sylow <span class="SimpleMath">\(2\)</span>-normalizer of <span class="SimpleMath">\(S\)</span> is available except if <span class="SimpleMath">\(S\)</span> is one of <span class="SimpleMath">\(Co_1\)</span>, <span class="SimpleMath">\(J_4\)</span>, <span class="SimpleMath">\(F_{3+}\)</span>, <span class="SimpleMath">\(B\)</span>, or <span class="SimpleMath">\(M\)</span>, and that the Sylow <span class="SimpleMath">\(2\)</span>-subgroup if self-normalizing in these cases.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">names:= AllCharacterTableNames( IsSporadicSimple, true,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> IsDuplicateTable, false : OrderedBy:= Size );</span>
[ "M11", "M12", "J1", "M22", "J2", "M23", "HS", "J3", "M24", "McL",
"He", "Ru", "Suz", "ON", "Co3", "Co2", "Fi22", "HN", "Ly", "Th",
"Fi23", "Co1", "J4", "F3+", "B", "M" ]
<span class="GAPprompt">gap></span> <span class="GAPinput">normindices:= rec( Co1:= 1, J4:= 1, F3\+:= 1, B:= 1, M:= 1 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for name in names do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> n:= CharacterTable( Concatenation( name, "N2" ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if n = fail then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Print( name, "\n" );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> 2part:= 2^Length( Positions( Factors( Size( n ) ), 2 ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> normindices.( name ):= Size( n ) / 2part;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
Co1
J4
F3+
B
M
</pre></div>
<p>For all sporadic simple groups <span class="SimpleMath">\(S\)</span> except the Monster group, the primitive permutation characters <span class="SimpleMath">\(1_M^S\)</span> can be computed from the data about maximal subgroups contained in <strong class="pkg">GAP</strong>'s library of character tables.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">maxbound:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for name in Filtered( names, x -> x <> "M" ) do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> t:= CharacterTable( name );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> mx:= List( Maxes( t ), CharacterTable );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> odd:= Filtered( mx, s -> ( Size( t ) / Size( s ) ) mod 2 <> 0 );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> primperm:= List( odd, s -> TrivialCharacter( s )^t );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> sum:= normindices.( name ) * Sum( primperm, pi -> pi / pi[1] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( maxbound,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ name, Maximum( sum{ [ 2 .. Length( sum ) ] } ) ] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SortBy( maxbound, x -> - x[2] );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">maxbound[1];</span>
[ "J2", 3/5 ]
</pre></div>
<p>We see that the left hand side of the above inequality is always less than or equal to <span class="SimpleMath">\(3/5\)</span>, in particular it is less than <span class="SimpleMath">\(1\)</span>.</p>
<p>The Monster group is known to contain exactly five classes of maximal subgroups of odd index, of the structures <span class="SimpleMath">\(2^{1+24}.Co_1\)</span> (the normalizer of a <code class="code">2B</code> element in the Monster), <span class="SimpleMath">\(2^{10+16}.O_{10}^+(2)\)</span>, <span class="SimpleMath">\(2^{2+11+22}.(M_{24} \times S_3)\)</span>, <span class="SimpleMath">\(2^{5+10+20}.(S_3 \times L_5(2))\)</span>, <span class="SimpleMath">\([2^{39}].(L_3(2) \times 3S_6)\)</span>. The corresponding permutation characters are known, see Section <a href="chap8_mj.html#X8337F3C682B6BE63"><span class="RefLink">8.16</span></a>. First we read the information about the known primitive permutation characters of the Monster into the <strong class="pkg">GAP</strong> session, and extract the primitive permutation characters of odd degree.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">dir:= DirectoriesPackageLibrary( "ctbllib", "data" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">filename:= Filename( dir, "prim_perm_M.json" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Monster_prim_data:= EvalString( StringFile( filename ) )[2];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( Monster_prim_data );</span>
46
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "M" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">monstermaxindices:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">monstermaxtables:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for entry in Monster_prim_data do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if Length( entry ) = 1 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> s:= CharacterTable( entry[1] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( monstermaxtables, s );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( monstermaxindices, Size( t ) / Size( s ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( monstermaxtables, fail );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( monstermaxindices, entry[2][1] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">odd_prim:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for i in [ 1 .. Length( Monster_prim_data ) ] do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if monstermaxindices[i] mod 2 <> 0 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if monstermaxtables[i] <> fail then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( odd_prim, TrivialCharacter( monstermaxtables[i] )^t );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( odd_prim, Monster_prim_data[i][2] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length( odd_prim );</span>
5
</pre></div>
<p>Now we can use the same approach as before.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">sum:= normindices.M * Sum( odd_prim, pi -> pi / pi[1] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">max:= Maximum( sum{ [ 2 .. Length( sum ) ] } );</span>
12784979/103007903752128375
<span class="GAPprompt">gap></span> <span class="GAPinput">max < 10^-9;</span>
true
</pre></div>
<p>Next we show <a href="chapBib_mj.html#biBBG21">[BG, Theorem 7.1]</a> and its stronger version stated above. Let us first assume that <span class="SimpleMath">\(S\)</span> is not the Monster.</p>
<p>As a first step, we generalize the approach from the above computations in order to check for which prime divisors <span class="SimpleMath">\(p\)</span> of <span class="SimpleMath">\(|S|\)</span> and for which nontrivial conjugacy classes <span class="SimpleMath">\(x^S\)</span> of <span class="SimpleMath">\(S\)</span> the group <span class="SimpleMath">\(S\)</span> is generated by a Sylow <span class="SimpleMath">\(p\)</span>-subgroup <span class="SimpleMath">\(P\)</span> together with a conjugate of <span class="SimpleMath">\(x\)</span>.</p>
<p>The upper bound <span class="SimpleMath">\([N_S(P):P]\)</span> for <span class="SimpleMath">\(|N_S(P)|/|N_M(P)|\)</span>, for a maximal subgroup <span class="SimpleMath">\(M\)</span> of <span class="SimpleMath">\(S\)</span> that contains <span class="SimpleMath">\(P\)</span>, is not good enough in some of the cases considered here. Instead of it, we compute the upper bound <span class="SimpleMath">\(u(S, M, p)\)</span> which is defined as follows; we assume that we know <span class="SimpleMath">\(|N_S(P)|\)</span>.</p>
<ul>
<li><p>If <span class="SimpleMath">\(P\)</span> is cyclic then we can compute <span class="SimpleMath">\(|N_M(P)|\)</span> from the character table of <span class="SimpleMath">\(M\)</span>, and set <span class="SimpleMath">\(u(S, M, p) = |N_S(P)| / |N_M(P)|\)</span>.</p>
</li>
<li><p>Otherwise, if <span class="SimpleMath">\(P\)</span> is normal in <span class="SimpleMath">\(M\)</span>, we set <span class="SimpleMath">\(u(S, M, p) = |N_S(P)| / |M|\)</span>.</p>
</li>
<li><p>Otherwise, if we know a subgroup <span class="SimpleMath">\(U\)</span> of <span class="SimpleMath">\(M\)</span> such that <span class="SimpleMath">\(P\)</span> is a proper normal subgroup of <span class="SimpleMath">\(U\)</span>, we set <span class="SimpleMath">\(u(S, M, p) = |N_S(P)| / |U|\)</span>.</p>
</li>
<li><p>Otherwise, we set <span class="SimpleMath">\(u(S, M, p) = |N_S(P)| / |P|\)</span>.</p>
</li>
</ul>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">upper_bound:= function( tblS, tblM, p )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> local ppart, ppartposS, ppartposM, n, N_S, f, subname, u;</span>
<span class="GAPprompt">></span> <span class="GAPinput"></span>
<span class="GAPprompt">></span> <span class="GAPinput"> ppart:= Product( Filtered( Factors( Size( tblS ) ), x -> x = p ), 1 );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> ppartposS:= Positions( OrdersClassRepresentatives( tblS ), ppart );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if 0 < Length( ppartposS ) then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # P is cyclic.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if tblM = fail then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return ( SizesCentralizers( tblS )[ ppartposS[1] ] * Phi( ppart )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> / Length( ppartposS ) ) / ppart;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> ppartposM:= Positions( OrdersClassRepresentatives( tblM ), ppart );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return ( SizesCentralizers( tblS )[ ppartposS[1] ] * Phi( ppart )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> / Length( ppartposS ) ) /</span>
<span class="GAPprompt">></span> <span class="GAPinput"> ( SizesCentralizers( tblM )[ ppartposM[1] ] * Phi( ppart )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> / Length( ppartposM ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> </span>
<span class="GAPprompt">></span> <span class="GAPinput"> # Compute |N_S(P)|.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> n:= CharacterTable( Concatenation( Identifier( tblS ), "N",</span>
<span class="GAPprompt">></span> <span class="GAPinput"> String( p ) ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if n <> fail then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> N_S:= Size( n );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif p = 2 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> N_S:= ppart * normindices.( Identifier( tblS ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif Identifier( tblS ) = "M" and p = 3 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # The Sylow 3-normalizer is contained in 3^(3+2+6+6):(L3(3)xSD16)</span>
<span class="GAPprompt">></span> <span class="GAPinput"> N_S:= ppart * 2^6;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif Identifier( tblS ) = "F3+" and p = 3 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> N_S:= ppart * 8;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Error( "cannot compute |N_S(P)|" );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> </span>
<span class="GAPprompt">></span> <span class="GAPinput"> if tblM = fail then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return N_S / ppart;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif Sum( SizesConjugacyClasses( tblM ){</span>
<span class="GAPprompt">></span> <span class="GAPinput"> ClassPositionsOfPCore( tblM, p ) } ) = ppart then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # P is normal in M.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return N_S / Size( tblM );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"></span>
<span class="GAPprompt">></span> <span class="GAPinput"> # Inspect known character tables of subgroups of M.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> f:= N_S / ppart;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for subname in NamesOfFusionSources( tblM ) do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> u:= CharacterTable( subname );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if ClassPositionsOfKernel( GetFusionMap( u, tblM ) ) = [ 1 ] and</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Sum( SizesConjugacyClasses( u ){</span>
<span class="GAPprompt">></span> <span class="GAPinput"> ClassPositionsOfPCore( u, p ) } ) = ppart then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> f:= Minimum( f, N_S / Size( u ) );</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"></span>
<span class="GAPprompt">></span> <span class="GAPinput"> return f;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> end;;</span>
</pre></div>
<p>We run over the sporadic simple groups (except the Monster), and collect in the list <code class="code">badcases_strong</code> those "bad" prime divisors <span class="SimpleMath">\(p\)</span> of <span class="SimpleMath">\(|S|\)</span> and conjugacy class representatives <span class="SimpleMath">\(x\)</span> of nonidentity elements in <span class="SimpleMath">\(S\)</span> for which</p>
<p class="center">\[
\sum_M u(S, M, p) 1_M^S(x) / 1_M^S(1) \geq 1
\]</p>
<p>holds, where the sum is taken over representatives <span class="SimpleMath">\(M\)</span> of conjugacy classes of maximal subgroups of <span class="SimpleMath">\(S\)</span> whose index in <span class="SimpleMath">\(S\)</span> is coprime to <span class="SimpleMath">\(p\)</span>. In these cases, we have to find other arguments.</p>
<p>For the proof of <a href="chapBib_mj.html#biBBG21">[BG, Theorem 7.1]</a>, we can discard all those entries from the list of "bad" <span class="SimpleMath">\(p\)</span> and <span class="SimpleMath">\(x\)</span> where <span class="SimpleMath">\(x\)</span> is not a <span class="SimpleMath">\(q\)</span>-element, for some prime <span class="SimpleMath">\(q\)</span>, or where another nonidentity <span class="SimpleMath">\(q\)</span>-element exists that does not occur in the list. This is done by collecting a second list <code class="code">badcases_thm</code> of the remaining "bad" cases.</p>
<p>For the proof of the stronger version, we will later explicitly compute group elements from the classes in question that generate <span class="SimpleMath">\(S\)</span> together with a Sylow <span class="SimpleMath">\(p\)</span>-subgroup. (The only technical complication is that the class fusion of maximal subgroups of the type <span class="SimpleMath">\((2^2 \times F_4(2)):2\)</span> of the Baby Monster is currently not known, thus we cannot simply induce the trivial character in this case. However, the permutation character is uniquely determined by the two character tables.)</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">badcases_thm:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">badcases_strong:= [];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for name in Filtered( names, x -> x <> "M" ) do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> t:= CharacterTable( name );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> orders:= OrdersClassRepresentatives( t );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> n:= NrConjugacyClasses( t );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> mx:= List( Maxes( t ), CharacterTable );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for p in PrimeDivisors( Size( t ) ) do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> good:= Filtered( mx, s -> ( Size( t ) / Size( s ) ) mod p <> 0 );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> primperm:= [];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for s in good do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if GetFusionMap( s, t ) <> fail then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( primperm, TrivialCharacter( s )^t );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> ind:= Set( PossibleClassFusions( s, t ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> map -> InducedClassFunctionsByFusionMap( s, t,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ TrivialCharacter( s ) ], map )[1] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if Length( ind ) <> 1 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Error( "permutation character not uniquely determined" );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( primperm, ind[1] );</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"> sum:= Sum( [ 1 .. Length( good ) ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> i -> upper_bound( t, good[i], p )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> * primperm[i] / primperm[i][1] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> badpos:= Filtered( [ 2 .. Length( sum ) ], i -> sum[i] >= 1 );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if badpos <> [] then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( badcases_strong, [ name, p, ShallowCopy( badpos ) ] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for i in ShallowCopy( badpos ) do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> q:= SmallestRootInt( orders[i] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if IsPrimeInt( q ) then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if ForAny( [ 2 .. n ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> j -> SmallestRootInt( orders[j] ) = q</span>
<span class="GAPprompt">></span> <span class="GAPinput"> and not j in badpos ) then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> RemoveSet( badpos, i );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</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"> if not IsEmpty( badpos ) then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( badcases_thm, [ name, p, badpos ] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</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">gap></span> <span class="GAPinput">badcases_thm;</span>
[ [ "M23", 3, [ 3 ] ], [ "HS", 3, [ 4, 11 ] ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">badcases_strong;</span>
[ [ "M11", 5, [ 2 ] ], [ "M12", 5, [ 3, 4 ] ], [ "M22", 3, [ 2 ] ],
[ "M22", 5, [ 2 ] ], [ "J2", 3, [ 2 ] ], [ "M23", 3, [ 2, 3 ] ],
[ "M23", 5, [ 2 ] ], [ "M23", 7, [ 2 ] ],
[ "HS", 3, [ 2, 3, 4, 5, 6, 7, 9, 11 ] ], [ "HS", 5, [ 2, 3, 5 ] ],
[ "M24", 5, [ 2, 4 ] ], [ "M24", 7, [ 2, 4 ] ], [ "He", 5, [ 2 ] ],
[ "Co2", 3, [ 2, 3 ] ], [ "Fi22", 5, [ 2 ] ], [ "Fi22", 7, [ 2 ] ],
[ "Fi23", 5, [ 2, 3, 5 ] ], [ "Fi23", 7, [ 2 ] ], [ "B", 7, [ 2 ] ]
]
</pre></div>
<p>Most of these open cases can be ruled out by constructing the group <span class="SimpleMath">\(S\)</span> and a Sylow <span class="SimpleMath">\(p\)</span>-subgroup <span class="SimpleMath">\(P\)</span> in question and then finding explicit elements <span class="SimpleMath">\(x\)</span> such that <span class="SimpleMath">\(S\)</span> is generated by <span class="SimpleMath">\(P\)</span> and <span class="SimpleMath">\(x\)</span>. For that, we use the data from the <strong class="pkg">Atlas</strong> of Group Representations <a href="chapBib_mj.html#biBAGRv3">[WWT+]</a>.</p>
<p>The following function tries to find random elements from all conjugacy classes of nonidentity elements that have the desired property. It returns <code class="keyw">fail</code> if no straight line program is available for computing class representatives, and returns <span class="SimpleMath">\(P\)</span> and the list of class representatives that generate together with <span class="SimpleMath">\(P\)</span> if such elements were found. Thus the function will not return if the generation property does not hold.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">prove_generation:= function( name, p )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> local S, prg, P, reps, good, x, g, U;</span>
<span class="GAPprompt">></span> <span class="GAPinput"></span>
<span class="GAPprompt">></span> <span class="GAPinput"> prg:= AtlasProgram( name, "classes" );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if prg = fail then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return fail;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"></span>
<span class="GAPprompt">></span> <span class="GAPinput"> S:= AtlasGroup( name );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> P:= SylowSubgroup( S, p );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> reps:= ResultOfStraightLineProgram( prg.program, GeneratorsOfGroup( S ) );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> good:= [];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for x in Filtered( reps, x -> Order( x ) <> 1 ) do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> repeat</span>
<span class="GAPprompt">></span> <span class="GAPinput"> g:= Random( S );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> U:= ClosureGroup( P, x^g );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> until Size( U ) = Size( S );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Add( good, x^g );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
<span class="GAPprompt">></span> <span class="GAPinput"></span>
<span class="GAPprompt">></span> <span class="GAPinput"> return [ P, good ];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> end;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for entry in badcases_strong do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> res:= prove_generation( entry[1], entry[2] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if res = fail then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Print( "no classes script for ", entry, "\n" );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> od;</span>
no classes script for [ "He", 5, [ 2 ] ]
no classes script for [ "Fi22", 5, [ 2 ] ]
no classes script for [ "Fi22", 7, [ 2 ] ]
no classes script for [ "Fi23", 5, [ 2, 3, 5 ] ]
no classes script for [ "Fi23", 7, [ 2 ] ]
no classes script for [ "B", 7, [ 2 ] ]
</pre></div>
<p>In the remaining cases, we show only the generation property for the class representatives in the list. These are involutions from the class <code class="code">2A</code>, and for the group <span class="SimpleMath">\(Fi_{23}\)</span> and <span class="SimpleMath">\(p = 5\)</span> additionally elements from the classes <code class="code">2B</code> and <code class="code">3A</code>.</p>
<p>A <code class="code">2A</code> element in the group <span class="SimpleMath">\(He\)</span> can be found as the fifth power of any element of order <span class="SimpleMath">\(10\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">S:= AtlasGroup( "He" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">repeat</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x:= Random( S );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> until Order( x ) = 10;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">x:= x^5;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">P5:= SylowSubgroup( S, 5 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">repeat</span>
<span class="GAPprompt">></span> <span class="GAPinput"> g:= Random( S );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> U:= ClosureGroup( P5, x^g );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> until Size( U ) = Size( S );</span>
</pre></div>
<p>A <code class="code">2A</code> element in the group <span class="SimpleMath">\(Fi_{22}\)</span> can be found as the <span class="SimpleMath">\(15\)</span>-th power of any element of order <span class="SimpleMath">\(30\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">S:= AtlasGroup( "Fi22" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">repeat</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x:= Random( S );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> until Order( x ) = 30;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">x:= x^15;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">P5:= SylowSubgroup( S, 5 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">repeat</span>
<span class="GAPprompt">></span> <span class="GAPinput"> g:= Random( S );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> U:= ClosureGroup( P5, x^g );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> until Size( U ) = Size( S );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">P7:= SylowSubgroup( S, 7 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">repeat</span>
<span class="GAPprompt">></span> <span class="GAPinput"> g:= Random( S );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> U:= ClosureGroup( P7, x^g );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> until Size( U ) = Size( S );</span>
</pre></div>
<p>A <code class="code">2A</code> element in the group <span class="SimpleMath">\(Fi_{23}\)</span> can be found as the <span class="SimpleMath">\(21\)</span>-st power of any element of order <span class="SimpleMath">\(42\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">S:= AtlasGroup( "Fi23" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">repeat</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x:= Random( S );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> until Order( x ) = 42;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">x:= x^21;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">P5:= SylowSubgroup( S, 5 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">repeat</span>
<span class="GAPprompt">></span> <span class="GAPinput"> g:= Random( S );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> U:= ClosureGroup( P5, x^g );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> until Size( U ) = Size( S );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">P7:= SylowSubgroup( S, 7 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">repeat</span>
<span class="GAPprompt">></span> <span class="GAPinput"> g:= Random( S );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> U:= ClosureGroup( P7, x^g );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> until Size( U ) = Size( S );</span>
</pre></div>
<p>A <code class="code">2B</code> element in the group <span class="SimpleMath">\(Fi_{23}\)</span> can be found as the <span class="SimpleMath">\(30\)</span>-th power of any element of order <span class="SimpleMath">\(60\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">repeat</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x:= Random( S );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> until Order( x ) = 60;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">x:= x^30;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">repeat</span>
<span class="GAPprompt">></span> <span class="GAPinput"> g:= Random( S );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> U:= ClosureGroup( P5, x^g );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> until Size( U ) = Size( S );</span>
</pre></div>
<p>A <code class="code">3A</code> element in the group <span class="SimpleMath">\(Fi_{23}\)</span> can be found as the <span class="SimpleMath">\(20\)</span>-th power of any element of order <span class="SimpleMath">\(60\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">repeat</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x:= Random( S );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> until Order( x ) = 60;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">x:= x^20;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">repeat</span>
<span class="GAPprompt">></span> <span class="GAPinput"> g:= Random( S );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> U:= ClosureGroup( P5, x^g );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> until Size( U ) = Size( S );</span>
</pre></div>
<p>In the open case for the Baby Monster, we have to show that the group is generated by a <code class="code">2A</code> element and an element of order <span class="SimpleMath">\(7\)</span>. This can be done character-theoretically, for example as follows. There are such elements <span class="SimpleMath">\(x\)</span> and <span class="SimpleMath">\(y\)</span> whose product <span class="SimpleMath">\(x y\)</span> has order <span class="SimpleMath">\(47\)</span>, and the only proper subgroups of the Baby Monster that contain elements of order <span class="SimpleMath">\(47\)</span> are contained in maximal subgroups of the type <span class="SimpleMath">\(47:23\)</span>. Thus <span class="SimpleMath">\(x\)</span> and <span class="SimpleMath">\(y\)</span> generate the Baby Monster.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "B" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">7pos:= Positions( OrdersClassRepresentatives( t ), 7 );</span>
[ 31 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">47pos:= Positions( OrdersClassRepresentatives( t ), 47 );</span>
[ 172, 173 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">ClassMultiplicationCoefficient( t, 2, 7pos[1], 47pos[1] );</span>
7332
<span class="GAPprompt">gap></span> <span class="GAPinput">Filtered( Maxes( t ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> Size( CharacterTable( x ) ) mod 47 = 0 );</span>
[ "47:23" ]
</pre></div>
<p>Now consider the case that <span class="SimpleMath">\(S\)</span> is the Monster, which is special because the complete list of classes of maximal subgroups of <span class="SimpleMath">\(S\)</span> is currently not known. From <a href="chapBib_mj.html#biBNW12">[NW13]</a> and <a href="chapBib_mj.html#biBMmaxes">[Wil]</a> we know <span class="SimpleMath">\(44\)</span> classes of maximal subgroups, and that each possible additional maximal subgroup is almost simple and has socle <span class="SimpleMath">\(L_2(13)\)</span>, <span class="SimpleMath">\(U_3(4)\)</span>, <span class="SimpleMath">\(U_3(8)\)</span>, or <span class="SimpleMath">\(Sz(8)\)</span>. This implies that we know all those maximal subgroups that contain a Sylow <span class="SimpleMath">\(p\)</span>-subgroup of <span class="SimpleMath">\(S\)</span> except in the case <span class="SimpleMath">\(p = 19\)</span>, where maximal subgroups with socle <span class="SimpleMath">\(U_3(8)\)</span> may arise.</p>
<p>Thus let us first consider that at least one of <span class="SimpleMath">\(p\)</span>, <span class="SimpleMath">\(r\)</span> is different from <span class="SimpleMath">\(19\)</span>. In this situation, we use the same approach as for the other sporadic simple groups. The only complication is that not all permutation characters <span class="SimpleMath">\(1_M^S\)</span>, for the relevant maximal subgroups <span class="SimpleMath">\(M\)</span> of <span class="SimpleMath">\(S\)</span>, are known; however, if this happens then the character table of <span class="SimpleMath">\(M\)</span> is known, and we can compute the possible permutation characters, and take the common upper bounds for these characters. In each case, we get that the claimed property holds.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">t:= CharacterTable( "M" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">orders:= OrdersClassRepresentatives( t );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">for p in Difference( PrimeDivisors( Size( t ) ), [ 19 ] ) do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> goodpos:= Filtered( [ 1 .. Length( Monster_prim_data ) ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> i -> monstermaxindices[i] mod p <> 0 );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> sum:= ListWithIdenticalEntries( NrConjugacyClasses( t ), 0 );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> for i in goodpos do</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if Length( Monster_prim_data[i] ) = 2 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # We know the permutation character but not the subgroup table.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> sum:= sum + upper_bound( t, fail, p )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> * Monster_prim_data[i][2] / monstermaxindices[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> s:= monstermaxtables[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if GetFusionMap( s, t ) <> fail then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # We can compute the permutation character.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> sum:= sum + upper_bound( t, s, p )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> * TrivialCharacter( s )^t / monstermaxindices[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # We get only candidates for the permutation character.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> cand:= Set( PossibleClassFusions( s, t ),</span>
<span class="GAPprompt">></span> <span class="GAPinput"> map -> InducedClassFunctionsByFusionMap( s, t,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> [ TrivialCharacter( s ) ], map )[1] );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> # For each class, take the maximum of the possible values.</span>
<span class="GAPprompt">></span> <span class="GAPinput"> sum:= sum + upper_bound( t, s, p )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> * List( TransposedMat( cand ), Maximum )</span>
<span class="GAPprompt">></span> <span class="GAPinput"> / monstermaxindices[i];</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</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"> badpos:= Filtered( [ 2 .. Length( sum ) ], i -> sum[i] >= 1 );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if badpos <> [] then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> Error( "check open cases in ", badpos, "\n" );</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput">od;</span>
</pre></div>
<p>Finally, let <span class="SimpleMath">\(p = r = 19\)</span>. The group <span class="SimpleMath">\(S\)</span> has exactly one class of elements of order <span class="SimpleMath">\(19\)</span>. Let <span class="SimpleMath">\(x\)</span> be such an element. From the character table of <span class="SimpleMath">\(S\)</span>, we compute that there exist conjugates <span class="SimpleMath">\(y\)</span> of <span class="SimpleMath">\(x\)</span> such that <span class="SimpleMath">\(x y\)</span> has order <span class="SimpleMath">\(71\)</span>. Since <span class="SimpleMath">\(\langle x, y \rangle = \langle x, x y \rangle\)</span> holds and no maximal subgroup of <span class="SimpleMath">\(S\)</span> has order divisible by <span class="SimpleMath">\(19 \cdot 71\)</span>, we have <span class="SimpleMath">\(\langle x, y \rangle = S\)</span>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">pos19:= Positions( OrdersClassRepresentatives( t ), 19 );</span>
[ 63 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">pos71:= Positions( OrdersClassRepresentatives( t ), 71 );</span>
[ 169, 170 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">ClassMultiplicationCoefficient( t, pos19[1], pos19[1], pos71[1] );</span>
621743152370566020417806353602387433415016198936
<span class="GAPprompt">gap></span> <span class="GAPinput">ForAny( monstermaxindices,</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> ( Size( t ) / x ) mod ( 19 * 71 ) = 0 );</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">ForAny( [ "L2(13)", "U3(4)", "U3(8)", "Sz(8)" ],</span>
<span class="GAPprompt">></span> <span class="GAPinput"> x -> Size( CharacterTable( x ) ) mod 71 = 0 );</span>
false
</pre></div>
<p><em>Remark</em> added in December 2023:</p>
<p>Meanwhile the complete list of conjugacy classes of maximal subgroups of the Monster group is known, due to <a href="chapBib_mj.html#biBDLP23">[DLP23]</a>. The result is that there are two more classes than had been known before, which consist of groups of the structures <span class="SimpleMath">\(L_2(13).2\)</span> and <span class="SimpleMath">\(U_3(4).4\)</span>, respectively.</p>
<div class="chlinkprevnextbot"> <a href="chap0_mj.html">[Top of Book]</a> <a href="chap0_mj.html#contents">[Contents]</a> <a href="chap7_mj.html">[Previous Chapter]</a> <a href="chap9_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>
|
