SSL ctblatlas.tst   Sprache: unbekannt

# This file was created from xpl/ctblatlas.xpl, do not edit!
#############################################################################
##
#W  ctblatlas.tst             GAP applications              Thomas Breuer
##
##  In order to run the tests, one starts GAP from the `tst` subdirectory
##  of the `pkg/ctbllib` directory, and calls `Test( "ctblatlas.tst" );`.
##
gap> START_TEST( "ctblatlas.tst" );

##
gap> LoadPackage( "ctbllib", false );
true

##
gap> lib:= CharacterTable( "Th" );;
gap> parrottnames:= [
>      "1A", "z", "c2", "c3", "c1", "r1", "v", "b", "zc1", "zc2",
>      "zc3", "a", "us1", "w", "f1", "f3", "f2", "zb",
>      "r1c2", "(r1c2)^-1", "r1c3", "vc1", "l", "za",
>      "c1b", "(c1b)^-1", "zf1", "zf2", "19A", "vb", "c2a2",
>      "us1c2", "(us1c2)^-1", "wc1", "(wc1)^-1",
>      "f4", "f5", "(f5)^-1", "r1a", "zbc1", "(zbc1)^-1",
>      "31A", "31B", "r1f1", "s1f1", "(s1f1)^-1",
>      "c2l", "(c2l)^-1" ];;
gap> orders:= OrdersClassRepresentatives( lib );;
gap> centralizers:= SizesCentralizers( lib );;
gap> descr:= TransposedMat( [ parrottnames, orders, centralizers ] );;
gap> for entry in descr do
>      Print( String( entry[1], -12 ),
>             String( entry[2], 2 ), "  ",
>             StringPP( entry[3] ), "\n" );
>    od;
1A           1  2^15*3^10*5^3*7^2*13*19*31
z            2  2^15*3^4*5*7
c2           3  2^6*3^7*7*13
c3           3  2^3*3^10
c1           3  2^4*3^7*5
r1           4  2^11*3^3*7
v            4  2^9*3*5
b            5  2^3*3*5^3
zc1          6  2^4*3^3*5
zc2          6  2^6*3^3
zc3          6  2^3*3^4
a            7  2^3*3*7^2
us1          8  2^7*3
w            8  2^5*3
f1           9  2^3*3^6
f3           9  3^6
f2           9  2*3^4
zb          10  2^3*3*5
r1c2        12  2^5*3^2
(r1c2)^-1   12  2^5*3^2
r1c3        12  2^2*3^3
vc1         12  2^3*3
l           13  3*13
za          14  2^3*7
c1b         15  2*3*5
(c1b)^-1    15  2*3*5
zf1         18  2^3*3^2
zf2         18  2*3^2
19A         19  19
vb          20  2^2*5
c2a2        21  3*7
us1c2       24  2^3*3
(us1c2)^-1  24  2^3*3
wc1         24  2^3*3
(wc1)^-1    24  2^3*3
f4          27  3^3
f5          27  3^3
(f5)^-1     27  3^3
r1a         28  2^2*7
zbc1        30  2*3*5
(zbc1)^-1   30  2*3*5
31A         31  31
31B         31  31
r1f1        36  2^2*3^2
s1f1        36  2^2*3^2
(s1f1)^-1   36  2^2*3^2
c2l         39  3*13
(c2l)^-1    39  3*13

##
gap> th:= rec( UnderlyingCharacteristic:= 0,
>              OrdersClassRepresentatives:= orders,
>              SizesCentralizers:= centralizers,
>              Size:= centralizers[1] );;
gap> ConvertToCharacterTableNC( th );;

##
gap> g:= AtlasGroup( "2^5.L5(2)" );;
gap> bl:= Blocks( g, MovedPoints( g ) );;
gap> Length( bl[1] );
2
gap> acthom:= ActionHomomorphism( g, bl, OnSets );;
gap> img:= Image( acthom );;
gap> Size( g ) / Size( img );
32
gap> sm:= SmallerDegreePermutationRepresentation( img );;
gap> NrMovedPoints( Image( sm ) );
31
gap> f:= CharacterTable( Image( sm ) );;
gap> d:= CharacterTable( g );;
gap> fus:= List( ConjugacyClasses( d ),
>            c -> PositionProperty( ConjugacyClasses( f ),
>                   cc -> ( Representative( c )^acthom )^sm in cc ) );;
gap> infl:= List( Irr( f ), x -> x{ fus } );;

##
gap> indcyc:= InducedCyclic( d, [ 2 .. NrConjugacyClasses( d ) ], "all" );;
gap> nat:= NaturalCharacter( g );;
gap> red:= ReducedOrdinary( d, infl, Concatenation( indcyc, [ nat ] ) );;
gap> Length( red.irreducibles );
1
gap> faithirr:= ShallowCopy( red.irreducibles );;
gap> ten:= Set( Tensored( infl, faithirr ) );;
gap> ten:= Reduced( d, faithirr, ten );;
gap> lll:= LLL( d, Concatenation( red.remainders, ten.remainders ) );;
gap> Length( lll.irreducibles );
5
gap> Append( faithirr, lll.irreducibles );

##
gap> sym2:= Symmetrizations( d, faithirr, 2 );;
gap> sym3:= Symmetrizations( d, faithirr, 3 );;
gap> irr:= Concatenation( infl, faithirr );;
gap> sym:= Reduced( d, irr, Concatenation( sym2, sym3 ) );;
gap> lll:= LLL( d, Concatenation( lll.remainders, sym.remainders ) );;
gap> Length( lll.irreducibles );
4
gap> Append( irr, lll.irreducibles );

##
gap> gram:= MatScalarProducts( d, lll.remainders, lll.remainders );;
gap> emb:= OrthogonalEmbeddings( gram );;                           
gap> Length( emb.solutions );
3
gap> dec:= List( emb.solutions,
>                x -> Decreased( d, lll.remainders, emb.vectors{ x } ) );;
gap> dec:= Filtered( dec, x -> x <> fail );;
gap> Length( dec );
2

##
gap> sym:= List( [ 1, 2 ],
>            i -> Symmetrizations( d, [ dec[i].irreducibles[1] ], 2 ) );;
gap> good:= Filtered( [ 1, 2 ],
>             i -> ForAll( dec[i].irreducibles,
>                    x -> IsInt( ScalarProduct( d, sym[i][1], x ) ) ) );;
gap> Length( good );
1
gap> SetIrr( d, Concatenation( irr, dec[ good[1] ].irreducibles ) );

##
gap> nsg:= ClassPositionsOfNormalSubgroups( d );
[ [ 1 ], [ 1, 2 ], [ 1 .. 41 ] ]
gap> SizesConjugacyClasses( d ){ nsg[2] };
[ 1, 31 ]
gap> OrdersClassRepresentatives( d ){ nsg[2] };
[ 1, 2 ]

##
gap> f:= d / nsg[2];;
gap> PossibleClassFusions( f, d );
[  ]

##
gap> n:= PCore( g, 2 );
<permutation group with 5 generators>
gap> Size( n );
32
gap> IsomorphismGroups( g / n, GL(5,2) ) = fail;
false

##
gap> libsub:= CharacterTable( "2^5.L5(2)" );;
gap> IsRecord( TransformingPermutationsCharacterTables( d, libsub ) );
true
gap> d:= libsub;;

##
gap> powinfo:= [
>     [ "zc3", 2, "c3" ],     # c3 commutes with z
>     [ "zf2", 2, "f2" ],     # f2 commutes with z
>     [ "r1c3", 2, "zc3" ],   # r1 commutes with c3
>     [ "vc1", 2, "zc1" ],    # v squares to z and commutes with c1
>     [ "wc1", 2, "vc1" ],    # w squares to v and commutes with c1
>     [ "(wc1)^-1", 2, "vc1" ],
>     [ "us1c2", 2, "r1c2" ], # us1 squares to r1
>     [ "(us1c2)^-1", 2, "(r1c2)^-1" ],
>     [ "us1", 2, "r1" ],     # (5.1)
>     [ "w", 2, "v" ],        # (5.1)
>     [ "zbc1", 2, "c1b" ],
>     [ "(zbc1)^-1", 2, "(c1b)^-1" ],
>     [ "f1", 3, "c3" ],
>     [ "f2", 3, "c3" ],
>     [ "f3", 3, "c3" ],
>     [ "vc1", 3, "v" ],      # v commutes with c1
>     [ "zf1", 3, "zc3" ],
>     [ "zf2", 3, "zc3" ],
>     [ "us1c2", 3, "us1" ],
>     [ "(us1c2)^-1", 3, "us1" ],
>     [ "wc1", 3, "w" ],
>     [ "(wc1)^-1", 3, "w" ],
>     [ "f4", 3, "f3" ],
>     [ "f5", 3, "f3" ],
>     [ "(f5)^-1", 3, "f3" ],
>     [ "r1f1", 3, "r1c3" ],
>     [ "s1f1", 3, "r1c3" ],
>     [ "(s1f1)^-1", 3, "r1c3" ],
>     ];;

##
gap> maxorder:= Maximum( OrdersClassRepresentatives( th ) );
39
gap> primes:= Filtered( [ 1 .. maxorder ], IsPrimeInt );;

##
gap> for p in primes do
>      if 36 mod p <> 0 then
>        Add( powinfo, [ "r1f1", p, "r1f1" ] );
>      fi;
>      if 27 mod p <> 0 then
>        Add( powinfo, [ "f4", p, "f4" ] );
>      fi;
>    od;

##
gap> powermaps:= [];;
gap> for p in primes do
>      powermaps[p]:= InitPowerMap( th, p );
>    od;
gap> for entry in powinfo do
>      p:= entry[2];
>      pow:= powermaps[p];
>      src:= Position( parrottnames, entry[1] );
>      trg:= Position( parrottnames, entry[3] );
>      if IsInt( pow[ src ] ) then
>        if pow[ src ] <> trg then
>          Error( "contradiction!" );
>        fi;
>      elif not trg in pow[ src ] then
>        Error( "contradiction!" );
>      else
>        pow[ src ]:= trg;
>      fi;
>    od;
gap> SetComputedPowerMaps( th, powermaps );

##
gap> setGaloisInfo:= function( powermaps, classes, orders, primes, x )
>    local ord, p;
>    ord:= orders[ classes[1] ];
>    for p in primes do
>      if ord mod p <> 0 then
>        if GaloisCyc( x, p ) = x then
>          powermaps[p]{ classes }:= classes;
>        else
>          powermaps[p]{ classes }:= classes{ [ 2, 1 ] };
>        fi;
>      fi;
>    od;
>    end;;

##
gap> pos:= Positions( OrdersClassRepresentatives( d ), 15 );
[ 22, 24 ]
gap> f:= Field( List( Irr( d ), x -> x[ pos[1] ] ) );
NF(15,[ 1, 2, 4, 8 ])
gap> Sqrt( -15 ) in f;
true
gap> pos:= Positions( orders, 15 );
[ 25, 26 ]
gap> setGaloisInfo( powermaps, pos, orders, primes, Sqrt( -15 ) );
gap> pos:= Positions( OrdersClassRepresentatives( d ), 30 );
[ 23, 25 ]
gap> f:= Field( List( Irr( d ), x -> x[ pos[1] ] ) );
NF(15,[ 1, 2, 4, 8 ])
gap> pos:= Positions( orders, 30 );
[ 40, 41 ]
gap> setGaloisInfo( powermaps, pos, orders, primes, Sqrt( -15 ) );

##
gap> setGaloisInfo( powermaps,
>        List( [ "f5", "(f5)^-1" ], x -> Position( parrottnames, x ) ),
>        orders, primes, Sqrt( -3 ) );
gap> setGaloisInfo( powermaps, Positions( orders, 31 ), orders, primes,
>                   Sqrt( -31 ) );

##
gap> pos:= Positions( orders, 39 );
[ 47, 48 ]
gap> setGaloisInfo( powermaps, pos, orders, primes, Sqrt( -3 ) );
gap> indcyc:= InducedCyclic( th, [ pos[1] ], "all" );;
gap> ForAll( indcyc, x -> IsInt( ScalarProduct( th, x, x ) ) );
false
gap> setGaloisInfo( powermaps, pos, orders, primes, Sqrt( -39 ) );
gap> indcyc:= InducedCyclic( th, [ pos[1] ], "all" );;
gap> ForAll( indcyc, x -> IsInt( ScalarProduct( th, x, x ) ) );
true

##
gap> pos:= Positions( orders, 36 );
[ 44, 45, 46 ]
gap> parrottnames{ pos };
[ "r1f1", "s1f1", "(s1f1)^-1" ]
gap> setGaloisInfo( powermaps, [ 45, 46 ], orders, primes, Sqrt( -3 ) );
gap> indcyc:= InducedCyclic( th, [ 45 ], "all" );;    
gap> ForAll( indcyc, x -> IsInt( ScalarProduct( th, x, x ) ) );
true
gap> setGaloisInfo( powermaps, [ 45, 46 ], orders, primes, Sqrt( -1 ) );
gap> indcyc:= InducedCyclic( th, [ 45 ], "all" );;
gap> ForAll( indcyc, x -> IsInt( ScalarProduct( th, x, x ) ) );
false
gap> setGaloisInfo( powermaps, [ 45, 46 ], orders, primes, Sqrt( -3 ) );

##
gap> List( [ "wc1", "(wc1)^-1" ], x -> Position( parrottnames, x ) );
[ 34, 35 ]
gap> vals:= [ Sqrt( -3 ), Sqrt( -1 ), Sqrt( -2 ), Sqrt( -6 ) ];
[ E(3)-E(3)^2, E(4), E(8)+E(8)^3, E(24)+E(24)^11-E(24)^17-E(24)^19 ]
gap> good:= [];;
gap> for val in vals do
>      setGaloisInfo( powermaps, [ 34, 35 ], orders, primes, val );
>      indcyc:= InducedCyclic( th, [ 34 ], "all" );
>      if ForAll( indcyc, x -> IsInt( ScalarProduct( th, x, x ) ) ) then
>        Add( good, val );
>      fi;
>    od;
gap> good;
[ E(24)+E(24)^11-E(24)^17-E(24)^19 ]
gap> setGaloisInfo( powermaps, [ 34, 35 ], orders, primes, good[1] );

##
gap> parrottnames{ [ 19, 20, 32, 33 ] };
[ "r1c2", "(r1c2)^-1", "us1c2", "(us1c2)^-1" ]
gap> fus:= InitFusion( d, th );;
gap> pos:= Positions( OrdersClassRepresentatives( d ), 12 );
[ 12, 15, 16 ]
gap> fus{ pos };
[ [ 19, 20, 21, 22 ], [ 19, 20 ], [ 19, 20 ] ]
gap> List( pos, x -> Field( List( Irr( d ), chi -> chi[x] ) ) );
[ Rationals, CF(3), CF(3) ]
gap> Sqrt( -3 ) in CF(3);
true
gap> setGaloisInfo( powermaps, [ 19, 20 ], orders, primes, Sqrt( -3 ) );
gap> setGaloisInfo( powermaps, [ 32, 33 ], orders, primes, Sqrt( -3 ) );

##
gap> indcyc:= InducedCyclic( th, [ 2 .. NrConjugacyClasses( th ) ], "all" );;

##
gap> fus:= InitFusion( d, th );
[ 1, 2, 2, 6, [ 6, 7 ], [ 6, 7 ], 13, [ 13, 14 ], [ 13, 14 ], 5, 9, 
  [ 19, 20, 21, 22 ], 3, 10, [ 19, 20 ], [ 19, 20 ], [ 9, 10 ], 
  [ 32, 33, 34, 35 ], [ 32, 33, 34, 35 ], 8, 18, [ 25, 26 ], [ 40, 41 ], 
  [ 25, 26 ], [ 40, 41 ], 12, 24, 24, 39, 31, 12, 24, 24, 39, 31, [ 42, 43 ], 
  [ 42, 43 ], [ 42, 43 ], [ 42, 43 ], [ 42, 43 ], [ 42, 43 ] ]
gap> Positions( OrdersClassRepresentatives( d ), 31 );
[ 36, 37, 38, 39, 40, 41 ]
gap> fus[36];
[ 42, 43 ]
gap> fus[36]:= 42;;
gap> TestConsistencyMaps( ComputedPowerMaps( d ), fus,
>        ComputedPowerMaps( th ) );
true
gap> possfus:= FusionsAllowedByRestrictions( d, th, Irr( d ), indcyc, fus,
>      rec( maxlen:= 10, minamb:= 1, maxamb:= 10^6, quick:= false,
>           contained:= ContainedPossibleCharacters ) );;
gap> possfus:= RepresentativesFusions( d, possfus, Group( () ) );
[ [ 1, 2, 2, 6, 7, 6, 13, 14, 13, 5, 9, 22, 3, 10, 19, 20, 10, 33, 32, 8, 18, 
      25, 40, 26, 41, 12, 24, 24, 39, 31, 12, 24, 24, 39, 31, 42, 43, 42, 42, 
      43, 43 ], 
  [ 1, 2, 2, 6, 7, 7, 13, 14, 14, 5, 9, 22, 3, 10, 19, 20, 10, 33, 32, 8, 18, 
      25, 40, 26, 41, 12, 24, 24, 39, 31, 12, 24, 24, 39, 31, 42, 43, 42, 42, 
      43, 43 ] ]

##
gap> indd:= InducedClassFunctionsByFusionMap( d, th, Irr( d ), possfus[1] );;
gap> ForAll( indd, x -> IsInt( ScalarProduct( th, x, x ) ) );
false
gap> indd:= InducedClassFunctionsByFusionMap( d, th, Irr( d ), possfus[2] );;
gap> ForAll( indd, x -> IsInt( ScalarProduct( th, x, x ) ) );
true

##
gap> irr:= [ TrivialCharacter( th ) ];;
gap> red:= ReducedOrdinary( th, irr, Concatenation( indcyc, indd ) );;
gap> lll:= LLL( th, red.remainders );;
gap> Length( lll.irreducibles );
4
gap> Append( irr, lll.irreducibles );

##
gap> sym:= Concatenation( List( [ 2, 3, 4, 5 ],
>              p -> Symmetrizations( th, irr, p ) ) );;
gap> sym:= ReducedOrdinary( th, irr, sym );;
gap> ten:= Set( Tensored( irr, irr ) );;
gap> ten:= ReducedOrdinary( th, irr, ten );;
gap> lll:= LLL( th, Concatenation( lll.remainders, sym.remainders,
>                               ten.remainders ) );;
gap> Length( lll.irreducibles );
3
gap> Append( irr, lll.irreducibles );
gap> DimensionsMat( irr );
[ 8, 48 ]

##
gap> indcyc:= ReducedOrdinary( th, irr, indcyc );;
gap> indd:= ReducedOrdinary( th, irr, indd );;
gap> sym:= ReducedOrdinary( th, irr, sym.remainders );;
gap> ten:= ReducedOrdinary( th, irr, ten.remainders );;
gap> lll:= LLL( th, Concatenation( indcyc.remainders, indd.remainders,
>                       sym.remainders, ten.remainders ) );;
gap> gram:= MatScalarProducts( th, lll.remainders, lll.remainders );;
gap> emb:= OrthogonalEmbeddings( gram, 40 );;
gap> Length( emb.solutions );
4

##
gap> dec:= List( emb.solutions,
>                x -> Decreased( th, lll.remainders, emb.vectors{ x } ) );;
gap> dec:= Filtered( dec, x -> x <> fail );;
gap> Length( dec );
2

##
gap> SetIrr( th, List( Concatenation( irr, dec[1].irreducibles ),
>                      x -> Character( th, x ) ) );
gap> IsRecord( TransformingPermutationsCharacterTables( th, lib ) );
true

##
gap> ResetFilterObj( th, HasIrr );
gap> SetIrr( th, List( Concatenation( irr, dec[2].irreducibles ),
>                      x -> Character( th, x ) ) );
gap> IsRecord( TransformingPermutationsCharacterTables( th, lib ) );
true

##
gap> lib:= CharacterTable( "J4" );;
gap> pos:= [ 1 .. NrConjugacyClasses( lib ) ];;
gap> orders:= OrdersClassRepresentatives( lib );;
gap> centralizers:= SizesCentralizers( lib );;
gap> descr:= TransposedMat( [ pos, orders, centralizers ] );;
gap> for entry in descr do
>      Print( String( entry[1], 2 ), "  ",
>             String( entry[2], 2 ), "  ",
>             StringPP( entry[3] ), "\n" );
>    od;
 1   1  2^21*3^3*5*7*11^3*23*29*31*37*43
 2   2  2^21*3^3*5*7*11
 3   2  2^19*3^2*5*7*11
 4   3  2^8*3^3*5*7*11
 5   4  2^15*3*5*11
 6   4  2^15*3
 7   4  2^11*3*7
 8   5  2^6*3*5*7
 9   6  2^8*3^3*5*7*11
10   6  2^8*3^2
11   6  2^8*3^2
12   7  2^3*3*5*7
13   7  2^3*3*5*7
14   8  2^8*5
15   8  2^8*3
16   8  2^9
17  10  2^6*3*5
18  10  2^4*5
19  11  2^3*3*11^3
20  11  2*11^2
21  12  2^6*3
22  12  2^6*3
23  12  2^4*3
24  14  2^2*3*7
25  14  2^2*3*7
26  14  2^3*7
27  14  2^3*7
28  15  2*3*5
29  16  2^5
30  20  2^5*5
31  20  2^5*5
32  21  2*3*7
33  21  2*3*7
34  22  2^3*3*11
35  22  2*11
36  23  23
37  24  2^4*3
38  24  2^4*3
39  28  2^2*7
40  28  2^2*7
41  29  29
42  30  2*3*5
43  31  31
44  31  31
45  31  31
46  33  2*3*11
47  33  2*3*11
48  35  5*7
49  35  5*7
50  37  37
51  37  37
52  37  37
53  40  2^3*5
54  40  2^3*5
55  42  2*3*7
56  42  2*3*7
57  43  43
58  43  43
59  43  43
60  44  2^2*11
61  66  2*3*11
62  66  2*3*11

##
gap> j4:= rec( UnderlyingCharacteristic:= 0,
>              OrdersClassRepresentatives:= orders,
>              SizesCentralizers:= centralizers,
>              Size:= centralizers[1] );;
gap> ConvertToCharacterTableNC( j4 );;

##
gap> u:= CharacterTable( "J4M1" );
CharacterTable( "mx1j4" )

##
gap> powinfo:= [
>     [  5,  2,  2 ],
>     [  6,  2,  2 ],
>     [  7,  2,  3 ],
>     [ 10,  3,  2 ],
>     [ 11,  3,  3 ],
>     [ 15,  2,  6 ],
>     [ 16,  2,  6 ],
>     [ 17,  5,  2 ],
>     [ 18,  5,  3 ],
>     [ 21,  3,  5 ],
>     [ 22,  3,  6 ],
>     [ 23,  3,  7 ],
>     [ 24,  7,  2 ],
>     [ 25,  7,  2 ],
>     [ 26,  7,  3 ],
>     [ 27,  7,  3 ],
>     [ 29,  2, 16 ],
>     [ 34, 11,  2 ],
>     [ 35, 11,  3 ],
>     ];;

##
gap> maxorder:= Maximum( OrdersClassRepresentatives( j4 ) );
66
gap> primes:= Filtered( [ 1 .. maxorder ], IsPrimeInt );;

##
gap> pos:= Union( Positions( orders, 6 ), Positions( orders, 12 ) );
[ 9, 10, 11, 21, 22, 23 ]
gap> for p in primes do
>      if 6 mod p <> 0 then
>        for i in pos do
>          Add( powinfo, [ i, p, i ] );
>        od;
>      fi;
>    od;

##
gap> Add( powinfo, [ 24, 2, 12 ] );
gap> Add( powinfo, [ 25, 2, 13 ] );
gap> Add( powinfo, [ 26, 2, 12 ] );
gap> Add( powinfo, [ 27, 2, 13 ] );
gap> Add( powinfo, [ 39, 2, 26 ] );
gap> Add( powinfo, [ 40, 2, 27 ] );
gap> Add( powinfo, [ 55, 2, 32 ] );
gap> Add( powinfo, [ 56, 2, 33 ] );
gap> Add( powinfo, [ 55, 3, 25 ] );
gap> Add( powinfo, [ 56, 3, 24 ] );
gap> Add( powinfo, [ 32, 3, 13 ] );
gap> Add( powinfo, [ 33, 3, 12 ] );

##
gap> powermaps:= [];;
gap> for p in primes do
>      powermaps[p]:= InitPowerMap( j4, p );
>    od;
gap> for entry in powinfo do
>      p:= entry[2];
>      pow:= powermaps[p];
>      src:= entry[1];
>      trg:= entry[3];
>      if IsInt( pow[ src ] ) then
>        if pow[ src ] <> trg then
>          Error( "contradiction!" );
>        fi;
>      elif not trg in pow[ src ] then
>        Error( "contradiction!" );
>      else
>        pow[ src ]:= trg;
>      fi;
>    od;
gap> SetComputedPowerMaps( j4, powermaps );

##
gap> x:= Sqrt( -7 );;
gap> pos:= Positions( orders, 7 );
[ 12, 13 ]
gap> setGaloisInfo( powermaps, pos, orders, primes, x );
gap> setGaloisInfo( powermaps, [ 24, 25 ], orders, primes, x );
gap> setGaloisInfo( powermaps, [ 26, 27 ], orders, primes, x );
gap> pos:= Positions( orders, 21 );
[ 32, 33 ]
gap> setGaloisInfo( powermaps, pos, orders, primes, x );
gap> pos:= Positions( orders, 28 );
[ 39, 40 ]
gap> setGaloisInfo( powermaps, pos, orders, primes, x );
gap> pos:= Positions( orders, 35 );
[ 48, 49 ]
gap> setGaloisInfo( powermaps, pos, orders, primes, x );
gap> pos:= Positions( orders, 42 );
[ 55, 56 ]
gap> setGaloisInfo( powermaps, pos, orders, primes, x );

##
gap> powermaps[5]{ [ 48, 49 ] }:= [ 13, 12 ];;

##
gap> pos:= Positions( orders, 33 );
[ 46, 47 ]
gap> setGaloisInfo( powermaps, pos, orders, primes, 1 );
gap> ind:= InducedCyclic( j4, [ 46 ], "all" );;
gap> ForAll( ind, x -> IsInt( ScalarProduct( j4, x, x ) ) );
false
gap> setGaloisInfo( powermaps, pos, orders, primes, Sqrt( -3 ) );
gap> ind:= InducedCyclic( j4, [ 46 ], "all" );;
gap> ForAll( ind, x -> IsInt( ScalarProduct( j4, x, x ) ) );
false
gap> setGaloisInfo( powermaps, pos, orders, primes, Sqrt( -11 ) );
gap> ind:= InducedCyclic( j4, [ 46 ], "all" );;
gap> ForAll( ind, x -> IsInt( ScalarProduct( j4, x, x ) ) );
false
gap> setGaloisInfo( powermaps, pos, orders, primes, Sqrt( 33 ) );
gap> ind:= InducedCyclic( j4, [ 46 ], "all" );;
gap> ForAll( ind, x -> IsInt( ScalarProduct( j4, x, x ) ) );
true

##
gap> setGaloisInfo( powermaps, pos, orders, primes, Sqrt( 33 ) );
gap> pos:= Positions( orders, 66 );
[ 61, 62 ]
gap> setGaloisInfo( powermaps, pos, orders, primes, Sqrt( 33 ) );
gap> powermaps[2]{ pos }:= [ 46, 47 ];;

##
gap> pos:= Positions( orders, 20 );
[ 30, 31 ]
gap> setGaloisInfo( powermaps, pos, orders, primes, 1 );
gap> ind:= InducedCyclic( j4, [ 30 ], "all" );;
gap> ForAll( ind, x -> IsInt( ScalarProduct( j4, x, x ) ) );
false
gap> u:= CharacterTable( "J4M1" );
CharacterTable( "mx1j4" )
gap> pos:= Positions( OrdersClassRepresentatives( u ), 20 );
[ 60, 61 ]
gap> flds:= List( pos, i -> Field( List( Irr( u ), x -> x[i] ) ) );
[ NF(5,[ 1, 4 ]), NF(5,[ 1, 4 ]) ]
gap> x:= Sqrt(5);;
gap> ForAll( flds, f -> x in f );
true
gap> setGaloisInfo( powermaps, Positions( orders, 20 ), orders, primes, x );

##
gap> pos:= Positions( orders, 40 );
[ 53, 54 ]
gap> setGaloisInfo( powermaps, pos, orders, primes, Sqrt( 5 ) );
gap> powermaps[2]{ pos }:= [ 31, 30 ];;

##
gap> x:= EC( 31 );;
gap> classes:= [ 43 .. 45 ];;
gap> vals:= List( [ 1, 5, 25 ], k -> GaloisCyc( x, k ) );;
gap> for p in primes do
>   if p mod 31 <> 0 then
>     for i in [ 1 .. 3 ] do
>       powermaps[p][ classes[i] ]:=
>         classes[ Position( vals, GaloisCyc( vals[i], p ) ) ];
>     od;
>   fi;
> od;
gap> x:= EC( 37 );;
gap> classes:= [ 50 .. 52 ];;
gap> vals:= List( [ 1, 2, 4 ], k -> GaloisCyc( x, k ) );;
gap> for p in primes do
>   if p mod 37 <> 0 then
>     for i in [ 1 .. 3 ] do
>       powermaps[p][ classes[i] ]:=
>         classes[ Position( vals, GaloisCyc( vals[i], p ) ) ];
>     od;
>   fi;
> od;
gap> x:= EC( 43 );;
gap> classes:= [ 57 .. 59 ];;
gap> vals:= List( [ 1, 6, 36 ], k -> GaloisCyc( x, k ) );;
gap> for p in primes do
>   if p mod 43 <> 0 then
>     for i in [ 1 .. 3 ] do
>       powermaps[p][ classes[i] ]:=
>         classes[ Position( vals, GaloisCyc( vals[i], p ) ) ];
>     od;
>   fi;
> od;

##
gap> pos:= PositionsProperty( powermaps[2], IsList );
[ 21, 22, 23, 35, 37, 38 ]
gap> orders{ pos };
[ 12, 12, 12, 22, 24, 24 ]

##
gap> powermaps[2]{ [ 34, 35 ] };
[ 19, [ 19, 20 ] ]
gap> powermaps[2][35]:= 20;;

##
gap> powermaps[2]{ [ 21, 22, 23 ] }:= [ [ 9, 10 ], [ 9, 10 ], 11 ];;

##
gap> powermaps[2]{ [ 37, 38 ] }:= [ 22, 22 ];;

##
gap> poss:= [];;
gap> for cand in [ [ 9, 9 ], [ 9, 10 ], [ 10, 9 ] ] do
>   powermaps[2]{ [ 21, 22 ] }:= cand;
>   fus:= InitFusion( u, j4 );
>   TestConsistencyMaps( ComputedPowerMaps( u ), fus, powermaps );
>   indcyc:= InducedCyclic( j4, [ 21, 22 ], "all" );
>   possfus:= FusionsAllowedByRestrictions( u, j4, Irr( u ), indcyc, fus,
>        rec( maxlen:= 10, minamb:= 1, maxamb:= 10^6, quick:= false,
>             contained:= ContainedPossibleCharacters ) );
>   Add( poss, Length( possfus ) );
> od;
gap> poss;
[ 0, 0, 0 ]
gap> powermaps[2]{ [ 21, 22 ] }:= [ 10, 10 ];;

##
gap> pos:= Positions( orders, 24 );
[ 37, 38 ]
gap> setGaloisInfo( powermaps, pos, orders, primes, 1 );
gap> indcyc:= InducedCyclic( j4, pos, "all" );;
gap> ForAll( indcyc, x -> IsInt( ScalarProduct( j4, x, x ) ) );
false

##
gap> setGaloisInfo( powermaps, pos, orders, primes, Sqrt( 3 ) );

##
gap> indcyc:= InducedCyclic( j4, [ 2 .. NrConjugacyClasses( j4 ) ], "all" );;

##
gap> u:= CharacterTable( "J4M1" );
CharacterTable( "mx1j4" )
gap> fus:= InitFusion( u, j4 );
[ 1, [ 2, 3 ], 2, [ 2, 3 ], [ 2, 3 ], [ 2, 3 ], [ 2, 3 ], 4, 4, 5, [ 5, 6 ], 
  [ 5, 6 ], 7, [ 5, 6 ], [ 5, 6, 7 ], [ 5, 6, 7 ], [ 5, 6, 7 ], [ 5, 6, 7 ], 
  [ 5, 6, 7 ], [ 5, 6, 7 ], [ 5, 6, 7 ], [ 5, 6, 7 ], 8, 9, [ 9, 10, 11 ], 
  [ 9, 10, 11 ], [ 9, 10, 11 ], [ 9, 10, 11 ], [ 9, 10, 11 ], [ 9, 10, 11 ], 
  [ 9, 10, 11 ], [ 12, 13 ], [ 12, 13 ], 15, 16, [ 14, 15, 16 ], 
  [ 14, 15, 16 ], [ 14, 15, 16 ], [ 14, 15, 16 ], 17, [ 17, 18 ], [ 17, 18 ], 
  [ 17, 18 ], [ 19, 20 ], [ 21, 22 ], [ 21, 22 ], [ 21, 22, 23 ], 
  [ 21, 22, 23 ], [ 21, 22, 23 ], [ 21, 22, 23 ], [ 21, 22, 23 ], 
  [ 21, 22, 23 ], [ 26, 27 ], [ 26, 27 ], [ 24, 25, 26, 27 ], 
  [ 24, 25, 26, 27 ], 28, 28, 29, [ 30, 31 ], [ 30, 31 ], [ 32, 33 ], 
  [ 32, 33 ], [ 34, 35 ], 36, 36, [ 37, 38 ], [ 37, 38 ], [ 39, 40 ], 
  [ 39, 40 ], 42, 42 ]
gap> Print( AutomorphismsOfTable( u ), "\n" );
Group( [ (67,68), (65,66), (60,61), (57,58)(71,72), (57,58)(67,68)(71,72), 
  (57,58)(60,61)(71,72), (32,33)(53,54)(55,56)(62,63)(69,70), 
  ( 5, 6)(15,16)(21,22)(30,31)(42,43)(49,50)(51,52) ] )
gap> fus{ [ 60, 61, 67, 68, 69, 70 ] };
[ [ 30, 31 ], [ 30, 31 ], [ 37, 38 ], [ 37, 38 ], [ 39, 40 ], [ 39, 40 ] ]
gap> fus[60]:= 30;;
gap> fus[67]:= 37;;
gap> fus[69]:= 40;;
gap> TestConsistencyMaps( ComputedPowerMaps( u ), fus,
>        ComputedPowerMaps( j4 ) );
true

##
gap> irr:= [ TrivialCharacter( j4 ) ];;
gap> indcyc:= ReducedOrdinary( j4, irr, indcyc );;
gap> possfus:= FusionsAllowedByRestrictions( u, j4, Irr( u ),
>      indcyc.remainders, fus,
>      rec( maxlen:= 10, minamb:= 1, maxamb:= 10^3, quick:= false,
>           contained:= ContainedPossibleCharacters ) );;
gap> Length( possfus );
1440
gap> reps:= RepresentativesFusions( u, possfus, Group(()) );;
gap> Length( reps );
720

##
gap> reps:= Filtered( reps,
>      map -> ForAll( InducedClassFunctionsByFusionMap( u, j4, Irr(u), map ),
>                     x -> IsPosInt( ScalarProduct( j4, x, x ) ) ) );;
gap> Length( reps );
2
gap> inds:= List( reps,
>      map -> InducedClassFunctionsByFusionMap( u, j4, Irr( u ), map ) );;
gap> ForAll( Flat( MatScalarProducts( j4, inds[1], inds[1] ) ), IsInt );
false
gap> ForAll( Flat( MatScalarProducts( j4, inds[2], inds[2] ) ), IsInt );
true

##
gap> ind:= ReducedOrdinary( j4, irr, inds[2] );;
gap> Length( ind.irreducibles );
0
gap> lll:= LLL( j4, Concatenation( indcyc.remainders, ind.remainders ) );;
gap> Length( lll.irreducibles );
29
gap> Append( irr, lll.irreducibles );

##
gap> lll.norms;
[ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
  2, 2, 2, 2, 2, 2, 2 ]
gap> dn:= DnLatticeIterative( j4, lll.remainders );;
gap> Length( dn.irreducibles );
28
gap> Append( irr, dn.irreducibles );

##
gap> gram:= MatScalarProducts( j4, dn.remainders, dn.remainders );;
gap> emb:= OrthogonalEmbeddings( gram, 4 );;
gap> Length( emb.solutions );
3

##
gap> dec:= List( emb.solutions,
>                x -> Decreased( j4, dn.remainders, emb.vectors{ x } ) );;
gap> dec:= Filtered( dec, x -> x <> fail );;
gap> Length( dec );
2

##
gap> possirr:= List( dec, x -> x.irreducibles );;
gap> chi:= possirr[1][1];;
gap> sym:= Symmetrizations( j4, [ chi ], 2 );;
gap> ForAll( sym, x -> IsInt( ScalarProduct( j4, x, chi ) ) );
false

##
gap> SetIrr( j4, List( Concatenation( irr, possirr[2] ),
>                      x -> Character( j4, x ) ) );
gap> IsRecord( TransformingPermutationsCharacterTables( lib, j4 ) );
true

##
gap> t:= CharacterTable( "2E6(2)" );;
gap> t2:= CharacterTable( "2E6(2).2" );;
gap> aut:= AutomorphismsOfTable( t );;
gap> Factors( Size( aut ) );
[ 2, 2, 2, 2, 2, 2, 2, 2, 3 ]
gap> syl:= SylowSubgroup( aut, 3 );;
gap> IsNormal( aut, syl );
true
gap> orbs:= Orbits( syl, [ 1 .. NrConjugacyClasses( t ) ] );;
gap> orbsalpha:= List( Filtered( orbs, l -> Length( l ) <> 1 ), Set );
[ [ 11, 12, 13 ], [ 16, 17, 18 ], [ 39, 40, 41 ], [ 43, 44, 45 ], 
  [ 46, 47, 48 ], [ 64, 65, 66 ], [ 67, 68, 69 ], [ 75, 76, 77 ], 
  [ 78, 79, 80 ], [ 88, 89, 90 ], [ 91, 92, 93 ], [ 94, 95, 96 ], 
  [ 114, 115, 116 ], [ 117, 118, 119 ] ]

##
gap> tfust2:= PossibleClassFusions( t, t2 );;
gap> poss:= Set( List( tfust2, l -> Filtered( InverseMap( l ), IsList ) ) );
[ [ [ 11, 12 ], [ 16, 17 ], [ 39, 40 ], [ 43, 44 ], [ 46, 47 ], [ 55, 56 ], 
      [ 61, 62 ], [ 64, 65 ], [ 67, 68 ], [ 75, 76 ], [ 78, 79 ], [ 88, 89 ], 
      [ 91, 92 ], [ 94, 95 ], [ 99, 100 ], [ 103, 104 ], [ 109, 110 ], 
      [ 114, 115 ], [ 117, 118 ], [ 123, 124 ], [ 125, 126 ] ], 
  [ [ 11, 13 ], [ 16, 18 ], [ 39, 41 ], [ 43, 45 ], [ 46, 48 ], [ 55, 56 ], 
      [ 61, 62 ], [ 64, 66 ], [ 67, 69 ], [ 75, 77 ], [ 78, 80 ], [ 88, 90 ], 
      [ 91, 93 ], [ 94, 96 ], [ 99, 100 ], [ 103, 104 ], [ 109, 110 ], 
      [ 114, 116 ], [ 117, 119 ], [ 123, 124 ], [ 125, 126 ] ], 
  [ [ 12, 13 ], [ 17, 18 ], [ 40, 41 ], [ 44, 45 ], [ 47, 48 ], [ 55, 56 ], 
      [ 61, 62 ], [ 65, 66 ], [ 68, 69 ], [ 76, 77 ], [ 79, 80 ], [ 89, 90 ], 
      [ 92, 93 ], [ 95, 96 ], [ 99, 100 ], [ 103, 104 ], [ 109, 110 ], 
      [ 115, 116 ], [ 118, 119 ], [ 123, 124 ], [ 125, 126 ] ] ]
gap> orbsbeta:= poss[3];;

##
gap> orders:= OrdersClassRepresentatives( t );;
gap> mustsplit:= PositionsProperty( orders, IsOddInt );
[ 1, 5, 6, 7, 23, 33, 34, 51, 52, 55, 56, 83, 86, 87, 97, 98, 103, 104, 107, 
  108, 123, 124, 125, 126 ]

##
gap> selfCentralizingClassesSplit:= function( t, mustsplit )
>      local centralizers, orders, i;
> 
>      centralizers:= SizesCentralizers( t );
>      orders:= OrdersClassRepresentatives( t );
>      for i in [ 1 .. Length( centralizers ) ] do
>        if centralizers[i] = orders[i] and not i in mustsplit then
>          Print( "#I  class ", i, " splits (self-centralizing)\n" );
>          AddSet( mustsplit, i );
>        fi;
>      od;
>    end;;
gap> selfCentralizingClassesSplit( t, mustsplit );
#I  class 109 splits (self-centralizing)
#I  class 110 splits (self-centralizing)
#I  class 120 splits (self-centralizing)
#I  class 122 splits (self-centralizing)

##
gap> oddRootsOfSplittingClassesSplit:= function( t, mustsplit )
>      local powmaps, found, p, map, i;
> 
>      powmaps:= ComputedPowerMaps( t );
>      repeat
>        found:= false;
>        for p in [ 1 .. Length( powmaps ) ] do
>          if p mod 2 = 1 and IsBound( powmaps[p] ) then
>            map:= powmaps[p];
>            for i in [ 1 .. Length( map ) ] do
>              if map[i] in mustsplit and not i in mustsplit then
>                Print( "#I  class ", i, " splits (",
>                       Ordinal( p ), " root of ", map[i], ")\n" );
>                found:= true;
>                AddSet( mustsplit, i );
>              fi;
>            od;
>          fi;
>        od;
>      until found = false;
>    end;;

##
gap> notSplittingClassesOfSubgroupDoNotSplit:= function( 2sfuss, sfust,
>                                                  mustnotsplit )
>      local new, i;
> 
>      new:= sfust{ PositionsProperty( InverseMap( 2sfuss ), IsInt ) };
>      for i in Set( new ) do
>        if not i in mustnotsplit then
>          Print( "#I  class ", i, " does not split (as in subgroup)\n" );
>        fi;
>      od;
>      UniteSet( mustnotsplit, new );
>    end;;

##
gap> splittingClassesWithOddCentralizerIndexSplit:= function( s, t,
>        sfust, 2sfuss, mustsplit )
>      local inv, scents, tcents, i;
> 
>      inv:= InverseMap( 2sfuss );
>      scents:= SizesCentralizers( s );
>      tcents:= SizesCentralizers( t );
>      for i in [ 1 .. Length( sfust ) ] do
>        if IsList( inv[i] ) and
>           IsOddInt( tcents[ sfust[i] ] / scents[i] ) then
>          if not sfust[i] in mustsplit then
>            Print( "#I  class ", sfust[i],
>                   " splits (odd centralizer index)\n" );
>            AddSet( mustsplit, sfust[i] );
>          fi;
>        fi;
>      od;
>      oddRootsOfSplittingClassesSplit( t, mustsplit );
>    end;;

##
gap> contributionData:= function( s, t, inv, chiprime, mustsplit )
>      local contrib, zeroonlyifnonsplit, safepart, n, tcents,
>            sclasses, i, j, val, choices, signs, cand;
> 
>      contrib:= [];
>      zeroonlyifnonsplit:= [];
>      safepart:= 0;
>      n:= 1;
>      tcents:= SizesCentralizers( t );
>      sclasses:= SizesConjugacyClasses( s );
>      for i in [ 1 .. Length( inv ) ] do
>        if IsBound( inv[i] ) then
>          # The subgroup contains elements in the 'i'-th class.
>          if IsInt( inv[i] ) then
>            # Only one class of the subgroup fuses into the 'i'-th class.
>            j:= inv[i];
>            val:= sclasses[j] * chiprime[j];
>            val:= tcents[i] / Size(s)^2 * val * GaloisCyc( val, -1 );
>            if not IsInt( val ) then
>              if i in mustsplit then
>                # The summand is known, add it to 'safepart'.
>                safepart:= safepart + val;
>              else
>                # The class may or may not split.
>                # If it splits then 'val' is the contribution to the norm.
>                contrib[i]:= [ 0, val ];
>                zeroonlyifnonsplit[i]:= true;
>                n:= n * 2;
>              fi;
>            fi;
>          else
>            # Several classes of the subgroup fuse into the 'i'-th class.
>            choices:= List( inv[i], j -> sclasses[j] * chiprime[j] );
>            signs:= Tuples( [ 1, -1 ], Length( choices ) );
>            cand:= signs * choices;
>            cand:= tcents[i] / Size(s)^2 *
>                     Set( List( cand, x -> x * GaloisCyc( x, -1 ) ) );
>            if not ForAll( cand, IsInt ) then
>              if Length( cand ) = 1 then
>                if i in mustsplit then
>                  # We get a contribution to 'safepart'.
>                  safepart:= safepart + cand[1];
>                else
>                  UniteSet( cand, [ 0 ] );
>                  contrib[i]:= cand;
>                  zeroonlyifnonsplit[i]:= true;
>                  n:= n * Length( cand );
>                fi;
>              else
>                if not i in mustsplit then
>                  if not 0 in cand then
>                    UniteSet( cand, [ 0 ] );
>                    zeroonlyifnonsplit[i]:= true;
>                  fi;
>                fi;
>                contrib[i]:= cand;
>                n:= n * Length( cand );
>              fi;
>            fi;
>          fi;
>        fi;
>      od;
> 
>      return rec( safepart:= safepart,
>                  contrib:= contrib,
>                  size:= n,
>                  bound:= Filtered( [ 1 .. Length( contrib ) ],
>                                    x -> IsBound( contrib[x] ) ),
>                  zeroonlyifnonsplit:= zeroonlyifnonsplit,
>                );
>    end;;

##
gap> integralContributions:= function( r )
>      local positions, len, images, number, index, direction, initial,
>            norm, solutions, i;
> 
>      # Initialize the counter and the list of solutions.
>      positions:= r.bound;
>      len:= Length( positions );
>      images:= r.contrib{ positions };
>      number:= List( images, Length );
>      index:= ListWithIdenticalEntries( len, 1 );
>      direction:= ShallowCopy( index );  # 1 means up, -1 means down
>      initial:= List( images, l -> l[1] );
>      norm:= r.safepart + Sum( initial );
>      solutions:= [];
>      if IsInt( norm ) then
>        solutions[1]:= initial;
>      fi;
> 
>      while true do
>        # Increase the counter. (Change only one position in each step.)
>        i:= 1;
>        while i <= len and
>              ( ( index[i] = number[i] and direction[i] = 1 ) or
>                ( index[i] = 1 and direction[i] = -1 ) ) do
>          direction[i]:= - direction[i];
>          i:= i+1;
>        od;
> 
>        if len < i then
>          # We are done.
>          return solutions;
>        fi;
> 
>        # Update at position 'i'.
>        norm:= norm - images[i][ index[i] ];
>        index[i]:= index[i] + direction[i];
>        norm:= norm + images[i][ index[i] ];
> 
>        if IsInt( norm ) then
>          # We have found a solution.
>          Add( solutions,
>               List( [ 1 .. len ], i -> images[i][ index[i] ] ) );
>        fi;
>      od;
>    end;;

##
gap> evaluateContributions:= function( r, res, sfust,
>                                      mustsplit, mustnotsplit )
>      local param, i, c;
> 
>      param:= Parametrized( res );
>      for i in [ 1 .. Length( r.bound ) ] do
>        c:= r.bound[i];
>        if param[i] = 0 then
>          # If contribution zero cannot arise as a sum of values
>          # then the class cannot split.
>          if IsBound( r.zeroonlyifnonsplit[c] ) and
>             r.zeroonlyifnonsplit[c] = true and
>             not c in mustnotsplit then
>            Print( "#I  class ", c,
>                   " does not split (contribution criterion)\n" );
>            if c in mustsplit then
>              Error( "contradiction for class ", c );
>            fi;
>            AddSet( mustnotsplit, c );
>          fi;
>        elif IsRat( param[i] ) then
>          if not c in mustsplit then
>            Print( "#I  class ", c, " splits (contribution criterion)\n" );
>            if c in mustnotsplit then
>              Error( "contradiction for class ", c );
>            fi;
>            AddSet( mustsplit, c );
>          fi;
>        elif IsList( param[i] ) and not 0 in param[i] then
>          # If no zero occurs then the class must split.
>          if not c in mustsplit then
>            Print( "#I  class ", c, " splits (contribution criterion)\n" );
>            if c in mustnotsplit then
>              Error( "contradiction for class ", c );
>            fi;
>            AddSet( mustsplit, c );
>          fi;
>        fi;
>      od;
>    end;;

##
gap> computeContributions:= function( s, t, sfust, classfuns, bound,
>                                     mustsplit, mustnotsplit )
>      local inv, i, known, candidates, r, res;
> 
>      inv:= InverseMap( sfust );
> 
>      repeat
>        for i in mustnotsplit do
>          # The induced character is zero at the preimage of 'i',
>          # there is no contribution to the norm.
>          Unbind( inv[i] );
>        od;
>        known:= [ ShallowCopy( mustsplit ), ShallowCopy( mustnotsplit ) ];
>        candidates:= List( classfuns,
>            chi -> contributionData( s, t, inv, chi, mustsplit ) );
>        candidates:= Filtered( candidates, r -> r.size < bound );
>        SortParallel( List( candidates, r -> r.size ), candidates );
>        for r in candidates do
>          res:= integralContributions( r );
>          if Length( res ) = 0 then
>            Error( "no solution" );
>          fi;
>          evaluateContributions( r, res, sfust, mustsplit, mustnotsplit );
>          oddRootsOfSplittingClassesSplit( t, mustsplit );
>        od;
>      until known = [ mustsplit, mustnotsplit ];
>    end;;

##
gap> s:= CharacterTable( "F4(2)" );;
gap> fus:= PossibleClassFusions( s, t );;
gap> rep:= RepresentativesFusions( s, fus, Group( () ) );;
gap> Length( rep );
3
gap> oneorbit:= orbsalpha[1];
[ 11, 12, 13 ]
gap> List( rep, map -> Intersection( map, oneorbit ) );
[ [ 11 ], [ 12 ], [ 13 ] ]

##
gap> m3:= s;;  m3fust:= rep[1];;
gap> m4:= s;;  m4fust:= rep[2];;
gap> m5:= s;;  m5fust:= rep[3];;

##
gap> 2m3:= CharacterTable( "Cyclic", 2 ) * m3;;
gap> 2m4:= CharacterTable( "2.F4(2)" );;
gap> 2m5:= 2m4;;

##
gap> splittingClassesWithOddCentralizerIndexSplit( m3, t, m3fust,
>        GetFusionMap( 2m3, m3 ), mustsplit );
#I  class 73 splits (odd centralizer index)
#I  class 85 splits (odd centralizer index)
#I  class 101 splits (odd centralizer index)
#I  class 106 splits (odd centralizer index)
gap> splittingClassesWithOddCentralizerIndexSplit( m4, t, m4fust,
>        GetFusionMap( 2m4, m4 ), mustsplit );
gap> splittingClassesWithOddCentralizerIndexSplit( m5, t, m5fust,
>        GetFusionMap( 2m5, m5 ), mustsplit );
gap> mustnotsplit:= [];;
gap> notSplittingClassesOfSubgroupDoNotSplit( GetFusionMap( 2m4, m4 ),
>        m4fust, mustnotsplit );
#I  class 9 does not split (as in subgroup)
#I  class 12 does not split (as in subgroup)
#I  class 14 does not split (as in subgroup)
#I  class 17 does not split (as in subgroup)
#I  class 20 does not split (as in subgroup)
#I  class 21 does not split (as in subgroup)
#I  class 22 does not split (as in subgroup)
#I  class 44 does not split (as in subgroup)
#I  class 47 does not split (as in subgroup)
#I  class 49 does not split (as in subgroup)
#I  class 58 does not split (as in subgroup)
#I  class 68 does not split (as in subgroup)
#I  class 72 does not split (as in subgroup)
#I  class 79 does not split (as in subgroup)
#I  class 81 does not split (as in subgroup)
#I  class 82 does not split (as in subgroup)
#I  class 92 does not split (as in subgroup)
gap> notSplittingClassesOfSubgroupDoNotSplit( GetFusionMap( 2m5, m5 ),
>        m5fust, mustnotsplit );
#I  class 13 does not split (as in subgroup)
#I  class 18 does not split (as in subgroup)
#I  class 45 does not split (as in subgroup)
#I  class 48 does not split (as in subgroup)
#I  class 69 does not split (as in subgroup)
#I  class 80 does not split (as in subgroup)
#I  class 93 does not split (as in subgroup)

##
gap> computeContributions( m3, t, m3fust, Irr( m3 ), 10^7,
>        mustsplit, mustnotsplit );
#I  class 2 splits (contribution criterion)
#I  class 24 splits (3rd root of 2)
#I  class 25 splits (3rd root of 2)
#I  class 27 splits (3rd root of 2)
#I  class 99 splits (3rd root of 27)
#I  class 100 splits (3rd root of 27)
#I  class 53 splits (5th root of 2)
#I  class 8 splits (contribution criterion)
#I  class 63 splits (3rd root of 8)
#I  class 105 splits (5th root of 8)
#I  class 15 splits (contribution criterion)
#I  class 70 splits (3rd root of 15)
#I  class 4 does not split (contribution criterion)
#I  class 16 splits (contribution criterion)
#I  class 78 splits (3rd root of 16)
#I  class 59 splits (contribution criterion)
#I  class 30 splits (contribution criterion)
#I  class 102 splits (3rd root of 30)
#I  class 3 splits (contribution criterion)
#I  class 84 splits (contribution criterion)
#I  class 26 splits (3rd root of 3)
#I  class 28 splits (3rd root of 3)
#I  class 54 splits (5th root of 3)
#I  class 121 splits (5th root of 28)
#I  class 32 splits (contribution criterion)
#I  class 11 splits (contribution criterion)
#I  class 67 splits (contribution criterion)
#I  class 75 splits (contribution criterion)
#I  class 117 splits (contribution criterion)
#I  class 64 splits (3rd root of 11)
#I  class 71 does not split (contribution criterion)
gap> proj:= Filtered( Irr( 2m4 ), x -> x[1] <> x[2] );;
gap> projmap:= ProjectionMap( GetFusionMap( 2m4, m4 ) );;
gap> proj:= List( proj, x -> x{ projmap } );;
gap> computeContributions( m4, t, m4fust, proj, 10^7,
>        mustsplit, mustnotsplit );
#I  class 118 does not split (contribution criterion)
#I  class 31 splits (contribution criterion)
#I  class 29 does not split (contribution criterion)
gap> computeContributions( m5, t, m5fust, proj, 10^7,
>        mustsplit, mustnotsplit );
#I  class 119 does not split (contribution criterion)
gap> mustsplit;
[ 1, 2, 3, 5, 6, 7, 8, 11, 15, 16, 23, 24, 25, 26, 27, 28, 30, 31, 32, 33, 
  34, 51, 52, 53, 54, 55, 56, 59, 63, 64, 67, 70, 73, 75, 78, 83, 84, 85, 86, 
  87, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 117, 
  120, 121, 122, 123, 124, 125, 126 ]
gap> mustnotsplit;
[ 4, 9, 12, 13, 14, 17, 18, 20, 21, 22, 29, 44, 45, 47, 48, 49, 58, 68, 69, 
  71, 72, 79, 80, 81, 82, 92, 93, 118, 119 ]

##
gap> invol:= Positions( orders, 2 );
[ 2, 3, 4 ]
gap> Difference( invol, m3fust );
[  ]

##
gap> open:= Difference( m3fust, Union( mustsplit, mustnotsplit ) );
[ 19, 35, 36, 39, 43, 46, 50, 91, 94, 111, 112, 114 ]

##
gap> orders{ open };
[ 4, 8, 8, 8, 8, 8, 8, 16, 16, 24, 24, 24 ]
gap> PowerMap( t, 3 ){ [ 111, 112, 114 ] };
[ 35, 36, 39 ]
gap> poss:= Filtered( Combinations( open ),
>               x -> ( not 35 in x or 111 in x ) and
>                    ( not 36 in x or 112 in x ) and
>                    ( not 39 in x or 114 in x ) );;
gap> Length( poss );
1728

##
gap> tableHead:= function( t, tosplit, invmustlift, invmaylift )
>      local tcents, orders, splcentralizers, spl, splorders, mustlift,
>            maylift, i, pow, ord;
> 
>      tcents:= SizesCentralizers( t );
>      orders:= OrdersClassRepresentatives( t );
>      splcentralizers:= [];
>      spl:= [];
>      splorders:= [];
>      mustlift:= ShallowCopy( invmustlift );
>      maylift:= ShallowCopy( invmaylift );
> 
>      if invmaylift <> [] or invmustlift <> [] then
>        for i in [ 2 .. NrConjugacyClasses( t ) ] do
>          if orders[i] mod 2 = 0 then
>            pow:= PowerMap( t, orders[i] / 2 )[i];
>            if pow in invmustlift then
>              Add( mustlift, i );
>            elif pow in invmaylift then
>              Add( maylift, i );
>            fi;
>          fi;
>        od;
>      fi;
> 
>      for i in [ 1 .. NrConjugacyClasses( t ) ] do
>        ord:= orders[i];
>        if i in tosplit then
>          Append( spl, [ i, i ] );
>          Append( splcentralizers, tcents[i] * [ 2, 2 ] );
>          if orders[i] mod 2 = 1 then
>            Append( splorders, [ ord, 2 * ord ] );
>          elif i in mustlift then
>            Append( splorders, [ 2 * ord, 2 * ord ] );
>          elif i in maylift then
>            Append( splorders, [ [ ord, 2 * ord ], [ ord, 2 * ord ] ] );
>          else
>            Append( splorders, [ ord, ord ] );
>          fi;
>        else
>          Add( spl, i );
>          Add( splcentralizers, tcents[i] );
>          if i in mustlift then
>            Add( splorders, 2 * ord );
>          elif i in maylift then
>            Add( splorders, [ ord, 2 * ord ] );
>          else
>            Add( splorders, ord );
>          fi;
>        fi;
>      od;
> 
>      return ConvertToCharacterTableNC( rec(
>                 UnderlyingCharacteristic:= 0,
>                 OrdersClassRepresentatives:= splorders,
>                 SizesCentralizers:= splcentralizers,
>                 Size:= splcentralizers[1],
>                 ComputedClassFusions:= [ rec( name:= Identifier( t ),
>                     map:= spl ) ],
>               ) );
>  end;;

##
gap> initialFusion:= function( 2s, 2t, 2sfuss, 2tfust, sfust, defined )
>      local fus, comp, pre, imgs;
> 
>      # Use element orders and centralizer orders.
>      fus:= InitFusion( 2s, 2t );
> 
>      # Use the commutative diagram.
>      comp:= CompositionMaps( InverseMap( 2tfust ),
>                              CompositionMaps( sfust, 2sfuss ) );
>      if MeetMaps( fus, comp ) <> true then
>        return fail;
>      fi;
> 
>      # Define classes that are not yet defined.
>      defined:= ShallowCopy( defined );
>      for pre in InverseMap( 2sfuss ) do
>        if IsList( pre ) then
>          imgs:= fus{ pre };
>          if imgs[1] = imgs[2] and IsList( imgs[1] ) then
>            if Intersection( defined, 2tfust{ imgs[1] } ) = [] then
>              # The classes in preimage and image split, and we may choose.
>              fus[ pre[1] ]:= imgs[1][1];
>              fus[ pre[2] ]:= imgs[1][2];
>              UniteSet( defined, 2tfust{ imgs[1] } );
>            fi;
>          fi;
>        elif IsList( fus[ pre ] ) then
>          # The class splits in the image but not in the preimage,
>          # we should have noticed this earlier.
>          return fail;
>        fi;
>      od;
> 
>      return fus;
>    end;;

##
gap> useInducedClassFunction:= function( 2s, 2t, chi, 2sfuss, 2sfus2t )
>      local localfus, unknown, i, swaps, inv, pair, poss, choices, choice,
>            map, ind, para, new;
> 
>      # Remove indet. in places where the character is zero.
>      localfus:= ShallowCopy( 2sfus2t );
>      unknown:= [];
>      for i in [ 1 .. Length( 2sfus2t ) ] do
>        if IsList( 2sfus2t[i] ) then
>          if chi[i] = 0 then
>            localfus[i]:= localfus[i][1];
>          else
>            Add( unknown, i );
>          fi;
>        fi;
>      od;
> 
>      # Collect the possible swaps.
>      swaps:= [];
>      inv:= InverseMap( 2sfuss );
>      for i in [ 1 .. Length( localfus ) ] do
>        if IsList( localfus[i] ) then
>          pair:= inv[ 2sfuss[i] ];
>          Add( swaps, ( pair[1], pair[2] ) );
>          localfus{ pair }:= localfus[i];
>        fi;
>      od;
> 
>      # Try all possibilities (hopefully not too many).
>      poss:= [];
>      if IsEmpty( swaps ) then
>        choices:= [ [] ];
>      else
>        choices:= IteratorOfCombinations( swaps );
>      fi;
>      for choice in choices do
>        map:= Permuted( localfus, Product( choice, () ) );
>        ind:= InducedClassFunctionsByFusionMap( 2s, 2t, [ chi ], map )[1];
>        if IsInt( ScalarProduct( 2t, ind, ind ) ) then
>          Add( poss, map );
>        fi;
>      od;
> 
>      if poss = [] then
>        return false;
>      fi;
> 
>      para:= Parametrized( poss );
>      new:= Filtered( unknown, i -> IsInt( para[i] ) );
>      if new <> [] then
>        2sfus2t{ new }:= para{ new };
>      fi;
> 
>      return true;
>    end;;

##
gap> good:= [];;
gap> ker:= ClassPositionsOfKernel( GetFusionMap( 2m3, m3 ) );;
gap> testcharsm3:= Filtered( Irr( 2m3 ),
>        chi -> not IsSubset( ClassPositionsOfKernel( chi ), ker ) );;
gap> runOneTest:= function( s, 2s, t, 2t, sfust, testchars, defined )
>      local fus, pos, l, chi;
>      fus:= initialFusion( 2s, 2t, GetFusionMap( 2s, s ),
>                           GetFusionMap( 2t, t ), sfust, defined );
>      # Process the irreducible characters,
>      # ordered by increasing indeterminateness.
>      pos:= PositionsProperty( fus, IsList );
>      testchars:= ShallowCopy( testchars );
>      l:= - List( testchars, x -> Number( pos, i -> x[i] = 0 ) );
>      SortParallel( l, testchars );
>      for chi in testchars do
>        if useInducedClassFunction( 2s, 2t, chi, GetFusionMap( 2s, s ),
>                                    fus ) = false then
>          # This splitting is not possible.
>          return fail;
>        fi;
>      od;
>      return fus;
>    end;;
gap> defined:= [];;
gap> for choice in poss do
>      2t:= tableHead( t, Union( mustsplit, choice ), [], [] );
>      fus:= runOneTest( m3, 2m3, t, 2t, m3fust, testcharsm3, defined );
>      if fus <> fail then
>        Add( good, choice );
>      fi;
>    od;
gap> Length( good );
1

##
gap> choice:= good[1];
[ 19, 36, 39, 43, 46, 50, 91, 94, 111, 112, 114 ]
gap> UniteSet( mustsplit, choice );
gap> oddRootsOfSplittingClassesSplit( t, mustsplit );
#I  class 74 splits (3rd root of 19)
#I  class 76 splits (3rd root of 19)
#I  class 77 splits (3rd root of 19)
gap> UniteSet( mustnotsplit, Difference( open, choice ) );
gap> Difference( [ 1 .. Length( orders ) ],
>                Union( mustsplit, mustnotsplit ) );
[ 10, 37, 38, 40, 41, 42, 57, 60, 61, 62, 65, 66, 88, 89, 90, 95, 96, 113, 
  115, 116 ]
gap> 2t:= tableHead( t, mustsplit, [], [] );;
gap> NrConjugacyClasses( 2t );
202
gap> 2m3fus2t:= runOneTest( m3, 2m3, t, 2t, m3fust, testcharsm3, defined );
[ 1, 3, 5, 5, 7, 8, 10, 12, 16, 18, 14, 18, 23, 23, 22, 25, 26, 31, 23, 29, 
  31, 32, 33, 34, 36, 44, 40, 38, 42, 47, 40, 44, 46, 49, 51, 55, 53, 71, 71, 
  57, 62, 58, 63, 67, 71, 68, 75, 76, 80, 78, 82, 84, 84, 99, 92, 91, 103, 
  107, 111, 107, 111, 99, 97, 109, 111, 110, 121, 115, 125, 126, 127, 131, 
  129, 135, 133, 144, 145, 140, 140, 148, 150, 156, 158, 166, 166, 170, 168, 
  181, 176, 182, 178, 189, 185, 193, 191, 2, 4, 6, 6, 7, 9, 11, 13, 16, 19, 
  15, 19, 24, 24, 22, 26, 25, 31, 24, 30, 31, 32, 33, 35, 37, 45, 41, 39, 43, 
  48, 41, 45, 46, 50, 52, 56, 54, 72, 72, 57, 63, 59, 62, 68, 72, 67, 75, 77, 
  81, 79, 83, 85, 85, 100, 93, 91, 104, 108, 112, 108, 112, 100, 98, 109, 
  112, 110, 122, 116, 125, 126, 128, 132, 130, 136, 134, 145, 144, 141, 141, 
  149, 151, 157, 159, 167, 167, 171, 169, 182, 177, 181, 179, 190, 186, 194, 
  192 ]
gap> defined:= Set( m3fust );;

##
gap> ind2m3:= InducedClassFunctionsByFusionMap( 2m3, 2t, testcharsm3,
>                 2m3fus2t );;

##
gap> s:= CharacterTable( "Fi22" );;
gap> fus:= PossibleClassFusions( s, t );;
gap> rep:= RepresentativesFusions( s, fus, Group( () ) );;
gap> Length( rep );
3
gap> List( rep, map -> Intersection( map, oneorbit ) );
[ [ 11 ], [ 12 ], [ 13 ] ]

##
gap> m7:= s;;  m7fust:= rep[1];;
gap> m8:= s;;  m8fust:= rep[2];;
gap> m9:= s;;  m9fust:= rep[3];;

##
gap> open:= Difference( m7fust, Union( mustsplit, mustnotsplit ) );
[  ]
gap> 2s:= CharacterTable( "2.Fi22" );;
gap> initialFusion( 2s, 2t, GetFusionMap( 2s, m7 ),
>        GetFusionMap( 2t, t ), m7fust, defined );
fail

##
gap> 2m7:= CharacterTable( "Cyclic", 2 ) * m7;;

##
gap> parametersFABR:= rec( maxlen:= 10, minamb:= 1, maxamb:= 10^6,
>        quick:= false, contained:= ContainedPossibleCharacters );;

##
gap> ker:= ClassPositionsOfKernel( GetFusionMap( 2m7, m7 ) );;
gap> testcharsm7:= Filtered( Irr( 2m7 ),
>        chi -> not IsSubset( ClassPositionsOfKernel( chi ), ker ) );;
gap> fus:= initialFusion( 2m7, 2t, GetFusionMap( 2m7, m7 ),
>              GetFusionMap( 2t, t ), m7fust, defined );;
gap> possfus:= FusionsAllowedByRestrictions( 2m7, 2t, testcharsm7,
>                  ind2m3, fus, parametersFABR );
[ [ 1, 4, 5, 7, 8, 12, 10, 12, 18, 24, 26, 29, 31, 34, 37, 43, 47, 40, 39, 
      46, 52, 49, 44, 50, 51, 55, 63, 62, 68, 75, 78, 80, 80, 83, 84, 86, 88, 
      103, 99, 99, 108, 117, 119, 113, 122, 109, 112, 115, 127, 127, 132, 
      135, 140, 140, 152, 154, 157, 158, 167, 170, 172, 174, 181, 182, 194, 
      2, 3, 6, 7, 9, 13, 11, 13, 19, 23, 25, 30, 31, 35, 36, 42, 48, 41, 38, 
      46, 51, 50, 45, 49, 52, 56, 62, 63, 67, 75, 79, 81, 81, 82, 85, 87, 89, 
      104, 100, 100, 107, 118, 120, 114, 121, 109, 111, 116, 128, 128, 131, 
      136, 141, 141, 153, 155, 156, 159, 166, 171, 173, 175, 182, 181, 193 ], 
  [ 1, 4, 5, 7, 8, 12, 10, 12, 18, 24, 26, 29, 31, 34, 37, 43, 47, 40, 39, 
      46, 52, 49, 44, 50, 51, 55, 62, 63, 68, 75, 78, 80, 80, 83, 84, 86, 88, 
      103, 99, 99, 108, 117, 119, 113, 122, 109, 112, 115, 127, 127, 132, 
      135, 140, 140, 152, 154, 157, 158, 167, 170, 172, 174, 182, 181, 194, 
      2, 3, 6, 7, 9, 13, 11, 13, 19, 23, 25, 30, 31, 35, 36, 42, 48, 41, 38, 
      46, 51, 50, 45, 49, 52, 56, 63, 62, 67, 75, 79, 81, 81, 82, 85, 87, 89, 
      104, 100, 100, 107, 118, 120, 114, 121, 109, 111, 116, 128, 128, 131, 
      136, 141, 141, 153, 155, 156, 159, 166, 171, 173, 175, 181, 182, 193 ] ]
gap> poss2m7fus2t:= possfus;;
gap> UniteSet( defined, Set( m7fust ) );
gap> possind2m7:= List( poss2m7fus2t,
>        map -> Set( InducedClassFunctionsByFusionMap( 2m7, 2t,
>                        testcharsm7, map ) ) );;
gap> List( possind2m7, Length );
[ 63, 63 ]
gap> Length( Intersection( possind2m7 ) );
39

##
gap> 2s:= 2m7;
CharacterTable( "C2xFi22" )
gap> open:= Difference( m8fust, Union( mustsplit, mustnotsplit ) );
[ 40, 65, 115 ]
gap> good:= [];;
gap> for choice in Combinations( open ) do
>      2t:= tableHead( t, Union( mustsplit, choice ), [], [] );
>      fus:= initialFusion( 2s, 2t, GetFusionMap( 2s, m8 ),
>                GetFusionMap( 2t, t ), m8fust, defined );;
>      if FusionsAllowedByRestrictions( 2s, 2t, testcharsm7, ind2m3, fus,
>             parametersFABR ) <> [] then
>        Add( good, choice );
>      fi;
>    od;
gap> good;
[  ]

##
gap> 2m8:= CharacterTable( "2.Fi22" );;

##
gap> notSplittingClassesOfSubgroupDoNotSplit( GetFusionMap( 2m8, m8 ),
> m8fust, mustnotsplit );
#I  class 40 does not split (as in subgroup)
#I  class 65 does not split (as in subgroup)
#I  class 115 does not split (as in subgroup)
gap> 2t:= tableHead( t, mustsplit, [], [] );;

##
gap> ker:= ClassPositionsOfKernel( GetFusionMap( 2m8, m8 ) );;
gap> testcharsm8:= Filtered( Irr( 2m8 ),
>        chi -> not IsSubset( ClassPositionsOfKernel( chi ), ker ) );;
gap> fus:= initialFusion( 2m8, 2t, GetFusionMap( 2m8, m8 ),
>        GetFusionMap( 2t, t ), m8fust, defined );;
gap> ind:= Concatenation( ind2m3, Intersection( possind2m7 ) );;
gap> possfus:= FusionsAllowedByRestrictions( 2m8, 2t, testcharsm8, ind,
>        fus, parametersFABR );
[ [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 10, 11, 12, 13, 20, 23, 24, 27, 29, 
      30, 31, 34, 35, 36, 37, 42, 43, 47, 48, 40, 41, 38, 39, 46, 51, 52, 49, 
      50, 44, 45, 49, 50, 51, 52, 55, 56, 64, 64, 69, 75, 75, 78, 79, 80, 81, 
      80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 105, 101, 101, 101, 107, 108, 
      116, 115, 120, 119, 113, 114, 123, 109, 111, 112, 117, 118, 127, 128, 
      127, 128, 131, 132, 135, 136, 142, 142, 153, 152, 155, 154, 156, 157, 
      158, 159, 166, 167, 170, 171, 173, 172, 175, 174, 183, 183, 193, 194 ] ]
gap> 2m8fus2t:= possfus[1];;
gap> UniteSet( defined, m8fust );
gap> ind2m8:= InducedClassFunctionsByFusionMap( 2m8, 2t, testcharsm8,
>                 2m8fus2t );;

##
gap> Filtered( orbsbeta, l -> Intersection( l, [ 40, 65, 115 ] ) <> [] );
[ [ 40, 41 ], [ 65, 66 ], [ 115, 116 ] ]
gap> UniteSet( mustnotsplit, [ 41, 66, 116 ] );
gap> open:= Difference( m9fust, Union( mustsplit, mustnotsplit ) );
[  ]
gap> 2m9:= 2m8;;
gap> testcharsm9:= testcharsm8;;
gap> fus:= initialFusion( 2m9, 2t, GetFusionMap( 2m9, m9 ),
>        GetFusionMap( 2t, t ), m9fust, defined );;
gap> ind:= Concatenation( ind2m3, Intersection( possind2m7 ), ind2m8 );;
gap> possfus:= FusionsAllowedByRestrictions( 2m9, 2t, testcharsm9, ind,
>        fus, parametersFABR );
[ [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 10, 11, 12, 13, 21, 23, 24, 28, 29, 
      30, 31, 34, 35, 36, 37, 42, 43, 47, 48, 40, 41, 38, 39, 46, 51, 52, 49, 
      50, 44, 45, 49, 50, 51, 52, 55, 56, 65, 65, 70, 75, 75, 78, 79, 80, 81, 
      80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 106, 102, 102, 102, 107, 108, 
      116, 115, 118, 117, 113, 114, 124, 109, 111, 112, 119, 120, 127, 128, 
      127, 128, 131, 132, 135, 136, 143, 143, 153, 152, 155, 154, 156, 157, 
      158, 159, 166, 167, 170, 171, 173, 172, 175, 174, 184, 184, 193, 194 ] ]
gap> 2m9fus2t:= possfus[1];;
gap> UniteSet( defined, m9fust );
gap> ind2m9:= InducedClassFunctionsByFusionMap( 2m9, 2t, testcharsm9,
>                 2m9fus2t );;

##
gap> open:= Difference( m4fust, Union( mustsplit, mustnotsplit ) );
[ 95 ]
gap> ker:= ClassPositionsOfKernel( GetFusionMap( 2m4, m4 ) );;
gap> testcharsm4:= Filtered( Irr( 2m4 ),
>        chi -> not IsSubset( ClassPositionsOfKernel( chi ), ker ) );;
gap> good:= [];;
gap> for choice in Combinations( open ) do
>      2t:= tableHead( t, Union( mustsplit, choice ), [], [] );
>      fus:= runOneTest( m4, 2m4, t, 2t, m4fust, testcharsm4, [] );
>      if fus <> fail then
>        Add( good, [ choice, 2t ] );
>      fi;
>    od;
gap> List( good, l -> l[1] );
[ [  ] ]
gap> UniteSet( mustnotsplit, open );
gap> 2t:= good[1][2];;
gap> 2tfust:= GetFusionMap( 2t, t );;
gap> fus:= initialFusion( 2m4, 2t, GetFusionMap( 2m4, m4 ),
>                         2tfust, m4fust, defined );;
gap> ind:= Concatenation( ind2m3, Intersection( possind2m7 ), ind2m8,
>                         ind2m9 );;
gap> possfus:= FusionsAllowedByRestrictions( 2m4, 2t, testcharsm4, ind,
>        fus, parametersFABR );
[ [ 1, 2, 3, 4, 6, 5, 5, 6, 7, 7, 8, 9, 10, 11, 12, 13, 16, 20, 14, 15, 20, 
      20, 24, 23, 24, 23, 22, 27, 27, 27, 31, 31, 23, 24, 29, 30, 31, 32, 33, 
      34, 35, 36, 37, 45, 44, 41, 40, 38, 39, 42, 43, 48, 47, 40, 41, 44, 45, 
      46, 46, 50, 49, 52, 51, 55, 56, 53, 54, 73, 73, 73, 57, 57, 64, 64, 58, 
      59, 64, 64, 69, 73, 69, 75, 76, 77, 80, 81, 78, 79, 82, 83, 85, 84, 84, 
      85, 101, 101, 92, 93, 91, 105, 108, 107, 112, 111, 108, 107, 112, 111, 
      101, 101, 97, 98, 109, 109, 111, 112, 110, 123, 117, 118, 125, 126, 
      127, 128, 131, 132, 130, 129, 135, 136, 133, 134, 146, 146, 146, 146, 
      142, 142, 148, 149, 150, 151, 156, 157, 159, 158, 167, 166, 167, 166, 
      170, 171, 168, 169, 183, 183, 177, 176, 183, 183, 178, 179, 189, 190, 
      187, 187, 194, 193, 192, 191 ] ]
gap> 2m4fus2t:= possfus[1];;
gap> UniteSet( defined, Set( m4fust ) );
gap> ind2m4:= InducedClassFunctionsByFusionMap( 2m4, 2t, testcharsm4,
>                 2m4fus2t );;

##
gap> open:= Difference( m5fust, Union( mustsplit, mustnotsplit ) );
[ 96 ]
gap> UniteSet( mustnotsplit, open );

##
gap> ker:= ClassPositionsOfKernel( GetFusionMap( 2m5, m5 ) );;
gap> testcharsm5:= Filtered( Irr( 2m5 ),
>        chi -> not IsSubset( ClassPositionsOfKernel( chi ), ker ) );;
gap> fus:= initialFusion( 2m5, 2t, GetFusionMap( 2m5, m5 ),
>              GetFusionMap( 2t, t ), m5fust, defined );;
gap> ind:= Concatenation( ind2m3, Intersection( possind2m7 ), ind2m8,
>              ind2m9, ind2m4 );;
gap> possfus:= FusionsAllowedByRestrictions( 2m5, 2t, testcharsm5,
>                  ind, fus, parametersFABR );
[ [ 1, 2, 3, 4, 6, 5, 5, 6, 7, 7, 8, 9, 10, 11, 12, 13, 16, 21, 14, 15, 21, 
      21, 24, 23, 24, 23, 22, 28, 28, 28, 31, 31, 23, 24, 29, 30, 31, 32, 33, 
      34, 35, 36, 37, 45, 44, 41, 40, 38, 39, 42, 43, 48, 47, 40, 41, 44, 45, 
      46, 46, 50, 49, 52, 51, 55, 56, 53, 54, 74, 74, 74, 57, 57, 65, 65, 58, 
      59, 65, 65, 70, 74, 70, 75, 76, 77, 80, 81, 78, 79, 82, 83, 85, 84, 84, 
      85, 102, 102, 92, 93, 91, 106, 108, 107, 112, 111, 108, 107, 112, 111, 
      102, 102, 97, 98, 109, 109, 111, 112, 110, 124, 119, 120, 125, 126, 
      127, 128, 131, 132, 130, 129, 135, 136, 133, 134, 147, 147, 147, 147, 
      143, 143, 148, 149, 150, 151, 156, 157, 159, 158, 167, 166, 167, 166, 
      170, 171, 168, 169, 184, 184, 177, 176, 184, 184, 178, 179, 189, 190, 
      188, 188, 194, 193, 192, 191 ] ]
gap> 2m5fus2t:= possfus[1];;
gap> UniteSet( defined, Set( m5fust ) );
gap> ind2m5:= InducedClassFunctionsByFusionMap( 2m5, 2t, testcharsm5,
>                 2m5fus2t );;

##
gap> s:= CharacterTable( "U6(2)" );;
gap> InitFusion( CharacterTable( "C6" ) * s, 2t );
fail

##
gap> 2s:= CharacterTable( "2.U6(2)" );;
gap> 2u12:= CharacterTable( "C3" ) * 2s;;
gap> orders2u12:= OrdersClassRepresentatives( 2u12 );;
gap> inv:= First( ClassPositionsOfCentre( 2u12 ), 
>                 i -> orders2u12[i] = 2 );;
gap> ker:= [ 1, inv ];;
gap> u12:= 2u12 / ker;;
gap> testcharsu12:= Filtered( Irr( 2u12 ),
>        chi -> not IsSubset( ClassPositionsOfKernel( chi ), ker ) );;

##
gap> fus:= PossibleClassFusions( u12, t );;
gap> rep:= RepresentativesFusions( u12, fus, Group( () ) );;
gap> Length( rep );
2
gap> possu12fust:= rep;;

##
gap> List( possu12fust, map -> Difference( map,
>                         Union( mustsplit, mustnotsplit ) ) );
[ [ 10, 37, 57, 60, 61, 62, 113 ], [ 10, 37, 57, 60, 61, 62, 113 ] ]
gap> possnotsplit:= List( [ 1, 2 ], i -> ShallowCopy( mustnotsplit ) );;
gap> for i in [ 1, 2 ] do
>      notSplittingClassesOfSubgroupDoNotSplit(
>          GetFusionMap( 2u12, u12 ), rep[i], possnotsplit[i] );
>    od;
#I  class 10 does not split (as in subgroup)
#I  class 37 does not split (as in subgroup)
#I  class 57 does not split (as in subgroup)
#I  class 60 does not split (as in subgroup)
#I  class 61 does not split (as in subgroup)
#I  class 62 does not split (as in subgroup)
#I  class 113 does not split (as in subgroup)
#I  class 10 does not split (as in subgroup)
#I  class 37 does not split (as in subgroup)
#I  class 57 does not split (as in subgroup)
#I  class 60 does not split (as in subgroup)
#I  class 61 does not split (as in subgroup)
#I  class 62 does not split (as in subgroup)
#I  class 113 does not split (as in subgroup)
gap> Set( possnotsplit );
[ [ 4, 9, 10, 12, 13, 14, 17, 18, 20, 21, 22, 29, 35, 37, 40, 41, 44, 45, 47, 
      48, 49, 57, 58, 60, 61, 62, 65, 66, 68, 69, 71, 72, 79, 80, 81, 82, 92, 
      93, 95, 96, 113, 115, 116, 118, 119 ] ]
gap> mustnotsplit:= possnotsplit[1];;

##
gap> s:= CharacterTable( "O10-(2)" );;
gap> fus:= PossibleClassFusions( s, t );;
gap> rep:= RepresentativesFusions( s, fus, Group( () ) );;
gap> Length( rep );
2
gap> m10:= s;;  possm10fust:= rep;;

##
gap> 2m10:= CharacterTable( "Cyclic", 2 ) * m10;;

##
gap> List( possm10fust, map -> Difference( map,
>                         Union( mustsplit, mustnotsplit ) ) );
[ [ 42 ], [ 42 ] ]
gap> possnotsplit:= List( [ 1, 2 ], i -> ShallowCopy( mustnotsplit ) );;
gap> for i in [ 1, 2 ] do
>      computeContributions( m10, t, possm10fust[i], Irr( m10 ), 10^7,
>          ShallowCopy( mustsplit ), possnotsplit[i] );
>    od;
#I  class 42 does not split (contribution criterion)
#I  class 42 does not split (contribution criterion)
gap> Set( possnotsplit );
[ [ 4, 9, 10, 12, 13, 14, 17, 18, 20, 21, 22, 29, 35, 37, 40, 41, 42, 44, 45, 
      47, 48, 49, 57, 58, 60, 61, 62, 65, 66, 68, 69, 71, 72, 79, 80, 81, 82, 
      92, 93, 95, 96, 113, 115, 116, 118, 119 ] ]
gap> mustnotsplit:= possnotsplit[1];;

##
gap> fus:= List( rep, map -> initialFusion( 2m10, 2t,
>                 GetFusionMap( 2m10, m10 ), GetFusionMap( 2t, t ),
>                 map, defined ) );;
gap> ker:= ClassPositionsOfKernel( GetFusionMap( 2m10, m10 ) );;
gap> testcharsm10:= Filtered( Irr( 2m10 ),
>        chi -> not IsSubset( ClassPositionsOfKernel( chi ), ker ) );;
gap> ind:= Concatenation( ind2m3, ind2m4, ind2m5,
>              Intersection( possind2m7 ), ind2m8, ind2m9 );;
gap> possfus:= List( fus, map -> FusionsAllowedByRestrictions( 2m10, 2t,
>                  testcharsm10, ind, map, parametersFABR ) );
[ [ [ 1, 3, 5, 5, 7, 10, 8, 8, 8, 10, 12, 16, 14, 17, 23, 22, 23, 31, 29, 33, 
          34, 34, 38, 36, 36, 36, 44, 44, 44, 40, 40, 36, 49, 42, 42, 38, 40, 
          42, 47, 40, 44, 47, 47, 46, 51, 53, 58, 57, 60, 66, 75, 76, 78, 78, 
          78, 78, 82, 84, 84, 86, 88, 92, 90, 90, 97, 94, 94, 90, 111, 111, 
          111, 92, 91, 94, 107, 107, 113, 107, 95, 96, 111, 110, 109, 129, 
          133, 133, 133, 135, 133, 135, 135, 148, 150, 153, 155, 153, 155, 
          158, 164, 166, 168, 178, 176, 180, 180, 191, 191, 191, 193, 195, 
          197, 197, 195, 199, 201, 2, 4, 6, 6, 7, 11, 9, 9, 9, 11, 13, 16, 
          15, 17, 24, 22, 24, 31, 30, 33, 35, 35, 39, 37, 37, 37, 45, 45, 45, 
          41, 41, 37, 50, 43, 43, 39, 41, 43, 48, 41, 45, 48, 48, 46, 52, 54, 
          59, 57, 60, 66, 75, 77, 79, 79, 79, 79, 83, 85, 85, 87, 89, 93, 90, 
          90, 98, 94, 94, 90, 112, 112, 112, 93, 91, 94, 108, 108, 114, 108, 
          95, 96, 112, 110, 109, 130, 134, 134, 134, 136, 134, 136, 136, 149, 
          151, 152, 154, 152, 154, 159, 165, 167, 169, 179, 177, 180, 180, 
          192, 192, 192, 194, 196, 198, 198, 196, 200, 202 ] ], 
  [ [ 1, 3, 5, 5, 7, 10, 8, 8, 8, 10, 12, 16, 14, 17, 23, 22, 23, 31, 29, 33, 
          34, 34, 38, 36, 36, 36, 44, 44, 44, 40, 40, 36, 49, 42, 42, 38, 40, 
          42, 47, 40, 44, 47, 47, 46, 51, 53, 58, 57, 60, 66, 75, 76, 78, 78, 
          78, 78, 82, 84, 84, 86, 88, 92, 90, 90, 97, 94, 94, 90, 111, 111, 
          111, 92, 91, 94, 107, 107, 113, 107, 95, 96, 111, 110, 109, 129, 
          133, 133, 133, 135, 133, 135, 135, 148, 150, 155, 153, 155, 153, 
          158, 164, 166, 168, 178, 176, 180, 180, 191, 191, 191, 193, 195, 
          197, 197, 195, 199, 201, 2, 4, 6, 6, 7, 11, 9, 9, 9, 11, 13, 16, 
          15, 17, 24, 22, 24, 31, 30, 33, 35, 35, 39, 37, 37, 37, 45, 45, 45, 
          41, 41, 37, 50, 43, 43, 39, 41, 43, 48, 41, 45, 48, 48, 46, 52, 54, 
--> --------------------

--> maximum size reached

--> --------------------