Spracherkennung für: .gi vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]
#############################################################################
##
## young.gi The SpinSym Package Lukas Maas
##
## Character tables of maximal Young subgroups of 2.Sym(n) and 2.Alt(n)
## Copyright (C) 2012 Lukas Maas
##
#############################################################################
## @Thomas:
## CharacterTable( "DoubleCoverMaximalYoungSubgroup", k, l )
## CharacterTable( "DoubleCoverMaximalYoungSubgroupSymmetric", k, l )
## CharacterTable( "DoubleCoverMaximalYoungSubgroupAlternatingSymmetric", k, l )
## CharacterTable( "DoubleCoverMaximalYoungSubgroupSymmetricAlternating", k, l )
## CharacterTable( "DoubleCoverMaximalYoungSubgroupAlternating", k, l )
#############################################################################
## returns true if the preimage of the conjugacy class
## of type <clpar> = [ pi, tau ] in Alt(k) x Alt(l)
## splits into a union of two distinct classes in
## 2.(Alt(k) x Alt(l)), false otherwise.
BindGlobal( "SPINSYM_YNG_IsSplitAA", function( clpar )
local c1, c2;
c1:= Filtered( Flat( clpar[1] ), IsInt );
c2:= Filtered( Flat( clpar[2] ), IsInt );
return ( SPINSYM_IsAPO( c1 ) or SPINSYM_IsAPD( c1 ) )
and ( SPINSYM_IsAPO( c2 ) or SPINSYM_IsAPD( c2 ) );
end );
## returns true if the preimage of the conjugacy class
## of type <clpar> = [ pi, tau ] in Alt(k) x Sym(l)
## splits into a union of two distinct classes in
## 2.(Alt(k) x Sym(l)), false otherwise.
BindGlobal( "SPINSYM_YNG_IsSplitAS", function( clpar )
local c1;
c1:= Filtered( Flat( clpar[1] ), IsInt );
# clpar[1] might contain '+' or '-'
return ( SPINSYM_IsAPO( c1 ) or SPINSYM_IsAPD( c1 ) )
and ( SPINSYM_IsAPO( clpar[2] ) or
( SPINSYM_IsAPD( clpar[2] ) and
SignPartition( clpar[2] ) = -1 ) );
end );
## returns true if the preimage of the conjugacy class
## of type <clpar> = [ pi, tau ] in Sym(k) x Alt(l)
## splits into a union of two distinct classes in
## 2.(Sym(k) x Alt(l)), false otherwise.
BindGlobal( "SPINSYM_YNG_IsSplitSA", function( clpar )
local c2;
c2:= Filtered( Flat( clpar[2] ), IsInt );
# clpar[2] might contain '+' or '-'
return ( SPINSYM_IsAPO( c2 ) or SPINSYM_IsAPD( c2 ) )
and ( SPINSYM_IsAPO( clpar[1] ) or
( SPINSYM_IsAPD( clpar[1] ) and
SignPartition( clpar[1] ) = -1 ) );
end );
## returns true if the preimage of the conjugacy class
## of type <clpar> = [ pi, tau ] in Sym(k) x Sym(l)
## splits into a union of two distinct classes in
## 2.(Sym(k) x Sym(l)), false otherwise.
BindGlobal( "SPINSYM_YNG_IsSplitSS", function( clpar )
local sgn1, sgn2;
if SPINSYM_IsAPO( clpar[1] ) and SPINSYM_IsAPO( clpar[2] ) then
return true;
elif SPINSYM_IsAPD( clpar[1] ) and SPINSYM_IsAPD( clpar[2] ) then
sgn1:= SignPartition( clpar[1] );
sgn2:= SignPartition( clpar[2] );
return Set( [sgn1,sgn2] ) = [-1,1];
else
return false;
fi;
end );
## just a wrapping function
BindGlobal( "SPINSYM_YNG_IsSplit", function( clpar, type )
if type = "AA" then
return SPINSYM_YNG_IsSplitAA( clpar );
elif type = "AS" then
return SPINSYM_YNG_IsSplitAS( clpar );
elif type = "SA" then
return SPINSYM_YNG_IsSplitSA( clpar );
else
return SPINSYM_YNG_IsSplitSS( clpar );
fi;
end );
## SPINSYM_YNG_OrderOfProductOfDisjointSchurLifts( cl1, cl2, o1, o2 )
## cl1 : partition of k
## cl2 : partition of l
## o1 : order of first standard representative t1 of type cl1
## o2 : order of first standard representative t2 of type cl2
## returns the order of the element t1*t2 in 2.(Sym(k) x Sym(l))
InstallGlobalFunction(
SPINSYM_YNG_OrderOfProductOfDisjointSchurLifts,
function( cl1, cl2, o1, o2 )
local c1, c2, cl, m, i, mo, m4;
# remove possible '+' or '-' from cl1 and cl2
c1:= Filtered( Flat( cl1 ), IsInt );
c2:= Filtered( Flat( cl2 ), IsInt );
cl:= Concatenation( c1, c2 );
m:= 1;
for i in [1..Length(cl)] do
m:= LcmOp( Integers, m, cl[i] );
od;
# now m is the l.c.m. of the orders of images of the
# Schur lifts of type cl1 and cl2 in Sym(n)
mo:= [ m mod o1, m mod o2 ];
if SignPartition(c1) = -1 and SignPartition(c2) = -1 then
# c1 and c2 are odd
m4:= m mod 4;
if m4 in [0,1] then
if mo = [0,0] or not 0 in mo then
return m;
else
return 2*m;
fi;
else # m4 = 2 or 3
if mo <> [0,0] and 0 in mo then
return m;
else
return 2*m;
fi;
fi;
else
if mo = [0,0] or not 0 in mo then
return m;
else
return 2*m;
fi;
fi;
end );
## SPINSYM_YNG_HEAD( k, l, type [, CT1, CT2] )
## k : an integer greater than 1
## l : an integer greater than 1
## type : a string "AA", "AS", "SA", or "SS"
## returns the 'head' of an ordinary character table of
## 2.(Alt(k) x Alt(l)), 2.(Alt(k) x Sym(l)), 2.(Sym(k) x Alt(l)),
## or 2.(Sym(k) x Sym(l)), respectively, depending on the value
## of type.
## The appropriate ordinary character tables of 2.Alt(k), 2.Alt(l),
## 2.Sym(k), or 2.Sym(l) may be given as optional arguments CT1, CT2.
InstallGlobalFunction( SPINSYM_YNG_HEAD,
function( arg )
local k, l, type,
tbl, # the table head that will be returned
NAME, name, # identifiers of 2.(X1 x X2) and X1 x X2
CT1, CT2, # generic character tables of 2.X1 and 2.X2
CCL1, ccl1, CCL2, ccl2, CCL, # class parameters
CEN1, cen1, CEN2, cen2, CEN, # sizes of centralizers
ORD1, ORD2, o1, o2, ORD, # orders of class reps
NR1, nr1, NR2, nr2, NR, # counter
FUS, # fusion map from 2.(X1 x X2) onto X1 x X2
ORIGIN, pos1, pos2, split1, split2,
1ST, 2ND, i, j, cl1, cl2, c, info;
k:= arg[ 1 ];
l:= arg[ 2 ];
type:= arg[ 3 ];
if type = "AA" then
NAME:= Concatenation( "2.(Alt(", String(k),
")xAlt(", String(l), "))" );
name:= Concatenation( "Alt(", String(k),
")xAlt(", String(l), ")" );
if Length( arg ) = 5 then
CT1:= arg[ 4 ];
CT2:= arg[ 5 ];
else
CT1:= CharacterTable( "DoubleCoverAlternating", k );
CT2:= CharacterTable( "DoubleCoverAlternating", l );
fi;
elif type = "AS" then
NAME:= Concatenation( "2.(Alt(", String(k),
")xSym(", String(l), "))" );
name:= Concatenation( "Alt(", String(k),
")xSym(", String(l), ")" );
if Length( arg ) = 5 then
CT1:= arg[ 4 ];
CT2:= arg[ 5 ];
else
CT1:= CharacterTable( "DoubleCoverAlternating", k );
CT2:= CharacterTable( "DoubleCoverSymmetric", l );
fi;
elif type = "SA" then
NAME:= Concatenation( "2.(Sym(", String(k),
")xAlt(", String(l), "))" );
name:= Concatenation( "Sym(", String(k),
")xAlt(", String(l), ")" );
if Length( arg ) = 5 then
CT1:= arg[ 4 ];
CT2:= arg[ 5 ];
else
CT1:= CharacterTable( "DoubleCoverSymmetric", k );
CT2:= CharacterTable( "DoubleCoverAlternating", l );
fi;
elif type = "SS" then
NAME:= Concatenation( "2.(Sym(", String(k),
")xSym(", String(l), "))" );
name:= Concatenation( "Sym(", String(k),
")xSym(", String(l), ")" );
if Length( arg ) = 5 then
CT1:= arg[ 4 ];
CT2:= arg[ 5 ];
else
CT1:= CharacterTable( "DoubleCoverSymmetric", k );
CT2:= CharacterTable( "DoubleCoverSymmetric", l );
fi;
fi;
tbl:= ConvertToCharacterTableNC(
rec( UnderlyingCharacteristic:= 0 ) );
SetIdentifier( tbl, NAME );
SetSize( tbl, Size( CT1 ) * Size( CT2 ) / 2 );
CCL1:= ClassParameters( CT1 );
CCL2:= ClassParameters( CT2 );
NR1:= NrConjugacyClasses( CT1 );
NR2:= NrConjugacyClasses( CT2 );
CEN1:= SizesCentralizers( CT1 );
CEN2:= SizesCentralizers( CT2 );
ORD1:= OrdersClassRepresentatives( CT1 );
ORD2:= OrdersClassRepresentatives( CT2 );
# collect data of the factor group X_i from 2.X_i for i=1,2
cen1:= [];
ccl1:= [];
nr1:= 0;
pos1:= [];
split1:= [];
for i in [ 1 .. NR1 ] do
if CCL1[i][1] = 1 then
nr1:= nr1 + 1;
pos1[ nr1 ]:= i;
ccl1[ nr1 ]:= CCL1[i][2];
cen1[ nr1 ]:= CEN1[i];
split1[ nr1 ]:= false;
else # CCL1[i][1] = 2
cen1[ nr1 ]:= CEN1[i] / 2;
split1[ nr1 ]:= true;
fi;
od;
cen2:= [];
ccl2:= [];
nr2:= 0;
pos2:= [];
split2:= [];
for i in [ 1 .. NR2 ] do
if CCL2[i][1] = 1 then
nr2:= nr2 + 1;
pos2[ nr2 ]:= i;
ccl2[ nr2 ]:= CCL2[i][2];
cen2[ nr2 ]:= CEN2[i];
split2[ nr2 ]:= false;
else # CCL2[i][1] = 2
cen2[ nr2 ]:= CEN2[i] / 2;
split2[ nr2 ]:= true;
fi;
od;
# classes, centralizers and fusion map
CCL:= [];
NR:= 0;
CEN:= [];
ORD:= [];
FUS:= [];
1ST:= [];
2ND:= [];
ORIGIN:= [];
for i in [ 1 .. nr1 ] do
for j in [ 1 .. nr2 ] do
NR:= NR + 1;
cl1:= ccl1[i];
cl2:= ccl2[j];
CCL[ NR ]:= [ 1, [ cl1, cl2 ] ];
Add( 1ST, NR );
FUS[ NR ]:= Length( 1ST );
ORIGIN[ NR ]:= [ i, j ];
o1:= ORD1[ pos1[i] ];
o2:= ORD2[ pos2[j] ];
ORD[ NR ]:= SPINSYM_YNG_OrderOfProductOfDisjointSchurLifts(
cl1, cl2, o1, o2 );
c:= cen1[i] * cen2[j];
if SPINSYM_YNG_IsSplit( [ cl1, cl2 ], type ) then
c:= 2 * c;
CEN[ NR ]:= c;
FUS[ NR + 1 ]:= FUS[ NR ];
NR:= NR + 1;
CCL[ NR ]:= [ 2, [ cl1, cl2 ] ];
Add( 2ND, NR );
ORIGIN[ NR ]:= [ i, j ];
# determine order of (zx)y or x(zy)
if split1[i] then
o1:= ORD1[ pos1[i] + 1 ];
ORD[ NR ]:= SPINSYM_YNG_OrderOfProductOfDisjointSchurLifts(
cl1, cl2, o1, o2 );
elif split2[j] then
o2:= ORD2[ pos2[j]+1 ];
ORD[ NR ]:= SPINSYM_YNG_OrderOfProductOfDisjointSchurLifts(
cl1, cl2, o1, o2 );
fi;
fi;
CEN[ NR ]:= c;
od;
od;
SetClassParameters( tbl, CCL );
SetNrConjugacyClasses( tbl, NR );
SetSizesCentralizers( tbl, CEN );
SetOrdersClassRepresentatives( tbl, ORD );
SetComputedClassFusions( tbl, [ rec( name:= name, map:= FUS ) ] );
# keep some information on the ingredients
info:= rec( k:= k,
l:= l,
type:= type,
ORIGIN:= ORIGIN,
pos1:= pos1,
pos2:= pos2,
nr1:= nr1,
nr2:= nr2,
1ST:= 1ST,
2ND:= 2ND );
if type <> "SS" then
SetSpinSymIngredients( tbl, [ CT1, CT2, info ] );
else
SetSpinSymIngredients( tbl, [ CT1, CT2, info,
CharacterTable( "DoubleCoverAlternating", k ),
CharacterTable( "DoubleCoverAlternating", l ) ] );
fi;
return tbl;
end );
## SPINSYM_YNG_HEADREG( tbl, p )
## tbl : an ordinary character table constructed by
## SpinSymCharacterTableOfMaximalYoungSubgroup
## p : an odd rational prime
## returns the head of the p-regular part of tbl
InstallGlobalFunction( SPINSYM_YNG_HEADREG,
function( tbl, p )
local CT1, CT2, info, AT1, AT2,
modtbl, fus, ccl, i;
CT1:= SpinSymIngredients( tbl )[ 1 ] mod p;
CT2:= SpinSymIngredients( tbl )[ 2 ] mod p;
info:= ShallowCopy( SpinSymIngredients( tbl )[ 3 ] );
if info.type = "SS" then
AT1:= SpinSymIngredients( tbl )[ 4 ] mod p;
AT2:= SpinSymIngredients( tbl )[ 5 ] mod p;
else AT1:= false; AT2:= false; fi;
if CT1 = fail or CT2 = fail
or AT1 = fail or AT2 = fail then
Error( "missing Brauer tables; " );
return fail;
fi;
modtbl:= ConvertToCharacterTableNC(
rec( UnderlyingCharacteristic:= p,
OrdinaryCharacterTable:= tbl ) );
SetSize( modtbl, Size( tbl ) );
fus:= Filtered( [ 1 .. NrConjugacyClasses( tbl ) ],
i-> OrdersClassRepresentatives( tbl )[i] mod p <> 0 );
StoreFusion( modtbl, fus, tbl );
Unbind( info.ORIGIN );
info.pos1:= Positions( List( ClassParameters( CT1 ),
x-> x[1] ), 1 );
info.pos2:= Positions( List( ClassParameters( CT2 ),
x-> x[1] ), 1 );
info.nr1:= Length( info.pos1 );
info.nr2:= Length( info.pos2 );
ccl:= ClassParameters( tbl ){ fus };
SetClassParameters( modtbl, ccl );
info.1ST:= [ ];
info.2ND:= [ ];
for i in [ 1 .. NrConjugacyClasses( modtbl ) ] do
if ccl[ i ][ 1 ] = 1 then
Add( info.1ST, i );
else
Add( info.2ND, i );
fi;
od;
if info.type <> "SS" then
SetSpinSymIngredients( modtbl, [ CT1, CT2, info ] );
else
SetSpinSymIngredients( modtbl, [ CT1, CT2, info, AT1, AT2 ] );
fi;
return modtbl;
end );
## SPINSYM_YNG_POWERMAPS( tbl )
## tbl : the character table head returned by
## SPINSYM_YNG_HEAD( k, l, type )
## computes the p-powermaps for all primes p <= k+l
## and sets the attribute ComputedPowerMaps( tbl )
InstallGlobalFunction( SPINSYM_YNG_POWERMAPS,
function( tbl )
local POW1, POW2, info, k, l, pprimepowermap,
res, CLPAR, signs, pow, p, powk, powl,
cl, cl1, cl2, pos, i, c, d, j1, j2;
if not HasSpinSymIngredients( tbl ) then
Error( "the ingredients of <tbl> must be known; " );
return;
fi;
# shortcuts
POW1:= ComputedPowerMaps( SpinSymIngredients( tbl )[1] );
POW2:= ComputedPowerMaps( SpinSymIngredients( tbl )[2] );
info:= SpinSymIngredients( tbl )[3];
k:= info.k;
l:= info.l;
pprimepowermap:= function( irr, p )
# returns the p-powermap when p is
# coprime to the group order
local n, trans1, trans2, perm;
n:= Length(irr);
trans1:= List( [1..n], i-> irr{[1..n]}[i] );
trans2:= GaloisCyc( trans1, p );
perm:= PermListList( trans2, trans1 );
return Permuted( [1..n], perm );
end;
res:= function( cl, clpar )
# returns the position of the Sym-class parameter
# cl in a list of Alt-class parameters
if SPINSYM_IsAPO( cl ) and SPINSYM_IsAPD( cl ) then
# cl splits in Alt()
return Position( clpar, [ 1, [ cl, '+' ] ] );
else
return Position( clpar, [ 1, cl ] );
fi;
end;
CLPAR:= ClassParameters( tbl );
signs:= List( CLPAR,
x-> [ SignPartition(Filtered( Flat( x[2][1] ), IsInt )),
SignPartition(Filtered( Flat( x[2][2] ), IsInt )) ] );
pow:= [];
for p in Set( FactorsInt( Size( tbl ) ) ) do
if p > k then
POW1[ p ]:= pprimepowermap( Irr( SpinSymIngredients( tbl )[1] ), p );
fi;
if p > l then
POW2[ p ]:= pprimepowermap( Irr( SpinSymIngredients( tbl )[2] ), p );
fi;
pow[ p ]:= [ ];
powk:= POW1[ p ];
powl:= POW2[ p ];
for i in [ 1 .. NrConjugacyClasses( tbl ) ] do
cl:= CLPAR[i];
if cl[1] = 1 or p = 2 then
c:= 1;
else
c:= -1;
fi;
if signs[i][1] = -1 and signs[i][2] = -1
and ( p = 2 or p mod 4 = 3 ) then
c:= -c;
fi;
j1:= powk[ info.pos1[ info.ORIGIN[i][1] ] ];
j2:= powl[ info.pos2[ info.ORIGIN[i][2] ] ];
cl1:= ClassParameters( SpinSymIngredients( tbl )[1] )[j1];
cl2:= ClassParameters( SpinSymIngredients( tbl )[2] )[j2];
if cl1[1] <> cl2[1] then
c:= -c;
fi;
if info.type <> "SS" then
pos:= fail;
if c = -1 then
pos:= Position( CLPAR, [ 2, [ cl1[2], cl2[2] ] ] );
fi;
if c = 1 or pos = fail then
pos:= Position( CLPAR, [ 1, [ cl1[2], cl2[2] ] ] );
fi;
Add( pow[p], pos );
else # SS
signs[i][1]:= SignPartition( cl1[2] );
signs[i][2]:= SignPartition( cl2[2] );
if signs[i][1] = -1 and signs[i][2] = 1 then
# find cl2 in 2.Alt(l) = SpinSymIngredients( tbl )[5]
pos:= res( cl2[2], ClassParameters( SpinSymIngredients( tbl )[5] ) );
pos:= PowerMap( SpinSymIngredients( tbl )[5], p )[ pos ];
d:= ClassParameters( SpinSymIngredients( tbl )[5] )[ pos ];
if d[1] = 2 then
c:= -c;
fi;
if '-' in d[2] then
c:= -c;
fi;
elif signs[i][1] = 1 and signs[i][2] = -1 then
# find cl1 in 2.Alt(k) = SpinSymIngredients( tbl )[4]
pos:= res( cl1[2], ClassParameters( SpinSymIngredients( tbl )[4] ) );
pos:= PowerMap( SpinSymIngredients( tbl )[4], p )[ pos ];
d:= ClassParameters( SpinSymIngredients( tbl )[4] )[ pos ];
if d[1] = 2 then
c:= -c;
fi;
if '-' in d[2] then
c:= -c;
fi;
fi;
pos:= fail;
if c = -1 then
pos:= Position( CLPAR, [ 2, [ cl1[2], cl2[2] ] ] );
fi;
if c = 1 or pos = fail then
pos:= Position( CLPAR, [ 1, [ cl1[2], cl2[2] ] ] );
fi;
pow[ p ][ i ]:= pos;
fi;
od;
od;
SetComputedPowerMaps( tbl, pow );
end );
## SPINSYM_YNG_TSR( tbl, IRR1, IRR2, CHPAR1, CHPAR2, c, d )
## tbl : the character table head returned by
## SPINSYM_YNG_HEAD( k, l, type, CT1, CT2 )
## IRR1 : subset of (spin) characters of Irr( CT1 )
## IRR2 : subset of (spin) characters of Irr( CT2 )
## CHPAR1 : character parameters for the elements of IRR1
## CHPAR2 : character parameters for the elements of IRR2
## c : -1 if spin characters are handled, otherwise 1
## d : 2 if spin characters are handled, otherwise 1
## returns a record with components IRR and CHPAR
## containing irreducible (spin) characters of tbl and their
## parameters, respectively
InstallGlobalFunction( SPINSYM_YNG_TSR,
function( tbl, IRR1, IRR2, CHPAR1, CHPAR2, c, d )
# c = 1 (for non-spin chars) or -1 (for spin chars)
# and d = 1 or 2, respectively
local info, IRR, CHPAR, 1ST, 2ND, pos1, pos2, pos, T,
i1, i2, phi, psi, chi, nr, j1, j2;
info:= SpinSymIngredients( tbl )[3];
# irreducible characters and their parameters
IRR:= [];
CHPAR:= [];
1ST:= info.1ST;
2ND:= info.2ND;
pos1:= info.pos1;
pos2:= info.pos2;
pos:= List( 2ND, i-> i-1 );
T:= []; # information on the inertia subgroups (for type SS only)
for i1 in [ 1 .. Length( IRR1 ) ] do
for i2 in [ 1 .. Length( IRR2 ) ] do
phi:= IRR1[ i1 ];
psi:= IRR2[ i2 ];
chi:= [ ];
nr:= 0;
for j1 in pos1 do
for j2 in pos2 do
nr:= nr+1;
chi[ 1ST[ nr ] ]:= phi[ j1 ] * psi[ j2 ];
od;
od;
chi{ 2ND }:= c * chi{ pos };
Add( IRR, Character( tbl, chi ) );
Add( CHPAR, [ d, [ CHPAR1[ i1 ][ 2 ], CHPAR2[ i2 ][ 2 ] ] ] );
if info.type = "AAspinonly" then
Add( T, [ '+' in CHPAR1[ i1 ][ 2 ] or '-' in CHPAR1[ i1 ][ 2 ],
'+' in CHPAR2[ i2 ][ 2 ] or '-' in CHPAR2[ i2 ][ 2 ] ] );
fi;
od;
od;
if info.type = "AAspinonly" then
info.T:= T; # remember T for the construction of type SS
fi;
return rec( IRR:= IRR, CHPAR:= CHPAR );
end );
## SPINSYM_YNG_IND( tbl )
## tbl : the character table head returned by
## SPINSYM_YNG_HEAD( k, l, "SS" )
## returns a record with components IRR and CHPAR
## containing irreducible spin characters of tbl and
## their parameters, respectively
InstallGlobalFunction( SPINSYM_YNG_IND,
function( tbl )
local AA, AS, SA, FUS, fus, T,
rAS, rSA, inn, out, pos1,
IRR, CHPAR, c, d, irr,
i, j1, j2, j, pos;
AA:= SpinSymIngredients( tbl )[ 6 ];
AS:= SpinSymIngredients( tbl )[ 7 ];
SA:= SpinSymIngredients( tbl )[ 8 ];
# fusion maps
FUS:= SpinSymClassFusion2AAin2AS(
ClassParameters( AA ), ClassParameters( AS ) );
StoreFusion( AA, FUS, AS );
# restrict spin characters of AS to AA
rAS:= Irr( AS ){ [ 1 .. Length( Irr( AS ) ) ] }{ FUS };
fus:= SpinSymClassFusion2AAin2SA(
ClassParameters( AA ), ClassParameters( SA ) );
StoreFusion( AA, fus, SA );
# restrict spin characters of SA to AA
rSA:= Irr( SA ){ [ 1 .. Length( Irr( SA ) ) ] }{ fus };
FUS:= SpinSymClassFusion2ASin2SS(
ClassParameters( AS ), ClassParameters( tbl ) );
StoreFusion( AS, FUS, tbl );
FUS:= SpinSymClassFusion2SAin2SS(
ClassParameters( SA ), ClassParameters( tbl ) );
StoreFusion( SA, FUS, tbl );
FUS:= CompositionMaps( FUS, fus );
StoreFusion( AA, FUS, tbl );
T:= SpinSymIngredients( AA )[ 3 ].T;
# now T[i] = [ true, true ] means that T(chi)/AA = 1, i.e. T(chi)=AA
# now T[i] = [ true, false ] means that T(chi)/AA = <t2>, i.e. T(chi)=AS
# now T[i] = [ false, true ] means that T(chi)/AA = <t1>, i.e. T(chi)=SA
# now T[i] = [ false, false ] means that T(chi)/AA = <t1> x <t2>
inn:= []; # positions of inner classes, i.e. classes of AA in SS
out:= []; # positions of outer classes, i.e. classes of SS \ AA
pos1:= [];
IRR:= [];
CHPAR:=[];
for i in [ 1 .. NrConjugacyClasses( tbl ) ] do
c:= ClassParameters( tbl )[ i ][ 2 ];
if SignPartition( c[ 1 ] ) = 1 and SignPartition( c[ 2 ] ) = 1 then
Add( inn, i );
Add( pos1, Position( FUS, i ) );
else
Add( out, i );
fi;
od;
irr:= Irr( AA );
for i in [ 1 .. Length( T ) ] do
j1:= T[ i ][ 1 ];
j2:= T[ i ][ 2 ];
if j1 and j2 then
c:= InducedClassFunction( irr[ i ], tbl );
if not c in IRR then
Add( IRR, Character( tbl, c ) );
d:= CharacterParameters( AA )[ i ];
Add( CHPAR, [ 2, [ [ d[2][1][1], "+-" ], [ d[2][2][1], "+-" ] ] ] );
fi;
elif j1 and not j2 then
pos:= Positions( rAS, irr[ i ] );
for j in pos do
c:= InducedClassFunction( Irr( AS )[ j ], tbl );
if not c in IRR then
Add( IRR, Character( tbl, c ) );
d:= CharacterParameters( AS )[ j ];
Add( CHPAR, [ 2, [ d[2][1][1], d[2][2] ] ] );
fi;
od;
elif not j1 and j2 then
pos:= Positions( rSA, irr[ i ] );
for j in pos do
c:= InducedClassFunction( Irr( SA )[ j ], tbl );
if not c in IRR then
Add( IRR, Character( tbl, c ) );
d:= CharacterParameters( SA )[ j ];
Add( CHPAR, [ 2, [ d[2][1], d[2][2][1] ] ] );
fi;
od;
else
# chi=irr[i]^SS vanishes outside AA and its restriction
# to AA is 2*phi=2*irr[i]
c:= irr[ i ];
d:= [];
for j in out do
d[ j ]:= 0;
od;
for j in [ 1 .. Length( inn ) ] do
d[ inn[ j ] ]:= 2 * c[ pos1[ j ] ];
od;
c:= Character( tbl, d );
if not c in IRR then
Add( IRR, Character( tbl, c ) );
d:= CharacterParameters( AA )[ i ];
Add( CHPAR, [ 2, [ d[2][1], d[2][2] ] ] );
fi;
fi;
od;
return rec( IRR:= IRR, CHPAR:= CHPAR );
end );
## SPINSYM_YNG_IRR( tbl )
## constructs and stores the full set of irreducible
## characters of tbl and the corresponding parameters
InstallGlobalFunction( SPINSYM_YNG_IRR, function( tbl )
local info, IRR, CHPAR, IRR1, IRR2,
CHPAR1, CHPAR2, R, NR1, NR2,
p, ordtbl, AA, AS, SA;
info:= SpinSymIngredients( tbl )[ 3 ];
IRR:= [];
CHPAR:= [];
if not IsSubset( info.type, "spinonly" ) then
# get all irreducible (Brauer) characters
IRR1:= Irr( SpinSymIngredients( tbl )[1] ){ [ 1 .. info.nr1 ] };
IRR2:= Irr( SpinSymIngredients( tbl )[2] ){ [ 1 .. info.nr2 ] };
CHPAR1:= CharacterParameters( SpinSymIngredients( tbl )[1] ){ [ 1 .. info.nr1 ] };
CHPAR2:= CharacterParameters( SpinSymIngredients( tbl )[2] ){ [ 1 .. info.nr2 ] };
R:= SPINSYM_YNG_TSR( tbl, IRR1, IRR2, CHPAR1, CHPAR2, 1, 1 );
Append( IRR, R.IRR );
Append( CHPAR, R.CHPAR );
# now IRR contains all non-spin irreducibles
fi;
if info.type{[1,2]} <> "SS" then
# construct spin-characters (for type AA, AS, or SA)
NR1:= NrConjugacyClasses( SpinSymIngredients( tbl )[1] );
NR2:= NrConjugacyClasses( SpinSymIngredients( tbl )[2] );
IRR1:= Irr( SpinSymIngredients( tbl )[1] ){ [ info.nr1 + 1 .. NR1 ] };
IRR2:= Irr( SpinSymIngredients( tbl )[2] ){ [ info.nr2 + 1 .. NR2 ] };
CHPAR1:= CharacterParameters( SpinSymIngredients( tbl )[1] ){ [ info.nr1 + 1 .. NR1 ] };
CHPAR2:= CharacterParameters( SpinSymIngredients( tbl )[2] ){ [ info.nr2 + 1 .. NR2 ] };
R:= SPINSYM_YNG_TSR( tbl, IRR1, IRR2, CHPAR1, CHPAR2, -1, 2 );
Append( IRR, R.IRR );
Append( CHPAR, R.CHPAR );
# now IRR contains all spin irreducibles
else # type SS
# construct spin-characters of 2.(Sym(k)xSym(l))
p:= UnderlyingCharacteristic( tbl );
# we need some more ingredients:
# partial character tables of type AA, AS, SA
# (without power maps, spin chars only)
if p = 0 then
AA:= SPINSYM_YNG_HEAD( info.k, info.l, "AA" );
AS:= SPINSYM_YNG_HEAD( info.k, info.l, "AS",
SpinSymIngredients( AA )[1], # 2.Alt(k)
SpinSymIngredients( tbl )[2] ); # 2.Sym(l)
SA:= SPINSYM_YNG_HEAD( info.k, info.l, "SA",
SpinSymIngredients( tbl )[1], # 2.Sym(k)
SpinSymIngredients( AA )[2] ); # 2.Alt(l)
else
ordtbl:= OrdinaryCharacterTable( tbl );
AA:= SPINSYM_YNG_HEADREG( SpinSymIngredients( ordtbl )[ 6 ], p );
AS:= SPINSYM_YNG_HEADREG( SpinSymIngredients( ordtbl )[ 7 ], p );
SA:= SPINSYM_YNG_HEADREG( SpinSymIngredients( ordtbl )[ 8 ], p );
fi;
SpinSymIngredients( AA )[ 3 ].type:= "AAspinonly";
SPINSYM_YNG_IRR( AA );
SpinSymIngredients( AS )[ 3 ].type:= "ASspinonly";
SPINSYM_YNG_IRR( AS );
SpinSymIngredients( SA )[ 3 ].type:= "SAspinonly";
SPINSYM_YNG_IRR( SA );
SpinSymIngredients( tbl )[ 6 ]:= AA;
SpinSymIngredients( tbl )[ 7 ]:= AS;
SpinSymIngredients( tbl )[ 8 ]:= SA;
# now we are ready to construct the spin chars via
# inducing up to SS from AA (possibly along AS or SA)
R:= SPINSYM_YNG_IND( tbl );
Append( IRR, R.IRR );
Append( CHPAR, R.CHPAR );
fi;
SetIrr( tbl, IRR );
SetCharacterParameters( tbl, CHPAR );
return tbl;
end );
## SpinSymCharacterTableOfMaximalYoungSubgroup( k, l, type )
## k : an integer greater than 1
## l : an integer greater than 1
## type : a string "Alternating",
## "AlternatingSymmetric",
## "SymmetricAlternating", or
## "Symmetric"
## returns an ordinary character table of
## 2.(Alt(k) x Alt(l)), 2.(Alt(k) x Sym(l)), 2.(Sym(k) x Alt(l)),
## or 2.(Sym(k) x Sym(l)), respectively, depending on the value
## of type.
InstallGlobalFunction(
SpinSymCharacterTableOfMaximalYoungSubgroup,
function( k, l, type )
local tbl, ty;
if not IsInt(k) or not IsInt(l) or k < 2 or l < 2 then
Error( "both <k> and <l> must be integers greater than 1; " );
fi;
if type = "Alternating" then
ty:= "AA";
elif type = "AlternatingSymmetric" then
ty:= "AS";
elif type = "SymmetricAlternating" then
ty:= "SA";
elif type = "Symmetric" then
ty:= "SS";
else
Error( "<type> must be \"Alternating\", \"AlternatingSymmetric\",\
\"SymmetricAlternating\", or \"Symmetric\"; " );
return fail;
fi;
tbl:= SPINSYM_YNG_HEAD( k, l, ty );
SPINSYM_YNG_POWERMAPS( tbl );
SPINSYM_YNG_IRR( tbl );
SetFilterObj( tbl, IsSpinSymTable );
return tbl;
end );
#############################################################################
##
## taken from Thomas' ctadmin.tbi -- just a hack for the mod-2 case in order
## to deal with character parameters
## obsolete if Thomas agrees to add the part that is marked by #LM below
## to the original function
##
#F SPINSYM_BrauerTableFromLibrary( <ordtbl>, <prime> )
##
InstallGlobalFunction( SPINSYM_BrauerTableFromLibrary, function( ordtbl, prime )
local op, orders, nccl, entry, fusion, facttbl, mfacttbl, reg;
op:= ClassPositionsOfPCore( ordtbl, prime );
orders:= OrdersClassRepresentatives( ordtbl );
nccl:= NrConjugacyClasses( ordtbl );
for entry in ComputedClassFusions( ordtbl ) do
fusion:= entry.map;
if Filtered( [ 1 .. nccl ], i -> fusion[i] = 1 ) = op then
# We found the ordinary factor for which the Brauer characters
# are equal to the ones we need.
facttbl:= CharacterTableFromLibrary( entry.name );
if facttbl = fail then
return fail;
fi;
mfacttbl:= BrauerTable( facttbl, prime );
if mfacttbl = fail then
return fail;
fi;
# Now we set up a *new* Brauer table since the ordinary table
# as well as the blocks information for the factor group is
# different from the one for the extension.
reg:= CharacterTableRegular( ordtbl, prime );
# Set the irreducibles.
# Note that the ordering of classes is in general *not* the same,
# so we must translate with the help of fusion maps.
fusion:= CompositionMaps(
InverseMap( GetFusionMap( mfacttbl, facttbl ) ),
CompositionMaps( GetFusionMap( ordtbl, facttbl ),
GetFusionMap( reg, ordtbl ) ) );
SetIrr( reg, List( Irr( mfacttbl ),
chi -> Character( reg,
ValuesOfClassFunction( chi ){ fusion } ) ) );
# Set known attribute values that can be copied from `mfacttbl'.
if HasAutomorphismsOfTable( mfacttbl ) then
SetAutomorphismsOfTable( reg, AutomorphismsOfTable( mfacttbl )
^ Inverse( PermList( fusion ) ) );
fi;
if HasInfoText( mfacttbl ) then
SetInfoText( reg, InfoText( mfacttbl ) );
fi;
if HasComputedIndicators( mfacttbl ) then
SetComputedIndicators( reg, ComputedIndicators( mfacttbl ) );
fi;
#LM starts here
if HasCharacterParameters( mfacttbl ) then
SetCharacterParameters( reg, CharacterParameters( mfacttbl ) );
fi;
#LM ends here
# Return the table.
return reg;
fi;
od;
end );
#############################################################################
## SpinSymBrauerTableOfMaximalYoungSubgroup( ordtbl, p )
## ordtbl : an ordinary character table constructed by
## SpinSymCharacterTableOfMaximalYoungSubgroup
## p : a rational prime
## returns the p-modular character table of ordtbl
InstallGlobalFunction(
SpinSymBrauerTableOfMaximalYoungSubgroup,
function( ordtbl, p )
local modtbl, ct1, ct2, ct;
if not IsPrimeInt( p ) then
Error( "<p> must be a rational prime; " );
fi;
if not ( IsSpinSymTable( ordtbl ) and
IsOrdinaryTable( ordtbl ) ) then
Error( "<ordtbl> must be constructed by the function \
SpinSymCharacterTableOfMaximalYoungSubgroup(); " );
fi;
# CTblLib construction for p = 2
if p = 2 then
modtbl:= CharacterTableRegular( ordtbl, p );
SetClassParameters( modtbl,
ClassParameters( ordtbl ){ GetFusionMap( modtbl, ordtbl ) } );
##ct1:= SpinSymIngredients( ordtbl )[ 1 ] mod p;
##ct2:= SpinSymIngredients( ordtbl )[ 2 ] mod p;
## remove the following two lines and uncomment the previous ones
## as soon as the hack SPINSYM_BrauerTableFromLibrary disappears
ct1:= SPINSYM_BrauerTableFromLibrary( SpinSymIngredients( ordtbl )[ 1 ], p);
ct2:= SPINSYM_BrauerTableFromLibrary( SpinSymIngredients( ordtbl )[ 2 ], p);
if ct1 = fail or ct2 = fail then
return fail;
else
ct:= CharacterTableDirectProduct( ct1, ct2 );
SetIrr( modtbl, Irr( ct ) );
SetCharacterParameters( modtbl,
Cartesian( CharacterParameters( ct1 ),
CharacterParameters( ct2 ) ) );
return modtbl;
fi;
fi;
# for p > 2 use the SpinSym construction
if not HasSpinSymIngredients( ordtbl ) then
Error( "missing ingredients of <ordtbl>; " );
fi;
modtbl:= SPINSYM_YNG_HEADREG( ordtbl, p );
SPINSYM_YNG_IRR( modtbl );
Unbind( modtbl!.SpinSymIngredients );
return modtbl;
end );
## access the Brauer table via the `mod'-operator
InstallMethod( BrauerTableOp,
Concatenation( "for an ordinary character table created by ",
"SpinSymCharacterTableOfMaximalYoungSubgroup() and a positive ",
"rational prime") ,
[ IsSpinSymTable, IsPosInt ],
function( ordtbl, p )
return SpinSymBrauerTableOfMaximalYoungSubgroup( ordtbl, p );
end );
