This file is indexed.

/usr/share/gap/doc/ref/chap73.html is in gap-doc 4r8p6-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

   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
<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<title>GAP (ref) - Chapter 73: Maps Concerning Character Tables</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="chap73"  onload="jscontent()">


<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a>  <a href="chap1.html">1</a>  <a href="chap2.html">2</a>  <a href="chap3.html">3</a>  <a href="chap4.html">4</a>  <a href="chap5.html">5</a>  <a href="chap6.html">6</a>  <a href="chap7.html">7</a>  <a href="chap8.html">8</a>  <a href="chap9.html">9</a>  <a href="chap10.html">10</a>  <a href="chap11.html">11</a>  <a href="chap12.html">12</a>  <a href="chap13.html">13</a>  <a href="chap14.html">14</a>  <a href="chap15.html">15</a>  <a href="chap16.html">16</a>  <a href="chap17.html">17</a>  <a href="chap18.html">18</a>  <a href="chap19.html">19</a>  <a href="chap20.html">20</a>  <a href="chap21.html">21</a>  <a href="chap22.html">22</a>  <a href="chap23.html">23</a>  <a href="chap24.html">24</a>  <a href="chap25.html">25</a>  <a href="chap26.html">26</a>  <a href="chap27.html">27</a>  <a href="chap28.html">28</a>  <a href="chap29.html">29</a>  <a href="chap30.html">30</a>  <a href="chap31.html">31</a>  <a href="chap32.html">32</a>  <a href="chap33.html">33</a>  <a href="chap34.html">34</a>  <a href="chap35.html">35</a>  <a href="chap36.html">36</a>  <a href="chap37.html">37</a>  <a href="chap38.html">38</a>  <a href="chap39.html">39</a>  <a href="chap40.html">40</a>  <a href="chap41.html">41</a>  <a href="chap42.html">42</a>  <a href="chap43.html">43</a>  <a href="chap44.html">44</a>  <a href="chap45.html">45</a>  <a href="chap46.html">46</a>  <a href="chap47.html">47</a>  <a href="chap48.html">48</a>  <a href="chap49.html">49</a>  <a href="chap50.html">50</a>  <a href="chap51.html">51</a>  <a href="chap52.html">52</a>  <a href="chap53.html">53</a>  <a href="chap54.html">54</a>  <a href="chap55.html">55</a>  <a href="chap56.html">56</a>  <a href="chap57.html">57</a>  <a href="chap58.html">58</a>  <a href="chap59.html">59</a>  <a href="chap60.html">60</a>  <a href="chap61.html">61</a>  <a href="chap62.html">62</a>  <a href="chap63.html">63</a>  <a href="chap64.html">64</a>  <a href="chap65.html">65</a>  <a href="chap66.html">66</a>  <a href="chap67.html">67</a>  <a href="chap68.html">68</a>  <a href="chap69.html">69</a>  <a href="chap70.html">70</a>  <a href="chap71.html">71</a>  <a href="chap72.html">72</a>  <a href="chap73.html">73</a>  <a href="chap74.html">74</a>  <a href="chap75.html">75</a>  <a href="chap76.html">76</a>  <a href="chap77.html">77</a>  <a href="chap78.html">78</a>  <a href="chap79.html">79</a>  <a href="chap80.html">80</a>  <a href="chap81.html">81</a>  <a href="chap82.html">82</a>  <a href="chap83.html">83</a>  <a href="chap84.html">84</a>  <a href="chap85.html">85</a>  <a href="chap86.html">86</a>  <a href="chap87.html">87</a>  <a href="chapBib.html">Bib</a>  <a href="chapInd.html">Ind</a>  </div>

<div class="chlinkprevnexttop">&nbsp;<a href="chap0.html">[Top of Book]</a>&nbsp;  <a href="chap0.html#contents">[Contents]</a>&nbsp;  &nbsp;<a href="chap72.html">[Previous Chapter]</a>&nbsp;  &nbsp;<a href="chap74.html">[Next Chapter]</a>&nbsp;  </div>

<p id="mathjaxlink" class="pcenter"><a href="chap73_mj.html">[MathJax on]</a></p>
<p><a id="X7DF1ACDE7E9C6294" name="X7DF1ACDE7E9C6294"></a></p>
<div class="ChapSects"><a href="chap73.html#X7DF1ACDE7E9C6294">73 <span class="Heading">Maps Concerning Character Tables</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap73.html#X7FED949A86575949">73.1 <span class="Heading">Power Maps</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X781FAA497E3B4D1A">73.1-1 PowerMap</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7C7B292E80590BE0">73.1-2 PossiblePowerMaps</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7E0289957E9D62EE">73.1-3 ElementOrdersPowerMap</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7C0F171F7DC846B7">73.1-4 PowerMapByComposition</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap73.html#X80980FF37F0D521B">73.2 <span class="Heading">Orbits on Sets of Possible Power Maps</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7ECB9DDE8608B9A9">73.2-1 OrbitPowerMaps</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X8753F5217A570529">73.2-2 RepresentativesPowerMaps</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap73.html#X806975FE81534444">73.3 <span class="Heading">Class Fusions between Character Tables</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X86CE53B681F13C63">73.3-1 <span class="Heading">FusionConjugacyClasses</span></a>
</span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7F71402285B7DE8E">73.3-2 ComputedClassFusions</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X8464DD23879431D9">73.3-3 GetFusionMap</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X808970FE87C3432F">73.3-4 StoreFusion</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7F6569D5786A9D49">73.3-5 NamesOfFusionSources</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7883271F7F26356E">73.3-6 PossibleClassFusions</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7BCC5B4B7E9DF42C">73.3-7 ConsiderStructureConstants</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap73.html#X7C34060278E4BFC4">73.4 <span class="Heading">Orbits on Sets of Possible Class Fusions</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X79A0FE1C853302D2">73.4-1 OrbitFusions</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X821D11D180B5D317">73.4-2 RepresentativesFusions</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap73.html#X7F18772E86F06179">73.5 <span class="Heading">Parametrized Maps</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X8740C1397C6A96C8">73.5-1 CompositionMaps</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7877EE167A711AB6">73.5-2 InverseMap</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X82C0E76F804C3FF7">73.5-3 ProjectionMap</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7D9CA09385467EDE">73.5-4 Indirected</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7910BE5687DDAAF3">73.5-5 Parametrized</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7917265684700B10">73.5-6 ContainedMaps</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X80C7328C85BFC20B">73.5-7 UpdateMap</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X81A1A0E88570E42A">73.5-8 MeetMaps</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X8593A72A8193EC8B">73.5-9 CommutativeDiagram</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7B6EC10C7F7411E9">73.5-10 CheckFixedPoints</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7AD5158E82AF1CD4">73.5-11 TransferDiagram</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X78487F03852A503B">73.5-12 TestConsistencyMaps</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7DAD6EA585D74615">73.5-13 Indeterminateness</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7888BDC88304BE5A">73.5-14 PrintAmbiguity</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7F957B1481E10A0C">73.5-15 ContainedSpecialVectors</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X84F87C2282EFB0EE">73.5-16 CollapsedMat</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X81F1137A874EB962">73.5-17 ContainedDecomposables</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap73.html#X86472A217D6C3CE7">73.6 <span class="Heading">Subroutines for the Construction of Power Maps</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X85D068D77C3C041C">73.6-1 InitPowerMap</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7B27749E7BF54EBB">73.6-2 Congruences</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7D31B1548205E222">73.6-3 ConsiderKernels</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7DD1DCF3865E0017">73.6-4 ConsiderSmallerPowerMaps</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X805B6C1C78AA5DB6">73.6-5 MinusCharacter</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X808CCF6087D5B661">73.6-6 PowerMapsAllowedBySymmetrizations</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap73.html#X7AF7305D80E1E5EF">73.7 <span class="Heading">Subroutines for the Construction of Class Fusions</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7E2BC50C86A16604">73.7-1 InitFusion</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X82F776A3850C6404">73.7-2 CheckPermChar</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X7C52CEDB7D98A6B8">73.7-3 ConsiderTableAutomorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap73.html#X85024BAE8585DB1C">73.7-4 FusionsAllowedByRestrictions</a></span>
</div></div>
</div>

<h3>73 <span class="Heading">Maps Concerning Character Tables</span></h3>

<p>Besides the characters, <em>power maps</em> are an important part of a character table, see Section <a href="chap73.html#X7FED949A86575949"><span class="RefLink">73.1</span></a>. Often their computation is not easy, and if the table has no access to the underlying group then in general they cannot be obtained from the matrix of irreducible characters; so it is useful to store them on the table.</p>

<p>If not only a single table is considered but different tables of a group and a subgroup or of a group and a factor group are used, also <em>class fusion maps</em> (see Section <a href="chap73.html#X806975FE81534444"><span class="RefLink">73.3</span></a>) must be known to get information about the embedding or simply to induce or restrict characters, see Section <a href="chap72.html#X854A4E3A85C5F89B"><span class="RefLink">72.9</span></a>).</p>

<p>These are examples of functions from conjugacy classes which will be called <em>maps</em> in the following. (This should not be confused with the term mapping, cf. Chapter <a href="chap32.html#X7C9734B880042C73"><span class="RefLink">32</span></a>.) In <strong class="pkg">GAP</strong>, maps are represented by lists. Also each character, each list of element orders, of centralizer orders, or of class lengths are maps, and the list returned by <code class="func">ListPerm</code> (<a href="chap42.html#X7A9DCFD986958C1E"><span class="RefLink">42.5-1</span></a>), when this function is called with a permutation of classes, is a map.</p>

<p>When maps are constructed without access to a group, often one only knows that the image of a given class is contained in a set of possible images, e. g., that the image of a class under a subgroup fusion is in the set of all classes with the same element order. Using further information, such as centralizer orders, power maps and the restriction of characters, the sets of possible images can be restricted further. In many cases, at the end the images are uniquely determined.</p>

<p>Because of this approach, many functions in this chapter work not only with maps but with <em>parametrized maps</em> (or <em>paramaps</em> for short). More about parametrized maps can be found in Section <a href="chap73.html#X7F18772E86F06179"><span class="RefLink">73.5</span></a>.</p>

<p>The implementation follows <a href="chapBib.html#biBBre91">[Bre91]</a>, a description of the main ideas together with several examples can be found in <a href="chapBib.html#biBBre99">[Bre99]</a>.</p>

<p>Several examples in this chapter require the <strong class="pkg">GAP</strong> Character Table Library to be available. If it is not yet loaded then we load it now.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">LoadPackage( "ctbllib" );</span>
true
</pre></div>

<p><a id="X7FED949A86575949" name="X7FED949A86575949"></a></p>

<h4>73.1 <span class="Heading">Power Maps</span></h4>

<p>The <span class="SimpleMath">n</span>-th power map of a character table is represented by a list that stores at position <span class="SimpleMath">i</span> the position of the class containing the <span class="SimpleMath">n</span>-th powers of the elements in the <span class="SimpleMath">i</span>-th class. The <span class="SimpleMath">n</span>-th power map can be composed from the power maps of the prime divisors of <span class="SimpleMath">n</span>, so usually only power maps for primes are actually stored in the character table.</p>

<p>For an ordinary character table <var class="Arg">tbl</var> with access to its underlying group <span class="SimpleMath">G</span>, the <span class="SimpleMath">p</span>-th power map of <var class="Arg">tbl</var> can be computed using the identification of the conjugacy classes of <span class="SimpleMath">G</span> with the classes of <var class="Arg">tbl</var>. For an ordinary character table without access to a group, in general the <span class="SimpleMath">p</span>-th power maps (and hence also the element orders) for prime divisors <span class="SimpleMath">p</span> of the group order are not uniquely determined by the matrix of irreducible characters. So only necessary conditions can be checked in this case, which in general yields only a list of several possibilities for the desired power map. Character tables of the <strong class="pkg">GAP</strong> character table library store all <span class="SimpleMath">p</span>-th power maps for prime divisors <span class="SimpleMath">p</span> of the group order.</p>

<p>Power maps of Brauer tables can be derived from the power maps of the underlying ordinary tables.</p>

<p>For (computing and) accessing the <span class="SimpleMath">n</span>-th power map of a character table, <code class="func">PowerMap</code> (<a href="chap73.html#X781FAA497E3B4D1A"><span class="RefLink">73.1-1</span></a>) can be used; if the <span class="SimpleMath">n</span>-th power map cannot be uniquely determined then <code class="func">PowerMap</code> (<a href="chap73.html#X781FAA497E3B4D1A"><span class="RefLink">73.1-1</span></a>) returns <code class="keyw">fail</code>.</p>

<p>The list of all possible <span class="SimpleMath">p</span>-th power maps of a table in the sense that certain necessary conditions are satisfied can be computed with <code class="func">PossiblePowerMaps</code> (<a href="chap73.html#X7C7B292E80590BE0"><span class="RefLink">73.1-2</span></a>). This provides a default strategy, the subroutines are listed in Section <a href="chap73.html#X86472A217D6C3CE7"><span class="RefLink">73.6</span></a>.</p>

<p><a id="X781FAA497E3B4D1A" name="X781FAA497E3B4D1A"></a></p>

<h5>73.1-1 PowerMap</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PowerMap</code>( <var class="Arg">tbl</var>, <var class="Arg">n</var>[, <var class="Arg">class</var>] )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PowerMapOp</code>( <var class="Arg">tbl</var>, <var class="Arg">n</var>[, <var class="Arg">class</var>] )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ComputedPowerMaps</code>( <var class="Arg">tbl</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Called with first argument a character table <var class="Arg">tbl</var> and second argument an integer <var class="Arg">n</var>, <code class="func">PowerMap</code> returns the <var class="Arg">n</var>-th power map of <var class="Arg">tbl</var>. This is a list containing at position <span class="SimpleMath">i</span> the position of the class of <var class="Arg">n</var>-th powers of the elements in the <span class="SimpleMath">i</span>-th class of <var class="Arg">tbl</var>.</p>

<p>If the additional third argument <var class="Arg">class</var> is present then the position of <var class="Arg">n</var>-th powers of the <var class="Arg">class</var>-th class is returned.</p>

<p>If the <var class="Arg">n</var>-th power map is not uniquely determined by <var class="Arg">tbl</var> then <code class="keyw">fail</code> is returned. This can happen only if <var class="Arg">tbl</var> has no access to its underlying group.</p>

<p>The power maps of <var class="Arg">tbl</var> that were computed already by <code class="func">PowerMap</code> are stored in <var class="Arg">tbl</var> as value of the attribute <code class="func">ComputedPowerMaps</code>, the <span class="SimpleMath">n</span>-th power map at position <span class="SimpleMath">n</span>. <code class="func">PowerMap</code> checks whether the desired power map is already stored, computes it using the operation <code class="func">PowerMapOp</code> if it is not yet known, and stores it. So methods for the computation of power maps can be installed for the operation <code class="func">PowerMapOp</code>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tbl:= CharacterTable( "L3(2)" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">ComputedPowerMaps( tbl );</span>
[ , [ 1, 1, 3, 2, 5, 6 ], [ 1, 2, 1, 4, 6, 5 ],,,, 
  [ 1, 2, 3, 4, 1, 1 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PowerMap( tbl, 5 );</span>
[ 1, 2, 3, 4, 6, 5 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">ComputedPowerMaps( tbl );</span>
[ , [ 1, 1, 3, 2, 5, 6 ], [ 1, 2, 1, 4, 6, 5 ],, [ 1, 2, 3, 4, 6, 5 ],
  , [ 1, 2, 3, 4, 1, 1 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PowerMap( tbl, 137, 2 );</span>
2
</pre></div>

<p><a id="X7C7B292E80590BE0" name="X7C7B292E80590BE0"></a></p>

<h5>73.1-2 PossiblePowerMaps</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PossiblePowerMaps</code>( <var class="Arg">tbl</var>, <var class="Arg">p</var>[, <var class="Arg">options</var>] )</td><td class="tdright">( operation )</td></tr></table></div>
<p>For the ordinary character table <var class="Arg">tbl</var> of the group <span class="SimpleMath">G</span>, say, and a prime integer <var class="Arg">p</var>, <code class="func">PossiblePowerMaps</code> returns the list of all maps that have the following properties of the <span class="SimpleMath">p</span>-th power map of <var class="Arg">tbl</var>. (Representative orders are used only if the <code class="func">OrdersClassRepresentatives</code> (<a href="chap71.html#X86F455DA7A9C30EE"><span class="RefLink">71.9-1</span></a>) value of <var class="Arg">tbl</var> is known.</p>

<ol>
<li><p>For class <span class="SimpleMath">i</span>, the centralizer order of the image is a multiple of the <span class="SimpleMath">i</span>-th centralizer order; if the elements in the <span class="SimpleMath">i</span>-th class have order coprime to <span class="SimpleMath">p</span> then the centralizer orders of class <span class="SimpleMath">i</span> and its image are equal.</p>

</li>
<li><p>Let <span class="SimpleMath">n</span> be the order of elements in class <span class="SimpleMath">i</span>. If <var class="Arg">prime</var> divides <span class="SimpleMath">n</span> then the images have order <span class="SimpleMath">n/p</span>; otherwise the images have order <span class="SimpleMath">n</span>. These criteria are checked in <code class="func">InitPowerMap</code> (<a href="chap73.html#X85D068D77C3C041C"><span class="RefLink">73.6-1</span></a>).</p>

</li>
<li><p>For each character <span class="SimpleMath">χ</span> of <span class="SimpleMath">G</span> and each element <span class="SimpleMath">g</span> in <span class="SimpleMath">G</span>, the values <span class="SimpleMath">χ(g^p)</span> and <code class="code">GaloisCyc</code><span class="SimpleMath">( χ(g), p )</span> are algebraic integers that are congruent modulo <span class="SimpleMath">p</span>; if <span class="SimpleMath">p</span> does not divide the element order of <span class="SimpleMath">g</span> then the two values are equal. This congruence is checked for the characters specified below in the discussion of the <var class="Arg">options</var> argument; For linear characters <span class="SimpleMath">λ</span> among these characters, the condition <span class="SimpleMath">χ(g)^p = χ(g^p)</span> is checked. The corresponding function is <code class="func">Congruences</code> (<a href="chap73.html#X7B27749E7BF54EBB"><span class="RefLink">73.6-2</span></a>).</p>

</li>
<li><p>For each character <span class="SimpleMath">χ</span> of <span class="SimpleMath">G</span>, the kernel is a normal subgroup <span class="SimpleMath">N</span>, and <span class="SimpleMath">g^p ∈ N</span> for all <span class="SimpleMath">g ∈ N</span>; moreover, if <span class="SimpleMath">N</span> has index <span class="SimpleMath">p</span> in <span class="SimpleMath">G</span> then <span class="SimpleMath">g^p ∈ N</span> for all <span class="SimpleMath">g ∈ G</span>, and if the index of <span class="SimpleMath">N</span> in <span class="SimpleMath">G</span> is coprime to <span class="SimpleMath">p</span> then <span class="SimpleMath">g^p not ∈ N</span> for each <span class="SimpleMath">g not ∈ N</span>. These conditions are checked for the kernels of all characters <span class="SimpleMath">χ</span> specified below, the corresponding function is <code class="func">ConsiderKernels</code> (<a href="chap73.html#X7D31B1548205E222"><span class="RefLink">73.6-3</span></a>).</p>

</li>
<li><p>If <span class="SimpleMath">p</span> is larger than the order <span class="SimpleMath">m</span> of an element <span class="SimpleMath">g ∈ G</span> then the class of <span class="SimpleMath">g^p</span> is determined by the power maps for primes dividing the residue of <span class="SimpleMath">p</span> modulo <span class="SimpleMath">m</span>. If these power maps are stored in the <code class="func">ComputedPowerMaps</code> (<a href="chap73.html#X781FAA497E3B4D1A"><span class="RefLink">73.1-1</span></a>) value of <var class="Arg">tbl</var> then this information is used. This criterion is checked in <code class="func">ConsiderSmallerPowerMaps</code> (<a href="chap73.html#X7DD1DCF3865E0017"><span class="RefLink">73.6-4</span></a>).</p>

</li>
<li><p>For each character <span class="SimpleMath">χ</span> of <span class="SimpleMath">G</span>, the symmetrization <span class="SimpleMath">ψ</span> defined by <span class="SimpleMath">ψ(g) = (χ(g)^p - χ(g^p))/p</span> is a character. This condition is checked for the kernels of all characters <span class="SimpleMath">χ</span> specified below, the corresponding function is <code class="func">PowerMapsAllowedBySymmetrizations</code> (<a href="chap73.html#X808CCF6087D5B661"><span class="RefLink">73.6-6</span></a>).</p>

</li>
</ol>
<p>If <var class="Arg">tbl</var> is a Brauer table, the possibilities are computed from those for the underlying ordinary table.</p>

<p>The optional argument <var class="Arg">options</var>, if given, must be a record that may have the following components:</p>


<dl>
<dt><strong class="Mark"><code class="code">chars</code>:</strong></dt>
<dd><p>a list of characters which are used for the check of the criteria 3., 4., and 6.; the default is <code class="code">Irr( <var class="Arg">tbl</var> )</code>,</p>

</dd>
<dt><strong class="Mark"><code class="code">powermap</code>:</strong></dt>
<dd><p>a parametrized map which is an approximation of the desired map</p>

</dd>
<dt><strong class="Mark"><code class="code">decompose</code>:</strong></dt>
<dd><p>a Boolean; a <code class="keyw">true</code> value indicates that all constituents of the symmetrizations of <code class="code">chars</code> computed for criterion 6. lie in <code class="code">chars</code>, so the symmetrizations can be decomposed into elements of <code class="code">chars</code>; the default value of <code class="code">decompose</code> is <code class="keyw">true</code> if <code class="code">chars</code> is not bound and <code class="code">Irr( <var class="Arg">tbl</var> )</code> is known, otherwise <code class="keyw">false</code>,</p>

</dd>
<dt><strong class="Mark"><code class="code">quick</code>:</strong></dt>
<dd><p>a Boolean; if <code class="keyw">true</code> then the subroutines are called with value <code class="keyw">true</code> for the argument <var class="Arg">quick</var>; especially, as soon as only one candidate remains this candidate is returned immediately; the default value is <code class="keyw">false</code>,</p>

</dd>
<dt><strong class="Mark"><code class="code">parameters</code>:</strong></dt>
<dd><p>a record with components <code class="code">maxamb</code>, <code class="code">minamb</code> and <code class="code">maxlen</code> which control the subroutine <code class="func">PowerMapsAllowedBySymmetrizations</code> (<a href="chap73.html#X808CCF6087D5B661"><span class="RefLink">73.6-6</span></a>); it only uses characters with current indeterminateness up to <code class="code">maxamb</code>, tests decomposability only for characters with current indeterminateness at least <code class="code">minamb</code>, and admits a branch according to a character only if there is one with at most <code class="code">maxlen</code> possible symmetrizations.</p>

</dd>
</dl>

<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tbl:= CharacterTable( "U4(3).4" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PossiblePowerMaps( tbl, 2 );</span>
[ [ 1, 1, 3, 4, 5, 2, 2, 8, 3, 4, 11, 12, 6, 14, 9, 1, 1, 2, 2, 3, 4, 
      5, 6, 8, 9, 9, 10, 11, 12, 16, 16, 16, 16, 17, 17, 18, 18, 18, 
      18, 20, 20, 20, 20, 22, 22, 24, 24, 25, 26, 28, 28, 29, 29 ] ]
</pre></div>

<p><a id="X7E0289957E9D62EE" name="X7E0289957E9D62EE"></a></p>

<h5>73.1-3 ElementOrdersPowerMap</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ElementOrdersPowerMap</code>( <var class="Arg">powermap</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Let <var class="Arg">powermap</var> be a nonempty list containing at position <span class="SimpleMath">p</span>, if bound, the <span class="SimpleMath">p</span>-th power map of a character table or group. <code class="func">ElementOrdersPowerMap</code> returns a list of the same length as each entry in <var class="Arg">powermap</var>, with entry at position <span class="SimpleMath">i</span> equal to the order of elements in class <span class="SimpleMath">i</span> if this order is uniquely determined by <var class="Arg">powermap</var>, and equal to an unknown (see Chapter <a href="chap74.html#X7C1FAB6280A02CCB"><span class="RefLink">74</span></a>) otherwise.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tbl:= CharacterTable( "U4(3).4" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">known:= ComputedPowerMaps( tbl );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Length( known );</span>
7
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">sub:= ShallowCopy( known );;  Unbind( sub[7] );</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">ElementOrdersPowerMap( sub );</span>
[ 1, 2, 3, 3, 3, 4, 4, 5, 6, 6, Unknown(1), Unknown(2), 8, 9, 12, 2, 
  2, 4, 4, 6, 6, 6, 8, 10, 12, 12, 12, Unknown(3), Unknown(4), 4, 4, 
  4, 4, 4, 4, 8, 8, 8, 8, 12, 12, 12, 12, 12, 12, 20, 20, 24, 24, 
  Unknown(5), Unknown(6), Unknown(7), Unknown(8) ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">ord:= ElementOrdersPowerMap( known );</span>
[ 1, 2, 3, 3, 3, 4, 4, 5, 6, 6, 7, 7, 8, 9, 12, 2, 2, 4, 4, 6, 6, 6, 
  8, 10, 12, 12, 12, 14, 14, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 12, 12, 
  12, 12, 12, 12, 20, 20, 24, 24, 28, 28, 28, 28 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">ord = OrdersClassRepresentatives( tbl );</span>
true
</pre></div>

<p><a id="X7C0F171F7DC846B7" name="X7C0F171F7DC846B7"></a></p>

<h5>73.1-4 PowerMapByComposition</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PowerMapByComposition</code>( <var class="Arg">tbl</var>, <var class="Arg">n</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p><var class="Arg">tbl</var> must be a nearly character table, and <var class="Arg">n</var> a positive integer. If the power maps for all prime divisors of <var class="Arg">n</var> are stored in the <code class="func">ComputedPowerMaps</code> (<a href="chap73.html#X781FAA497E3B4D1A"><span class="RefLink">73.1-1</span></a>) list of <var class="Arg">tbl</var> then <code class="func">PowerMapByComposition</code> returns the <var class="Arg">n</var>-th power map of <var class="Arg">tbl</var>. Otherwise <code class="keyw">fail</code> is returned.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tbl:= CharacterTable( "U4(3).4" );;  exp:= Exponent( tbl );</span>
2520
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PowerMapByComposition( tbl, exp );</span>
[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
  1, 1, 1, 1, 1, 1, 1, 1, 1 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Length( ComputedPowerMaps( tbl ) );</span>
7
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PowerMapByComposition( tbl, 11 );</span>
fail
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PowerMap( tbl, 11 );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PowerMapByComposition( tbl, 11 );</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, 26, 25, 27, 28, 29, 31, 30, 33, 32, 35, 34, 37, 
  36, 39, 38, 41, 40, 43, 42, 45, 44, 47, 46, 49, 48, 51, 50, 53, 52 ]
</pre></div>

<p><a id="X80980FF37F0D521B" name="X80980FF37F0D521B"></a></p>

<h4>73.2 <span class="Heading">Orbits on Sets of Possible Power Maps</span></h4>

<p>The permutation group of matrix automorphisms (see <code class="func">MatrixAutomorphisms</code> (<a href="chap71.html#X84353BB884AF0365"><span class="RefLink">71.22-1</span></a>)) acts on the possible power maps returned by <code class="func">PossiblePowerMaps</code> (<a href="chap73.html#X7C7B292E80590BE0"><span class="RefLink">73.1-2</span></a>) by permuting a list via <code class="func">Permuted</code> (<a href="chap21.html#X7B5A19098406347A"><span class="RefLink">21.20-18</span></a>) and then mapping the images via <code class="func">OnPoints</code> (<a href="chap41.html#X7FE417DD837987B4"><span class="RefLink">41.2-1</span></a>). Note that by definition, the group of <em>table</em> automorphisms acts trivially.</p>

<p><a id="X7ECB9DDE8608B9A9" name="X7ECB9DDE8608B9A9"></a></p>

<h5>73.2-1 OrbitPowerMaps</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; OrbitPowerMaps</code>( <var class="Arg">map</var>, <var class="Arg">permgrp</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>returns the orbit of the power map <var class="Arg">map</var> under the action of the permutation group <var class="Arg">permgrp</var> via a combination of <code class="func">Permuted</code> (<a href="chap21.html#X7B5A19098406347A"><span class="RefLink">21.20-18</span></a>) and <code class="func">OnPoints</code> (<a href="chap41.html#X7FE417DD837987B4"><span class="RefLink">41.2-1</span></a>).</p>

<p><a id="X8753F5217A570529" name="X8753F5217A570529"></a></p>

<h5>73.2-2 RepresentativesPowerMaps</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; RepresentativesPowerMaps</code>( <var class="Arg">listofmaps</var>, <var class="Arg">permgrp</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>returns a list of orbit representatives of the power maps in the list <var class="Arg">listofmaps</var> under the action of the permutation group <var class="Arg">permgrp</var> via a combination of <code class="func">Permuted</code> (<a href="chap21.html#X7B5A19098406347A"><span class="RefLink">21.20-18</span></a>) and <code class="func">OnPoints</code> (<a href="chap41.html#X7FE417DD837987B4"><span class="RefLink">41.2-1</span></a>).</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tbl:= CharacterTable( "3.McL" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">grp:= MatrixAutomorphisms( Irr( tbl ) );  Size( grp );</span>
&lt;permutation group with 5 generators&gt;
32
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">poss:= PossiblePowerMaps( CharacterTable( "3.McL" ), 3 );</span>
[ [ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17, 
      4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 9, 8, 37, 
      37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49, 
      49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ], 
  [ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17, 
      4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 8, 9, 37, 
      37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49, 
      49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">reps:= RepresentativesPowerMaps( poss, grp );</span>
[ [ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17, 
      4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 8, 9, 37, 
      37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49, 
      49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">orb:= OrbitPowerMaps( reps[1], grp );</span>
[ [ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17, 
      4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 8, 9, 37, 
      37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49, 
      49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ], 
  [ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17, 
      4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 9, 8, 37, 
      37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49, 
      49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Parametrized( orb );</span>
[ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17, 
  4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, [ 8, 9 ], 
  [ 8, 9 ], 37, 37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 
  52, 49, 49, 49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ]
</pre></div>

<p><a id="X806975FE81534444" name="X806975FE81534444"></a></p>

<h4>73.3 <span class="Heading">Class Fusions between Character Tables</span></h4>

<p>For a group <span class="SimpleMath">G</span> and a subgroup <span class="SimpleMath">H</span> of <span class="SimpleMath">G</span>, the fusion map between the character table of <span class="SimpleMath">H</span> and the character table of <span class="SimpleMath">G</span> is represented by a list that stores at position <span class="SimpleMath">i</span> the position of the <span class="SimpleMath">i</span>-th class of the table of <span class="SimpleMath">H</span> in the classes list of the table of <span class="SimpleMath">G</span>.</p>

<p>For ordinary character tables <var class="Arg">tbl1</var> and <var class="Arg">tbl2</var> of <span class="SimpleMath">H</span> and <span class="SimpleMath">G</span>, with access to the groups <span class="SimpleMath">H</span> and <span class="SimpleMath">G</span>, the class fusion between <var class="Arg">tbl1</var> and <var class="Arg">tbl2</var> can be computed using the identifications of the conjugacy classes of <span class="SimpleMath">H</span> with the classes of <var class="Arg">tbl1</var> and the conjugacy classes of <span class="SimpleMath">G</span> with the classes of <var class="Arg">tbl2</var>. For two ordinary character tables without access to an underlying group, or in the situation that the group stored in <var class="Arg">tbl1</var> is not physically a subgroup of the group stored in <var class="Arg">tbl2</var> but an isomorphic copy, in general the class fusion is not uniquely determined by the information stored on the tables such as irreducible characters and power maps. So only necessary conditions can be checked in this case, which in general yields only a list of several possibilities for the desired class fusion. Character tables of the <strong class="pkg">GAP</strong> character table library store various class fusions that are regarded as important, for example fusions from maximal subgroups (see <code class="func">ComputedClassFusions</code> (<a href="chap73.html#X7F71402285B7DE8E"><span class="RefLink">73.3-2</span></a>) and <code class="func">Maxes</code> (<a href="../../pkg/ctbllib/doc/chap3.html#X8150E63F7DBDF252"><span class="RefLink">CTblLib: Maxes</span></a>) in the manual for the <strong class="pkg">GAP</strong> Character Table Library).</p>

<p>Class fusions between Brauer tables can be derived from the class fusions between the underlying ordinary tables. The class fusion from a Brauer table to the underlying ordinary table is stored when the Brauer table is constructed from the ordinary table, so no method is needed to compute such a fusion.</p>

<p>For (computing and) accessing the class fusion between two character tables, <code class="func">FusionConjugacyClasses</code> (<a href="chap73.html#X86CE53B681F13C63"><span class="RefLink">73.3-1</span></a>) can be used; if the class fusion cannot be uniquely determined then <code class="func">FusionConjugacyClasses</code> (<a href="chap73.html#X86CE53B681F13C63"><span class="RefLink">73.3-1</span></a>) returns <code class="keyw">fail</code>.</p>

<p>The list of all possible class fusion between two tables in the sense that certain necessary conditions are satisfied can be computed with <code class="func">PossibleClassFusions</code> (<a href="chap73.html#X7883271F7F26356E"><span class="RefLink">73.3-6</span></a>). This provides a default strategy, the subroutines are listed in Section <a href="chap73.html#X7AF7305D80E1E5EF"><span class="RefLink">73.7</span></a>.</p>

<p>It should be noted that all the following functions except <code class="func">FusionConjugacyClasses</code> (<a href="chap73.html#X86CE53B681F13C63"><span class="RefLink">73.3-1</span></a>) deal only with the situation of class fusions from subgroups. The computation of <em>factor fusions</em> from a character table to the table of a factor group is not dealt with here. Since the ordinary character table of a group <span class="SimpleMath">G</span> determines the character tables of all factor groups of <span class="SimpleMath">G</span>, the factor fusion to a given character table of a factor group of <span class="SimpleMath">G</span> is determined up to table automorphisms (see <code class="func">AutomorphismsOfTable</code> (<a href="chap71.html#X7C2753DE8094F4BA"><span class="RefLink">71.9-4</span></a>)) once the class positions of the kernel of the natural epimorphism have been fixed.</p>

<p><a id="X86CE53B681F13C63" name="X86CE53B681F13C63"></a></p>

<h5>73.3-1 <span class="Heading">FusionConjugacyClasses</span></h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; FusionConjugacyClasses</code>( <var class="Arg">tbl1</var>, <var class="Arg">tbl2</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; FusionConjugacyClasses</code>( <var class="Arg">H</var>, <var class="Arg">G</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; FusionConjugacyClasses</code>( <var class="Arg">hom</var>[, <var class="Arg">tbl1</var>, <var class="Arg">tbl2</var>] )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; FusionConjugacyClassesOp</code>( <var class="Arg">tbl1</var>, <var class="Arg">tbl2</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; FusionConjugacyClassesOp</code>( <var class="Arg">hom</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Called with two character tables <var class="Arg">tbl1</var> and <var class="Arg">tbl2</var>, <code class="func">FusionConjugacyClasses</code> returns the fusion of conjugacy classes between <var class="Arg">tbl1</var> and <var class="Arg">tbl2</var>. (If one of the tables is a Brauer table, it will delegate this task to the underlying ordinary table.)</p>

<p>Called with two groups <var class="Arg">H</var> and <var class="Arg">G</var> where <var class="Arg">H</var> is a subgroup of <var class="Arg">G</var>, <code class="func">FusionConjugacyClasses</code> returns the fusion of conjugacy classes between <var class="Arg">H</var> and <var class="Arg">G</var>. This is done by delegating to the ordinary character tables of <var class="Arg">H</var> and <var class="Arg">G</var>, since class fusions are stored only for character tables and not for groups.</p>

<p>Note that the returned class fusion refers to the ordering of conjugacy classes in the character tables if the arguments are character tables and to the ordering of conjugacy classes in the groups if the arguments are groups (see <code class="func">ConjugacyClasses</code> (<a href="chap71.html#X849A38F887F6EC86"><span class="RefLink">71.6-2</span></a>)).</p>

<p>Called with a group homomorphism <var class="Arg">hom</var>, <code class="func">FusionConjugacyClasses</code> returns the fusion of conjugacy classes between the preimage and the image of <var class="Arg">hom</var>; contrary to the two cases above, also factor fusions can be handled by this variant. If <var class="Arg">hom</var> is the only argument then the class fusion refers to the ordering of conjugacy classes in the groups. If the character tables of preimage and image are given as <var class="Arg">tbl1</var> and <var class="Arg">tbl2</var>, respectively (each table with its group stored), then the fusion refers to the ordering of classes in these tables.</p>

<p>If no class fusion exists or if the class fusion is not uniquely determined, <code class="keyw">fail</code> is returned; this may happen when <code class="func">FusionConjugacyClasses</code> is called with two character tables that do not know compatible underlying groups.</p>

<p>Methods for the computation of class fusions can be installed for the operation <code class="func">FusionConjugacyClassesOp</code>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">s4:= SymmetricGroup( 4 );</span>
Sym( [ 1 .. 4 ] )
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tbls4:= CharacterTable( s4 );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">d8:= SylowSubgroup( s4, 2 );</span>
Group([ (1,2), (3,4), (1,3)(2,4) ])
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">FusionConjugacyClasses( d8, s4 );</span>
[ 1, 2, 3, 3, 5 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tbls5:= CharacterTable( "S5" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">FusionConjugacyClasses( CharacterTable( "A5" ), tbls5 );</span>
[ 1, 2, 3, 4, 4 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">FusionConjugacyClasses(CharacterTable("A5"), CharacterTable("J1"));</span>
fail
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PossibleClassFusions(CharacterTable("A5"), CharacterTable("J1"));</span>
[ [ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 5, 4 ] ]
</pre></div>

<p><a id="X7F71402285B7DE8E" name="X7F71402285B7DE8E"></a></p>

<h5>73.3-2 ComputedClassFusions</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ComputedClassFusions</code>( <var class="Arg">tbl</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>The class fusions from the character table <var class="Arg">tbl</var> that have been computed already by <code class="func">FusionConjugacyClasses</code> (<a href="chap73.html#X86CE53B681F13C63"><span class="RefLink">73.3-1</span></a>) or explicitly stored by <code class="func">StoreFusion</code> (<a href="chap73.html#X808970FE87C3432F"><span class="RefLink">73.3-4</span></a>) are stored in the <code class="func">ComputedClassFusions</code> list of <var class="Arg">tbl1</var>. Each entry of this list is a record with the following components.</p>


<dl>
<dt><strong class="Mark"><code class="code">name</code></strong></dt>
<dd><p>the <code class="func">Identifier</code> (<a href="chap71.html#X79C40EE97890202F"><span class="RefLink">71.9-8</span></a>) value of the character table to which the fusion maps,</p>

</dd>
<dt><strong class="Mark"><code class="code">map</code></strong></dt>
<dd><p>the list of positions of image classes,</p>

</dd>
<dt><strong class="Mark"><code class="code">text</code> (optional)</strong></dt>
<dd><p>a string giving additional information about the fusion map, for example whether the map is uniquely determined by the character tables,</p>

</dd>
<dt><strong class="Mark"><code class="code">specification</code> (optional, rarely used)</strong></dt>
<dd><p>a value that distinguishes different fusions between the same tables.</p>

</dd>
</dl>
<p>Note that stored fusion maps may differ from the maps returned by <code class="func">GetFusionMap</code> (<a href="chap73.html#X8464DD23879431D9"><span class="RefLink">73.3-3</span></a>) and the maps entered by <code class="func">StoreFusion</code> (<a href="chap73.html#X808970FE87C3432F"><span class="RefLink">73.3-4</span></a>) if the table <var class="Arg">destination</var> has a nonidentity <code class="func">ClassPermutation</code> (<a href="chap71.html#X8099FEDC7DE03AEE"><span class="RefLink">71.21-5</span></a>) value. So if one fetches a fusion map from a table <var class="Arg">tbl1</var> to a table <var class="Arg">tbl2</var> via access to the data in the <code class="func">ComputedClassFusions</code> list of <var class="Arg">tbl1</var> then the stored value must be composed with the <code class="func">ClassPermutation</code> (<a href="chap71.html#X8099FEDC7DE03AEE"><span class="RefLink">71.21-5</span></a>) value of <var class="Arg">tbl2</var> in order to obtain the correct class fusion. (If one handles fusions only via <code class="func">GetFusionMap</code> (<a href="chap73.html#X8464DD23879431D9"><span class="RefLink">73.3-3</span></a>) and <code class="func">StoreFusion</code> (<a href="chap73.html#X808970FE87C3432F"><span class="RefLink">73.3-4</span></a>) then this adjustment is made automatically.)</p>

<p>Fusions are identified via the <code class="func">Identifier</code> (<a href="chap71.html#X79C40EE97890202F"><span class="RefLink">71.9-8</span></a>) value of the destination table and not by this table itself because many fusions between character tables in the <strong class="pkg">GAP</strong> character table library are stored on library tables, and it is not desirable to load together with a library table also all those character tables that occur as destinations of fusions from this table.</p>

<p>For storing fusions and accessing stored fusions, see also <code class="func">GetFusionMap</code> (<a href="chap73.html#X8464DD23879431D9"><span class="RefLink">73.3-3</span></a>), <code class="func">StoreFusion</code> (<a href="chap73.html#X808970FE87C3432F"><span class="RefLink">73.3-4</span></a>). For accessing the identifiers of tables that store a fusion into a given character table, see <code class="func">NamesOfFusionSources</code> (<a href="chap73.html#X7F6569D5786A9D49"><span class="RefLink">73.3-5</span></a>).</p>

<p><a id="X8464DD23879431D9" name="X8464DD23879431D9"></a></p>

<h5>73.3-3 GetFusionMap</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; GetFusionMap</code>( <var class="Arg">source</var>, <var class="Arg">destination</var>[, <var class="Arg">specification</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>For two ordinary character tables <var class="Arg">source</var> and <var class="Arg">destination</var>, <code class="func">GetFusionMap</code> checks whether the <code class="func">ComputedClassFusions</code> (<a href="chap73.html#X7F71402285B7DE8E"><span class="RefLink">73.3-2</span></a>) list of <var class="Arg">source</var> contains a record with <code class="code">name</code> component <code class="code">Identifier( <var class="Arg">destination</var> )</code>, and returns returns the <code class="code">map</code> component of the first such record. <code class="code">GetFusionMap( <var class="Arg">source</var>, <var class="Arg">destination</var>, <var class="Arg">specification</var> )</code> fetches that fusion map for which the record additionally has the <code class="code">specification</code> component <var class="Arg">specification</var>.</p>

<p>If both <var class="Arg">source</var> and <var class="Arg">destination</var> are Brauer tables, first the same is done, and if no fusion map was found then <code class="func">GetFusionMap</code> looks whether a fusion map between the ordinary tables is stored; if so then the fusion map between <var class="Arg">source</var> and <var class="Arg">destination</var> is stored on <var class="Arg">source</var>, and then returned.</p>

<p>If no appropriate fusion is found, <code class="func">GetFusionMap</code> returns <code class="keyw">fail</code>. For the computation of class fusions, see <code class="func">FusionConjugacyClasses</code> (<a href="chap73.html#X86CE53B681F13C63"><span class="RefLink">73.3-1</span></a>).</p>

<p><a id="X808970FE87C3432F" name="X808970FE87C3432F"></a></p>

<h5>73.3-4 StoreFusion</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; StoreFusion</code>( <var class="Arg">source</var>, <var class="Arg">fusion</var>, <var class="Arg">destination</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>For two character tables <var class="Arg">source</var> and <var class="Arg">destination</var>, <code class="func">StoreFusion</code> stores the fusion <var class="Arg">fusion</var> from <var class="Arg">source</var> to <var class="Arg">destination</var> in the <code class="func">ComputedClassFusions</code> (<a href="chap73.html#X7F71402285B7DE8E"><span class="RefLink">73.3-2</span></a>) list of <var class="Arg">source</var>, and adds the <code class="func">Identifier</code> (<a href="chap71.html#X79C40EE97890202F"><span class="RefLink">71.9-8</span></a>) string of <var class="Arg">destination</var> to the <code class="func">NamesOfFusionSources</code> (<a href="chap73.html#X7F6569D5786A9D49"><span class="RefLink">73.3-5</span></a>) list of <var class="Arg">destination</var>.</p>

<p><var class="Arg">fusion</var> can either be a fusion map (that is, the list of positions of the image classes) or a record as described in <code class="func">ComputedClassFusions</code> (<a href="chap73.html#X7F71402285B7DE8E"><span class="RefLink">73.3-2</span></a>).</p>

<p>If fusions to <var class="Arg">destination</var> are already stored on <var class="Arg">source</var> then another fusion can be stored only if it has a record component <code class="code">specification</code> that distinguishes it from the stored fusions. In the case of such an ambiguity, <code class="func">StoreFusion</code> raises an error.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tbld8:= CharacterTable( d8 );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">ComputedClassFusions( tbld8 );</span>
[ rec( map := [ 1, 2, 3, 3, 5 ], name := "CT1" ) ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Identifier( tbls4 );</span>
"CT1"
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">GetFusionMap( tbld8, tbls4 );</span>
[ 1, 2, 3, 3, 5 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">GetFusionMap( tbls4, tbls5 );</span>
fail
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">poss:= PossibleClassFusions( tbls4, tbls5 );</span>
[ [ 1, 5, 2, 3, 6 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">StoreFusion( tbls4, poss[1], tbls5 );</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">GetFusionMap( tbls4, tbls5 );</span>
[ 1, 5, 2, 3, 6 ]
</pre></div>

<p><a id="X7F6569D5786A9D49" name="X7F6569D5786A9D49"></a></p>

<h5>73.3-5 NamesOfFusionSources</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; NamesOfFusionSources</code>( <var class="Arg">tbl</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>For a character table <var class="Arg">tbl</var>, <code class="func">NamesOfFusionSources</code> returns the list of identifiers of all those character tables that are known to have fusions to <var class="Arg">tbl</var> stored. The <code class="func">NamesOfFusionSources</code> value is updated whenever a fusion to <var class="Arg">tbl</var> is stored using <code class="func">StoreFusion</code> (<a href="chap73.html#X808970FE87C3432F"><span class="RefLink">73.3-4</span></a>).</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">NamesOfFusionSources( tbls4 );</span>
[ "CT2" ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Identifier( CharacterTable( d8 ) );</span>
"CT2"
</pre></div>

<p><a id="X7883271F7F26356E" name="X7883271F7F26356E"></a></p>

<h5>73.3-6 PossibleClassFusions</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PossibleClassFusions</code>( <var class="Arg">subtbl</var>, <var class="Arg">tbl</var>[, <var class="Arg">options</var>] )</td><td class="tdright">( operation )</td></tr></table></div>
<p>For two ordinary character tables <var class="Arg">subtbl</var> and <var class="Arg">tbl</var> of the groups <span class="SimpleMath">H</span> and <span class="SimpleMath">G</span>, say, <code class="func">PossibleClassFusions</code> returns the list of all maps that have the following properties of class fusions from <var class="Arg">subtbl</var> to <var class="Arg">tbl</var>.</p>

<ol>
<li><p>For class <span class="SimpleMath">i</span>, the centralizer order of the image in <span class="SimpleMath">G</span> is a multiple of the <span class="SimpleMath">i</span>-th centralizer order in <span class="SimpleMath">H</span>, and the element orders in the <span class="SimpleMath">i</span>-th class and its image are equal. These criteria are checked in <code class="func">InitFusion</code> (<a href="chap73.html#X7E2BC50C86A16604"><span class="RefLink">73.7-1</span></a>).</p>

</li>
<li><p>The class fusion commutes with power maps. This is checked using <code class="func">TestConsistencyMaps</code> (<a href="chap73.html#X78487F03852A503B"><span class="RefLink">73.5-12</span></a>).</p>

</li>
<li><p>If the permutation character of <span class="SimpleMath">G</span> corresponding to the action of <span class="SimpleMath">G</span> on the cosets of <span class="SimpleMath">H</span> is specified (see the discussion of the <var class="Arg">options</var> argument below) then it prescribes for each class <span class="SimpleMath">C</span> of <span class="SimpleMath">G</span> the number of elements of <span class="SimpleMath">H</span> fusing into <span class="SimpleMath">C</span>. The corresponding function is <code class="func">CheckPermChar</code> (<a href="chap73.html#X82F776A3850C6404"><span class="RefLink">73.7-2</span></a>).</p>

</li>
<li><p>The table automorphisms of <var class="Arg">tbl</var> (see <code class="func">AutomorphismsOfTable</code> (<a href="chap71.html#X7C2753DE8094F4BA"><span class="RefLink">71.9-4</span></a>)) are used in order to compute only orbit representatives. (But note that the list returned by <code class="func">PossibleClassFusions</code> contains the full orbits.)</p>

</li>
<li><p>For each character <span class="SimpleMath">χ</span> of <span class="SimpleMath">G</span>, the restriction to <span class="SimpleMath">H</span> via the class fusion is a character of <span class="SimpleMath">H</span>. This condition is checked for all characters specified below, the corresponding function is <code class="func">FusionsAllowedByRestrictions</code> (<a href="chap73.html#X85024BAE8585DB1C"><span class="RefLink">73.7-4</span></a>).</p>

</li>
<li><p>The class multiplication coefficients in <var class="Arg">subtbl</var> do not exceed the corresponding coefficients in <var class="Arg">tbl</var>. This is checked in <code class="func">ConsiderStructureConstants</code> (<a href="chap73.html#X7BCC5B4B7E9DF42C"><span class="RefLink">73.3-7</span></a>), see also the comment on the parameter <code class="code">verify</code> below.</p>

</li>
</ol>
<p>If <var class="Arg">subtbl</var> and <var class="Arg">tbl</var> are Brauer tables then the possibilities are computed from those for the underlying ordinary tables.</p>

<p>The optional argument <var class="Arg">options</var> must be a record that may have the following components:</p>


<dl>
<dt><strong class="Mark"><code class="code">chars</code></strong></dt>
<dd><p>a list of characters of <var class="Arg">tbl</var> which are used for the check of 5.; the default is <code class="code">Irr( <var class="Arg">tbl</var> )</code>,</p>

</dd>
<dt><strong class="Mark"><code class="code">subchars</code></strong></dt>
<dd><p>a list of characters of <var class="Arg">subtbl</var> which are constituents of the restrictions of <code class="code">chars</code>, the default is <code class="code">Irr( <var class="Arg">subtbl</var> )</code>,</p>

</dd>
<dt><strong class="Mark"><code class="code">fusionmap</code></strong></dt>
<dd><p>a parametrized map which is an approximation of the desired map,</p>

</dd>
<dt><strong class="Mark"><code class="code">decompose</code></strong></dt>
<dd><p>a Boolean; a <code class="keyw">true</code> value indicates that all constituents of the restrictions of <code class="code">chars</code> computed for criterion 5. lie in <code class="code">subchars</code>, so the restrictions can be decomposed into elements of <code class="code">subchars</code>; the default value of <code class="code">decompose</code> is <code class="keyw">true</code> if <code class="code">subchars</code> is not bound and <code class="code">Irr( <var class="Arg">subtbl</var> )</code> is known, otherwise <code class="keyw">false</code>,</p>

</dd>
<dt><strong class="Mark"><code class="code">permchar</code></strong></dt>
<dd><p>(a values list of) a permutation character; only those fusions affording that permutation character are computed,</p>

</dd>
<dt><strong class="Mark"><code class="code">quick</code></strong></dt>
<dd><p>a Boolean; if <code class="keyw">true</code> then the subroutines are called with value <code class="keyw">true</code> for the argument <var class="Arg">quick</var>; especially, as soon as only one possibility remains then this possibility is returned immediately; the default value is <code class="keyw">false</code>,</p>

</dd>
<dt><strong class="Mark"><code class="code">verify</code></strong></dt>
<dd><p>a Boolean; if <code class="keyw">false</code> then <code class="func">ConsiderStructureConstants</code> (<a href="chap73.html#X7BCC5B4B7E9DF42C"><span class="RefLink">73.3-7</span></a>) is called only if more than one orbit of possible class fusions exists, under the action of the groups of table automorphisms; the default value is <code class="keyw">false</code> (because the computation of the structure constants is usually very time consuming, compared with checking the other criteria),</p>

</dd>
<dt><strong class="Mark"><code class="code">parameters</code></strong></dt>
<dd><p>a record with components <code class="code">maxamb</code>, <code class="code">minamb</code> and <code class="code">maxlen</code> which control the subroutine <code class="func">FusionsAllowedByRestrictions</code> (<a href="chap73.html#X85024BAE8585DB1C"><span class="RefLink">73.7-4</span></a>); it only uses characters with current indeterminateness up to <code class="code">maxamb</code>, tests decomposability only for characters with current indeterminateness at least <code class="code">minamb</code>, and admits a branch according to a character only if there is one with at most <code class="code">maxlen</code> possible restrictions.</p>

</dd>
</dl>

<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">subtbl:= CharacterTable( "U3(3)" );;  tbl:= CharacterTable( "J4" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PossibleClassFusions( subtbl, tbl );</span>
[ [ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ], 
  [ 1, 2, 4, 4, 5, 5, 6, 10, 13, 12, 14, 14, 21, 21 ], 
  [ 1, 2, 4, 4, 6, 6, 6, 10, 12, 13, 15, 15, 22, 22 ], 
  [ 1, 2, 4, 4, 6, 6, 6, 10, 12, 13, 16, 16, 22, 22 ], 
  [ 1, 2, 4, 4, 6, 6, 6, 10, 13, 12, 15, 15, 22, 22 ], 
  [ 1, 2, 4, 4, 6, 6, 6, 10, 13, 12, 16, 16, 22, 22 ] ]
</pre></div>

<p><a id="X7BCC5B4B7E9DF42C" name="X7BCC5B4B7E9DF42C"></a></p>

<h5>73.3-7 ConsiderStructureConstants</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ConsiderStructureConstants</code>( <var class="Arg">subtbl</var>, <var class="Arg">tbl</var>, <var class="Arg">fusions</var>, <var class="Arg">quick</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Let <var class="Arg">subtbl</var> and <var class="Arg">tbl</var> be ordinary character tables and <var class="Arg">fusions</var> be a list of possible class fusions from <var class="Arg">subtbl</var> to <var class="Arg">tbl</var>. <code class="func">ConsiderStructureConstants</code> returns the list of those maps <span class="SimpleMath">σ</span> in <var class="Arg">fusions</var> with the property that for all triples <span class="SimpleMath">(i,j,k)</span> of class positions, <code class="code">ClassMultiplicationCoefficient</code><span class="SimpleMath">( <var class="Arg">subtbl</var>, i, j, k )</span> is not bigger than <code class="code">ClassMultiplicationCoefficient</code><span class="SimpleMath">( <var class="Arg">tbl</var>, σ[i], σ[j], σ[k] )</span>; see <code class="func">ClassMultiplicationCoefficient</code> (<a href="chap71.html#X7E2EA9FE7D3062D3"><span class="RefLink">71.12-7</span></a>) for the definition of class multiplication coefficients/structure constants.</p>

<p>The argument <var class="Arg">quick</var> must be a Boolean; if it is <code class="keyw">true</code> then only those triples are checked for which for which at least two entries in <var class="Arg">fusions</var> have different images.</p>

<p><a id="X7C34060278E4BFC4" name="X7C34060278E4BFC4"></a></p>

<h4>73.4 <span class="Heading">Orbits on Sets of Possible Class Fusions</span></h4>

<p>The permutation groups of table automorphisms (see <code class="func">AutomorphismsOfTable</code> (<a href="chap71.html#X7C2753DE8094F4BA"><span class="RefLink">71.9-4</span></a>)) of the subgroup table <var class="Arg">subtbl</var> and the supergroup table <var class="Arg">tbl</var> act on the possible class fusions from <var class="Arg">subtbl</var> to <var class="Arg">tbl</var> that are returned by <code class="func">PossibleClassFusions</code> (<a href="chap73.html#X7883271F7F26356E"><span class="RefLink">73.3-6</span></a>), the former by permuting a list via <code class="func">Permuted</code> (<a href="chap21.html#X7B5A19098406347A"><span class="RefLink">21.20-18</span></a>), the latter by mapping the images via <code class="func">OnPoints</code> (<a href="chap41.html#X7FE417DD837987B4"><span class="RefLink">41.2-1</span></a>).</p>

<p>If a set of possible fusions with certain properties was computed that are not invariant under the full groups of table automorphisms then only a smaller group acts on this set. This may happen for example if a permutation character or if an explicit approximation of the fusion map was prescribed in the call of <code class="func">PossibleClassFusions</code> (<a href="chap73.html#X7883271F7F26356E"><span class="RefLink">73.3-6</span></a>).</p>

<p><a id="X79A0FE1C853302D2" name="X79A0FE1C853302D2"></a></p>

<h5>73.4-1 OrbitFusions</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; OrbitFusions</code>( <var class="Arg">subtblautomorphisms</var>, <var class="Arg">fusionmap</var>, <var class="Arg">tblautomorphisms</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>returns the orbit of the class fusion map <var class="Arg">fusionmap</var> under the actions of the permutation groups <var class="Arg">subtblautomorphisms</var> and <var class="Arg">tblautomorphisms</var> of automorphisms of the character table of the subgroup and the supergroup, respectively.</p>

<p><a id="X821D11D180B5D317" name="X821D11D180B5D317"></a></p>

<h5>73.4-2 RepresentativesFusions</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; RepresentativesFusions</code>( <var class="Arg">subtbl</var>, <var class="Arg">listofmaps</var>, <var class="Arg">tbl</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Let <var class="Arg">listofmaps</var> be a list of class fusions from the character table <var class="Arg">subtbl</var> to the character table <var class="Arg">tbl</var>. <code class="func">RepresentativesFusions</code> returns a list of orbit representatives of the class fusions under the action of maximal admissible subgroups of the table automorphism groups of these character tables.</p>

<p>Instead of the character tables <var class="Arg">subtbl</var> and <var class="Arg">tbl</var>, also the permutation groups of their table automorphisms (see <code class="func">AutomorphismsOfTable</code> (<a href="chap71.html#X7C2753DE8094F4BA"><span class="RefLink">71.9-4</span></a>)) may be entered.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus:= GetFusionMap( subtbl, tbl );</span>
[ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">orb:= OrbitFusions( AutomorphismsOfTable( subtbl ), fus,</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">             AutomorphismsOfTable( tbl ) );</span>
[ [ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ], 
  [ 1, 2, 4, 4, 5, 5, 6, 10, 13, 12, 14, 14, 21, 21 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">rep:= RepresentativesFusions( subtbl, orb, tbl );</span>
[ [ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ] ]
</pre></div>

<p><a id="X7F18772E86F06179" name="X7F18772E86F06179"></a></p>

<h4>73.5 <span class="Heading">Parametrized Maps</span></h4>

<p>A <em>parametrized map</em> is a list whose <span class="SimpleMath">i</span>-th entry is either unbound (which means that nothing is known about the image(s) of the <span class="SimpleMath">i</span>-th class) or the image of the <span class="SimpleMath">i</span>-th class (i.e., an integer for fusion maps, power maps, element orders etc., and a cyclotomic for characters), or a list of possible images of the <span class="SimpleMath">i</span>-th class. In this sense, maps are special parametrized maps. We often identify a parametrized map <var class="Arg">paramap</var> with the set of all maps <var class="Arg">map</var> with the property that either <code class="code"><var class="Arg">map</var>[i] = <var class="Arg">paramap</var>[i]</code> or <code class="code"><var class="Arg">map</var>[i]</code> is contained in the list <code class="code"><var class="Arg">paramap</var>[i]</code>; we say then that <var class="Arg">map</var> is contained in <var class="Arg">paramap</var>.</p>

<p>This definition implies that parametrized maps cannot be used to describe sets of maps where lists are possible images. An exception are strings which naturally arise as images when class names are considered. So strings and lists of strings are allowed in parametrized maps, and character constants (see Chapter <a href="chap27.html#X7D28329B7EDB8F47"><span class="RefLink">27</span></a>) are not allowed in maps.</p>

<p><a id="X8740C1397C6A96C8" name="X8740C1397C6A96C8"></a></p>

<h5>73.5-1 CompositionMaps</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; CompositionMaps</code>( <var class="Arg">paramap2</var>, <var class="Arg">paramap1</var>[, <var class="Arg">class</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>The composition of two parametrized maps <var class="Arg">paramap1</var>, <var class="Arg">paramap2</var> is defined as the parametrized map <var class="Arg">comp</var> that contains all compositions <span class="SimpleMath">f_2 ∘ f_1</span> of elements <span class="SimpleMath">f_1</span> of <var class="Arg">paramap1</var> and <span class="SimpleMath">f_2</span> of <var class="Arg">paramap2</var>. For example, the composition of a character <span class="SimpleMath">χ</span> of a group <span class="SimpleMath">G</span> by a parametrized class fusion map from a subgroup <span class="SimpleMath">H</span> to <span class="SimpleMath">G</span> is the parametrized map that contains all restrictions of <span class="SimpleMath">χ</span> by elements of the parametrized fusion map.</p>

<p><code class="code">CompositionMaps(<var class="Arg">paramap2</var>, <var class="Arg">paramap1</var>)</code> is a parametrized map with entry <code class="code">CompositionMaps(<var class="Arg">paramap2</var>, <var class="Arg">paramap1</var>, <var class="Arg">class</var>)</code> at position <var class="Arg">class</var>. If <code class="code"><var class="Arg">paramap1</var>[<var class="Arg">class</var>]</code> is an integer then <code class="code">CompositionMaps(<var class="Arg">paramap2</var>, <var class="Arg">paramap1</var>, <var class="Arg">class</var>)</code> is equal to <code class="code"><var class="Arg">paramap2</var>[ <var class="Arg">paramap1</var>[ <var class="Arg">class</var> ] ]</code>. Otherwise it is the union of <code class="code"><var class="Arg">paramap2</var>[<var class="Arg">i</var>]</code> for <var class="Arg">i</var> in <code class="code"><var class="Arg">paramap1</var>[ <var class="Arg">class</var> ]</code>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">map1:= [ 1, [ 2 .. 4 ], [ 4, 5 ], 1 ];;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">map2:= [ [ 1, 2 ], 2, 2, 3, 3 ];;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">CompositionMaps( map2, map1 );</span>
[ [ 1, 2 ], [ 2, 3 ], 3, [ 1, 2 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">CompositionMaps( map1, map2 );</span>
[ [ 1, 2, 3, 4 ], [ 2, 3, 4 ], [ 2, 3, 4 ], [ 4, 5 ], [ 4, 5 ] ]
</pre></div>

<p><a id="X7877EE167A711AB6" name="X7877EE167A711AB6"></a></p>

<h5>73.5-2 InverseMap</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; InverseMap</code>( <var class="Arg">paramap</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>For a parametrized map <var class="Arg">paramap</var>, <code class="func">InverseMap</code> returns a mutable parametrized map whose <span class="SimpleMath">i</span>-th entry is unbound if <span class="SimpleMath">i</span> is not in the image of <var class="Arg">paramap</var>, equal to <span class="SimpleMath">j</span> if <span class="SimpleMath">i</span> is (in) the image of <code class="code"><var class="Arg">paramap</var>[<var class="Arg">j</var>]</code> exactly for <span class="SimpleMath">j</span>, and equal to the set of all preimages of <span class="SimpleMath">i</span> under <var class="Arg">paramap</var> otherwise.</p>

<p>We have <code class="code">CompositionMaps( <var class="Arg">paramap</var>, InverseMap( <var class="Arg">paramap</var> ) )</code> the identity map.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tbl:= CharacterTable( "2.A5" );;  f:= CharacterTable( "A5" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus:= GetFusionMap( tbl, f );</span>
[ 1, 1, 2, 3, 3, 4, 4, 5, 5 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">inv:= InverseMap( fus );</span>
[ [ 1, 2 ], 3, [ 4, 5 ], [ 6, 7 ], [ 8, 9 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">CompositionMaps( fus, inv );</span>
[ 1, 2, 3, 4, 5 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># transfer a power map ``up'' to the factor group</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">pow:= PowerMap( tbl, 2 );</span>
[ 1, 1, 2, 4, 4, 8, 8, 6, 6 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">CompositionMaps( fus, CompositionMaps( pow, inv ) );</span>
[ 1, 1, 3, 5, 4 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">last = PowerMap( f, 2 );</span>
true
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># transfer a power map of the factor group ``down'' to the group</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">CompositionMaps( inv, CompositionMaps( PowerMap( f, 2 ), fus ) );</span>
[ [ 1, 2 ], [ 1, 2 ], [ 1, 2 ], [ 4, 5 ], [ 4, 5 ], [ 8, 9 ], 
  [ 8, 9 ], [ 6, 7 ], [ 6, 7 ] ]
</pre></div>

<p><a id="X82C0E76F804C3FF7" name="X82C0E76F804C3FF7"></a></p>

<h5>73.5-3 ProjectionMap</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ProjectionMap</code>( <var class="Arg">fusionmap</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>For a map <var class="Arg">fusionmap</var>, <code class="func">ProjectionMap</code> returns a parametrized map whose <span class="SimpleMath">i</span>-th entry is unbound if <span class="SimpleMath">i</span> is not in the image of <var class="Arg">fusionmap</var>, and equal to <span class="SimpleMath">j</span> if <span class="SimpleMath">j</span> is the smallest position such that <span class="SimpleMath">i</span> is the image of <var class="Arg">fusionmap</var><code class="code">[</code><span class="SimpleMath">j</span><code class="code">]</code>.</p>

<p>We have <code class="code">CompositionMaps( <var class="Arg">fusionmap</var>, ProjectionMap( <var class="Arg">fusionmap</var> ) )</code> the identity map, i.e., first projecting and then fusing yields the identity. Note that <var class="Arg">fusionmap</var> must <em>not</em> be a parametrized map.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">ProjectionMap( [ 1, 1, 1, 2, 2, 2, 3, 4, 5, 5, 5, 6, 6, 6 ] );</span>
[ 1, 4, 7, 8, 9, 12 ]
</pre></div>

<p><a id="X7D9CA09385467EDE" name="X7D9CA09385467EDE"></a></p>

<h5>73.5-4 Indirected</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Indirected</code>( <var class="Arg">character</var>, <var class="Arg">paramap</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>For a map <var class="Arg">character</var> and a parametrized map <var class="Arg">paramap</var>, <code class="func">Indirected</code> returns a parametrized map whose entry at position <span class="SimpleMath">i</span> is <var class="Arg">character</var><code class="code">[ </code><var class="Arg">paramap</var><code class="code">[</code><span class="SimpleMath">i</span><code class="code">] ]</code> if <var class="Arg">paramap</var><code class="code">[</code><span class="SimpleMath">i</span><code class="code">]</code> is an integer, and an unknown (see Chapter <a href="chap74.html#X7C1FAB6280A02CCB"><span class="RefLink">74</span></a>) otherwise.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tbl:= CharacterTable( "M12" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus:= [ 1, 3, 4, [ 6, 7 ], 8, 10, [ 11, 12 ], [ 11, 12 ],</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">           [ 14, 15 ], [ 14, 15 ] ];;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">List( Irr( tbl ){ [ 1 .. 6 ] }, x -&gt; Indirected( x, fus ) );</span>
[ [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 
  [ 11, 3, 2, Unknown(9), 1, 0, Unknown(10), Unknown(11), 0, 0 ], 
  [ 11, 3, 2, Unknown(12), 1, 0, Unknown(13), Unknown(14), 0, 0 ], 
  [ 16, 0, -2, 0, 1, 0, 0, 0, Unknown(15), Unknown(16) ], 
  [ 16, 0, -2, 0, 1, 0, 0, 0, Unknown(17), Unknown(18) ], 
  [ 45, -3, 0, 1, 0, 0, -1, -1, 1, 1 ] ]
</pre></div>

<p><a id="X7910BE5687DDAAF3" name="X7910BE5687DDAAF3"></a></p>

<h5>73.5-5 Parametrized</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Parametrized</code>( <var class="Arg">list</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>For a list <var class="Arg">list</var> of (parametrized) maps of the same length, <code class="func">Parametrized</code> returns the smallest parametrized map containing all elements of <var class="Arg">list</var>.</p>

<p><code class="func">Parametrized</code> is the inverse function to <code class="func">ContainedMaps</code> (<a href="chap73.html#X7917265684700B10"><span class="RefLink">73.5-6</span></a>).</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Parametrized( [ [ 1, 2, 3, 4, 5 ], [ 1, 3, 2, 4, 5 ],</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">                   [ 1, 2, 3, 4, 6 ] ] );</span>
[ 1, [ 2, 3 ], [ 2, 3 ], 4, [ 5, 6 ] ]
</pre></div>

<p><a id="X7917265684700B10" name="X7917265684700B10"></a></p>

<h5>73.5-6 ContainedMaps</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ContainedMaps</code>( <var class="Arg">paramap</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>For a parametrized map <var class="Arg">paramap</var>, <code class="func">ContainedMaps</code> returns the set of all maps contained in <var class="Arg">paramap</var>.</p>

<p><code class="func">ContainedMaps</code> is the inverse function to <code class="func">Parametrized</code> (<a href="chap73.html#X7910BE5687DDAAF3"><span class="RefLink">73.5-5</span></a>) in the sense that <code class="code">Parametrized( ContainedMaps( <var class="Arg">paramap</var> ) )</code> is equal to <var class="Arg">paramap</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">ContainedMaps( [ 1, [ 2, 3 ], [ 2, 3 ], 4, [ 5, 6 ] ] );</span>
[ [ 1, 2, 2, 4, 5 ], [ 1, 2, 2, 4, 6 ], [ 1, 2, 3, 4, 5 ], 
  [ 1, 2, 3, 4, 6 ], [ 1, 3, 2, 4, 5 ], [ 1, 3, 2, 4, 6 ], 
  [ 1, 3, 3, 4, 5 ], [ 1, 3, 3, 4, 6 ] ]
</pre></div>

<p><a id="X80C7328C85BFC20B" name="X80C7328C85BFC20B"></a></p>

<h5>73.5-7 UpdateMap</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; UpdateMap</code>( <var class="Arg">character</var>, <var class="Arg">paramap</var>, <var class="Arg">indirected</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Let <var class="Arg">character</var> be a map, <var class="Arg">paramap</var> a parametrized map, and <var class="Arg">indirected</var> a parametrized map that is contained in <code class="code">CompositionMaps( <var class="Arg">character</var>, <var class="Arg">paramap</var> )</code>.</p>

<p>Then <code class="func">UpdateMap</code> changes <var class="Arg">paramap</var> to the parametrized map containing exactly the maps whose composition with <var class="Arg">character</var> is equal to <var class="Arg">indirected</var>.</p>

<p>If a contradiction is detected then <code class="keyw">false</code> is returned immediately, otherwise <code class="keyw">true</code>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">subtbl:= CharacterTable("S4(4).2");; tbl:= CharacterTable("He");;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus:= InitFusion( subtbl, tbl );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus;</span>
[ 1, 2, 2, [ 2, 3 ], 4, 4, [ 7, 8 ], [ 7, 8 ], 9, 9, 9, [ 10, 11 ], 
  [ 10, 11 ], 18, 18, 25, 25, [ 26, 27 ], [ 26, 27 ], 2, [ 6, 7 ], 
  [ 6, 7 ], [ 6, 7, 8 ], 10, 10, 17, 17, 18, [ 19, 20 ], [ 19, 20 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">chi:= Irr( tbl )[2];</span>
Character( CharacterTable( "He" ), [ 51, 11, 3, 6, 0, 3, 3, -1, 1, 2, 
  0, 3*E(7)+3*E(7)^2+3*E(7)^4, 3*E(7)^3+3*E(7)^5+3*E(7)^6, 2, 
  E(7)+E(7)^2+2*E(7)^3+E(7)^4+2*E(7)^5+2*E(7)^6, 
  2*E(7)+2*E(7)^2+E(7)^3+2*E(7)^4+E(7)^5+E(7)^6, 1, 1, 0, 0, 
  -E(7)-E(7)^2-E(7)^4, -E(7)^3-E(7)^5-E(7)^6, E(7)+E(7)^2+E(7)^4, 
  E(7)^3+E(7)^5+E(7)^6, 1, 0, 0, -1, -1, 0, 0, E(7)+E(7)^2+E(7)^4, 
  E(7)^3+E(7)^5+E(7)^6 ] )
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">filt:= Filtered( Irr( subtbl ), x -&gt; x[1] = 50 );</span>
[ Character( CharacterTable( "S4(4).2" ), 
    [ 50, 10, 10, 2, 5, 5, -2, 2, 0, 0, 0, 1, 1, 0, 0, 0, 0, -1, -1, 
      10, 2, 2, 2, 1, 1, 0, 0, 0, -1, -1 ] ), 
  Character( CharacterTable( "S4(4).2" ), 
    [ 50, 10, 10, 2, 5, 5, -2, 2, 0, 0, 0, 1, 1, 0, 0, 0, 0, -1, -1, 
      -10, -2, -2, -2, -1, -1, 0, 0, 0, 1, 1 ] ) ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">UpdateMap( chi, fus, filt[1] + TrivialCharacter( subtbl ) );</span>
true
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus;</span>
[ 1, 2, 2, 3, 4, 4, 8, 7, 9, 9, 9, 10, 10, 18, 18, 25, 25, 
  [ 26, 27 ], [ 26, 27 ], 2, [ 6, 7 ], [ 6, 7 ], [ 6, 7 ], 10, 10, 
  17, 17, 18, [ 19, 20 ], [ 19, 20 ] ]
</pre></div>

<p><a id="X81A1A0E88570E42A" name="X81A1A0E88570E42A"></a></p>

<h5>73.5-8 MeetMaps</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; MeetMaps</code>( <var class="Arg">paramap1</var>, <var class="Arg">paramap2</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>For two parametrized maps <var class="Arg">paramap1</var> and <var class="Arg">paramap2</var>, <code class="func">MeetMaps</code> changes <var class="Arg">paramap1</var> such that the image of class <span class="SimpleMath">i</span> is the intersection of <var class="Arg">paramap1</var><code class="code">[</code><span class="SimpleMath">i</span><code class="code">]</code> and <var class="Arg">paramap2</var><code class="code">[</code><span class="SimpleMath">i</span><code class="code">]</code>.</p>

<p>If this implies that no images remain for a class, the position of such a class is returned. If no such inconsistency occurs, <code class="func">MeetMaps</code> returns <code class="keyw">true</code>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">map1:= [ [ 1, 2 ], [ 3, 4 ], 5, 6, [ 7, 8, 9 ] ];;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">map2:= [ [ 1, 3 ], [ 3, 4 ], [ 5, 6 ], 6, [ 8, 9, 10 ] ];;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">MeetMaps( map1, map2 );  map1;</span>
true
[ 1, [ 3, 4 ], 5, 6, [ 8, 9 ] ]
</pre></div>

<p><a id="X8593A72A8193EC8B" name="X8593A72A8193EC8B"></a></p>

<h5>73.5-9 CommutativeDiagram</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; CommutativeDiagram</code>( <var class="Arg">paramap1</var>, <var class="Arg">paramap2</var>, <var class="Arg">paramap3</var>, <var class="Arg">paramap4</var>[, <var class="Arg">improvements</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>Let <var class="Arg">paramap1</var>, <var class="Arg">paramap2</var>, <var class="Arg">paramap3</var>, <var class="Arg">paramap4</var> be parametrized maps covering parametrized maps <span class="SimpleMath">f_1</span>, <span class="SimpleMath">f_2</span>, <span class="SimpleMath">f_3</span>, <span class="SimpleMath">f_4</span> with the property that <code class="code">CompositionMaps</code><span class="SimpleMath">( f_2, f_1 )</span> is equal to <code class="code">CompositionMaps</code><span class="SimpleMath">( f_4, f_3 )</span>.</p>

<p><code class="func">CommutativeDiagram</code> checks this consistency, and changes the arguments such that all possible images are removed that cannot occur in the parametrized maps <span class="SimpleMath">f_i</span>.</p>

<p>The return value is <code class="keyw">fail</code> if an inconsistency was found. Otherwise a record with the components <code class="code">imp1</code>, <code class="code">imp2</code>, <code class="code">imp3</code>, <code class="code">imp4</code> is returned, each bound to the list of positions where the corresponding parametrized map was changed,</p>

<p>The optional argument <var class="Arg">improvements</var> must be a record with components <code class="code">imp1</code>, <code class="code">imp2</code>, <code class="code">imp3</code>, <code class="code">imp4</code>. If such a record is specified then only diagrams are considered where entries of the <span class="SimpleMath">i</span>-th component occur as preimages of the <span class="SimpleMath">i</span>-th parametrized map.</p>

<p>When an inconsistency is detected, <code class="func">CommutativeDiagram</code> immediately returns <code class="keyw">fail</code>. Otherwise a record is returned that contains four lists <code class="code">imp1</code>, <span class="SimpleMath">...</span>, <code class="code">imp4</code>: The <span class="SimpleMath">i</span>-th component is the list of classes where the <span class="SimpleMath">i</span>-th argument was changed.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">map1:= [[ 1, 2, 3 ], [ 1, 3 ]];; map2:= [[ 1, 2 ], 1, [ 1, 3 ]];;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">map3:= [ [ 2, 3 ], 3 ];;  map4:= [ , 1, 2, [ 1, 2 ] ];;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">imp:= CommutativeDiagram( map1, map2, map3, map4 );</span>
rec( imp1 := [ 2 ], imp2 := [ 1 ], imp3 := [  ], imp4 := [  ] )
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">map1;  map2;  map3;  map4;</span>
[ [ 1, 2, 3 ], 1 ]
[ 2, 1, [ 1, 3 ] ]
[ [ 2, 3 ], 3 ]
[ , 1, 2, [ 1, 2 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">imp2:= CommutativeDiagram( map1, map2, map3, map4, imp );</span>
rec( imp1 := [  ], imp2 := [  ], imp3 := [  ], imp4 := [  ] )
</pre></div>

<p><a id="X7B6EC10C7F7411E9" name="X7B6EC10C7F7411E9"></a></p>

<h5>73.5-10 CheckFixedPoints</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; CheckFixedPoints</code>( <var class="Arg">inside1</var>, <var class="Arg">between</var>, <var class="Arg">inside2</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Let <var class="Arg">inside1</var>, <var class="Arg">between</var>, <var class="Arg">inside2</var> be parametrized maps, where <var class="Arg">between</var> is assumed to map each fixed point of <var class="Arg">inside1</var> (that is, <var class="Arg">inside1</var><code class="code">[</code><span class="SimpleMath">i</span><code class="code">] = </code><var class="Arg">i</var>) to a fixed point of <var class="Arg">inside2</var> (that is, <var class="Arg">between</var><code class="code">[</code><span class="SimpleMath">i</span><code class="code">]</code> is either an integer that is fixed by <var class="Arg">inside2</var> or a list that has nonempty intersection with the union of its images under <var class="Arg">inside2</var>). <code class="func">CheckFixedPoints</code> changes <var class="Arg">between</var> and <var class="Arg">inside2</var> by removing all those entries violate this condition.</p>

<p>When an inconsistency is detected, <code class="func">CheckFixedPoints</code> immediately returns <code class="keyw">fail</code>. Otherwise the list of positions is returned where changes occurred.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">subtbl:= CharacterTable( "L4(3).2_2" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tbl:= CharacterTable( "O7(3)" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus:= InitFusion( subtbl, tbl );;  fus{ [ 48, 49 ] };</span>
[ [ 54, 55, 56, 57 ], [ 54, 55, 56, 57 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">CheckFixedPoints( ComputedPowerMaps( subtbl )[5], fus,</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">       ComputedPowerMaps( tbl )[5] );</span>
[ 48, 49 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus{ [ 48, 49 ] };</span>
[ [ 56, 57 ], [ 56, 57 ] ]
</pre></div>

<p><a id="X7AD5158E82AF1CD4" name="X7AD5158E82AF1CD4"></a></p>

<h5>73.5-11 TransferDiagram</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; TransferDiagram</code>( <var class="Arg">inside1</var>, <var class="Arg">between</var>, <var class="Arg">inside2</var>[, <var class="Arg">improvements</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>Let <var class="Arg">inside1</var>, <var class="Arg">between</var>, <var class="Arg">inside2</var> be parametrized maps covering parametrized maps <span class="SimpleMath">m_1</span>, <span class="SimpleMath">f</span>, <span class="SimpleMath">m_2</span> with the property that <code class="code">CompositionMaps</code><span class="SimpleMath">( m_2, f )</span> is equal to <code class="code">CompositionMaps</code><span class="SimpleMath">( f, m_1 )</span>.</p>

<p><code class="func">TransferDiagram</code> checks this consistency, and changes the arguments such that all possible images are removed that cannot occur in the parametrized maps <span class="SimpleMath">m_i</span> and <span class="SimpleMath">f</span>.</p>

<p>So <code class="func">TransferDiagram</code> is similar to <code class="func">CommutativeDiagram</code> (<a href="chap73.html#X8593A72A8193EC8B"><span class="RefLink">73.5-9</span></a>), but <var class="Arg">between</var> occurs twice in each diagram checked.</p>

<p>If a record <var class="Arg">improvements</var> with fields <code class="code">impinside1</code>, <code class="code">impbetween</code>, and <code class="code">impinside2</code> is specified, only those diagrams with elements of <code class="code">impinside1</code> as preimages of <var class="Arg">inside1</var>, elements of <code class="code">impbetween</code> as preimages of <var class="Arg">between</var> or elements of <code class="code">impinside2</code> as preimages of <var class="Arg">inside2</var> are considered.</p>

<p>When an inconsistency is detected, <code class="func">TransferDiagram</code> immediately returns <code class="keyw">fail</code>. Otherwise a record is returned that contains three lists <code class="code">impinside1</code>, <code class="code">impbetween</code>, and <code class="code">impinside2</code> of positions where the arguments were changed.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">subtbl:= CharacterTable( "2F4(2)" );;  tbl:= CharacterTable( "Ru" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus:= InitFusion( subtbl, tbl );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">permchar:= Sum( Irr( tbl ){ [ 1, 5, 6 ] } );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">CheckPermChar( subtbl, tbl, fus, permchar );; fus;</span>
[ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, [ 13, 15 ], 16, [ 18, 19 ], 20, 
  [ 25, 26 ], [ 25, 26 ], 5, 5, 6, 8, 14, [ 13, 15 ], [ 18, 19 ], 
  [ 18, 19 ], [ 25, 26 ], [ 25, 26 ], 27, 27 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tr:= TransferDiagram(PowerMap( subtbl, 2), fus, PowerMap(tbl, 2));</span>
rec( impbetween := [ 12, 23 ], impinside1 := [  ], impinside2 := [  ] 
 )
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tr:= TransferDiagram(PowerMap(subtbl, 3), fus, PowerMap( tbl, 3 ));</span>
rec( impbetween := [ 14, 24, 25 ], impinside1 := [  ], 
  impinside2 := [  ] )
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tr:= TransferDiagram( PowerMap(subtbl, 3), fus, PowerMap(tbl, 3),</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">            tr );</span>
rec( impbetween := [  ], impinside1 := [  ], impinside2 := [  ] )
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus;</span>
[ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, 15, 16, 18, 20, [ 25, 26 ], 
  [ 25, 26 ], 5, 5, 6, 8, 14, 13, 19, 19, [ 25, 26 ], [ 25, 26 ], 27, 
  27 ]
</pre></div>

<p><a id="X78487F03852A503B" name="X78487F03852A503B"></a></p>

<h5>73.5-12 TestConsistencyMaps</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; TestConsistencyMaps</code>( <var class="Arg">powermap1</var>, <var class="Arg">fusionmap</var>, <var class="Arg">powermap2</var>[, <var class="Arg">fusimp</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>Let <var class="Arg">powermap1</var> and <var class="Arg">powermap2</var> be lists of parametrized maps, and <var class="Arg">fusionmap</var> a parametrized map, such that for each <span class="SimpleMath">i</span>, the <span class="SimpleMath">i</span>-th entry in <var class="Arg">powermap1</var>, <var class="Arg">fusionmap</var>, and the <span class="SimpleMath">i</span>-th entry in <var class="Arg">powermap2</var> (if bound) are valid arguments for <code class="func">TransferDiagram</code> (<a href="chap73.html#X7AD5158E82AF1CD4"><span class="RefLink">73.5-11</span></a>). So a typical situation for applying <code class="func">TestConsistencyMaps</code> is that <var class="Arg">fusionmap</var> is an approximation of a class fusion, and <var class="Arg">powermap1</var>, <var class="Arg">powermap2</var> are the lists of power maps of the subgroup and the group.</p>

<p><code class="func">TestConsistencyMaps</code> repeatedly applies <code class="func">TransferDiagram</code> (<a href="chap73.html#X7AD5158E82AF1CD4"><span class="RefLink">73.5-11</span></a>) to these arguments for all <span class="SimpleMath">i</span> until no more changes occur.</p>

<p>If a list <var class="Arg">fusimp</var> is specified then only those diagrams with elements of <var class="Arg">fusimp</var> as preimages of <var class="Arg">fusionmap</var> are considered.</p>

<p>When an inconsistency is detected, <code class="func">TestConsistencyMaps</code> immediately returns <code class="keyw">false</code>. Otherwise <code class="keyw">true</code> is returned.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">subtbl:= CharacterTable( "2F4(2)" );;  tbl:= CharacterTable( "Ru" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus:= InitFusion( subtbl, tbl );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">permchar:= Sum( Irr( tbl ){ [ 1, 5, 6 ] } );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">CheckPermChar( subtbl, tbl, fus, permchar );; fus;</span>
[ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, [ 13, 15 ], 16, [ 18, 19 ], 20, 
  [ 25, 26 ], [ 25, 26 ], 5, 5, 6, 8, 14, [ 13, 15 ], [ 18, 19 ], 
  [ 18, 19 ], [ 25, 26 ], [ 25, 26 ], 27, 27 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">TestConsistencyMaps( ComputedPowerMaps( subtbl ), fus,</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">       ComputedPowerMaps( tbl ) );</span>
true
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus;</span>
[ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, 15, 16, 18, 20, [ 25, 26 ], 
  [ 25, 26 ], 5, 5, 6, 8, 14, 13, 19, 19, [ 25, 26 ], [ 25, 26 ], 27, 
  27 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Indeterminateness( fus );</span>
16
</pre></div>

<p><a id="X7DAD6EA585D74615" name="X7DAD6EA585D74615"></a></p>

<h5>73.5-13 Indeterminateness</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Indeterminateness</code>( <var class="Arg">paramap</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>For a parametrized map <var class="Arg">paramap</var>, <code class="func">Indeterminateness</code> returns the number of maps contained in <var class="Arg">paramap</var>, that is, the product of lengths of lists in <var class="Arg">paramap</var> denoting lists of several images.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Indeterminateness([ 1, [ 2, 3 ], [ 4, 5 ], [ 6, 7, 8, 9, 10 ], 11 ]);</span>
20
</pre></div>

<p><a id="X7888BDC88304BE5A" name="X7888BDC88304BE5A"></a></p>

<h5>73.5-14 PrintAmbiguity</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PrintAmbiguity</code>( <var class="Arg">list</var>, <var class="Arg">paramap</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>For each map in the list <var class="Arg">list</var>, <code class="func">PrintAmbiguity</code> prints its position in <var class="Arg">list</var>, the indeterminateness (see <code class="func">Indeterminateness</code> (<a href="chap73.html#X7DAD6EA585D74615"><span class="RefLink">73.5-13</span></a>)) of the composition with the parametrized map <var class="Arg">paramap</var>, and the list of positions where a list of images occurs in this composition.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">paramap:= [ 1, [ 2, 3 ], [ 3, 4 ], [ 2, 3, 4 ], 5 ];;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">list:= [ [ 1, 1, 1, 1, 1 ], [ 1, 1, 2, 2, 3 ], [ 1, 2, 3, 4, 5 ] ];;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PrintAmbiguity( list, paramap );</span>
1 1 [  ]
2 4 [ 2, 4 ]
3 12 [ 2, 3, 4 ]
</pre></div>

<p><a id="X7F957B1481E10A0C" name="X7F957B1481E10A0C"></a></p>

<h5>73.5-15 ContainedSpecialVectors</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ContainedSpecialVectors</code>( <var class="Arg">tbl</var>, <var class="Arg">chars</var>, <var class="Arg">paracharacter</var>, <var class="Arg">func</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IntScalarProducts</code>( <var class="Arg">tbl</var>, <var class="Arg">chars</var>, <var class="Arg">candidate</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; NonnegIntScalarProducts</code>( <var class="Arg">tbl</var>, <var class="Arg">chars</var>, <var class="Arg">candidate</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ContainedPossibleVirtualCharacters</code>( <var class="Arg">tbl</var>, <var class="Arg">chars</var>, <var class="Arg">paracharacter</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ContainedPossibleCharacters</code>( <var class="Arg">tbl</var>, <var class="Arg">chars</var>, <var class="Arg">paracharacter</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Let <var class="Arg">tbl</var> be an ordinary character table, <var class="Arg">chars</var> a list of class functions (or values lists), <var class="Arg">paracharacter</var> a parametrized class function of <var class="Arg">tbl</var>, and <var class="Arg">func</var> a function that expects the three arguments <var class="Arg">tbl</var>, <var class="Arg">chars</var>, and a values list of a class function, and that returns either <code class="keyw">true</code> or <code class="keyw">false</code>.</p>

<p><code class="func">ContainedSpecialVectors</code> returns the list of all those elements <var class="Arg">vec</var> of <var class="Arg">paracharacter</var> that have integral norm, have integral scalar product with the principal character of <var class="Arg">tbl</var>, and that satisfy <var class="Arg">func</var><code class="code">( </code><var class="Arg">tbl</var>, <var class="Arg">chars</var>, <var class="Arg">vec</var> <code class="code">) = </code><code class="keyw">true</code>.</p>

<p>Two special cases of <var class="Arg">func</var> are the check whether the scalar products in <var class="Arg">tbl</var> between the vector <var class="Arg">vec</var> and all lists in <var class="Arg">chars</var> are integers or nonnegative integers, respectively. These functions are accessible as global variables <code class="func">IntScalarProducts</code> and <code class="func">NonnegIntScalarProducts</code>, and <code class="func">ContainedPossibleVirtualCharacters</code> and <code class="func">ContainedPossibleCharacters</code> provide access to these special cases of <code class="func">ContainedSpecialVectors</code>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">subtbl:= CharacterTable( "HSM12" );;  tbl:= CharacterTable( "HS" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus:= InitFusion( subtbl, tbl );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">rest:= CompositionMaps( Irr( tbl )[8], fus );</span>
[ 231, [ -9, 7 ], [ -9, 7 ], [ -9, 7 ], 6, 15, 15, [ -1, 15 ], 
  [ -1, 15 ], 1, [ 1, 6 ], [ 1, 6 ], [ 1, 6 ], [ 1, 6 ], [ -2, 0 ], 
  [ 1, 2 ], [ 1, 2 ], [ 1, 2 ], 0, 0, 1, 0, 0, 0, 0 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">irr:= Irr( subtbl );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># no further condition</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">cont1:= ContainedSpecialVectors( subtbl, irr, rest,</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">               function( tbl, chars, vec ) return true; end );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Length( cont1 );</span>
24
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># require scalar products to be integral</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">cont2:= ContainedSpecialVectors( subtbl, irr, rest,</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">               IntScalarProducts );</span>
[ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
      0, 1, 0, 0, 0, 0 ], 
  [ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
      0, 1, 0, 0, 0, 0 ], 
  [ 231, 7, -9, -9, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
      0, 1, 0, 0, 0, 0 ], 
  [ 231, 7, -9, 7, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
      0, 1, 0, 0, 0, 0 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># additionally require scalar products to be nonnegative</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">cont3:= ContainedSpecialVectors( subtbl, irr, rest,</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">               NonnegIntScalarProducts );</span>
[ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
      0, 1, 0, 0, 0, 0 ], 
  [ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
      0, 1, 0, 0, 0, 0 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">cont2 = ContainedPossibleVirtualCharacters( subtbl, irr, rest );</span>
true
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">cont3 = ContainedPossibleCharacters( subtbl, irr, rest );</span>
true
</pre></div>

<p><a id="X84F87C2282EFB0EE" name="X84F87C2282EFB0EE"></a></p>

<h5>73.5-16 CollapsedMat</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; CollapsedMat</code>( <var class="Arg">mat</var>, <var class="Arg">maps</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>is a record with the components</p>


<dl>
<dt><strong class="Mark"><code class="code">fusion</code></strong></dt>
<dd><p>fusion that collapses those columns of <var class="Arg">mat</var> that are equal in <var class="Arg">mat</var> and also for all maps in the list <var class="Arg">maps</var>,</p>

</dd>
<dt><strong class="Mark"><code class="code">mat</code></strong></dt>
<dd><p>the image of <var class="Arg">mat</var> under that fusion.</p>

</dd>
</dl>

<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">mat:= [ [ 1, 1, 1, 1 ], [ 2, -1, 0, 0 ], [ 4, 4, 1, 1 ] ];;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">coll:= CollapsedMat( mat, [] );</span>
rec( fusion := [ 1, 2, 3, 3 ], 
  mat := [ [ 1, 1, 1 ], [ 2, -1, 0 ], [ 4, 4, 1 ] ] )
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">List( last.mat, x -&gt; x{ last.fusion } ) = mat;</span>
true
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">coll:= CollapsedMat( mat, [ [ 1, 1, 1, 2 ] ] );</span>
rec( fusion := [ 1, 2, 3, 4 ], 
  mat := [ [ 1, 1, 1, 1 ], [ 2, -1, 0, 0 ], [ 4, 4, 1, 1 ] ] )
</pre></div>

<p><a id="X81F1137A874EB962" name="X81F1137A874EB962"></a></p>

<h5>73.5-17 ContainedDecomposables</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ContainedDecomposables</code>( <var class="Arg">constituents</var>, <var class="Arg">moduls</var>, <var class="Arg">parachar</var>, <var class="Arg">func</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ContainedCharacters</code>( <var class="Arg">tbl</var>, <var class="Arg">constituents</var>, <var class="Arg">parachar</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>For these functions, let <var class="Arg">constituents</var> be a list of <em>rational</em> class functions, <var class="Arg">moduls</var> a list of positive integers, <var class="Arg">parachar</var> a parametrized rational class function, <var class="Arg">func</var> a function that returns either <code class="keyw">true</code> or <code class="keyw">false</code> when called with (a values list of) a class function, and <var class="Arg">tbl</var> a character table.</p>

<p><code class="func">ContainedDecomposables</code> returns the set of all elements <span class="SimpleMath">χ</span> of <var class="Arg">parachar</var> that satisfy <var class="Arg">func</var><span class="SimpleMath">( χ ) =</span> <code class="keyw">true</code> and that lie in the <span class="SimpleMath"></span>-lattice spanned by <var class="Arg">constituents</var>, modulo <var class="Arg">moduls</var>. The latter means they lie in the <span class="SimpleMath"></span>-lattice spanned by <var class="Arg">constituents</var> and the set <span class="SimpleMath">{ <var class="Arg">moduls</var>[i] ⋅ e_i; 1 ≤ i ≤ n }</span> where <span class="SimpleMath">n</span> is the length of <var class="Arg">parachar</var> and <span class="SimpleMath">e_i</span> is the <span class="SimpleMath">i</span>-th standard basis vector.</p>

<p>One application of <code class="func">ContainedDecomposables</code> is the following. <var class="Arg">constituents</var> is a list of (values lists of) rational characters of an ordinary character table <var class="Arg">tbl</var>, <var class="Arg">moduls</var> is the list of centralizer orders of <var class="Arg">tbl</var> (see <code class="func">SizesCentralizers</code> (<a href="chap71.html#X7CF7907F790A5DE6"><span class="RefLink">71.9-2</span></a>)), and <var class="Arg">func</var> checks whether a vector in the lattice mentioned above has nonnegative integral scalar product in <var class="Arg">tbl</var> with all entries of <var class="Arg">constituents</var>. This situation is handled by <code class="func">ContainedCharacters</code>. Note that the entries of the result list are <em>not</em> necessary linear combinations of <var class="Arg">constituents</var>, and they are <em>not</em> necessarily characters of <var class="Arg">tbl</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">subtbl:= CharacterTable( "HSM12" );;  tbl:= CharacterTable( "HS" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">rat:= RationalizedMat( Irr( subtbl ) );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus:= InitFusion( subtbl, tbl );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">rest:= CompositionMaps( Irr( tbl )[8], fus );</span>
[ 231, [ -9, 7 ], [ -9, 7 ], [ -9, 7 ], 6, 15, 15, [ -1, 15 ], 
  [ -1, 15 ], 1, [ 1, 6 ], [ 1, 6 ], [ 1, 6 ], [ 1, 6 ], [ -2, 0 ], 
  [ 1, 2 ], [ 1, 2 ], [ 1, 2 ], 0, 0, 1, 0, 0, 0, 0 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># compute all vectors in the lattice</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">ContainedDecomposables( rat, SizesCentralizers( subtbl ), rest,</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">       ReturnTrue );</span>
[ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
      0, 1, 0, 0, 0, 0 ], 
  [ 231, 7, -9, -9, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
      0, 1, 0, 0, 0, 0 ], 
  [ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
      0, 1, 0, 0, 0, 0 ], 
  [ 231, 7, -9, 7, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
      0, 1, 0, 0, 0, 0 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># compute only those vectors that are characters</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">ContainedDecomposables( rat, SizesCentralizers( subtbl ), rest,</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">       x -&gt; NonnegIntScalarProducts( subtbl, Irr( subtbl ), x ) );</span>
[ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
      0, 1, 0, 0, 0, 0 ], 
  [ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
      0, 1, 0, 0, 0, 0 ] ]
</pre></div>

<p><a id="X86472A217D6C3CE7" name="X86472A217D6C3CE7"></a></p>

<h4>73.6 <span class="Heading">Subroutines for the Construction of Power Maps</span></h4>

<p>In the argument lists of the functions <code class="func">Congruences</code> (<a href="chap73.html#X7B27749E7BF54EBB"><span class="RefLink">73.6-2</span></a>), <code class="func">ConsiderKernels</code> (<a href="chap73.html#X7D31B1548205E222"><span class="RefLink">73.6-3</span></a>), and <code class="func">ConsiderSmallerPowerMaps</code> (<a href="chap73.html#X7DD1DCF3865E0017"><span class="RefLink">73.6-4</span></a>), <var class="Arg">tbl</var> is an ordinary character table, <var class="Arg">chars</var> a list of (values lists of) characters of <var class="Arg">tbl</var>, <var class="Arg">prime</var> a prime integer, <var class="Arg">approxmap</var> a parametrized map that is an approximation for the <var class="Arg">prime</var>-th power map of <var class="Arg">tbl</var> (e.g., a list returned by <code class="func">InitPowerMap</code> (<a href="chap73.html#X85D068D77C3C041C"><span class="RefLink">73.6-1</span></a>), and <var class="Arg">quick</var> a Boolean.</p>

<p>The <var class="Arg">quick</var> value <code class="keyw">true</code> means that only those classes are considered for which <var class="Arg">approxmap</var> lists more than one possible image.</p>

<p><a id="X85D068D77C3C041C" name="X85D068D77C3C041C"></a></p>

<h5>73.6-1 InitPowerMap</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; InitPowerMap</code>( <var class="Arg">tbl</var>, <var class="Arg">prime</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>For an ordinary character table <var class="Arg">tbl</var> and a prime <var class="Arg">prime</var>, <code class="func">InitPowerMap</code> returns a parametrized map that is a first approximation of the <var class="Arg">prime</var>-th powermap of <var class="Arg">tbl</var>, using the conditions 1. and 2. listed in the description of <code class="func">PossiblePowerMaps</code> (<a href="chap73.html#X7C7B292E80590BE0"><span class="RefLink">73.1-2</span></a>).</p>

<p>If there are classes for which no images are possible, according to these criteria, then <code class="keyw">fail</code> is returned.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">t:= CharacterTable( "U4(3).4" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">pow:= InitPowerMap( t, 2 );</span>
[ 1, 1, 3, 4, 5, [ 2, 16 ], [ 2, 16, 17 ], 8, 3, [ 3, 4 ], 
  [ 11, 12 ], [ 11, 12 ], [ 6, 7, 18, 19, 30, 31, 32, 33 ], 14, 
  [ 9, 20 ], 1, 1, 2, 2, 3, [ 3, 4, 5 ], [ 3, 4, 5 ], 
  [ 6, 7, 18, 19, 30, 31, 32, 33 ], 8, 9, 9, [ 9, 10, 20, 21, 22 ], 
  [ 11, 12 ], [ 11, 12 ], 16, 16, [ 2, 16 ], [ 2, 16 ], 17, 17, 
  [ 6, 18, 30, 31, 32, 33 ], [ 6, 18, 30, 31, 32, 33 ], 
  [ 6, 7, 18, 19, 30, 31, 32, 33 ], [ 6, 7, 18, 19, 30, 31, 32, 33 ], 
  20, 20, [ 9, 20 ], [ 9, 20 ], [ 9, 10, 20, 21, 22 ], 
  [ 9, 10, 20, 21, 22 ], 24, 24, [ 15, 25, 26, 40, 41, 42, 43 ], 
  [ 15, 25, 26, 40, 41, 42, 43 ], [ 28, 29 ], [ 28, 29 ], [ 28, 29 ], 
  [ 28, 29 ] ]
</pre></div>

<p><a id="X7B27749E7BF54EBB" name="X7B27749E7BF54EBB"></a></p>

<h5>73.6-2 Congruences</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Congruences</code>( <var class="Arg">tbl</var>, <var class="Arg">chars</var>, <var class="Arg">approxmap</var>, <var class="Arg">prime</var>, <var class="Arg">quick</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p><code class="func">Congruences</code> replaces the entries of <var class="Arg">approxmap</var> by improved values, according to condition 3. listed in the description of <code class="func">PossiblePowerMaps</code> (<a href="chap73.html#X7C7B292E80590BE0"><span class="RefLink">73.1-2</span></a>).</p>

<p>For each class for which no images are possible according to the tests, the new value of <var class="Arg">approxmap</var> is an empty list. <code class="func">Congruences</code> returns <code class="keyw">true</code> if no such inconsistencies occur, and <code class="keyw">false</code> otherwise.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Congruences( t, Irr( t ), pow, 2, false );  pow;</span>
true
[ 1, 1, 3, 4, 5, 2, 2, 8, 3, 4, 11, 12, [ 6, 7 ], 14, 9, 1, 1, 2, 2, 
  3, 4, 5, [ 6, 7 ], 8, 9, 9, 10, 11, 12, 16, 16, 16, 16, 17, 17, 18, 
  18, [ 18, 19 ], [ 18, 19 ], 20, 20, 20, 20, 22, 22, 24, 24, 
  [ 25, 26 ], [ 25, 26 ], 28, 28, 29, 29 ]
</pre></div>

<p><a id="X7D31B1548205E222" name="X7D31B1548205E222"></a></p>

<h5>73.6-3 ConsiderKernels</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ConsiderKernels</code>( <var class="Arg">tbl</var>, <var class="Arg">chars</var>, <var class="Arg">approxmap</var>, <var class="Arg">prime</var>, <var class="Arg">quick</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p><code class="func">ConsiderKernels</code> replaces the entries of <var class="Arg">approxmap</var> by improved values, according to condition 4. listed in the description of <code class="func">PossiblePowerMaps</code> (<a href="chap73.html#X7C7B292E80590BE0"><span class="RefLink">73.1-2</span></a>).</p>

<p><code class="func">Congruences</code> (<a href="chap73.html#X7B27749E7BF54EBB"><span class="RefLink">73.6-2</span></a>) returns <code class="keyw">true</code> if the orders of the kernels of all characters in <var class="Arg">chars</var> divide the order of the group of <var class="Arg">tbl</var>, and <code class="keyw">false</code> otherwise.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">t:= CharacterTable( "A7.2" );;  init:= InitPowerMap( t, 2 );</span>
[ 1, 1, 3, 4, [ 2, 9, 10 ], 6, 3, 8, 1, 1, [ 2, 9, 10 ], 3, [ 3, 4 ], 
  6, [ 7, 12 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">ConsiderKernels( t, Irr( t ), init, 2, false );</span>
true
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">init;</span>
[ 1, 1, 3, 4, 2, 6, 3, 8, 1, 1, 2, 3, [ 3, 4 ], 6, 7 ]
</pre></div>

<p><a id="X7DD1DCF3865E0017" name="X7DD1DCF3865E0017"></a></p>

<h5>73.6-4 ConsiderSmallerPowerMaps</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ConsiderSmallerPowerMaps</code>( <var class="Arg">tbl</var>, <var class="Arg">approxmap</var>, <var class="Arg">prime</var>, <var class="Arg">quick</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p><code class="func">ConsiderSmallerPowerMaps</code> replaces the entries of <var class="Arg">approxmap</var> by improved values, according to condition 5. listed in the description of <code class="func">PossiblePowerMaps</code> (<a href="chap73.html#X7C7B292E80590BE0"><span class="RefLink">73.1-2</span></a>).</p>

<p><code class="func">ConsiderSmallerPowerMaps</code> returns <code class="keyw">true</code> if each class admits at least one image after the checks, otherwise <code class="keyw">false</code> is returned. If no element orders of <var class="Arg">tbl</var> are stored (see <code class="func">OrdersClassRepresentatives</code> (<a href="chap71.html#X86F455DA7A9C30EE"><span class="RefLink">71.9-1</span></a>)) then <code class="keyw">true</code> is returned without any tests.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">t:= CharacterTable( "3.A6" );;  init:= InitPowerMap( t, 5 );</span>
[ 1, [ 2, 3 ], [ 2, 3 ], 4, [ 5, 6 ], [ 5, 6 ], [ 7, 8 ], [ 7, 8 ], 
  9, [ 10, 11 ], [ 10, 11 ], 1, [ 2, 3 ], [ 2, 3 ], 1, [ 2, 3 ], 
  [ 2, 3 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Indeterminateness( init );</span>
4096
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">ConsiderSmallerPowerMaps( t, init, 5, false );</span>
true
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Indeterminateness( init );</span>
256
</pre></div>

<p><a id="X805B6C1C78AA5DB6" name="X805B6C1C78AA5DB6"></a></p>

<h5>73.6-5 MinusCharacter</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; MinusCharacter</code>( <var class="Arg">character</var>, <var class="Arg">primepowermap</var>, <var class="Arg">prime</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Let <var class="Arg">character</var> be (the list of values of) a class function <span class="SimpleMath">χ</span>, <var class="Arg">prime</var> a prime integer <span class="SimpleMath">p</span>, and <var class="Arg">primepowermap</var> a parametrized map that is an approximation of the <span class="SimpleMath">p</span>-th power map for the character table of <span class="SimpleMath">χ</span>. <code class="func">MinusCharacter</code> returns the parametrized map of values of <span class="SimpleMath">χ^{p-}</span>, which is defined by <span class="SimpleMath">χ^{p-}(g) = ( χ(g)^p - χ(g^p) ) / p</span>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tbl:= CharacterTable( "S7" );;  pow:= InitPowerMap( tbl, 2 );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">pow;</span>
[ 1, 1, 3, 4, [ 2, 9, 10 ], 6, 3, 8, 1, 1, [ 2, 9, 10 ], 3, [ 3, 4 ], 
  6, [ 7, 12 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">chars:= Irr( tbl ){ [ 2 .. 5 ] };;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">List( chars, x -&gt; MinusCharacter( x, pow, 2 ) );</span>
[ [ 0, 0, 0, 0, [ 0, 1 ], 0, 0, 0, 0, 0, [ 0, 1 ], 0, 0, 0, [ 0, 1 ] ]
    , 
  [ 15, -1, 3, 0, [ -2, -1, 0 ], 0, -1, 1, 5, -3, [ 0, 1, 2 ], -1, 0, 
      0, [ 0, 1 ] ], 
  [ 15, -1, 3, 0, [ -1, 0, 2 ], 0, -1, 1, 5, -3, [ 1, 2, 4 ], -1, 0, 
      0, 1 ], 
  [ 190, -2, 1, 1, [ 0, 2 ], 0, 1, 1, -10, -10, [ 0, 2 ], -1, -1, 0, 
      [ -1, 0 ] ] ]
</pre></div>

<p><a id="X808CCF6087D5B661" name="X808CCF6087D5B661"></a></p>

<h5>73.6-6 PowerMapsAllowedBySymmetrizations</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PowerMapsAllowedBySymmetrizations</code>( <var class="Arg">tbl</var>, <var class="Arg">subchars</var>, <var class="Arg">chars</var>, <var class="Arg">approxmap</var>, <var class="Arg">prime</var>, <var class="Arg">parameters</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Let <var class="Arg">tbl</var> be an ordinary character table, <var class="Arg">prime</var> a prime integer, <var class="Arg">approxmap</var> a parametrized map that is an approximation of the <var class="Arg">prime</var>-th power map of <var class="Arg">tbl</var> (e.g., a list returned by <code class="func">InitPowerMap</code> (<a href="chap73.html#X85D068D77C3C041C"><span class="RefLink">73.6-1</span></a>), <var class="Arg">chars</var> and <var class="Arg">subchars</var> two lists of (values lists of) characters of <var class="Arg">tbl</var>, and <var class="Arg">parameters</var> a record with components <code class="code">maxlen</code>, <code class="code">minamb</code>, <code class="code">maxamb</code> (three integers), <code class="code">quick</code> (a Boolean), and <code class="code">contained</code> (a function). Usual values of <code class="code">contained</code> are <code class="func">ContainedCharacters</code> (<a href="chap73.html#X81F1137A874EB962"><span class="RefLink">73.5-17</span></a>) or <code class="func">ContainedPossibleCharacters</code> (<a href="chap73.html#X7F957B1481E10A0C"><span class="RefLink">73.5-15</span></a>).</p>

<p><code class="func">PowerMapsAllowedBySymmetrizations</code> replaces the entries of <var class="Arg">approxmap</var> by improved values, according to condition 6. listed in the description of <code class="func">PossiblePowerMaps</code> (<a href="chap73.html#X7C7B292E80590BE0"><span class="RefLink">73.1-2</span></a>).</p>

<p>More precisely, the strategy used is as follows.</p>

<p>First, for each <span class="SimpleMath">χ ∈ <var class="Arg">chars</var></span>, let <code class="code">minus:= MinusCharacter(</code><span class="SimpleMath">χ</span><code class="code">, <var class="Arg">approxmap</var>, <var class="Arg">prime</var>)</code>.</p>


<ul>
<li><p>If <code class="code">Indeterminateness( minus )</code><span class="SimpleMath">= 1</span> and <code class="code"><var class="Arg">parameters</var>.quick = false</code> then the scalar products of <code class="code">minus</code> with <var class="Arg">subchars</var> are checked; if not all scalar products are nonnegative integers then an empty list is returned, otherwise <span class="SimpleMath">χ</span> is deleted from the list of characters to inspect.</p>

</li>
<li><p>Otherwise if <code class="code">Indeterminateness( minus )</code> is smaller than <code class="code"><var class="Arg">parameters</var>.minamb</code> then <span class="SimpleMath">χ</span> is deleted from the list of characters.</p>

</li>
<li><p>If <code class="code"><var class="Arg">parameters</var>.minamb</code> <span class="SimpleMath"></span> <code class="code">Indeterminateness( minus )</code> <span class="SimpleMath"></span> <code class="code"><var class="Arg">parameters</var>.maxamb</code> then construct the list of contained class functions <code class="code">poss:= <var class="Arg">parameters</var>.contained(<var class="Arg">tbl</var>, <var class="Arg">subchars</var>, minus)</code> and <code class="code">Parametrized( poss )</code>, and improve the approximation of the power map using <code class="func">UpdateMap</code> (<a href="chap73.html#X80C7328C85BFC20B"><span class="RefLink">73.5-7</span></a>).</p>

</li>
</ul>
<p>If this yields no further immediate improvements then we branch. If there is a character from <var class="Arg">chars</var> left with less or equal <code class="code"><var class="Arg">parameters</var>.maxlen</code> possible symmetrizations, compute the union of power maps allowed by these possibilities. Otherwise we choose a class <span class="SimpleMath">C</span> such that the possible symmetrizations of a character in <var class="Arg">chars</var> differ at <span class="SimpleMath">C</span>, and compute recursively the union of all allowed power maps with image at <span class="SimpleMath">C</span> fixed in the set given by the current approximation of the power map.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">tbl:= CharacterTable( "U4(3).4" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">pow:= InitPowerMap( tbl, 2 );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Congruences( tbl, Irr( tbl ), pow, 2 );;  pow;</span>
[ 1, 1, 3, 4, 5, 2, 2, 8, 3, 4, 11, 12, [ 6, 7 ], 14, 9, 1, 1, 2, 2, 
  3, 4, 5, [ 6, 7 ], 8, 9, 9, 10, 11, 12, 16, 16, 16, 16, 17, 17, 18, 
  18, [ 18, 19 ], [ 18, 19 ], 20, 20, 20, 20, 22, 22, 24, 24, 
  [ 25, 26 ], [ 25, 26 ], 28, 28, 29, 29 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PowerMapsAllowedBySymmetrizations( tbl, Irr( tbl ), Irr( tbl ),</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">      pow, 2, rec( maxlen:= 10, contained:= ContainedPossibleCharacters,</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">      minamb:= 2, maxamb:= infinity, quick:= false ) );</span>
[ [ 1, 1, 3, 4, 5, 2, 2, 8, 3, 4, 11, 12, 6, 14, 9, 1, 1, 2, 2, 3, 4, 
      5, 6, 8, 9, 9, 10, 11, 12, 16, 16, 16, 16, 17, 17, 18, 18, 18, 
      18, 20, 20, 20, 20, 22, 22, 24, 24, 25, 26, 28, 28, 29, 29 ] ]
</pre></div>

<p><a id="X7AF7305D80E1E5EF" name="X7AF7305D80E1E5EF"></a></p>

<h4>73.7 <span class="Heading">Subroutines for the Construction of Class Fusions</span></h4>

<p><a id="X7E2BC50C86A16604" name="X7E2BC50C86A16604"></a></p>

<h5>73.7-1 InitFusion</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; InitFusion</code>( <var class="Arg">subtbl</var>, <var class="Arg">tbl</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>For two ordinary character tables <var class="Arg">subtbl</var> and <var class="Arg">tbl</var>, <code class="func">InitFusion</code> returns a parametrized map that is a first approximation of the class fusion from <var class="Arg">subtbl</var> to <var class="Arg">tbl</var>, using condition 1. listed in the description of <code class="func">PossibleClassFusions</code> (<a href="chap73.html#X7883271F7F26356E"><span class="RefLink">73.3-6</span></a>).</p>

<p>If there are classes for which no images are possible, according to this criterion, then <code class="keyw">fail</code> is returned.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">subtbl:= CharacterTable( "2F4(2)" );;  tbl:= CharacterTable( "Ru" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus:= InitFusion( subtbl, tbl );</span>
[ 1, 2, 2, 4, [ 5, 6 ], [ 5, 6, 7, 8 ], [ 5, 6, 7, 8 ], [ 9, 10 ], 
  11, 14, 14, [ 13, 14, 15 ], [ 16, 17 ], [ 18, 19 ], 20, [ 25, 26 ], 
  [ 25, 26 ], [ 5, 6 ], [ 5, 6 ], [ 5, 6 ], [ 5, 6, 7, 8 ], 
  [ 13, 14, 15 ], [ 13, 14, 15 ], [ 18, 19 ], [ 18, 19 ], [ 25, 26 ], 
  [ 25, 26 ], [ 27, 28, 29 ], [ 27, 28, 29 ] ]
</pre></div>

<p><a id="X82F776A3850C6404" name="X82F776A3850C6404"></a></p>

<h5>73.7-2 CheckPermChar</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; CheckPermChar</code>( <var class="Arg">subtbl</var>, <var class="Arg">tbl</var>, <var class="Arg">approxmap</var>, <var class="Arg">permchar</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p><code class="func">CheckPermChar</code> replaces the entries of the parametrized map <var class="Arg">approxmap</var> by improved values, according to condition 3. listed in the description of <code class="func">PossibleClassFusions</code> (<a href="chap73.html#X7883271F7F26356E"><span class="RefLink">73.3-6</span></a>).</p>

<p><code class="func">CheckPermChar</code> returns <code class="keyw">true</code> if no inconsistency occurred, and <code class="keyw">false</code> otherwise.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">permchar:= Sum( Irr( tbl ){ [ 1, 5, 6 ] } );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">CheckPermChar( subtbl, tbl, fus, permchar ); fus;</span>
true
[ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, [ 13, 15 ], 16, [ 18, 19 ], 20, 
  [ 25, 26 ], [ 25, 26 ], 5, 5, 6, 8, 14, [ 13, 15 ], [ 18, 19 ], 
  [ 18, 19 ], [ 25, 26 ], [ 25, 26 ], 27, 27 ]
</pre></div>

<p><a id="X7C52CEDB7D98A6B8" name="X7C52CEDB7D98A6B8"></a></p>

<h5>73.7-3 ConsiderTableAutomorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; ConsiderTableAutomorphisms</code>( <var class="Arg">approxmap</var>, <var class="Arg">grp</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p><code class="func">ConsiderTableAutomorphisms</code> replaces the entries of the parametrized map <var class="Arg">approxmap</var> by improved values, according to condition 4. listed in the description of <code class="func">PossibleClassFusions</code> (<a href="chap73.html#X7883271F7F26356E"><span class="RefLink">73.3-6</span></a>).</p>

<p>Afterwards exactly one representative of fusion maps (contained in <var class="Arg">approxmap</var>) in each orbit under the action of the permutation group <var class="Arg">grp</var> is contained in the modified parametrized map.</p>

<p><code class="func">ConsiderTableAutomorphisms</code> returns the list of positions where <var class="Arg">approxmap</var> was changed.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">ConsiderTableAutomorphisms( fus, AutomorphismsOfTable( tbl ) );</span>
[ 16 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus;</span>
[ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, [ 13, 15 ], 16, [ 18, 19 ], 20, 
  25, [ 25, 26 ], 5, 5, 6, 8, 14, [ 13, 15 ], [ 18, 19 ], [ 18, 19 ], 
  [ 25, 26 ], [ 25, 26 ], 27, 27 ]
</pre></div>

<p><a id="X85024BAE8585DB1C" name="X85024BAE8585DB1C"></a></p>

<h5>73.7-4 FusionsAllowedByRestrictions</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; FusionsAllowedByRestrictions</code>( <var class="Arg">subtbl</var>, <var class="Arg">tbl</var>, <var class="Arg">subchars</var>, <var class="Arg">chars</var>, <var class="Arg">approxmap</var>, <var class="Arg">parameters</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Let <var class="Arg">subtbl</var> and <var class="Arg">tbl</var> be ordinary character tables, <var class="Arg">subchars</var> and <var class="Arg">chars</var> two lists of (values lists of) characters of <var class="Arg">subtbl</var> and <var class="Arg">tbl</var>, respectively, <var class="Arg">approxmap</var> a parametrized map that is an approximation of the class fusion of <var class="Arg">subtbl</var> in <var class="Arg">tbl</var>, and <var class="Arg">parameters</var> a record with components <code class="code">maxlen</code>, <code class="code">minamb</code>, <code class="code">maxamb</code> (three integers), <code class="code">quick</code> (a Boolean), and <code class="code">contained</code> (a function). Usual values of <code class="code">contained</code> are <code class="func">ContainedCharacters</code> (<a href="chap73.html#X81F1137A874EB962"><span class="RefLink">73.5-17</span></a>) or <code class="func">ContainedPossibleCharacters</code> (<a href="chap73.html#X7F957B1481E10A0C"><span class="RefLink">73.5-15</span></a>).</p>

<p><code class="func">FusionsAllowedByRestrictions</code> replaces the entries of <var class="Arg">approxmap</var> by improved values, according to condition 5. listed in the description of <code class="func">PossibleClassFusions</code> (<a href="chap73.html#X7883271F7F26356E"><span class="RefLink">73.3-6</span></a>).</p>

<p>More precisely, the strategy used is as follows.</p>

<p>First, for each <span class="SimpleMath">χ ∈ <var class="Arg">chars</var></span>, let <code class="code">restricted:= CompositionMaps( </code><span class="SimpleMath">χ</span><code class="code">, <var class="Arg">approxmap</var> )</code>.</p>


<ul>
<li><p>If <code class="code">Indeterminateness( restricted )</code><span class="SimpleMath">= 1</span> and <code class="code"><var class="Arg">parameters</var>.quick = false</code> then the scalar products of <code class="code">restricted</code> with <var class="Arg">subchars</var> are checked; if not all scalar products are nonnegative integers then an empty list is returned, otherwise <span class="SimpleMath">χ</span> is deleted from the list of characters to inspect.</p>

</li>
<li><p>Otherwise if <code class="code">Indeterminateness( minus )</code> is smaller than <code class="code"><var class="Arg">parameters</var>.minamb</code> then <span class="SimpleMath">χ</span> is deleted from the list of characters.</p>

</li>
<li><p>If <code class="code"><var class="Arg">parameters</var>.minamb</code> <span class="SimpleMath"></span> <code class="code">Indeterminateness( restricted )</code> <span class="SimpleMath"></span> <code class="code"><var class="Arg">parameters</var>.maxamb</code> then construct <code class="code">poss:= <var class="Arg">parameters</var>.contained( <var class="Arg">subtbl</var>, <var class="Arg">subchars</var>, restricted )</code> and <code class="code">Parametrized( poss )</code>, and improve the approximation of the fusion map using <code class="func">UpdateMap</code> (<a href="chap73.html#X80C7328C85BFC20B"><span class="RefLink">73.5-7</span></a>).</p>

</li>
</ul>
<p>If this yields no further immediate improvements then we branch. If there is a character from <var class="Arg">chars</var> left with less or equal <var class="Arg">parameters</var><code class="code">.maxlen</code> possible restrictions, compute the union of fusion maps allowed by these possibilities. Otherwise we choose a class <span class="SimpleMath">C</span> such that the possible restrictions of a character in <var class="Arg">chars</var> differ at <span class="SimpleMath">C</span>, and compute recursively the union of all allowed fusion maps with image at <span class="SimpleMath">C</span> fixed in the set given by the current approximation of the fusion map.</p>


<div class="example"><pre>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">subtbl:= CharacterTable( "U3(3)" );;  tbl:= CharacterTable( "J4" );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus:= InitFusion( subtbl, tbl );;</span>
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">TestConsistencyMaps( ComputedPowerMaps( subtbl ), fus,</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">       ComputedPowerMaps( tbl ) );</span>
true
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus;</span>
[ 1, 2, 4, 4, [ 5, 6 ], [ 5, 6 ], [ 5, 6 ], 10, [ 12, 13 ], 
  [ 12, 13 ], [ 14, 15, 16 ], [ 14, 15, 16 ], [ 21, 22 ], [ 21, 22 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">ConsiderTableAutomorphisms( fus, AutomorphismsOfTable( tbl ) );</span>
[ 9 ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fus;</span>
[ 1, 2, 4, 4, [ 5, 6 ], [ 5, 6 ], [ 5, 6 ], 10, 12, [ 12, 13 ], 
  [ 14, 15, 16 ], [ 14, 15, 16 ], [ 21, 22 ], [ 21, 22 ] ]
<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">FusionsAllowedByRestrictions( subtbl, tbl, Irr( subtbl ),</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">       Irr( tbl ), fus, rec( maxlen:= 10,</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">       contained:= ContainedPossibleCharacters, minamb:= 2,</span>
<span class="GAPprompt">&gt;</span> <span class="GAPinput">       maxamb:= infinity, quick:= false ) );</span>
[ [ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ], 
  [ 1, 2, 4, 4, 6, 6, 6, 10, 12, 13, 15, 15, 22, 22 ], 
  [ 1, 2, 4, 4, 6, 6, 6, 10, 12, 13, 16, 16, 22, 22 ] ]
</pre></div>


<div class="chlinkprevnextbot">&nbsp;<a href="chap0.html">[Top of Book]</a>&nbsp;  <a href="chap0.html#contents">[Contents]</a>&nbsp;  &nbsp;<a href="chap72.html">[Previous Chapter]</a>&nbsp;  &nbsp;<a href="chap74.html">[Next Chapter]</a>&nbsp;  </div>


<div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a>  <a href="chap1.html">1</a>  <a href="chap2.html">2</a>  <a href="chap3.html">3</a>  <a href="chap4.html">4</a>  <a href="chap5.html">5</a>  <a href="chap6.html">6</a>  <a href="chap7.html">7</a>  <a href="chap8.html">8</a>  <a href="chap9.html">9</a>  <a href="chap10.html">10</a>  <a href="chap11.html">11</a>  <a href="chap12.html">12</a>  <a href="chap13.html">13</a>  <a href="chap14.html">14</a>  <a href="chap15.html">15</a>  <a href="chap16.html">16</a>  <a href="chap17.html">17</a>  <a href="chap18.html">18</a>  <a href="chap19.html">19</a>  <a href="chap20.html">20</a>  <a href="chap21.html">21</a>  <a href="chap22.html">22</a>  <a href="chap23.html">23</a>  <a href="chap24.html">24</a>  <a href="chap25.html">25</a>  <a href="chap26.html">26</a>  <a href="chap27.html">27</a>  <a href="chap28.html">28</a>  <a href="chap29.html">29</a>  <a href="chap30.html">30</a>  <a href="chap31.html">31</a>  <a href="chap32.html">32</a>  <a href="chap33.html">33</a>  <a href="chap34.html">34</a>  <a href="chap35.html">35</a>  <a href="chap36.html">36</a>  <a href="chap37.html">37</a>  <a href="chap38.html">38</a>  <a href="chap39.html">39</a>  <a href="chap40.html">40</a>  <a href="chap41.html">41</a>  <a href="chap42.html">42</a>  <a href="chap43.html">43</a>  <a href="chap44.html">44</a>  <a href="chap45.html">45</a>  <a href="chap46.html">46</a>  <a href="chap47.html">47</a>  <a href="chap48.html">48</a>  <a href="chap49.html">49</a>  <a href="chap50.html">50</a>  <a href="chap51.html">51</a>  <a href="chap52.html">52</a>  <a href="chap53.html">53</a>  <a href="chap54.html">54</a>  <a href="chap55.html">55</a>  <a href="chap56.html">56</a>  <a href="chap57.html">57</a>  <a href="chap58.html">58</a>  <a href="chap59.html">59</a>  <a href="chap60.html">60</a>  <a href="chap61.html">61</a>  <a href="chap62.html">62</a>  <a href="chap63.html">63</a>  <a href="chap64.html">64</a>  <a href="chap65.html">65</a>  <a href="chap66.html">66</a>  <a href="chap67.html">67</a>  <a href="chap68.html">68</a>  <a href="chap69.html">69</a>  <a href="chap70.html">70</a>  <a href="chap71.html">71</a>  <a href="chap72.html">72</a>  <a href="chap73.html">73</a>  <a href="chap74.html">74</a>  <a href="chap75.html">75</a>  <a href="chap76.html">76</a>  <a href="chap77.html">77</a>  <a href="chap78.html">78</a>  <a href="chap79.html">79</a>  <a href="chap80.html">80</a>  <a href="chap81.html">81</a>  <a href="chap82.html">82</a>  <a href="chap83.html">83</a>  <a href="chap84.html">84</a>  <a href="chap85.html">85</a>  <a href="chap86.html">86</a>  <a href="chap87.html">87</a>  <a href="chapBib.html">Bib</a>  <a href="chapInd.html">Ind</a>  </div>

<hr />
<p class="foot">generated by <a href="http://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
</body>
</html>