Spracherkennung für: .tst vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]
# 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,
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, 154, 152, 154, 152, 159, 165, 167, 169, 179, 177, 180, 180,
192, 192, 192, 194, 196, 198, 198, 196, 200, 202 ] ] ]
gap> List( possfus, Length );
[ 1, 1 ]
gap> poss2m10fus2t:= Concatenation( possfus );;
gap> Set( possm10fust[1] ) = Set( possm10fust[2] );
true
gap> UniteSet( defined, possm10fust[1] );
##
gap> possind2m10:= List( poss2m10fus2t,
> map -> Set( InducedClassFunctionsByFusionMap( 2m10, 2t,
> testcharsm10, map ) ) );;
gap> possind2m10[1] = possind2m10[2];
true
gap> ind2m10:= possind2m10[1];;
##
gap> fus:= List( possu12fust, map -> initialFusion( 2u12, 2t,
> GetFusionMap( 2u12, u12 ), GetFusionMap( 2t, t ),
> map, defined ) );;
gap> ind:= Concatenation( ind2m3, ind2m4, ind2m5,
> Intersection( possind2m7 ), ind2m8, ind2m9, ind2m10 );;
gap> possfus:= List( fus, map -> FusionsAllowedByRestrictions( 2u12, 2t,
> testcharsu12, ind, map, parametersFABR ) );
[ [ [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 10, 11, 16, 17, 18, 19, 20, 21, 23,
24, 31, 34, 35, 42, 43, 42, 43, 36, 37, 47, 48, 40, 41, 38, 39, 44,
45, 49, 50, 55, 56, 60, 62, 63, 64, 65, 78, 79, 78, 79, 80, 81, 82,
83, 86, 87, 88, 89, 91, 91, 90, 90, 95, 96, 103, 104, 105, 106,
107, 108, 135, 136, 153, 152, 155, 154, 8, 9, 36, 37, 40, 41, 46,
10, 11, 8, 9, 12, 13, 90, 94, 99, 100, 101, 102, 107, 108, 109,
135, 136, 36, 37, 36, 37, 38, 39, 40, 41, 44, 45, 42, 43, 47, 48,
51, 52, 170, 171, 180, 181, 182, 183, 184, 78, 79, 78, 79, 80, 81,
193, 194, 195, 196, 197, 198, 90, 90, 92, 93, 94, 94, 99, 100, 101,
102, 111, 112, 133, 134, 153, 152, 155, 154, 8, 9, 36, 37, 40, 41,
46, 10, 11, 8, 9, 12, 13, 90, 94, 99, 100, 101, 102, 107, 108, 109,
135, 136, 36, 37, 36, 37, 38, 39, 40, 41, 44, 45, 42, 43, 47, 48,
51, 52, 170, 171, 180, 181, 182, 183, 184, 78, 79, 78, 79, 80, 81,
193, 194, 195, 196, 197, 198, 90, 90, 92, 93, 94, 94, 99, 100, 101,
102, 111, 112, 133, 134, 153, 152, 155, 154 ] ],
[ [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 10, 11, 16, 17, 18, 19, 20, 21, 23,
24, 31, 34, 35, 42, 43, 42, 43, 36, 37, 47, 48, 40, 41, 38, 39, 44,
45, 49, 50, 55, 56, 60, 62, 63, 64, 65, 78, 79, 78, 79, 80, 81, 82,
83, 86, 87, 88, 89, 91, 91, 90, 90, 95, 96, 103, 104, 105, 106,
107, 108, 135, 136, 155, 154, 153, 152, 8, 9, 36, 37, 40, 41, 46,
10, 11, 8, 9, 12, 13, 90, 94, 99, 100, 101, 102, 107, 108, 109,
135, 136, 36, 37, 36, 37, 38, 39, 40, 41, 44, 45, 42, 43, 47, 48,
51, 52, 170, 171, 180, 181, 182, 183, 184, 78, 79, 78, 79, 80, 81,
193, 194, 195, 196, 197, 198, 90, 90, 92, 93, 94, 94, 99, 100, 101,
102, 111, 112, 133, 134, 155, 154, 153, 152, 8, 9, 36, 37, 40, 41,
46, 10, 11, 8, 9, 12, 13, 90, 94, 99, 100, 101, 102, 107, 108, 109,
135, 136, 36, 37, 36, 37, 38, 39, 40, 41, 44, 45, 42, 43, 47, 48,
51, 52, 170, 171, 180, 181, 182, 183, 184, 78, 79, 78, 79, 80, 81,
193, 194, 195, 196, 197, 198, 90, 90, 92, 93, 94, 94, 99, 100, 101,
102, 111, 112, 133, 134, 155, 154, 153, 152 ] ] ]
gap> List( possfus, Length );
[ 1, 1 ]
gap> poss2u12fus2t:= Concatenation( possfus );;
gap> Set( possu12fust[1] ) = Set( possu12fust[2] );
true
gap> UniteSet( defined, possu12fust[1] );
##
gap> possind2u12:= List( poss2u12fus2t,
> map -> Set( InducedClassFunctionsByFusionMap( 2u12, 2t,
> testcharsu12, map ) ) );;
gap> possind2u12[1] = possind2u12[2];
true
gap> ind2u12:= possind2u12[1];;
##
gap> posssplit:= Difference( [ 1 .. Length( orders ) ],
> Union( mustsplit, mustnotsplit ) );
[ 38, 88, 89, 90 ]
gap> NrConjugacyClasses( t );
126
gap> NrConjugacyClasses( 2t );
202
##
gap> ForAll( ind2u12,
> chi -> ForAll( possind2m7[1],
> psi -> IsInt( ScalarProduct( 2t, chi, psi ) ) ) );
false
##
gap> 2m7fus2t:= poss2m7fus2t[2];;
gap> ind2m7:= possind2m7[2];;
##
gap> nothit:= Difference( [ 1 .. Length( orders ) ],
> Flat( [ m3fust, m4fust, m5fust, m7fust, m8fust, m9fust,
> possm10fust, possu12fust ] ) );
[ 38, 88, 89, 90, 103, 104 ]
gap> orders{ nothit };
[ 8, 16, 16, 16, 19, 19 ]
##
gap> for p in [ 2 .. Maximum( OrdersClassRepresentatives( 2t ) ) ] do
> if IsPrimeInt( p ) then
> PowerMap( t, p );
> pow:= InitPowerMap( 2t, p );
> comp:= CompositionMaps( InverseMap( GetFusionMap( 2t, t ) ),
> CompositionMaps( PowerMap( t, p ),
> GetFusionMap( 2t, t ) ) );
> MeetMaps( pow, comp );
> ComputedPowerMaps( 2t )[p]:= pow;
> fi;
> od;
##
gap> pos:= Positions( OrdersClassRepresentatives( 2t ), 38 );
[ 161, 163 ]
gap> indcyc:= Filtered( InducedCyclic( 2t, pos, "all" ),
> chi -> chi[1] = - chi[2] );;
##
gap> pow:= ComputedPowerMaps( 2t )[5];;
gap> comp:= CompositionMaps( CompositionMaps( 2m3fus2t, PowerMap( 2m3, 5 ) ),
> InverseMap( 2m3fus2t ) );;
gap> MeetMaps( pow, comp );
true
gap> comp:= CompositionMaps( CompositionMaps( 2m7fus2t, PowerMap( 2m7, 5 ) ),
> InverseMap( 2m7fus2t ) );;
gap> MeetMaps( pow, comp );
true
gap> fus:= Parametrized( poss2m10fus2t );;
gap> comp:= CompositionMaps( CompositionMaps( fus, PowerMap( 2m10, 5 ) ),
> InverseMap( fus ) );;
gap> MeetMaps( pow, comp );
true
gap> ForAll( pow, IsInt );
true
gap> Intersection( PowerMap( t, 5 ), posssplit ) = posssplit;
true
gap> ForAll( posssplit, i -> Positions( PowerMap( t, 5 ), i ) = [ i ] );
true
gap> ind:= Concatenation(
> [ ind2m3, ind2m4, ind2m5, ind2m7, ind2m8, ind2m9 ] );;
gap> minus:= List( ind, chi -> MinusCharacter( chi, pow, 5 ) );;
gap> ind:= Concatenation(
> [ ind2m3, ind2m4, ind2m5, minus, ind2m7, ind2m8, ind2m9,
> ind2u12, ind2m10, indcyc ] );;
##
gap> lll:= LLL( 2t, ind );;
gap> Length( lll.irreducibles );
2
gap> irr:= Set( lll.irreducibles );;
gap> red:= Reduced( 2t, irr, lll.remainders );;
gap> lll:= LLL( 2t, red.remainders );;
gap> Length( lll.irreducibles );
2
gap> UniteSet( irr, lll.irreducibles );
gap> red:= Reduced( 2t, irr, lll.remainders );;
gap> lll:= LLL( 2t, red.remainders );;
gap> Sum( lll.norms );
772
gap> lll:= LLL( 2t, lll.remainders, "sort" );;
gap> Sum( lll.norms );
729
gap> Length( lll.irreducibles );
0
gap> red:= Reduced( 2t, irr, lll.remainders );;
gap> lll:= LLL( 2t, red.remainders );;
gap> Sum( lll.norms );
710
##
gap> Length( lll.norms );
72
gap> gram:= MatScalarProducts( 2t, lll.remainders, lll.remainders );;
gap> emb:= OrthogonalEmbeddings( gram, 72 + 4 );;
gap> Length( emb.solutions );
1
gap> Length( emb.solutions[1] );
72
##
gap> dec:= Decreased( 2t, lll.remainders,
> emb.vectors{ emb.solutions[1] } );;
gap> Length( dec.irreducibles );
72
gap> UniteSet( irr, dec.irreducibles );
gap> factchars:= RestrictedClassFunctions( Irr( t ), 2t );;
gap> irr:= Concatenation( factchars, irr );;
gap> DimensionsMat( irr );
[ 202, 202 ]
##
gap> Size( 2t ) = Sum( List( irr, chi -> chi[1]^2 ) );
true
gap> SetIrr( 2t, List( irr, x -> Character( 2t, x ) ) );
##
gap> for p in [ 2 .. Maximum( OrdersClassRepresentatives( 2t ) ) ] do
> if IsPrimeInt( p ) then
> poss:= PossiblePowerMaps( 2t, p,
> rec( powermap:= ComputedPowerMaps( 2t )[p] ) );
> if Length( poss ) <> 1 then
> Error( "problem with ", Ordinal( p ), " power map" );
> fi;
> ComputedPowerMaps( 2t )[p]:= poss[1];
> fi;
> od;
gap> lib:= CharacterTable( "2.2E6(2)" );;
gap> tr:= TransformingPermutationsCharacterTables( lib, 2t );;
gap> IsRecord( tr );
true
##
gap> tr.columns;
(25,26)(62,63)(67,68)(121,122)(144,145)(152,153)(154,155)(172,173)(174,
175)(181,182)
##
gap> t:= CharacterTable( "2E6(2)" );;
gap> t2:= CharacterTable( "2E6(2).2" );;
gap> 2t:= CharacterTable( "2.2E6(2)" );;
gap> tfust2:= GetFusionMap( t, t2 );;
gap> 2tfust:= GetFusionMap( 2t, t );;
gap> orbsbeta:= Filtered( InverseMap( tfust2 ), IsList );
[ [ 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> beta:= Product( List( orbsbeta, x -> ( x[1], x[2] ) ) );
(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> aut:= AutomorphismsOfTable( 2t );;
gap> Size( aut );
256
gap> filt:= Filtered( Elements( aut ),
> x -> OnTuples( 2tfust, beta ) = Permuted( 2tfust, x ) );;
gap> Length( filt );
1
gap> betalift:= filt[1];;
##
gap> 2tfus2t2:= [];;
gap> max:= 0;;
gap> for i in [ 1 .. NrConjugacyClasses( 2t ) ] do
> img:= i^betalift;
> if img = i then
> # no fusion
> max:= max + 1;
> 2tfus2t2[i]:= max;
> elif i < img then
> # fusion of two classes
> max:= max + 1;
> 2tfus2t2[i]:= max;
> 2tfus2t2[ img ]:= max;
> fi;
> od;
gap> max;
174
##
gap> n:= NrConjugacyClasses( 2t );
202
gap> f:= NrMovedPoints( betalift ) / 2;
28
gap> 2 * n - 3 * f; n - f; n - 2 * f;
320
174
146
##
gap> NrConjugacyClasses( t2 ) - Maximum( tfust2 );
84
gap> 320 - NrConjugacyClasses( t2 );
131
##
gap> inv:= InverseMap( 2tfust );;
gap> nonsplit:= PositionsProperty( inv, IsInt);;
gap> mustnotsplit:= Set( tfust2{ nonsplit } );
[ 4, 9, 10, 12, 13, 16, 18, 19, 20, 27, 33, 35, 36, 38, 39, 41, 43, 44, 51,
52, 54, 55, 58, 60, 62, 63, 69, 70, 71, 77, 78, 80, 82, 96, 98, 100 ]
gap> split:= PositionsProperty( inv, IsList );;
gap> mustsplit:= Set( tfust2{ split } );
[ 1, 2, 3, 5, 6, 7, 8, 11, 14, 15, 17, 21, 22, 23, 24, 25, 26, 28, 29, 30,
31, 32, 34, 37, 40, 42, 45, 46, 47, 48, 49, 50, 53, 56, 57, 59, 61, 64, 65,
66, 67, 68, 72, 73, 74, 75, 76, 79, 81, 83, 84, 85, 86, 87, 88, 89, 90, 91,
92, 93, 94, 95, 97, 99, 101, 102, 103, 104, 105 ]
gap> selfCentralizingClassesSplit( t2, mustsplit );
#I class 172 splits (self-centralizing)
#I class 180 splits (self-centralizing)
#I class 181 splits (self-centralizing)
#I class 182 splits (self-centralizing)
#I class 183 splits (self-centralizing)
#I class 184 splits (self-centralizing)
#I class 185 splits (self-centralizing)
#I class 188 splits (self-centralizing)
#I class 189 splits (self-centralizing)
##
gap> c2:= CharacterTable( "C2" );;
gap> s:= CharacterTable( "F4(2)" );;
gap> s2:= c2 * s;;
gap> 2s:= s * c2;;
gap> 2s2:= s2 * c2;;
gap> sfuss2:= GetFusionMap( s, s2 );;
gap> 2sfuss:= GetFusionMap( 2s, s );;
gap> 2s2fuss2:= GetFusionMap( 2s2, s2 );;
##
gap> 2s2alt:= c2 * 2s;;
gap> Irr( 2s2alt ) = Irr( 2s2 );
true
gap> ComputedPowerMaps( 2s2alt ) = ComputedPowerMaps( 2s2 );
true
gap> 2sfus2s2:= GetFusionMap( 2s, 2s2alt );;
##
gap> CompositionMaps( sfuss2, 2sfuss )
> = CompositionMaps( 2s2fuss2, 2sfus2s2 );
true
##
gap> sfust:= PossibleClassFusions( s, t );;
gap> rep:= RepresentativesFusions( AutomorphismsOfTable( s ),
> sfust, Group( () ) );;
gap> Length( rep );
3
gap> comp:= List( rep, map -> CompositionMaps( InverseMap( 2tfust ),
> CompositionMaps( map, 2sfuss ) ) );;
gap> poss:= List( comp, map -> PossibleClassFusions( 2s, 2t,
> rec( fusionmap:= map ) ) );;
gap> List( poss, Length );
[ 1, 0, 0 ]
gap> sfust:= rep[1];;
gap> 2sfus2t:= poss[1][1];;
gap> CompositionMaps( sfust, 2sfuss )
> = CompositionMaps( 2tfust, 2sfus2t );
true
##
gap> comp:= CompositionMaps( CompositionMaps( tfust2, sfust ),
> InverseMap( sfuss2 ) );;
gap> poss:= PossibleClassFusions( s2, t2, rec( fusionmap:= comp ) );;
gap> Length( poss );
1
gap> s2fust2:= poss[1];;
gap> CompositionMaps( tfust2, sfust )
> = CompositionMaps( s2fust2, sfuss2 );
true
##
gap> splittingClassesWithOddCentralizerIndexSplit( s2, t2, s2fust2,
> 2s2fuss2, mustsplit );
#I class 106 splits (odd centralizer index)
#I class 107 splits (odd centralizer index)
#I class 114 splits (odd centralizer index)
#I class 115 splits (odd centralizer index)
#I class 117 splits (odd centralizer index)
#I class 133 splits (odd centralizer index)
#I class 116 splits (odd centralizer index)
#I class 118 splits (odd centralizer index)
#I class 119 splits (odd centralizer index)
#I class 148 splits (odd centralizer index)
#I class 147 splits (odd centralizer index)
#I class 156 splits (odd centralizer index)
#I class 155 splits (odd centralizer index)
#I class 134 splits (odd centralizer index)
#I class 140 splits (odd centralizer index)
#I class 143 splits (odd centralizer index)
#I class 149 splits (odd centralizer index)
#I class 176 splits (odd centralizer index)
#I class 175 splits (odd centralizer index)
#I class 157 splits (odd centralizer index)
#I class 174 splits (odd centralizer index)
#I class 177 splits (odd centralizer index)
##
gap> c3:= CharacterTable( "Cyclic", 3 );;
gap> h:= c3 * CharacterTable( "U6(2)" );;
gap> poss:= PossibleClassFusions( h, t );;
gap> cen:= ClassPositionsOfCentre( h );
[ 1, 47, 93 ]
gap> Set( List( poss, x -> x{ cen } ) );
[ [ 1, 5, 5 ] ]
gap> SizesCentralizers( t )[5] = Size( h );
true
##
gap> h:= CharacterTable( "U6(2)" );;
gap> pos:= PositionsProperty( SizesCentralizers( t2 ),
> x -> x mod Size( h ) = 0 );
[ 1, 2, 5 ]
gap> Difference( pos, tfust2 );
[ ]
##
gap> h:= c3 * CharacterTable( "U6(2).2" );;
gap> possfus:= PossibleClassFusions( h, t2 );;
gap> inv:= Positions( OrdersClassRepresentatives( h ), 2 );
[ 2, 3, 4, 38, 39 ]
gap> outerinv:= Difference( inv, ClassPositionsOfDerivedSubgroup( h ) );
[ 38, 39 ]
gap> imgs:= Set( List( possfus, x -> x{ outerinv } ) );
[ [ 106, 107 ] ]
gap> List( imgs[1], x -> Positions( s2fust2, x ) );
[ [ 96, 98 ], [ 97, 99, 100 ] ]
gap> h:= CharacterTable( "2.U6(2).2" );
CharacterTable( "2.U6(2).2" )
gap> Positions( OrdersClassRepresentatives( h ), 2 );
[ 2, 3, 4, 5, 6, 7, 65, 66, 67, 68 ]
##
gap> c3:= CharacterTable( "Cyclic", 3 );;
gap> 2u:= c3 * CharacterTable( "2.U6(2)" );;
gap> 2uorders:= OrdersClassRepresentatives( 2u );;
gap> ker:= First( ClassPositionsOfCentre( 2u ), i -> 2uorders[i] = 2 );
2
gap> u:= 2u / [ 1, ker ];;
gap> 2u2:= c3 * CharacterTable( "2.U6(2).2" );;
gap> 2u2orders:= OrdersClassRepresentatives( 2u2 );;
gap> ker:= First( ClassPositionsOfCentre( 2u2 ), i -> 2u2orders[i] = 2 );
2
gap> u2:= 2u2 / [ 1, ker ];;
gap> 2ufusu:= GetFusionMap( 2u, u );;
gap> 2u2fusu2:= GetFusionMap( 2u2, u2 );;
gap> poss:= PossibleClassFusions( 2u, 2u2 );;
gap> rep:= RepresentativesFusions( 2u, poss, Group( () ) );;
gap> Length( rep );
1
gap> 2ufus2u2:= rep[1];;
gap> ufusu2:= CompositionMaps( 2u2fusu2,
> CompositionMaps( 2ufus2u2, InverseMap( 2ufusu ) ) );;
##
gap> CompositionMaps( ufusu2, 2ufusu )
> = CompositionMaps( 2u2fusu2, 2ufus2u2 );
true
##
gap> poss:= PossibleClassFusions( 2u, 2t );;
gap> rep:= RepresentativesFusions( 2u, poss, Group( () ) );;
gap> Length( rep );
2
gap> poss2ufus2t:= rep;;
gap> possufust:= List( rep, map -> CompositionMaps( 2tfust,
> CompositionMaps( map, InverseMap( 2ufusu ) ) ) );;
gap> Length( Set( possufust ) );
2
##
gap> comp1:= CompositionMaps(
> CompositionMaps( tfust2, possufust[1] ),
> InverseMap( ufusu2 ) );;
gap> poss1:= PossibleClassFusions( u2, t2, rec( fusionmap:= comp1 ) );;
gap> Length( poss1 );
2
gap> comp2:= CompositionMaps(
> CompositionMaps( tfust2, possufust[2] ),
> InverseMap( ufusu2 ) );;
gap> poss2:= PossibleClassFusions( u2, t2, rec( fusionmap:= comp2 ) );;
gap> Length( poss2 );
2
gap> poss1 = poss2;
true
gap> rep:= RepresentativesFusions( u2, poss1, Group( () ) );;
gap> Length( rep );
1
gap> u2fust2:= rep[1];;
##
gap> splittingClassesWithOddCentralizerIndexSplit( u2, t2, u2fust2,
> 2u2fusu2, mustsplit );
#I class 135 splits (odd centralizer index)
#I class 139 splits (odd centralizer index)
#I class 141 splits (odd centralizer index)
#I class 161 splits (odd centralizer index)
gap> notSplittingClassesOfSubgroupDoNotSplit( 2u2fusu2, u2fust2,
> mustnotsplit );
#I class 120 does not split (as in subgroup)
#I class 126 does not split (as in subgroup)
#I class 127 does not split (as in subgroup)
#I class 150 does not split (as in subgroup)
#I class 151 does not split (as in subgroup)
#I class 163 does not split (as in subgroup)
#I class 164 does not split (as in subgroup)
#I class 165 does not split (as in subgroup)
#I class 186 does not split (as in subgroup)
#I class 187 does not split (as in subgroup)
##
gap> computeContributions2:= function( s2, 2s, t2, 2t, s2fust2, 2sfus2s2,
> 2sfus2t, tfust2,
> characters, bound,
> mustsplit, mustnotsplit, proj )
> local inv, i, known, candidates, r, psi, res;
>
> inv:= InverseMap( s2fust2 );
>
> repeat
> for i in Union( mustnotsplit, tfust2 ) do
> # The induced character is either zero at the preimage of 'i',
> # and there is no contribution to the norm,
> # or the preimage of 'i' lies inside the subgroup of index 2.
> Unbind( inv[i] );
> od;
> known:= [ ShallowCopy( mustsplit ), ShallowCopy( mustnotsplit ) ];
> candidates:= [];
> for i in [ 1 .. Length( characters ) ] do
> r:= contributionData( s2, t2, inv, characters[i]{ proj },
> mustsplit );
> if r.size < bound then
> # Restrict the character to 2.U, and induce it to 2.G.
> psi:= InducedClassFunctionsByFusionMap( 2s, 2t,
> [ characters[i]{ 2sfus2s2 } ], 2sfus2t )[1];
> r.safepart:= r.safepart + ScalarProduct( 2t, psi, psi ) / 2;
> Add( candidates, r );
> fi;
> od;
> 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, s2fust2, mustsplit, mustnotsplit );
> oddRootsOfSplittingClassesSplit( t2, mustsplit );
> od;
> until known = [ mustsplit, mustnotsplit ];
> end;;
##
gap> ker:= ClassPositionsOfKernel( 2s2fuss2 );;
gap> testchars:= Filtered( Irr( 2s2 ), x -> x[ ker[1] ] <> x[ ker[2] ] );;
gap> computeContributions2( s2, 2s, t2, 2t, s2fust2, 2sfus2s2, 2sfus2t,
> tfust2, testchars, 10^7, mustsplit, mustnotsplit,
> ProjectionMap( 2s2fuss2 ) );
#I class 109 splits (contribution criterion)
#I class 136 splits (contribution criterion)
#I class 158 splits (5th root of 109)
#I class 173 splits (7th root of 109)
#I class 110 splits (contribution criterion)
#I class 108 splits (contribution criterion)
#I class 137 splits (contribution criterion)
#I class 159 splits (contribution criterion)
#I class 138 splits (3rd root of 108)
#I class 111 splits (contribution criterion)
#I class 112 splits (contribution criterion)
#I class 142 splits (3rd root of 111)
#I class 144 splits (3rd root of 111)
#I class 145 splits (3rd root of 112)
##
gap> orders:= OrdersClassRepresentatives( t2 );;
gap> invol:= Positions( orders, 2 );;
gap> Difference( invol, s2fust2 );
[ ]
##
gap> open:= Difference( s2fust2, Union( mustsplit, mustnotsplit ) );
[ 113, 121, 122, 123, 125, 128, 129, 131, 132, 146, 153, 154, 162, 166 ]
##
gap> PowerMap( t2, 3 ){ [ 146, 162, 166 ] };
[ 113, 123, 121 ]
gap> poss:= Filtered( Combinations( open ),
> x -> ( not 113 in x or 146 in x ) and
> ( not 123 in x or 162 in x ) and
> ( not 121 in x or 166 in x ) );;
gap> Length( poss );
6912
##
gap> initialFusion2:= function( 2s2, 2t2,
> 2s2fuss2, 2t2fust2, s2fust2,
> 2sfus2s2, 2tfus2t2, 2sfus2t,
> defined )
> local fus, comp, pre, imgs;
>
> # Use element orders and centralizer orders.
> fus:= InitFusion( 2s2, 2t2 );
>
> # Use the commutative diagram on the right of the cube.
> comp:= CompositionMaps( InverseMap( 2t2fust2 ),
> CompositionMaps( s2fust2, 2s2fuss2 ) );
> if not MeetMaps( fus, comp ) then
> return fail;
> fi;
>
> # Use the commutative diagram on the bottom of the cube.
> comp:= CompositionMaps( 2tfus2t2,
> CompositionMaps( 2sfus2t, InverseMap( 2sfus2s2 ) ) );
>
> if not MeetMaps( fus, comp ) then
> return fail;
> fi;
>
> # Define classes that are not yet defined.
> defined:= ShallowCopy( defined );
> for pre in InverseMap( 2s2fuss2 ) do
> if IsList( pre ) then
> imgs:= fus{ pre };
> if imgs[1] = imgs[2] and IsList( imgs[1] )
> and Intersection( defined, 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, imgs[1] );
> fi;
> elif IsList( fus[ pre ] ) then
> # The class splits in the image but not in the preimage,
> # something must be wrong.
> return fail;
> fi;
> od;
>
> return fus;
> end;;
##
gap> good:= [];;
gap> ker:= ClassPositionsOfKernel( GetFusionMap( 2s2, s2 ) );;
gap> testcharss:= Filtered( Irr( 2s2 ),
> chi -> not IsSubset( ClassPositionsOfKernel( chi ), ker ) );;
gap> runOneTest2:= function( s2, 2s2, t2, 2t2, s2fust2,
> 2sfus2s2, 2tfus2t2, 2sfus2t,
> testchars, defined )
> local fus, pos, l, chi;
>
> fus:= initialFusion2( 2s2, 2t2,
> GetFusionMap( 2s2, s2 ),
> GetFusionMap( 2t2, t2 ),
> s2fust2,
> 2sfus2s2, 2tfus2t2, 2sfus2t,
> 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( 2s2, 2t2, chi,
> GetFusionMap( 2s2, s2 ), fus ) = false then
> # This splitting is not possible.
> return fail;
> fi;
> od;
> return fus;
> end;;
gap> defined:= [];;
gap> for choice in poss do
> 2t2:= tableHead( t2, Union( mustsplit, choice ), [], [] );
> fus:= runOneTest2( s2, 2s2, t2, 2t2, s2fust2,
> 2sfus2s2, 2tfus2t2, 2sfus2t,
> testcharss, defined );
> if fus <> fail then
> Add( good, choice );
> fi;
> od;
gap> Length( good );
1
##
gap> choice:= good[1];
[ 113, 121, 122, 123, 125, 131, 146, 153, 154, 162, 166 ]
gap> UniteSet( mustsplit, choice );
gap> UniteSet( mustnotsplit, Difference( open, choice ) );
gap> oddRootsOfSplittingClassesSplit( t2, mustsplit );
#I class 168 splits (3rd root of 122)
#I class 171 splits (3rd root of 131)
##
gap> 2t2:= tableHead( t2, mustsplit, [], [] );;
gap> 2s2fus2t2:= runOneTest2( s2, 2s2, t2, 2t2, s2fust2,
> 2sfus2s2, 2tfus2t2, 2sfus2t,
> testcharss, defined );;
gap> NrConjugacyClasses( 2t2 );
320
gap> defined:= Set( 2s2fus2t2 );;
gap> inds:= Set( InducedClassFunctionsByFusionMap( 2s2, 2t2, testcharss,
> 2s2fus2t2 ) );;
##
gap> poss2u2fus2t2:= List( poss2ufus2t, map ->
> initialFusion2( 2u2, 2t2,
> GetFusionMap( 2u2, u2 ),
> GetFusionMap( 2t2, t2 ),
> u2fust2,
> 2ufus2u2, 2tfus2t2, map,
> defined ) );;
gap> Length( Set( poss2u2fus2t2 ) );
1
gap> fus:= poss2u2fus2t2[1];;
gap> ker:= ClassPositionsOfKernel( GetFusionMap( 2u2, u2 ) );;
gap> testcharsu:= Filtered( Irr( 2u2 ),
> chi -> not IsSubset( ClassPositionsOfKernel( chi ), ker ) );;
gap> possfus:= FusionsAllowedByRestrictions( 2u2, 2t2, testcharsu,
> inds, fus, parametersFABR );;
gap> List( possfus, Indeterminateness );
[ 16, 16 ]
##
gap> good:= [];;
gap> for map in Set( Concatenation( List( possfus, ContainedMaps ) ) ) do
> indu:= Set( InducedClassFunctionsByFusionMap( 2u2, 2t2,
> testcharsu, map ) );
> if ForAll( indu, x -> IsInt( ScalarProduct( 2t2, x, x ) ) ) then
> Add( good, map );
> fi;
> od;
gap> Length( good );
2
gap> poss2u2fus2t2:= good;;
gap> indu:= List( good,
> map -> Set( InducedClassFunctionsByFusionMap( 2u2, 2t2,
> testcharsu, map ) ) );;
gap> List( indu, Length );
[ 98, 98 ]
gap> Length( Intersection( indu ) );
34
gap> Set( poss2u2fus2t2[1] ) = Set( poss2u2fus2t2[2] );
true
gap> UniteSet( defined, Set( poss2u2fus2t2[1] ) );
##
gap> 2t2fust2:= GetFusionMap( 2t2, t2 );;
gap> p:= 5;;
gap> pow5:= InitPowerMap( 2t2, p );;
gap> comp:= CompositionMaps( InverseMap( 2t2fust2 ),
> CompositionMaps( PowerMap( t2, p ), 2t2fust2 ) );;
gap> MeetMaps( pow5, comp );
true
gap> comp:= CompositionMaps( 2tfus2t2,
> CompositionMaps( PowerMap( 2t, p ),
> InverseMap( 2tfus2t2 ) ) );;
gap> MeetMaps( pow5, comp );
true
gap> comp:= CompositionMaps( 2s2fus2t2,
> CompositionMaps( PowerMap( 2s2, p ),
> InverseMap( 2s2fus2t2 ) ) );;
gap> MeetMaps( pow5, comp );
true
gap> para:= Parametrized( poss2u2fus2t2 );;
gap> comp:= CompositionMaps( para,
> CompositionMaps( PowerMap( 2u2, p ),
> InverseMap( para ) ) );;
gap> MeetMaps( pow5, comp );
true
gap> Indeterminateness( pow5 );
4096
##
gap> ambig:= PositionsProperty( pow5, IsList );
[ 283, 284, 287, 288, 307, 308, 309, 310, 317, 318, 319, 320 ]
gap> ambig:= Filtered( ambig,
> i -> OrdersClassRepresentatives( 2t2 )[i] mod 5 = 0 );
[ 309, 310, 319, 320 ]
gap> Intersection( ambig, defined );
[ ]
gap> pow5{ ambig };
[ [ 204, 205 ], [ 204, 205 ], [ 227, 228 ], [ 227, 228 ] ]
gap> pow5{ ambig }:= [ 204, 205, 227, 228 ];;
gap> UniteSet( defined, ambig );
##
gap> p:= 3;;
gap> pow3:= InitPowerMap( 2t2, p );;
gap> comp:= CompositionMaps( InverseMap( 2t2fust2 ),
> CompositionMaps( PowerMap( t2, p ), 2t2fust2 ) );;
gap> MeetMaps( pow3, comp );
true
gap> comp:= CompositionMaps( 2tfus2t2,
> CompositionMaps( PowerMap( 2t, p ),
> InverseMap( 2tfus2t2 ) ) );;
gap> MeetMaps( pow3, comp );
true
gap> comp:= CompositionMaps( 2s2fus2t2,
> CompositionMaps( PowerMap( 2s2, p ),
> InverseMap( 2s2fus2t2 ) ) );;
gap> MeetMaps( pow3, comp );
true
gap> para:= Parametrized( poss2u2fus2t2 );;
gap> comp:= CompositionMaps( para,
> CompositionMaps( PowerMap( 2u2, p ),
> InverseMap( para ) ) );;
gap> MeetMaps( pow3, comp );
true
gap> Indeterminateness( pow3 );
65536
gap> CommutativeDiagram( pow3, pow5, pow5, pow3 );
rec( imp1 := [ 309, 310, 319, 320 ], imp2 := [ ], imp3 := [ ], imp4 := [ ]
)
gap> Indeterminateness( pow3 );
4096
gap> ambig:= PositionsProperty( pow3, IsList );
[ 239, 240, 273, 274, 283, 284, 287, 288, 307, 308, 317, 318 ]
gap> ambig:= Difference( ambig, defined );
[ 283, 284, 287, 288, 307, 308, 317, 318 ]
gap> pow3{ ambig };
[ [ 206, 207 ], [ 206, 207 ], [ 218, 219 ], [ 218, 219 ], [ 231, 232 ],
[ 231, 232 ], [ 317, 318 ], [ 317, 318 ] ]
gap> pow3{ [ 283, 284, 287, 288, 307, 308 ] }:=
> [ 206, 207, 218, 219, 231, 232 ];;
gap> CommutativeDiagram( pow3, pow5, pow5, pow3 );
rec( imp1 := [ ], imp2 := [ ], imp3 := [ 283, 284, 287, 288, 307, 308 ],
imp4 := [ ] )
##
gap> poss3:= [];;
gap> for possindu in indu do
> testchars:= Concatenation( inds, possindu );
> Add( poss3, PowerMapsAllowedBySymmetrizations( 2t2, testchars,
> testchars, StructuralCopy( pow3 ), p,
> parametersFABR ) );
> od;
gap> List( poss3, Length );
[ 1, 1 ]
gap> poss3:= List( poss3, l -> l[1] );;
gap> List( poss3, Indeterminateness );
[ 4, 4 ]
##
gap> p:= 2;;
gap> pow2:= InitPowerMap( 2t2, p );;
gap> comp:= CompositionMaps( InverseMap( 2t2fust2 ),
> CompositionMaps( PowerMap( t2, p ), 2t2fust2 ) );;
gap> MeetMaps( pow2, comp );
true
gap> comp:= CompositionMaps( 2tfus2t2,
> CompositionMaps( PowerMap( 2t, p ),
> InverseMap( 2tfus2t2 ) ) );;
gap> MeetMaps( pow2, comp );
true
gap> comp:= CompositionMaps( 2s2fus2t2,
> CompositionMaps( PowerMap( 2s2, p ),
> InverseMap( 2s2fus2t2 ) ) );;
gap> MeetMaps( pow2, comp );
true
gap> para:= Parametrized( poss2u2fus2t2 );;
gap> comp:= CompositionMaps( para,
> CompositionMaps( PowerMap( 2u2, p ),
> InverseMap( para ) ) );;
gap> MeetMaps( pow2, comp );
true
gap> Indeterminateness( pow2 );
131072
gap> CommutativeDiagram( pow3, pow2, pow2, pow3 );
rec( imp1 := [ ], imp2 := [ ],
imp3 := [ 283, 284, 287, 288, 307, 308, 319, 320 ], imp4 := [ ] )
gap> Indeterminateness( pow2 );
512
gap> CommutativeDiagram( pow5, pow2, pow2, pow5 );
rec( imp1 := [ ], imp2 := [ ], imp3 := [ 309, 310 ], imp4 := [ ] )
gap> Indeterminateness( pow2 );
128
##
gap> indt:= Set( InducedClassFunctionsByFusionMap( 2t, 2t2,
> Filtered( Irr( 2t ), x -> x[1] <> x[2] ), 2tfus2t2 ) );;
gap> irr:= Filtered( indt, x -> ScalarProduct( 2t2, x, x ) = 1 );;
gap> Length( irr );
7
##
gap> red:= Reduced( 2t2, irr, Concatenation( indt, inds ) );;
gap> Length( red.irreducibles );
0
gap> lll:= LLL( 2t2, red.remainders, 99/100 );;
gap> Length( lll.irreducibles );
4
gap> UniteSet( irr, lll.irreducibles );
gap> Length( irr );
11
gap> missing:= NrConjugacyClasses( 2t2 ) - NrConjugacyClasses( t2 )
> - Length( irr );
120
gap> redindu:= List( indu, l -> ReducedCharacters( 2t2, irr, l ) );;
gap> List( redindu, r -> r.irreducibles );
[ [ ], [ ] ]
gap> redindu:= List( redindu, r -> r.remainders );;
##
gap> inducand:= redindu[1];;
gap> testchars:= Concatenation( irr, red.remainders, inducand );;
gap> minus5:= List( testchars, x -> MinusCharacter( x, pow5, 5 ) );;
gap> minus3:= List( testchars, x -> MinusCharacter( x, poss3[1], 3 ) );;
gap> minus:= Reduced( 2t2, irr, Concatenation( minus5, minus3 ) );;
gap> Length( minus.irreducibles );
0
gap> lll2:= LLL( 2t2, Concatenation( lll.remainders, inducand,
> minus.remainders ), 99/100 );;
gap> Length( lll2.irreducibles );
0
gap> Length( lll2.norms );
119
gap> gram:= MatScalarProducts( 2t2, lll2.remainders, lll2.remainders );;
gap> emb:= OrthogonalEmbeddings( gram, missing );;
gap> Length( emb.solutions );
1
gap> dec:= Decreased( 2t2, lll2.remainders, emb.vectors{ emb.solutions[1] } );;
gap> Length( dec.irreducibles );
118
gap> Length( dec.remainders );
1
##
gap> redt:= Reduced( 2t2, Concatenation( irr, dec.irreducibles ), indt );;
gap> Length( redt.remainders );
1
gap> redt.remainders[1] in indt;
true
##
gap> split:= Union( Filtered( InverseMap( 2t2fust2 ), IsList ) );;
gap> Filtered( split, i -> ForAll( Concatenation( irr, dec.irreducibles ),
> x -> x[i] = 0 ) );
[ 317, 318 ]
gap> Positions( OrdersClassRepresentatives( 2t2 ), 56 );
[ 317, 318 ]
gap> SizesCentralizers( 2t2 )[317];
112
##
gap> factirr:= List( Irr( t2 ), x -> x{ 2t2fust2 } );;
gap> poss2:= PowerMapsAllowedBySymmetrizations( 2t2, factirr,
> dec.irreducibles, StructuralCopy( pow2 ), 2,
> parametersFABR );;
gap> Length( poss2 );
1
gap> Indeterminateness( poss2[1] );
1
gap> cand:= ShallowCopy( redt.remainders[1] / 2 );;
gap> cand{ [ 317, 318 ] }:= [ 1, -1 ] * ( 2 * Sqrt(-7) );;
gap> minus2:= MinusCharacter( cand, poss2[1], 2 );;
gap> ForAll( Flat( MatScalarProducts( 2t2, factirr, [ minus2 ] ) ), IsInt );
false
gap> cand{ [ 317, 318 ] }:= [ 1, -1 ] * ( 2 * Sqrt(7) );;
gap> minus2:= MinusCharacter( cand, poss2[1], 2 );;
gap> ForAll( Flat( MatScalarProducts( 2t2, factirr, [ minus2 ] ) ), IsInt );
true
##
gap> cand2:= ShallowCopy( cand );;
gap> cand2{ [ 317, 318 ] }:= [ -1, 1 ] * ( 2 * Sqrt(7) );;
gap> SetIrr( 2t2, Concatenation( factirr, irr, dec.irreducibles,
> [ cand, cand2 ] ) );
gap> for p in [ 2 .. Maximum( OrdersClassRepresentatives( 2t2 ) ) ] do
> if IsPrimeInt( p ) then
> if p = 2 then
> poss:= PossiblePowerMaps( 2t2, p,
> rec( powermap:= poss2[1] ) );
> elif p = 3 then
> poss:= PossiblePowerMaps( 2t2, p,
> rec( powermap:= StructuralCopy( pow3 ) ) );
> elif p = 5 then
> poss:= PossiblePowerMaps( 2t2, p,
> rec( powermap:= StructuralCopy( pow5 ) ) );
> else
> poss:= PossiblePowerMaps( 2t2, p );
> fi;
> if Length( poss ) <> 1 then
> Error( "not expected" );
> fi;
> ComputedPowerMaps( 2t2 )[p]:= poss[1];
> fi;
> od;
gap> lib:= CharacterTable( "2.2E6(2).2" );;
gap> tr:= TransformingPermutationsCharacterTables( lib, 2t2 );;
gap> tr.columns;
(177,178)(179,180)(183,184)(185,186)(189,190)(195,196)(199,200)(201,202)(204,
205)(206,207)(208,209)(218,219)(223,224)(225,226)(227,228)(231,232)(233,
234)(235,236)(241,242)(243,244)(245,246)(247,248)(253,254)(258,259)(260,
261)(266,267)(268,269)(273,274)(275,276)(280,281)(283,284)(287,288)(293,
294)(299,300)(307,308)(309,310)
##
gap> 2t2:= tableHead( t2, mustsplit, [], [] );;
gap> inducand:= redindu[2];;
gap> testchars:= Concatenation( irr, red.remainders, inducand );;
gap> minus5:= List( testchars, x -> MinusCharacter( x, pow5, 5 ) );;
gap> minus3:= List( testchars, x -> MinusCharacter( x, poss3[2], 3 ) );;
gap> minus:= Reduced( 2t2, irr, Concatenation( minus5, minus3 ) );;
gap> Length( minus.irreducibles );
0
gap> lll2:= LLL( 2t2, Concatenation( lll.remainders, inducand,
> minus.remainders ), 99/100 );;
gap> Length( lll2.irreducibles );
0
gap> Length( lll2.norms );
119
gap> gram:= MatScalarProducts( 2t2, lll2.remainders, lll2.remainders );;
gap> emb:= OrthogonalEmbeddings( gram, missing );;
gap> Length( emb.solutions );
1
gap> dec:= Decreased( 2t2, lll2.remainders, emb.vectors{ emb.solutions[1] } );;
gap> Length( dec.irreducibles );
118
gap> Length( dec.remainders );
1
gap> redt:= Reduced( 2t2, Concatenation( irr, dec.irreducibles ), indt );;
gap> Length( redt.remainders );
1
gap> redt.remainders[1] in indt;
true
gap> poss2:= PowerMapsAllowedBySymmetrizations( 2t2, factirr,
> dec.irreducibles, StructuralCopy( pow2 ), 2,
> parametersFABR );;
gap> Length( poss2 );
1
gap> Indeterminateness( poss2[1] );
1
gap> cand:= ShallowCopy( redt.remainders[1] / 2 );;
gap> cand{ [ 317, 318 ] }:= [ 1, -1 ] * ( 2 * Sqrt(-7) );;
gap> minus2:= MinusCharacter( cand, poss2[1], 2 );;
gap> ForAll( Flat( MatScalarProducts( 2t2, factirr, [ minus2 ] ) ), IsInt );
false
gap> cand{ [ 317, 318 ] }:= [ 1, -1 ] * ( 2 * Sqrt(7) );;
gap> minus2:= MinusCharacter( cand, poss2[1], 2 );;
gap> ForAll( Flat( MatScalarProducts( 2t2, factirr, [ minus2 ] ) ), IsInt );
true
gap> cand2:= ShallowCopy( cand );;
gap> cand2{ [ 317, 318 ] }:= [ -1, 1 ] * ( 2 * Sqrt(7) );;
gap> SetIrr( 2t2, Concatenation( factirr, irr, dec.irreducibles,
> [ cand, cand2 ] ) );
gap> for p in [ 2 .. Maximum( OrdersClassRepresentatives( 2t2 ) ) ] do
> if IsPrimeInt( p ) then
> if p = 2 then
> poss:= PossiblePowerMaps( 2t2, p,
> rec( powermap:= poss2 ) );
> elif p = 3 then
> poss:= PossiblePowerMaps( 2t2, p,
> rec( powermap:= StructuralCopy( pow3 ) ) );
> elif p = 5 then
> poss:= PossiblePowerMaps( 2t2, p,
> rec( powermap:= StructuralCopy( pow5 ) ) );
> else
> poss:= PossiblePowerMaps( 2t2, p );
> fi;
> if Length( poss ) <> 1 then
> Error( "not expected" );
> fi;
> ComputedPowerMaps( 2t2 )[p]:= poss[1];
> fi;
> od;
gap> tr:= TransformingPermutationsCharacterTables( lib, 2t2 );;
gap> tr.columns;
(177,178)(179,180)(183,184)(185,186)(189,190)(195,196)(199,200)(201,202)(204,
205)(206,207)(208,209)(218,219)(223,224)(225,226)(227,228)(231,232)(233,
234)(235,236)(239,240)(241,242)(243,244)(245,246)(247,248)(253,254)(258,
259)(260,261)(266,267)(268,269)(275,276)(280,281)(283,284)(287,288)(293,
294)(299,300)(307,308)(309,310)
##
gap> t:= CharacterTable( "B" );;
gap> s:= CharacterTable( "2.2E6(2).2" );;
gap> 2s:= CharacterTable( "2^2.2E6(2).2" );;
gap> 2sfuss:= GetFusionMap( 2s, s );;
##
gap> fus:= PossibleClassFusions( s, t );;
gap> Length( fus );
16
gap> n:= NrConjugacyClasses( 2s );;
gap> indperm:= pi -> PermList( CompositionMaps( 2sfuss,
> CompositionMaps( ListPerm( pi, n ), InverseMap( 2sfuss ) ) ) );;
gap> ind:= Group( List( GeneratorsOfGroup( AutomorphismsOfTable( 2s ) ),
> indperm ) );;
gap> Size( ind );
16
gap> rep:= RepresentativesFusions( ind, fus, Group( () ) );;
gap> Length( rep );
2
##
gap> List( rep, map -> map{ ClassPositionsOfCentre( s ) } );
[ [ 1, 2 ], [ 1, 2 ] ]
gap> List( rep, map -> Positions( map, 2 ) );
[ [ 2, 4, 175 ], [ 2, 4, 176 ] ]
gap> pos:= List( [ 175, 176 ], i -> Positions( 2sfuss, i ) );
[ [ 251 ], [ 252 ] ]
gap> OrdersClassRepresentatives( 2s ){ [ 251, 252 ] };
[ 2, 4 ]
gap> sfust:= rep[1];;
##
gap> orders:= OrdersClassRepresentatives( t );;
gap> mustsplit:= PositionsProperty( orders, IsOddInt );
[ 1, 6, 7, 18, 19, 31, 46, 47, 54, 75, 81, 82, 91, 98, 109, 112, 113, 128,
131, 145, 146, 151, 155, 160, 172, 173, 177 ]
gap> selfCentralizingClassesSplit( t, mustsplit );
#I class 158 splits (self-centralizing)
#I class 159 splits (self-centralizing)
#I class 165 splits (self-centralizing)
#I class 169 splits (self-centralizing)
#I class 170 splits (self-centralizing)
#I class 171 splits (self-centralizing)
#I class 176 splits (self-centralizing)
#I class 182 splits (self-centralizing)
#I class 183 splits (self-centralizing)
#I class 184 splits (self-centralizing)
gap> splittingClassesWithOddCentralizerIndexSplit( s, t, sfust,
> 2sfuss, mustsplit );
#I class 110 splits (odd centralizer index)
#I class 68 splits (odd centralizer index)
#I class 73 splits (odd centralizer index)
#I class 79 splits (odd centralizer index)
#I class 94 splits (odd centralizer index)
#I class 136 splits (odd centralizer index)
#I class 140 splits (odd centralizer index)
gap> mustnotsplit:= [];;
gap> notSplittingClassesOfSubgroupDoNotSplit( 2sfuss, sfust, mustnotsplit );
#I class 2 does not split (as in subgroup)
#I class 4 does not split (as in subgroup)
#I class 5 does not split (as in subgroup)
#I class 8 does not split (as in subgroup)
#I class 9 does not split (as in subgroup)
#I class 10 does not split (as in subgroup)
#I class 11 does not split (as in subgroup)
#I class 13 does not split (as in subgroup)
#I class 14 does not split (as in subgroup)
#I class 15 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 23 does not split (as in subgroup)
#I class 24 does not split (as in subgroup)
#I class 25 does not split (as in subgroup)
#I class 27 does not split (as in subgroup)
#I class 29 does not split (as in subgroup)
#I class 30 does not split (as in subgroup)
#I class 32 does not split (as in subgroup)
#I class 33 does not split (as in subgroup)
#I class 34 does not split (as in subgroup)
#I class 35 does not split (as in subgroup)
#I class 36 does not split (as in subgroup)
#I class 37 does not split (as in subgroup)
#I class 38 does not split (as in subgroup)
#I class 39 does not split (as in subgroup)
#I class 40 does not split (as in subgroup)
#I class 41 does not split (as in subgroup)
#I class 44 does not split (as in subgroup)
#I class 48 does not split (as in subgroup)
#I class 50 does not split (as in subgroup)
#I class 52 does not split (as in subgroup)
#I class 55 does not split (as in subgroup)
#I class 56 does not split (as in subgroup)
#I class 57 does not split (as in subgroup)
#I class 58 does not split (as in subgroup)
#I class 59 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 63 does not split (as in subgroup)
#I class 65 does not split (as in subgroup)
#I class 66 does not split (as in subgroup)
#I class 67 does not split (as in subgroup)
#I class 69 does not split (as in subgroup)
#I class 70 does not split (as in subgroup)
#I class 71 does not split (as in subgroup)
#I class 72 does not split (as in subgroup)
#I class 76 does not split (as in subgroup)
#I class 77 does not split (as in subgroup)
#I class 78 does not split (as in subgroup)
#I class 80 does not split (as in subgroup)
#I class 83 does not split (as in subgroup)
#I class 84 does not split (as in subgroup)
#I class 85 does not split (as in subgroup)
#I class 86 does not split (as in subgroup)
#I class 87 does not split (as in subgroup)
#I class 88 does not split (as in subgroup)
#I class 92 does not split (as in subgroup)
#I class 93 does not split (as in subgroup)
#I class 95 does not split (as in subgroup)
#I class 97 does not split (as in subgroup)
#I class 99 does not split (as in subgroup)
#I class 101 does not split (as in subgroup)
#I class 102 does not split (as in subgroup)
#I class 103 does not split (as in subgroup)
#I class 114 does not split (as in subgroup)
#I class 115 does not split (as in subgroup)
#I class 116 does not split (as in subgroup)
#I class 117 does not split (as in subgroup)
#I class 118 does not split (as in subgroup)
#I class 119 does not split (as in subgroup)
#I class 120 does not split (as in subgroup)
#I class 122 does not split (as in subgroup)
#I class 123 does not split (as in subgroup)
#I class 124 does not split (as in subgroup)
#I class 126 does not split (as in subgroup)
#I class 129 does not split (as in subgroup)
#I class 130 does not split (as in subgroup)
#I class 132 does not split (as in subgroup)
#I class 133 does not split (as in subgroup)
#I class 134 does not split (as in subgroup)
#I class 135 does not split (as in subgroup)
#I class 137 does not split (as in subgroup)
#I class 138 does not split (as in subgroup)
#I class 139 does not split (as in subgroup)
#I class 141 does not split (as in subgroup)
#I class 149 does not split (as in subgroup)
#I class 150 does not split (as in subgroup)
#I class 152 does not split (as in subgroup)
#I class 153 does not split (as in subgroup)
#I class 154 does not split (as in subgroup)
#I class 156 does not split (as in subgroup)
#I class 157 does not split (as in subgroup)
#I class 161 does not split (as in subgroup)
#I class 163 does not split (as in subgroup)
#I class 166 does not split (as in subgroup)
#I class 167 does not split (as in subgroup)
#I class 168 does not split (as in subgroup)
#I class 175 does not split (as in subgroup)
#I class 178 does not split (as in subgroup)
#I class 179 does not split (as in subgroup)
#I class 180 does not split (as in subgroup)
#I class 181 does not split (as in subgroup)
gap> proj:= Filtered( Irr( 2s ), x -> x[1] <> x[2] );;
gap> projmap:= ProjectionMap( 2sfuss );;
gap> proj:= List( proj, x -> x{ projmap } );;
gap> computeContributions( s, t, sfust, proj, 10^6,
> mustsplit, mustnotsplit );
#I class 3 splits (contribution criterion)
#I class 12 splits (contribution criterion)
#I class 42 splits (contribution criterion)
#I class 22 splits (3rd root of 3)
#I class 26 splits (3rd root of 3)
#I class 60 splits (3rd root of 12)
#I class 64 splits (3rd root of 12)
#I class 125 splits (3rd root of 42)
#I class 49 splits (5th root of 3)
#I class 51 splits (5th root of 3)
#I class 105 splits (5th root of 12)
#I class 143 splits (5th root of 26)
#I class 144 splits (5th root of 26)
#I class 111 splits (11th root of 3)
#I class 104 does not split (contribution criterion)
#I class 28 splits (contribution criterion)
#I class 142 splits (5th root of 28)
##
gap> invol:= Positions( OrdersClassRepresentatives( t ), 2 );
[ 2, 3, 4, 5 ]
gap> IsSubset( sfust, invol );
true
gap> invols:= List( invol, i -> Positions( sfust, i ) );
[ [ 2, 4, 175 ], [ 3, 5 ], [ 176, 177 ], [ 6, 7, 178 ] ]
gap> preim2s:= List( invols,
> l -> PositionsProperty( 2sfuss, x -> x in l ) );
[ [ 3, 6, 251 ], [ 4, 5, 7, 8 ], [ 252, 253 ], [ 9, 10, 254 ] ]
gap> List( preim2s, l -> OrdersClassRepresentatives( 2s ){ l } );
[ [ 2, 2, 2 ], [ 2, 2, 2, 2 ], [ 4, 4 ], [ 2, 2, 2 ] ]
gap> invmustlift:= [ 4 ];;
gap> invmaylift:= [];;
##
gap> open:= Difference( sfust, Union( mustsplit, mustnotsplit ) );
[ 89, 90 ]
gap> defined:= [];;
gap> ker:= ClassPositionsOfKernel( GetFusionMap( 2s, s ) );
[ 1, 2 ]
gap> testcharss:= Filtered( Irr( 2s ),
> chi -> not IsSubset( ClassPositionsOfKernel( chi ), ker ) );;
gap> good:= [];;
gap> for choice in Combinations( open ) do
> 2t:= tableHead( t, Union( mustsplit, choice ),
> invmustlift, invmaylift );
> fus:= runOneTest( s, 2s, t, 2t, sfust, testcharss, defined );
> if fus <> fail then
> Add( good, rec( choice:= choice, table:= 2t, map:= fus ) );
> fi;
> od;
gap> List( good, x -> x.choice );
[ [ 89 ], [ 90 ] ]
##
gap> List( good, x -> Indeterminateness( x.map ) );
[ 4, 4 ]
gap> goodfus:= [];;
gap> for map in ContainedMaps( good[1].map ) do
> 2t:= good[1].table;
> ind:= InducedClassFunctionsByFusionMap( 2s, 2t, testcharss, map );
> if ForAll( Flat( MatScalarProducts( 2t, ind, ind ) ), IsInt ) then
> Add( goodfus, map );
> fi;
> od;
gap> Length( goodfus );
0
gap> 2t:= good[2].table;;
gap> 2tfust:= GetFusionMap( 2t, t );;
gap> AddSet( mustnotsplit, 89 );
gap> AddSet( mustsplit, 90 );
##
gap> inds:= [];;
gap> for map in ContainedMaps( good[2].map ) do
> ind:= InducedClassFunctionsByFusionMap( 2s, 2t, testcharss, map );
> if ForAll( Flat( MatScalarProducts( 2t, ind, ind ) ), IsInt ) then
> Add( inds, rec( 2tfust:= 2tfust, characters:= ind, map:= map ) );
> fi;
> od;
gap> Length( inds );
2
##
gap> p:= 2;;
gap> 2tfust:= GetFusionMap( 2t, t );;
gap> for testinds in inds do
> pow:= InitPowerMap( 2t, p );
> Congruences( 2t, testinds.characters, pow, p, false );
> TransferDiagram( pow, 2tfust, PowerMap( t, p ) );
> TransferDiagram( PowerMap( 2s, p ), testinds.map, pow );
> factirr:= List( Irr( t ), x -> x{ 2tfust } );
> testinds.pow2:= PowerMapsAllowedBySymmetrizations( 2t, factirr,
> testinds.characters, pow, p, parametersFABR );
> od;
gap> List( inds, x -> Length( x.pow2 ) );
[ 1, 0 ]
gap> inds:= inds[1];;
##
gap> Length( Difference( [ 1 .. NrConjugacyClasses( t ) ],
> Union( mustsplit, mustnotsplit ) ) );
17
##
gap> th:= CharacterTable( "Th" );;
gap> poss:= PossibleClassFusions( th, t );;
gap> Length( poss );
2
gap> rep:= RepresentativesFusions( th, poss, Group( () ) );;
gap> Length( rep );
1
gap> thfust:= rep[1];;
gap> 2th:= CharacterTable( "Cyclic", 2 ) * th;;
gap> 2thfusth:= GetFusionMap( 2th, th );;
gap> splittingClassesWithOddCentralizerIndexSplit( th, t, thfust,
> 2thfusth, mustsplit );
#I class 96 splits (odd centralizer index)
##
gap> splitFusionAndCharacters:= function( r, t, tosplit_in_t )
> local 2tfust, inv, tosplit_in_2t, result, shift, j, i, spl;
>
> 2tfust:= r.2tfust;
> inv:= InverseMap( 2tfust );
> tosplit_in_2t:= inv{ tosplit_in_t };
> if ForAny( inv{ tosplit_in_t }, IsList ) then
> Error( "the classes in ",
> Filtered( tosplit_in_t, i -> IsList( inv[i] ) ),
> " were already split" );
> elif ForAny( r.characters,
> x -> not IsZero( x{ tosplit_in_2t } ) ) then
> Error( "all characters must vanish on the classes to be split" );
> fi;
>
> # Adjust the characters of '2t'.
> spl:= Concatenation( [ 1 .. Length( r.characters[1] ) ],
> tosplit_in_2t );
> Sort( spl );
> result:= rec( characters:= List( r.characters, chi -> chi{ spl } ),
> 2tfust:= 2tfust{ spl } );
>
> if IsBound( r.map ) then
> if Intersection( tosplit_in_2t, r.map ) <> [] then
> Error( "the classes to be split must not occur in the subgroup" );
> fi;
>
> # Adjust the fusion from a subgroup to '2t'.
> Add( tosplit_in_2t, Length( 2tfust ) + 1 );
> shift:= [];
> for j in [ 1 .. tosplit_in_2t[1] - 1 ] do
> shift[j]:= 0;
> od;
> for i in [ 1 .. Length( tosplit_in_2t ) - 1 ] do
> for j in [ tosplit_in_2t[i] .. tosplit_in_2t[ i+1 ] - 1 ] do
> shift[j]:= i;
> od;
> od;
> result.map:= r.map + shift{ r.map };
> fi;
>
> return result;
> end;;
gap> inds:= splitFusionAndCharacters( inds, t, [ 96 ] );;
##
gap> open:= Difference( thfust, Union( mustsplit, mustnotsplit ) );
[ 45, 53, 108, 127 ]
gap> defined:= Set( sfust );;
gap> ker:= ClassPositionsOfKernel( GetFusionMap( 2th, th ) );
[ 1, 49 ]
gap> testcharsth:= Filtered( Irr( 2th ),
> x -> not IsSubset( ClassPositionsOfKernel( x ), ker ) );;
gap> good:= [];;
gap> for choice in Combinations( open ) do
> 2t:= tableHead( t, Union( mustsplit, choice ),
> invmustlift, invmaylift );
> fus:= runOneTest( th, 2th, t, 2t, thfust, testcharsth, defined );
> if fus <> fail then
> Add( good, rec( choice:= choice, map:= fus, table:= 2t ) );
> fi;
> od;
gap> List( good, x -> x.choice );
[ [ 45, 53, 127 ], [ 53 ], [ 53, 127 ] ]
##
gap> UniteSet( mustsplit, [ 53 ] );
gap> UniteSet( mustnotsplit, [ 108 ] );
##
gap> good2:= [];;
gap> for r in good do
> splitinds:= splitFusionAndCharacters( inds, t, r.choice );
> 2t:= r.table;;
> fus:= StructuralCopy( r.map );;
> 2tfust:= GetFusionMap( 2t, t );;
> factirr:= List( Irr( t ), x -> x{ 2tfust } );;
> possfus:= FusionsAllowedByRestrictions( 2th, 2t, testcharsth,
> splitinds.characters, fus, parametersFABR );;
> for paramap in possfus do
> for map in ContainedMaps( paramap ) do
> indth:= Set( InducedClassFunctionsByFusionMap( 2th, 2t,
> testcharsth, map ) );
> if ForAll( Flat( MatScalarProducts( 2t, indth, indth ) ),
> IsInt ) and
> ForAll( Flat( MatScalarProducts( 2t, indth,
> splitinds.characters ) ), IsInt ) then
> # Use the 2-nd power map.
> ind:= Concatenation( splitinds.characters, indth );
> pow:= InitPowerMap( 2t, p );
> if Congruences( 2t, ind, pow, p, false ) = true and
> TransferDiagram( pow, 2tfust, PowerMap( t, p ) ) <> fail and
> TransferDiagram( PowerMap( 2th, p ), map, pow ) <> fail and
> TransferDiagram( PowerMap( 2s, p ), splitinds.map,
> pow ) <> fail then
> poss:= PowerMapsAllowedBySymmetrizations( 2t, factirr, ind,
> pow, p, parametersFABR );
> if Length( poss ) <> 0 then
> r.pow2:= poss;
> Add( good2, rec( table:= 2t,
> choice:= r.choice,
> 2thfus2t:= map,
> ind:= ind,
> 2sfus2t:= splitinds.map ) );
> fi;
> fi;
> fi;
> od;
> od;
> od;
gap> List( good2, x -> x.choice );
[ [ 45, 53, 127 ], [ 53 ], [ 53, 127 ] ]
##
gap> 2t:= good2[2].table;;
gap> 2tfust:= GetFusionMap( 2t, t );;
gap> 2thfus2t:= good2[2].2thfus2t;;
gap> 2sfus2t:= good2[2].2sfus2t;;
gap> ind:= good2[2].ind;;
gap> factirr:= List( Irr( t ), x -> x{ 2tfust } );;
##
gap> nothit_in_t:= Difference( mustsplit, Union( thfust, sfust ) );;
gap> nothit_in_2t:= PositionsProperty( 2tfust, i -> i in nothit_in_t );
[ 66, 67, 136, 137, 147, 148, 149, 150, 162, 163, 166, 167, 186, 187, 188,
189, 217, 218, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 234, 235,
236, 237, 242, 243 ]
gap> orders_2t:= OrdersClassRepresentatives( 2t );;
gap> orders_2t{ nothit_in_2t };
[ 10, 10, 20, 20, 23, 46, 23, 46, 24, 24, 25, 50, 30, 30, 30, 30, 40, 40, 44,
44, 46, 46, 46, 46, 47, 94, 47, 94, 104, 104, 55, 110, 60, 60 ]
##
gap> powermaps:= ComputedPowerMaps( 2t );;
gap> primes:= Filtered( [ 1 .. Maximum( orders_2t ) ], IsPrimeInt );;
gap> for p in primes do
> pow:= InitPowerMap( 2t, p );
> if TransferDiagram( pow, 2tfust, PowerMap( t, p ) ) = fail or
> TransferDiagram( PowerMap( 2th, p ), 2thfus2t, pow ) = fail or
> TransferDiagram( PowerMap( 2s, p ), 2sfus2t, pow ) = fail or
> ConsiderSmallerPowerMaps( 2t, pow, p, false ) <> true or
> Congruences( 2t, ind, pow, p, false ) <> true then
> Error( "contradiction" );
> fi;
> poss:= PowerMapsAllowedBySymmetrizations( 2t, ind, ind,
> pow, p, parametersFABR );
> if Length( poss ) = 1 then
> powermaps[p]:= poss[1];
> else
> powermaps[p]:= pow;
> fi;
> od;
##
gap> known:= Filtered( nothit_in_2t,
> i -> ForAll( powermaps, map -> IsInt( map[i] ) ) );
[ 147, 148, 149, 150, 166, 167, 228, 229, 230, 231, 236, 237 ]
##
gap> List( Difference( nothit_in_2t, known ),
> i -> Number( powermaps, map -> IsList( map[i] ) ) );
[ 22, 22, 25, 25, 26, 26, 26, 26, 26, 26, 27, 27, 26, 26, 27, 27, 27, 27, 27,
27, 27, 27 ]
gap> oddprimes:= Difference( primes, [ 2 ] );;
gap> inv:= InverseMap( 2tfust );;
gap> for i in [ 1 .. Length( inv ) ] do
> if IsList( inv[i] ) then
> # the classes of g and g*z
> pair:= inv[i];
> for p in oddprimes do
> if powermaps[p]{ pair } = [ pair, pair ] then
> # the p-th powers of g and g*z are conj. to g or g*z
> for k in Filtered( oddprimes,
> x -> orders_2t[ pair[1] ] mod x = 0 ) do
> img:= powermaps[k][ pair[1] ];
> if IsList( img ) then
> if powermaps[p]{ img } = img then
> # the p-th power of g^k is conj. to g^k
> powermaps[p]{ pair }:= pair;
> elif powermaps[p]{ img } = Reversed( img ) then
> # the p-th power of g^k is conj. to g^k*z
> powermaps[p]{ pair }:= pair{ [ 2, 1 ] };
> fi;
> fi;
> od;
> fi;
> od;
> fi;
> od;
gap> List( Difference( nothit_in_2t, known ),
> i -> Number( powermaps, map -> IsList( map[i] ) ) );
[ 1, 1, 1, 1, 1, 1, 17, 17, 17, 17, 27, 27, 26, 26, 18, 18, 18, 18, 27, 27,
2, 2 ]
##
gap> pos:= [ 66, 67, 136, 137 ];;
gap> powermaps[5]{ pos };
[ [ 4, 5 ], [ 4, 5 ], [ 16, 17 ], [ 16, 17 ] ]
gap> powermaps[5]{ pos }:= [ 4, 5, 16, 17 ];;
gap> pos:= [ 162, 163 ];;
gap> powermaps[3]{ pos };
[ [ 53, 54 ], [ 53, 54 ] ]
gap> powermaps[3]{ pos }:= [ 53, 54 ];;
##
gap> pos:= [ 242, 243 ];;
gap> powermaps[3]{ pos };
[ [ 136, 137 ], [ 136, 137 ] ]
gap> powermaps[5]{ pos };
[ [ 78, 79 ], [ 78, 79 ] ]
gap> powermaps[3]{ [ 78, 79 ] };
[ 16, 17 ]
gap> powermaps[3]{ pos }:= [ 136, 137 ];;
gap> powermaps[5]{ pos }:= [ 78, 79 ];;
##
gap> pos:= Intersection( Difference( nothit_in_2t, known ),
> Positions( orders_2t, 46 ) );
[ 224, 225, 226, 227 ]
gap> powermaps[5]{ pos };
[ [ 226, 227 ], [ 226, 227 ], [ 224, 225 ], [ 224, 225 ] ]
gap> setGaloisInfo( powermaps, [ 224, 226 ], orders_2t, primes, Sqrt(-23) );
gap> setGaloisInfo( powermaps, [ 225, 227 ], orders_2t, primes, Sqrt(-23) );
##
gap> powermaps[23]{ pos };
[ [ 4, 5 ], [ 4, 5 ], [ 4, 5 ], [ 4, 5 ] ]
gap> powermaps[23]{ pos }:= [ 4, 5, 4, 5 ];;
gap> ForAll( List( powermaps, x -> x{ pos } ), IsPositionsList );
true
##
gap> pos:= Intersection( nothit_in_2t, Positions( orders_2t, 30 ) );
[ 186, 187, 188, 189 ]
gap> Field( Flat( List( factirr, x -> x{ pos } ) ) )
> = Field( Rationals, [ Sqrt( -15 ) ] );
true
##
gap> List( powermaps, x -> x[66] );
[ , 25, 66,, 4,, 66,,,, 66,, 66,,,, 66,, 66,,,, 66,,,,,, 66,, 66,,,,,, 66,,,,
66,, 66,,,, 66,,,,,, 66,,,,,, 66,, 66,,,,,, 66,,,, 66,, 66,,,,,, 66,,,, 66,,
,,,, 66,,,,,,,, 66,,,, 66,, 66,,,, 66,, 66 ]
gap> setGaloisInfo( powermaps, [ 186, 188 ], orders_2t, primes, Sqrt(-15) );
gap> setGaloisInfo( powermaps, [ 187, 189 ], orders_2t, primes, Sqrt(-15) );
gap> powermaps[3]{ pos };
[ [ 66, 67 ], [ 66, 67 ], [ 66, 67 ], [ 66, 67 ] ]
gap> powermaps[3]{ pos }:= [ 66, 67, 66, 67 ];;
gap> powermaps[5]{ pos };
[ [ 34, 35 ], [ 34, 35 ], [ 34, 35 ], [ 34, 35 ] ]
gap> powermaps[3]{ [ 34, 35 ] };
[ 4, 5 ]
gap> powermaps[5]{ [ 66, 67 ] };
[ 4, 5 ]
gap> powermaps[5]{ pos }:= [ 34, 35, 34, 35 ];;
gap> ForAll( List( powermaps, x -> x{ pos } ), IsPositionsList ); # true
true
##
gap> pos:= Intersection( nothit_in_2t, Positions( orders_2t, 44 ) );
[ 222, 223 ]
gap> vals:= List( [ 1, -1, 11, -11 ], Sqrt );;
gap> good:= [];;
gap> for val in vals do
> setGaloisInfo( powermaps, pos, orders_2t, primes, val );
> indcyc:= InducedCyclic( 2t, pos, "all" );
> if ForAll( indcyc, x -> IsInt( ScalarProduct( 2t, x, x ) ) ) then
> minus:= MinusCharacter( indcyc[1], powermaps[2], 2 );
> if ForAll( List( factirr, x -> ScalarProduct( 2t, x, minus ) ),
> IsInt ) then
> Add( good, val );
> fi;
> fi;
> od;
gap> good = [ Sqrt( -11 ) ];
true
gap> setGaloisInfo( powermaps, pos, orders_2t, primes, good[1] );
##
gap> pos:= Intersection( nothit_in_2t, Positions( orders_2t, 104 ) );
[ 234, 235 ]
gap> vals:= List( [ 1, -1, 2, -2, 13, -13, 26, -26 ], Sqrt );;
gap> good:= [];;
gap> for val in vals do
> setGaloisInfo( powermaps, pos, orders_2t, primes, val );
> indcyc:= InducedCyclic( 2t, pos, "all" );
> if ForAll( indcyc, x -> IsInt( ScalarProduct( 2t, x, x ) ) ) then
> minus:= MinusCharacter( indcyc[1], powermaps[2], 2 );
> if ForAll( List( factirr, x -> ScalarProduct( 2t, x, minus ) ),
> IsInt ) then
> Add( good, val );
> fi;
> fi;
> od;
gap> good = [ Sqrt( -26 ) ];
true
gap> setGaloisInfo( powermaps, pos, orders_2t, primes, good[1] );
##
gap> pos:= Intersection( nothit_in_2t, Positions( orders_2t, 40 ) );
[ 217, 218 ]
##
gap> powermaps[2]{ pos };
[ [ 136, 137 ], [ 136, 137 ] ]
gap> TransferDiagram( powermaps[5], powermaps[2], powermaps[5] );
rec( impbetween := [ 131, 139, 217, 218 ], impinside1 := [ ],
impinside2 := [ ] )
gap> IsPositionsList( powermaps[2] );
true
##
gap> vals:= List( [ 1, -1, 2, -2, 5, -5, 10, -10 ], Sqrt );;
gap> good:= [];;
gap> for val in vals do
> setGaloisInfo( powermaps, pos, orders_2t, primes, val );
> indcyc:= InducedCyclic( 2t, pos, "all" );
> if ForAll( indcyc, x -> IsInt( ScalarProduct( 2t, x, x ) ) ) then
> minus:= MinusCharacter( indcyc[1], powermaps[2], 2 );
> if ForAll( List( factirr, x -> ScalarProduct( 2t, x, minus ) ),
> IsInt ) then
> Add( good, val );
> fi;
> fi;
> od;
gap> good = [ Sqrt( 5 ), Sqrt( -5 ) ];
true
##
gap> indcyc:= InducedCyclic( 2t, Difference( nothit_in_2t, pos ), "all" );;
gap> indcyc:= Reduced( 2t, factirr, indcyc ).remainders;;
gap> setGaloisInfo( powermaps, pos, orders_2t, primes, Sqrt( 5 ) );
gap> indcyc40r5:= InducedCyclic( 2t, pos, "all" );;
gap> indcyc40r5:= Reduced( 2t, factirr, indcyc40r5 ).remainders;;
gap> testind:= Concatenation( ind, indcyc, indcyc40r5 );;
gap> lll:= LLL( 2t, testind, 99/100 );;
gap> Length( lll.norms );
63
gap> Length( mustsplit );
63
gap> Length( Difference( [ 1 .. NrConjugacyClasses( t ) ],
> Union( mustsplit, mustnotsplit ) ) );
14
gap> gram:= MatScalarProducts( 2t, lll.remainders, lll.remainders );;
gap> emb:= OrthogonalEmbeddings( gram, 63 + 14 );;
gap> List( emb.solutions, Length );
[ 63, 63, 63, 65, 65, 65 ]
gap> dec:= List( emb.solutions,
> x -> Decreased( 2t, lll.remainders, emb.vectors{ x } ) );;
gap> Positions( dec, fail );
[ 1, 2, 3, 6 ]
##
gap> dec:= Filtered( dec, x -> x <> fail );;
gap> List( dec, r -> Length( r.irreducibles ) );
[ 61, 61 ]
##
gap> degreesum:= List( dec,
> r -> Sum( List( r.irreducibles, x -> x[1]^2 ) ) );;
gap> Set( degreesum );
[ 4154780380522839827726467072000000 ]
gap> n:= Size( t ) - degreesum[1];
1100703586363451113472000000
##
gap> red:= List( dec, r -> Reduced( 2t, r.irreducibles, testind ) );;
gap> norm2:= List( red, r -> First( r.remainders,
> x -> ScalarProduct( 2t, x, x ) = 2 ) );;
gap> norm2[1] = norm2[2];
true
gap> norm2[1][1] = Sqrt( 2 * n );
true
##
gap> setGaloisInfo( powermaps, pos, orders_2t, primes, Sqrt( -5 ) );
gap> indcyc40i5:= InducedCyclic( 2t, pos, "all" );;
gap> indcyc40i5:= Reduced( 2t, factirr, indcyc40i5 ).remainders;;
gap> testind:= Concatenation( ind, indcyc, indcyc40i5 );;
gap> lll:= LLL( 2t, testind, 99/100 );;
gap> gram:= MatScalarProducts( 2t, lll.remainders, lll.remainders );;
gap> emb:= OrthogonalEmbeddings( gram, 63 + 14 );;
gap> List( emb.solutions, Length );
[ 63, 63, 63, 65, 65, 65 ]
gap> dec:= List( emb.solutions,
> x -> Decreased( 2t, lll.remainders, emb.vectors{ x } ) );;
gap> Positions( dec, fail );
[ 3, 6 ]
gap> dec:= Filtered( dec, x -> x <> fail );;
gap> List( dec, r -> Length( r.irreducibles ) );
[ 63, 63, 61, 61 ]
##
gap> dec1:= dec{ [ 1, 2 ] };;
gap> dec2:= dec{ [ 3, 4 ] };;
gap> degreesum:= List( dec2,
> r -> Sum( List( r.irreducibles, x -> x[1]^2 ) ) );;
gap> Set( degreesum );
[ 4154780380522839827726467072000000 ]
gap> n:= Size( t ) - degreesum[1];
1100703586363451113472000000
gap> red:= List( dec2, r -> Reduced( 2t, r.irreducibles, testind ) );;
gap> norm2:= List( red, r -> First( r.remainders,
> x -> ScalarProduct( 2t, x, x ) = 2 ) );;
gap> Length( Set( norm2 ) );
1
gap> norm2[1][1] = Sqrt( 2 * n );
true
##
gap> HasIrr( 2t );
false
gap> SetIrr( 2t, Concatenation( factirr, dec1[1].irreducibles ) );
gap> lib:= CharacterTable( "2.B" );;
gap> TransformingPermutationsCharacterTables( 2t, lib );
rec( columns := (4,5)(29,30)(34,35)(63,64)(66,67)(122,123)(125,126)(145,
146)(186,187)(188,189)(224,225)(226,227),
group := <permutation group with 17 generators>,
rows := (185,213,243,236,191,205,225,229,247,200,232,222,207,216,187,206,
212,234,194,244,217,202,245,199,238,235,221,192,214,230,201,186,211,227,
226,208,198,242,218,193,209,220,196,210,241,203,189,224,219,197,204,223,
240,190,215,195,233)(188,239)(231,246,237) )
gap> ResetFilterObj( 2t, HasIrr );
gap> SetIrr( 2t, Concatenation( factirr, dec1[2].irreducibles ) );
gap> TransformingPermutationsCharacterTables( 2t, lib );
rec( columns := (4,5)(29,30)(34,35)(63,64)(66,67)(122,123)(125,126)(143,
144)(145,146)(186,187)(188,189)(224,225)(226,227)(244,245),
group := <permutation group with 17 generators>,
rows := (185,212,234,194,244,217,202,245,199,238,190,215,195,233)(186,211,
227,226,208,198,242,218,193,209,220,196,210,241,203,189,224,219,197,204,
223,240,235,221,192,214,230,201)(187,206,213,243,191,205,225,229,247,200,
232,222,207,216)(188,239)(231,246,237) )
##
gap> good2[3].choice;
[ 53, 127 ]
gap> pos:= Positions( 2tfust, 127 );
[ 165 ]
gap> 2t:= good2[3].table;;
gap> 2tfust:= GetFusionMap( 2t, t );;
gap> 2thfus2t:= good2[3].2thfus2t;;
gap> 2sfus2t:= good2[3].2sfus2t;;
gap> ind:= good2[3].ind;;
gap> factirr:= List( Irr( t ), x -> x{ 2tfust } );;
gap> UniteSet( mustsplit, good2[3].choice );
gap> spl:= SortedList( Concatenation( [ 1 .. 247 ], pos ) );;
gap> testind:= Concatenation( good2[3].ind,
> List( Concatenation( indcyc, indcyc40r5 ), x -> x{ spl } ) );;
gap> lll:= LLL( 2t, testind, 99/100 );;
gap> Length( lll.norms );
64
gap> Length( mustsplit );
64
gap> Length( Difference( [ 1 .. NrConjugacyClasses( t ) ],
> Union( mustsplit, mustnotsplit ) ) );
13
gap> gram:= MatScalarProducts( 2t, lll.remainders, lll.remainders );;
gap> emb:= OrthogonalEmbeddings( gram, 64+13 );;
gap> List( emb.solutions, Length );
[ 64, 64, 64, 65, 65, 65, 66, 66, 66, 67, 67, 67, 67, 67, 67, 67, 67, 67, 69,
69, 69 ]
gap> dec:= List( emb.solutions,
> x -> Decreased( 2t, lll.remainders, emb.vectors{ x } ) );;
gap> Positions( dec, fail );
[ 1, 2, 3, 6, 7, 8, 9, 16, 17, 18, 21 ]
gap> dec:= Filtered( dec, x -> x <> fail );;
gap> List( dec, r -> Length( r.irreducibles ) );
[ 61, 61, 63, 61, 61, 63, 61, 61, 61, 61 ]
gap> degreesum:= List( dec,
> r -> Sum( List( r.irreducibles, x -> x[1]^2 ) ) );;
gap> degreesumset:= Set( degreesum );
[ 4154780380522839827726467072000000, 4154781481226426191177580544000000 ]
gap> n:= Size( t ) - degreesumset;
[ 1100703586363451113472000000, 0 ]
gap> List( degreesumset, x -> Positions( degreesum, x ) );
[ [ 1, 2, 4, 5, 7, 8, 9, 10 ], [ 3, 6 ] ]
gap> dec:= dec{ Positions( degreesum, degreesumset[1] ) };;
gap> red:= List( dec, r -> Reduced( 2t, r.irreducibles, testind ) );;
gap> norm2:= List( red, r -> First( r.remainders,
> x -> ScalarProduct( 2t, x, x ) = 2 ) );;
gap> Length( Set( norm2 ) );
1
gap> norm2[1][1] = Sqrt( 2 * n[1] );
true
##
gap> testind:= Concatenation( good2[3].ind,
> List( Concatenation( indcyc, indcyc40i5 ), x -> x{ spl } ) );;
gap> lll:= LLL( 2t, testind, 99/100 );;
gap> gram:= MatScalarProducts( 2t, lll.remainders, lll.remainders );;
gap> emb:= OrthogonalEmbeddings( gram, 64+13 );;
gap> List( emb.solutions, Length );
[ 64, 64, 64, 65, 65, 65, 66, 66, 66, 67, 67, 67, 67, 67, 67, 67, 67, 67, 69,
69, 69 ]
gap> dec:= List( emb.solutions,
> x -> Decreased( 2t, lll.remainders, emb.vectors{ x } ) );;
gap> Positions( dec, fail );
[ 1, 2, 3, 6, 7, 8, 9, 16, 17, 18, 21 ]
gap> dec:= Filtered( dec, x -> x <> fail );;
gap> List( dec, r -> Length( r.irreducibles ) );
[ 61, 61, 63, 61, 61, 63, 61, 61, 61, 61 ]
gap> degreesum:= List( dec,
> r -> Sum( List( r.irreducibles, x -> x[1]^2 ) ) );;
gap> degreesumset:= Set( degreesum );
[ 4154780380522839827726467072000000, 4154781481226426191177580544000000 ]
gap> n:= Size( t ) - degreesumset;
[ 1100703586363451113472000000, 0 ]
gap> List( degreesumset, x -> Positions( degreesum, x ) );
[ [ 1, 2, 4, 5, 7, 8, 9, 10 ], [ 3, 6 ] ]
gap> dec:= dec{ Positions( degreesum, degreesumset[1] ) };;
gap> red:= List( dec, r -> Reduced( 2t, r.irreducibles, testind ) );;
gap> norm2:= List( red, r -> First( r.remainders,
> x -> ScalarProduct( 2t, x, x ) = 2 ) );;
gap> Length( Set( norm2 ) );
1
gap> norm2[1][1] = Sqrt( 2 * n[1] );
true
##
gap> good2[1].choice;
[ 45, 53, 127 ]
gap> 2tfust:= GetFusionMap( good2[2].table, t );;
gap> pos:= Union( Positions( 2tfust, 45 ), Positions( 2tfust, 127 ) );
[ 57, 165 ]
gap> 2t:= good2[1].table;;
gap> 2tfust:= GetFusionMap( 2t, t );;
gap> 2thfus2t:= good2[1].2thfus2t;;
gap> 2sfus2t:= good2[1].2sfus2t;;
gap> ind:= good2[1].ind;;
gap> factirr:= List( Irr( t ), x -> x{ 2tfust } );;
gap> UniteSet( mustsplit, good2[1].choice );
gap> spl:= SortedList( Concatenation( [ 1 .. 247 ], pos ) );;
gap> testind:= Concatenation( good2[1].ind,
> List( Concatenation( indcyc, indcyc40r5 ), x -> x{ spl } ) );;
gap> lll:= LLL( 2t, testind, 99/100 );;
gap> Length( lll.norms );
65
gap> Length( mustsplit );
65
gap> Length( Difference( [ 1 .. NrConjugacyClasses( t ) ],
> Union( mustsplit, mustnotsplit ) ) );
12
gap> gram:= MatScalarProducts( 2t, lll.remainders, lll.remainders );;
gap> emb:= OrthogonalEmbeddings( gram, 65+12 );;
gap> List( emb.solutions, Length );
[ 66, 66, 66, 66, 66, 66, 66, 66, 66, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67,
67, 67, 67, 67, 67, 67, 67, 67, 68, 68, 68, 69, 69, 69, 69, 69, 69, 69, 69,
69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 71, 71, 71 ]
gap> dec:= List( emb.solutions,
> x -> Decreased( 2t, lll.remainders, emb.vectors{ x } ) );;
gap> Positions( dec, fail );
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 33,
34, 35, 36, 45, 46, 47, 48, 51 ]
gap> dec:= Filtered( dec, x -> x <> fail );;
gap> List( dec, r -> Length( r.irreducibles ) );
[ 63, 63, 63, 61, 61, 61, 63, 61, 61, 61, 63, 63, 63, 61, 61, 61, 63, 61, 61,
61, 61, 61 ]
gap> degreesum:= List( dec,
> r -> Sum( List( r.irreducibles, x -> x[1]^2 ) ) );;
gap> degreesumset:= Set( degreesum );
[ 4154780380522839827726467072000000, 4154781481226426191177580544000000 ]
gap> Size( t ) - degreesumset;
[ 1100703586363451113472000000, 0 ]
gap> Positions( degreesum, degreesumset[2] );
[ 1, 2, 3, 7, 11, 12, 13, 17 ]
gap> dec:= dec{ Positions( degreesum, degreesumset[1] ) };;
gap> red:= List( dec, r -> Reduced( 2t, r.irreducibles, testind ) );;
gap> norm2:= List( red, r -> First( r.remainders,
> x -> ScalarProduct( 2t, x, x ) = 2 ) );;
gap> Length( Set( norm2 ) );
1
gap> norm2[1][1];
0
##
gap> testind:= Concatenation( good2[1].ind,
> List( Concatenation( indcyc, indcyc40i5 ), x -> x{ spl } ) );;
gap> lll:= LLL( 2t, testind, 99/100 );;
gap> gram:= MatScalarProducts( 2t, lll.remainders, lll.remainders );;
gap> emb:= OrthogonalEmbeddings( gram, 65+12 );;
gap> List( emb.solutions, Length );
[ 66, 66, 66, 66, 66, 66, 66, 66, 66, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67,
67, 67, 67, 67, 67, 67, 67, 67, 68, 68, 68, 69, 69, 69, 69, 69, 69, 69, 69,
69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 71, 71, 71 ]
gap> dec:= List( emb.solutions,
> x -> Decreased( 2t, lll.remainders, emb.vectors{ x } ) );;
gap> Positions( dec, fail );
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 24, 25, 26, 27, 28, 29, 30, 33,
34, 35, 36, 45, 46, 47, 48, 51 ]
gap> dec:= Filtered( dec, x -> x <> fail );;
gap> List( dec, r -> Length( r.irreducibles ) );
[ 63, 63, 63, 61, 61, 61, 63, 61, 61, 61, 63, 63, 63, 61, 61, 61, 63, 61, 61,
61, 61, 61 ]
gap> degreesum:= List( dec,
> r -> Sum( List( r.irreducibles, x -> x[1]^2 ) ) );;
gap> degreesumset:= Set( degreesum );
[ 4154780380522839827726467072000000, 4154781481226426191177580544000000 ]
gap> Size( t ) - degreesumset;
[ 1100703586363451113472000000, 0 ]
gap> Positions( degreesum, degreesumset[2] );
[ 1, 2, 3, 7, 11, 12, 13, 17 ]
gap> dec:= dec{ Positions( degreesum, degreesumset[1] ) };;
gap> red:= List( dec, r -> Reduced( 2t, r.irreducibles, testind ) );;
gap> norm2:= List( red, r -> First( r.remainders,
> x -> ScalarProduct( 2t, x, x ) = 2 ) );;
gap> Length( Set( norm2 ) );
1
gap> norm2[1][1];
0
##
gap> STOP_TEST( "ctblatlas.tst" );
#############################################################################
##
#E
