-modular basic spin character of
InstallGlobalFunction( SpinSymBasicCharacter, function( modtbl )
local ccl, ords, rep;
ccl:= ClassParameters( modtbl );
ords:= OrdersClassRepresentatives( modtbl );
rep:= BasicSpinRepresentationOfSymmetricGroup( Sum( ccl[1][2] ),
UnderlyingCharacteristic( modtbl ) );
return SpinSymBrauerCharacter( ccl, ords, rep );
end );
## SPINSYM_Transposition( , , )
## returns the transposition t_, under the matrix representation
BindGlobal( "SPINSYM_Transposition",
function( i, j, rep )
local pos;
if i <= j then
pos:= [ i .. j-1 ];
Append( pos, Reversed( [ i .. j-2 ] ) );
else
pos:= [ j .. i-1 ];
Append( pos, Reversed( [ j .. i-2 ] ) );
fi;
return Product( rep{ pos } );
end );
## SPINSYM_DecompositionInTranspositions( )
## writes a permutation as a product of transpositions
##
## returns a list [ [i1,i2], [i3,i4], ... ] such that
## pi = (i1,i2)(i3,i4)...
BindGlobal( "SPINSYM_DecompositionInTranspositions",
function( pi )
local m, mp, pos, t, i, s, spos, j;
if pi = () then
return [];
fi;
m:= ListPerm( pi );
mp:= MovedPoints( pi );
pos:= List( mp, x-> Position( m, x ) );
t:= [];
while Length( pos ) > 1 do
i:= pos[1];
# get the orbit of pi starting from m[i]
s:= [];
spos:= [i];
j:= i;
while m[j] <> i do
j := m[j];
Add( s, [ i, j ] );
Add( spos, j );
od;
pos:= DifferenceLists( pos, spos );
Append( t, s );
od;
return t;
end );
## SpinSymPreimage( , )
## returns a (standard) preimage of the element of Sym(n)
## in 2.Sym(n) under the representation
## : an element of Sym(n)
## : a faithful representation of 2.Sym(n)
InstallGlobalFunction( SpinSymPreimage, function( pi, rep )
local trans, PI, ij;
trans:= SPINSYM_DecompositionInTranspositions( pi );
PI:= rep[1]^0;
for ij in trans do
PI:= PI * SPINSYM_Transposition( ij[1], ij[2], rep );
od;
return PI;
end );
spinsym-1.5.2/gap/fus.gi 0000644 0000766 0000024 00000042515 13544575277 014147 0 ustar mhorn staff #############################################################################
##
## fus.gi The SpinSym Package Lukas Maas
##
## Class fusion maps between some subgroups of 2.Sym(n)
## Copyright (C) 2012 Lukas Maas
##
#############################################################################
## SOURCE ................ DEST ................ FUNCTION
## 2.Alt(n) .............. 2.Sym(n) ............ SpinSymClassFusion2Ain2S
## 2.Sym(k) .............. 2.Sym(n) ............ SpinSymClassFusion2Sin2S
## 2.Alt(k) .............. 2.Alt(n) ............ SpinSymClassFusion2Ain2A
## 2.Sym(n-2) ............ 2.Alt(n) ............ SpinSymClassFusion2Sin2A
## 2.(Sym(k) x Sym(l)) ... 2.Sym(k+l) .......... SpinSymClassFusion2SSin2S
## 2.(Sym(k) x Alt(l)) ... 2.(Sym(k) x Sym(l)) . SpinSymClassFusion2SAin2SS
## 2.(Alt(k) x Sym(l)) ... 2.(Sym(k) x Sym(l)) . SpinSymClassFusion2ASin2SS
## 2.(Alt(k) x Alt(l)) ... 2.(Sym(k) x Alt(l)) . SpinSymClassFusion2AAin2SA
## 2.(Alt(k) x Alt(l)) ... 2.(Alt(k) x Sym(l)) . SpinSymClassFusion2AAin2AS
## 2.(Alt(k) x Alt(l)) ... 2.Alt(k+l) .......... SpinSymClassFusion2AAin2A
## for m=n,k,l we denote:
## Sym(m) .... Sm
## Alt(m) .... Am
## 2.Sym(m) .. 2Sm
## 2.Alt(m) .. 2Sm
#############################################################################
## HELPER FUNCTIONS
## SPINSYM_IsAPD( ) ....... { All Parts Distinct }
## INPUT .... a list of integers
## OUTPUT ... true iff has pairwise distinct entries
BindGlobal( "SPINSYM_IsAPD", function( tau )
return Length( Set( tau ) ) = Length( tau );
end );
## SPINSYM_IsAPO( ) ......... { All Parts Odd }
## INPUT .... a list of integers
## OUTPUT ... true iff all entries of are odd
BindGlobal( "SPINSYM_IsAPO", function( tau )
return ForAll( tau, IsOddInt );
end );
#############################################################################
## USER FUNCTIONS
## SpinSymClassFusion2Ain2S( , )
## INPUT .... class parameters of 2.Alt(n)
## .......... class parameters of 2.Sym(n)
## see \cite{Maas2011}*{(5.4.1)}
InstallGlobalFunction( SpinSymClassFusion2Ain2S, function( cclX, cclY )
local fus, x, y, z;
fus:= [];
for x in cclX do
if '+' in x[2] or '-' in x[2] then
y:= x[2][1];
else
y:= x[2];
fi;
if SPINSYM_IsAPO( y ) and SPINSYM_IsAPD( y ) then
## y in O(n)\cap D^+(n):
## +\- split classes of corresponding type (1\2) fuse in 2.Sym(n)
z:= [ x[1], y ];
elif SPINSYM_IsAPO(y) then
## y in O(n) but not in D^+(n):
## there is a class in 2.Sym(n) of corresponding type (1\2)
z:= [ x[1], y ];
else
## y in D^+(n) but not in O(n), or y is not in O(n)\cup D(n):
## either the classes of type 1 and 2 fuse in 2.Sym(n),
## or there is only one class of type 1 in both 2.Alt(n) and 2.Sym(n)
z:= [ 1, y ];
fi;
Add( fus, Position( cclY, z ) );
od;
return fus;
end );
## SpinSymClassFusion2Sin2S( , )
## INPUT .... class parameters of 2.Sym(k)
## .......... class parameters of 2.Sym(n) for k, )
## INPUT .... class parameters of 2.Alt(k)
## .......... class parameters of 2.Alt(n) for knot IsChar(y)));
end;
m:= Sum( filt(cclY[1][2]) ) - Sum( filt(cclX[1][2]) );
m:= ListWithIdenticalEntries( m, 1 );
fus:= [ ];
for x in cclX do
if '+' in x[2] or '-' in x[2] then
y:= Concatenation( x[2][1], m );
else
y:= Concatenation( x[2], m );
fi;
if SPINSYM_IsAPO( y ) and SPINSYM_IsAPD( y ) then
## k = n-1 and 1 is not a part of x:
## then 1\2_x+- of 2.Alt(k) corresponds to 1\2_y+- in 2.Alt(n)
z:= [ x[1], [ y, x[2][2] ] ];
elif SPINSYM_IsAPO( y ) or SPINSYM_IsAPD( y ) then
## y is a 1\2 split class in 2.Alt(n);
## the +\- split classes fuse in 2.Alt(n) in correspondence with their type 1\2
z:= [ x[1], y ];
else
z:= [ 1, y ];
fi;
Add( fus, Position( cclY, z ) );
od;
return fus;
end );
## SpinSymClassFusion2Sin2A( , )
## INPUT .... class parameters of 2.Sym(n-2)
## .......... class parameters of 2.Alt(n)
## see \cite{Maas2011}*{(5.4.4)}
InstallGlobalFunction( SpinSymClassFusion2Sin2A, function( cclX, cclY )
local fus, x, y, z;
fus:= [];
for x in cclX do
y:= x[2];
if SignPartition( y ) = 1 then
z:= Concatenation( y, [1,1] );
if SPINSYM_IsAPO( y ) then
z:= [ x[1], z ];
else
z:= [ 1, z ];
fi;
else ## SignPartition( y ) = -1
z:= Reversed( SortedList( Concatenation( y, [2] ) ) );
if SPINSYM_IsAPD( y ) and not 2 in y then
z:= [ x[1], z ];
else
z:= [ 1, z ];
fi;
fi;
Add( fus, Position( cclY, z ) );
od;
return fus;
end );
## SpinSymClassFusion2SSin2S( , )
## INPUT .... class parameters of 2.(Sym(k) x Sym(l))
## .......... class parameters of 2.Sym(n) for n=k+l
## see \cite{Maas2011}*{(5.4.5)}
InstallGlobalFunction( SpinSymClassFusion2SSin2S, function( cclX, cclY )
local fus, x, pi, tau, mu, y, pi_o, pi_e, tau_o, tau_e, o, e, s;
fus:= [];
for x in cclX do
pi:= x[2][1];
tau:= x[2][2];
mu:= Reversed( SortedList( Concatenation( pi, tau ) ) );
if SPINSYM_IsAPO( mu ) then
y:= [ x[1], mu ];
elif SPINSYM_IsAPD( mu ) and SignPartition( mu ) = -1 then
pi_o:= Filtered( pi, k-> k mod 2 = 1 );
pi_e:= Filtered( pi, k-> k mod 2 = 0 );
tau_o:= Filtered( tau, k-> k mod 2 = 1 );
tau_e:= Filtered( tau, k-> k mod 2 = 0 );
## number of shuffles (i,j) -> (j,i) with i=j=1 mod 2:
o:= List( tau_o, i-> Number( pi_o, j-> j (j,i) with i=j=0 mod 2:
e:= List( tau_e, i-> Number( pi_e, j-> j, )
## INPUT .... class parameters of 2.(Sym(k) x Alt(l))
## .......... class parameters of 2.(Sym(k) x Sym(l))
## see \cite{Maas2011}*{(5.4.6)}
InstallGlobalFunction( SpinSymClassFusion2SAin2SS, function( cclX, cclY )
local fus, x, pi, xtau, tau, y;
fus:= [];
for x in cclX do
pi:= x[2][1];
xtau:= x[2][2];
if '+' in xtau or '-' in xtau then
tau:= xtau[1];
else
tau:= xtau;
fi;
if SPINSYM_IsAPO( pi ) and SPINSYM_IsAPO( tau ) then
if not SPINSYM_IsAPD( tau ) then
## (pi,tau) is in O(k) x (O(l)\D^+(l))
y:= [ x[1], [ pi, tau ] ];
else
## (pi,tau) is in O(k) x (O(l)\cap D^+(l))
if '+' in xtau then
y:= [ x[1], [ pi, tau ] ];
else ## '-' in xtau
y:= [ x[1], [ pi, tau ] ]; ## since pi is even
fi;
fi;
elif SPINSYM_IsAPD( pi ) and SignPartition( pi ) = -1 and SPINSYM_IsAPD( tau ) then
## now (pi,tau) is in D(k)^- x D^+(k)
if not SPINSYM_IsAPO( tau ) then
y:= [ x[1], [ pi, tau ] ];
else
## (pi,tau) is in D^-(k) x (O(l)\cap D^+(l))
if '+' in xtau then
y:= [ x[1], [ pi, tau ] ];
else ## '-' in xtau
y:= [ x[1] mod 2 + 1, [ pi, tau ] ]; ## since pi is odd
fi;
fi;
else
## (pi,tau) is not split in 2.(Sym(k) x Sym(l))
y:= [ 1, [ pi, tau ] ];
fi;
Add( fus, Position( cclY, y ) );
od;
return fus;
end );
## SpinSymClassFusion2ASin2SS( , )
## INPUT .... class parameters of 2.(Alt(k) x Sym(l))
## .......... class parameters of 2.(Sym(k) x Sym(l))
InstallGlobalFunction( SpinSymClassFusion2ASin2SS, function( cclX, cclY )
local fus, x, xpi, pi, tau, y;
fus:= [];
for x in cclX do
xpi:= x[2][1];
tau:= x[2][2];
if '+' in xpi or '-' in xpi then
pi:= xpi[1];
else
pi:= xpi;
fi;
if SPINSYM_IsAPO( pi ) and SPINSYM_IsAPO( tau ) then
if not SPINSYM_IsAPD( pi ) then
y:= [ x[1], [ pi, tau ] ];
else
if '+' in xpi then
y:= [ x[1], [ pi, tau ] ];
else ## '-' in xpi
y:= [ x[1], [ pi, tau ] ];
fi;
fi;
elif SPINSYM_IsAPD( pi ) and SPINSYM_IsAPD( tau ) and SignPartition( tau ) = -1 then
if not SPINSYM_IsAPO( pi ) then
y:= [ x[1], [ pi, tau ] ];
else
if '+' in xpi then
y:= [ x[1], [ pi, tau ] ];
else ## '-' in xpi
y:= [ x[1] mod 2 + 1, [ pi, tau ] ];
fi;
fi;
else
y:= [ 1, [ pi, tau ] ];
fi;
Add( fus, Position( cclY, y ) );
od;
return fus;
end );
## SpinSymClassFusion2AAin2SA( , )
## INPUT .... class parameters of 2.(Alt(k) x Alt(l))
## .......... class parameters of 2.(Sym(k) x Alt(l))
## see \cite{Maas2011}*{(5.4.7)}
InstallGlobalFunction( SpinSymClassFusion2AAin2SA, function( cclX, cclY )
local fus, x, xpi, pi, tau, y, pos;
fus:= [ ];
for x in cclX do
xpi:= x[2][1];
tau:= x[2][2];
if '+' in xpi or '-' in xpi then
pi:= xpi[1];
else
pi:= xpi;
fi;
y:= [ x[1], [ pi, tau ] ];
## 1\2_x corresponds to 1\2_y if there are split classes 1_y and 2_y
## otherwise, 1\2_x fuse in 1_y
pos:= Position( cclY, y );
if pos = fail then
y:= [ 1, [ pi, tau ] ];
pos:= Position( cclY, y );
fi;
Add( fus, pos );
od;
return fus;
end );
## SpinSymClassFusion2AAin2AS( , )
## INPUT .... class parameters of 2.(Alt(k) x Alt(l))
## .......... class parameters of 2.(Alt(k) x Sym(l))
InstallGlobalFunction( SpinSymClassFusion2AAin2AS, function( cclX, cclY )
local fus, x, pi, xtau, tau, y, pos;
fus:= [ ];
for x in cclX do
pi:= x[2][1];
xtau:= x[2][2];
if '+' in xtau or '-' in xtau then
tau:= xtau[1];
else
tau:= xtau;
fi;
y:= [ x[1], [ pi, tau ] ];
## 1\2_x corresponds to 1\2_y if there are split classes 1_y and 2_y
## otherwise, 1\2_x fuse in 1_y
pos:= Position( cclY, y );
if pos = fail then
y:= [ 1, [ pi, tau ] ];
pos:= Position( cclY, y );
fi;
Add( fus, pos );
od;
return fus;
end );
## SpinSymClassFusion2AAin2A( , )
## INPUT .... class parameters of 2.(Alt(k) x Alt(l))
## .......... class parameters of 2.Alt(n) for n=k+l
## see \cite{Maas2011}*{(5.4.8)}
## RECALL: the 1\2 split classes of 2.Alt(n) are parameterized by O(n)\cup D^+(n);
## RECALL: the +\- split classes of Alt(n) are parameterized by O(n)\cap D^+(n).
InstallGlobalFunction( SpinSymClassFusion2AAin2A, function( cclX, cclY )
local splittype, fus, x, xpi, xtau, pi, tau, sgnpi, sgntau,
mu, y, pi_o, pi_e, tau_e, o, e, f, type;
splittype:= function( tau )
if SPINSYM_IsAPO( tau ) and SPINSYM_IsAPD( tau ) then
return [ tau, '+' ];
else
return tau;
fi;
end;
fus:= [];
for x in cclX do
xpi:= x[2][1];
xtau:= x[2][2];
if '+' in xpi or '-' in xpi then
pi:= xpi[1];
sgnpi:= xpi[2];
else
pi:= xpi;
sgnpi:= '+';
fi;
if '+' in xtau or '-' in xtau then
tau:= xtau[1];
sgntau:= xtau[2];
else
tau:= xtau;
sgntau:= '+';
fi;
mu:= Reversed( SortedList( Concatenation( pi, tau ) ) );
if not SPINSYM_IsAPO( mu ) and not SPINSYM_IsAPD( mu ) then
y:= [ 1, mu ];
else
pi_o:= Filtered( pi, t-> t mod 2 = 1 );
pi_e:= Filtered( pi, t-> t mod 2 = 0 );
tau_e:= Filtered( tau, t-> t mod 2 = 0 );
e:= Sum( List( tau_e, i-> Number( pi, j-> j Number( pi_o, j-> j 0 then ## o is odd
y:= [ e+f-1, mu ];
elif not SPINSYM_IsAPD(mu) then ## o is odd and f=0
y:= [ e, mu ];
else
y:= [ e, [ mu, '-' ] ];
fi;
else # type = "+-"
if o mod 2 = 1 then
y:= [ e, splittype( mu ) ];
elif f > 0 then ## o is even
y:= [ e+f-1, mu ];
elif not SPINSYM_IsAPD(mu) then ## o is even and f=0
y:= [ e, mu ];
else
y:= [ e, [ mu, '-' ] ];
fi;
fi;
## y[1]=1 if the exponent of z in even, y[2]=2 otherwise
y:= [ y[1] mod 2 + 1, y[2] ];
fi;
Add( fus, Position( cclY, y ) );
od;
return fus;
end );
#############################################################################
## MAIN USER FUNCTION
## SpinSymClassFusion( , )
## INPUT .... (ordinary or modular) 'generic' character table of SOURCE
## .......... (ordinary or modular) 'generic' character table of DEST
## .......... where the possible pairs of SOURCE and DEST are
## .......... ...............................................
## .......... SOURCE ................ DEST ..................
## .......... 2.Alt(n) .............. 2.Sym(n)
## .......... 2.Sym(k) .............. 2.Sym(n)
## .......... 2.Alt(k) .............. 2.Alt(n)
## .......... 2.Sym(n-2) ............ 2.Alt(n)
## .......... 2.(Sym(k) x Sym(l)) ... 2.Sym(k+l)
## .......... 2.(Sym(k) x Alt(l)) ... 2.(Sym(k) x Sym(l))
## .......... 2.(Alt(k) x Sym(l)) ... 2.(Sym(k) x Sym(l))
## .......... 2.(Alt(k) x Alt(l)) ... 2.(Sym(k) x Alt(l))
## .......... 2.(Alt(k) x Alt(l)) ... 2.(Alt(k) x Sym(l))
## .......... 2.(Alt(k) x Alt(l)) ... 2.Alt(k+l)
## OUTPUT ... the fusion map fus from SOURCE to DEST as returned by
## .......... SpinSymClassFusionSOURCEinDEST
## .......... the fusion map is stored only if there is no fusion map from
## .......... SOURCE to DEST stored yet
InstallGlobalFunction( SpinSymClassFusion, function( X, Y )
local idX, idY, S, A, type, cclX, cclY, fus, storedfus;
idX:= Identifier( X );
idY:= Identifier( Y );
S:= Filtered( idX, x-> x = 'S' );
A:= Filtered( idX, x-> x = 'A' );
if Length(S) = Length(A) then ## type 2SA or 2AS
if Position( idX, 'S' ) < Position( idX, 'A' ) then
type:= Concatenation( "2", S, A );
else
type:= Concatenation( "2", A, S );
fi;
else
type:= Concatenation( "2", S, A );
fi;
S:= Filtered( idY, x-> x = 'S' );
A:= Filtered( idY, x-> x = 'A' );
if Length(S) = Length(A) then ## type 2SA or 2AS
if Position( idY, 'S' ) < Position( idY, 'A' ) then
type:= Concatenation( type, "fus", "2", S, A );
else
type:= Concatenation( type, "fus", "2", A, S );
fi;
else
type:= Concatenation( type, "fus", "2", S, A );
fi;
cclX:= ClassParameters( X );
cclY:= ClassParameters( Y );
## call the appropriate SpinSymClassFusionSOURCEinDEST function
if type="2Afus2S" then
fus:= SpinSymClassFusion2Ain2S( cclX, cclY );
elif type="2Sfus2S" then
fus:= SpinSymClassFusion2Sin2S( cclX, cclY );
elif type="2Afus2A" then
fus:= SpinSymClassFusion2Ain2A( cclX, cclY );
elif type="2Sfus2A" then
fus:= SpinSymClassFusion2Sin2A( cclX, cclY );
elif type="2SSfus2S" then
fus:= SpinSymClassFusion2SSin2S( cclX, cclY );
elif type="2SAfus2SS" then
fus:= SpinSymClassFusion2SAin2SS( cclX, cclY );
elif type="2ASfus2SS" then
fus:= SpinSymClassFusion2ASin2SS( cclX, cclY );
elif type="2AAfus2SA" then
fus:= SpinSymClassFusion2AAin2SA( cclX, cclY );
elif type="2AAfus2AS" then
fus:= SpinSymClassFusion2AAin2AS( cclX, cclY );
elif type="2AAfus2A" then
fus:= SpinSymClassFusion2AAin2A( cclX, cclY );
else
fus:= fail;
fi;
## now store the fusion only if there is no fusion map available
storedfus:= GetFusionMap( X, Y );
if storedfus <> fail then
if storedfus <> fus then
Print( "#I SpinSymClassFusion: WARNING\n",
"#I ................... a different fusion map from ", idX, " to ",
idY, " is stored already\n" );
fi;
elif not fail in fus then
StoreFusion( X, fus, Y );
Print( "#I SpinSymClassFusion: stored fusion map from ",
idX, " to ", idY, "\n" );
else
return fail;
fi;
return fus;
end );
spinsym-1.5.2/gap/young.gi 0000644 0000766 0000024 00000100106 13544575277 014502 0 ustar mhorn staff #############################################################################
##
## 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 = [ 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 = [ 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 = [ 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 = [ 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 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 = , i.e. T(chi)=AS
# now T[i] = [ false, true ] means that T(chi)/AA = , i.e. T(chi)=SA
# now T[i] = [ false, false ] means that T(chi)/AA = x
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 and 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( " 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( , )
##
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( "
The SpinSymGAP package is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program (see the file LICENSE). If not, see http://www.gnu.org/licenses/.
All Brauer tables in this package are relative to a generic ordinary character table obtained by one of the following constructions
CharacterTable( "2.Sym(n)" ), the character table of 2.Sym(n) ,
CharacterTable( "2.Alt(n)" ), the character table of 2.Alt(n) ,
CharacterTable( "Sym(n)" ), the character table of Sym(n),
CharacterTable( "Alt(n)" ), the character table of Alt(n).
Note that these are synonymous expressions for
CharacterTable( "DoubleCoverSymmetric", n ),
CharacterTable( "DoubleCoverAlternating", n ),
CharacterTable( "Symmetric", n ),
CharacterTable( "Alternating", n ),
respectively. More detailed information on these tables is to be found in [3]. In this manual, we call such a character table an (ordinary) SpinSym table. If ordtbl is an ordinary SpinSym table, the relative Brauer table in characteristic p can be accessed using the mod-operator (i.e. ordtbl mod p;). Such a Brauer table is called a (p-modular) SpinSym table in the following.
An ordinary SpinSym table has character parameters, that is, a list of suitable labels corresponding to the rows of ordtbl and therefore the irreducible ordinary characters of the underlying group. See CharacterParameters() in the GAP Reference Manual.
2.2-1 Parameters of ordinary characters
In the following, `ordinary (spin) character' is used synonymously for `irreducible ordinary (spin) character'. It is well known that there is a bijection between the set of ordinary characters of Sym(n) and the set P(n) of all partitions of n. Recall that a partition of a natural number n is a list of non-increasing positive integers (its parts) that sum up to n. In this way, every ordinary character χ of Sym(n) has a label of the form [1,c] where c is a partition of n. The labels of the ordinary characters of Alt(n) are induced by Clifford theory as follows. Either the restriction ψ=χ|_Alt(n) of χ to Alt(n) is an ordinary character of Alt(n), or ψ decomposes as the sum of two distinct ordinary characters ψ_1 and ψ_2.
In the first case there is another ordinary character of Sym(n), say ξ labelled by [1,d], such that the restriction of ξ to Alt(n) is equal to ψ. Moreover, the induced character of Sym(n) obtained from ψ decomposes as the sum of χ and ξ. Then ψ is labelled by [1,c] or [1,d].
In the second case, both ψ_1 and ψ_2 induce irreducibly up to χ. Then ψ_1 and ψ_2 are labelled by [1,[c,'+']] and [1,[c,'-']].
If χ is an ordinary character of 2.Sym(n) or 2.Alt(n) , then χ(z)=χ(1) or χ(z)=-χ(1). If χ(z)=χ(1), then χ is obtained by inflation (along the central subgroup generated by z) from an ordinary character of Sym(n) or Alt(n), respectively, whose label is given to χ. Otherwise, if χ is a spin character, that is χ(z)=-χ(1), then its label is described next.
The set of ordinary spin characters of 2.Sym(n) is parameterized by the subset D(n) of P(n) of all distinct-parts partitions of n (also called bar partitions). If c is an even distinct-parts partition of n, then there is a unique ordinary spin character of 2.Sym(n) that is labelled by [2,c]. In contrast, if c is an odd distinct-parts partition of n, then there are two distinct ordinary spin characters of 2.Sym(n) that are labelled by [2,[c,'+']] and [2,[c,'-']]. Now the labels of the ordinary spin characters of 2.Alt(n) follow from the labels of 2.Sym(n) in the same way as those of Alt(n) follow from the labels of Sym(n) (see the beginning of this subsection 2.2-1).
In the following, `p-modular (spin) character' is used synonymously for `irreducible p-modular (spin) character'. The set of p-modular characters of Sym(n) is parameterized by the set of all p-regular partitions of n. A partition is p-regular if no part is repeated more than p-1 times. Now every p-modular character χ of Sym(n) has a label of the form [1,c] where c is a p-regular partition of n.
Again, the labels for the p-modular spin characters of Alt(n) follow from the labels of Sym(n). However, comparing subsection 2.2-1, their format is slightly different.
If χ and ξ are distinct p-modular characters of Sym(n) that restrict to the same p-modular character ψ of Alt(n), then ψ is labelled by [1,[c,'0']] where either χ or ξ is labelled by [1,c]. If χ is a p-modular character of Sym(n) whose restriction to Alt(n) decomposes as the sum of two distinct p-modular characters, then these are labelled by [1,[c,'+']] and [1,[c,'-']] where χ is labelled by [1,c].
As in the ordinary case, the set of p-modular characters of 2.Sym(n) is the union of the subset consisting of all inflated p-modular characters of Sym(n) and the subset of spin characters characterized by negative integer values on the central element z. The analogue statement holds for 2.Alt(n). The set of p-modular spin characters of 2.Sym(n) is parameterized by the set of all restricted p-strict partitions of n. A partition is called p-strict if every repeated part is divisible by p, and a p-strict partition λ is restricted if λ_i-λ_i+1<p whenever λ_i is divisible p, and λ_i-λ_i+1≤ p otherwise for all parts λ_i of λ (where we set λ_i+1=0 if λ_i is the last part). If c is a restricted p-strict partition of n such that n minus the number of parts not divisible by p is even, then there is a unique p-modular spin character of 2.Sym(n) that is labelled by [2,[c,'0']]. Its restriction to 2.Alt(n) decomposes as the sum of two distinct p-modular characters which are labelled by [2,[c,'+']] and [2,[c,'-']]. If n minus the number of parts of c that are not divisible by p is odd, then there are two distinct p-modular spin characters of 2.Sym(n) that are labelled by [2,[c,'+']] and [2,[c,'-']]. Both of these characters restrict to the same irreducible p-modular spin character of 2.Alt(n) which is labelled by [2,[c,'0']].
Let ct be an ordinary SpinSym table. Then ct has a list of class parameters, that is, a list of suitable labels corresponding to the columns of ct and therefore the conjugacy classes of the underlying group. See ClassParameters() in the GAP Reference Manual. If bt is a Brauer table in characteristic p relative to ct, its class parameters are inherited from ct in correspondence with the p-regular conjugacy classes of the underlying group.
Let P(n) denote the set of partitions of n.
The conjugacy classes of Sym(n) are naturally parameterized by the cycle types of their elements, and each cycle type corresponds to a partition of n. Therefore a conjugacy class C of Sym(n) is characterized by its typec in P(n). The corresponding entry in the list of class parameters is [1,c]. Assume that C is a subset of Alt(n). Then C is also a conjugacy class of Alt(n) if and only if not all parts of c are odd and pairwise distinct. Otherwise, C splits as the union of two distinct Alt(n)-classes of the same size, C^+ of type c^+ and C^- of type c^-. The corresponding entries in the list of class parameters are [1,[c,'+']] and [1,[c,'-']], respectively.
Furthermore, the preimage C'=C^{π^-1} is either a conjugacy class of 2.Sym(n) of type c with class parameter [1,c], or C' splits as the union of two distinct 2.Sym(n) -classes C'_1 and C'_2=zC'_1 , both of type c with corresponding class parameters [1,c] and [2,c], respectively. An analogous description applies for the conjugacy classes of 2.Alt(n) .
To each conjugacy class of 2.Sym(n) or 2.Alt(n) a certain standard representative is assigned in the following way. Let c=[c_1,c_2,...,c_m] be a partition of n. We set d_1=0, d_i=c_1+... +c_i-1 for i≥ 2, and
t(c_i,d_i)= t_d_i+1t_d_i+2... t_d_i+c_i-1
for 1≤ i≤ m-1, where t(c_i,d_i)= 1 if c_i=1. The standard representative of typec is defined as
t_c=t(c_1,d_1)t(c_2,d_2)...t(c_m-1,d_m-1).
Furthermore, we define the standard representatives of type c^+=[c,'+'] and c^-=[c,'-'] to be t_c^+=t_c and t_c^-=t_1^-1t_c t_1, respectively.
For example, the standard representative of type c=[7,4,3,1] in P(15) is
t_c=t_1t_2t_3t_4t_5t_6t_8t_9t_10t_12t_13.
Now C' is a conjugacy class of 2.Sym(n) or 2.Alt(n) with parameter
[1,c] if and only if t_c is an element of C' ,
[2,c] if and only if zt_c is an element of C' ,
[1,[c,'+']] if and only if t_c^+ is an element of C' ,
[2,[c,'+']] if and only if zt_c^+ is an element of C' ,
[1,[c,'-']] if and only if t_c^- is an element of C' ,
[2,[c,'-']] if and only if zt_c^- is an element of C' .
2.3-1 SpinSymStandardRepresentative
‣ SpinSymStandardRepresentative( c, rep )
( function )
Returns: the image of the standard representative of type c under a given 2.Sym(n)-representation.
Expecting the second entry of a class parameter of 2.Sym(n) or 2.Alt(n) , say c, the standard representative of type c under a given representation of 2.Sym(n) is computed. The argument rep is assumed to be a list [t_1^R,t_2^R,...,t_n-1^R] given by the images of the generators t_1,...,t_n-1 of 2.Sym(n) under a (not necessarily faithful) representation R of 2.Sym(n) .
Returns: the image of the standard representative of type c under the natural epimorphism π:2.Sym({j,...,j+n-1}) -> Sym({j,...,j+n-1}).
Given the second entry c of a class parameter of 2.Sym(n) or 2.Alt(n) , and optionally a positive integer j, the image of the standard representative of type c under π:2.Sym({j,...,j+n-1}) -> Sym({j,...,j+n-1}) with t_i^π=(i,i+1) for j≤ i≤ j+n-2 is computed by calling SpinSymStandardRepresentative(c,rep) where rep is the list [(j,j+1),(j+1,j+2),...,(j+n-2,j+n-1)]. By default, j=1.
Returns: a (standard) lift of the element c of Sym(n) in 2.Sym(n) under a given 2.Sym(n)-representation.
See [2, (5.1.12)] for the definition of the lift that is returned by this function. The permutation c is written as a product of simple transpositions (i,i+1), then these are replaced by the images of their canonical lifts t_i under a given representation R of 2.Sym(n) (recall the beginning of Chapter 1 for the definition of t_i). Here rep is assumed to be the list [t_1^R,t_2^R,...,t_n-1^R].
Note that a more efficient computation may be achieved by computing and storing a list of all necessary transpositions once and for all, before lifting (many) elements (under a possibly large representation).
Returns: the Brauer character afforded by a given representation of 2.Sym(n) .
This function is based on a simplified computation of the GAP attribute BrauerCharacterValue(mat) for an invertible matrix mat over a finite field whose characteristic is coprime to the order of mat.
The arguments ccl and ords are expected to be the values of the attributes ClassParameters(modtbl) and OrdersClassRepresentatives(modtbl) of a (possibly incomplete) p-modular SpinSym table modtbl of 2.Sym(n) .
The argument rep is assumed to be a list [t_1^R,t_2^R,...,t_n-1^R] given by the images of the generators t_1,...,t_n-1 of 2.Sym(n) under a (not necessarily faithful) 2.Sym(n) -representation R.
gap>ct:= CharacterTable("DoubleCoverSymmetric",15);;gap>bt:= CharacterTableRegular(ct,5);;gap>fus:= GetFusionMap(bt,ct);;gap>ccl:= ClassParameters(ct){fus};;gap>ords:= OrdersClassRepresentatives(bt);;gap>rep:= BasicSpinRepresentationOfSymmetricGroup(15,5);;gap>phi:= SpinSymBrauerCharacter(ccl,ords,rep);;gap>phi in Irr(ct mod 5);
true
2.3-5 SpinSymBasicCharacter
‣ SpinSymBasicCharacter( modtbl )
( function )
Returns: a p-modular basic spin character of the (possibly incomplete) p-modular SpinSym table modtbl of 2.Sym(n) .
This is just a shortcut for constructing a basic spin representation of 2.Sym(n) in characteristic p and computing its Brauer character by calling SpinSymBrauerCharacter (2.3-4) afterwards.
is called a (maximal) Young subgroup of 2.Sym(n) . Similarly, the intersection 2.(Alt(k)×Alt(l)) of 2.(Sym(k)×Sym(l)) and 2.Alt(n) is a (maximal) Young subgroup of 2.Alt(n) . Note that (2.(Sym(k)×Sym(l)))^π is isomorphic to Sym(k)×Sym(l) and (2.(Alt(k)×Alt(l)))^π is isomorphic to Alt(k)×Alt(l) but only 2.(Alt(k)×Alt(l)) which is isomorphic to (2.Alt(k)×2.Alt(l))/ <(z,z)> is a central product. In between 2.(Alt(k)×Alt(l)) and 2.(Sym(k)×Sym(l)) there are further central products 2.(Sym(k)×Alt(l)) which is isomorphic to (2.Sym(k)×2.Alt(l))/<(z,z)> and 2.(Alt(k)×Sym(l)) which is isomorphic to (2.Alt(k)×2.Sym(l))/<(z,z)> which are π-preimages of Sym(k)×Alt(l) and Alt(k)×Sym(l), respectively. See [2, Section 5.2].
2.4-1 SpinSymCharacterTableOfMaximalYoungSubgroup
‣ SpinSymCharacterTableOfMaximalYoungSubgroup( k, l, type )
( function )
Returns: the ordinary character table of a maximal Young subgroup depending on type.
For integers k and l greater than 1 the function returns the ordinary character table of 2.(Alt(k)×Alt(l)), 2.(Alt(k)×Sym(l)), 2.(Sym(k)×Alt(l)), or 2.(Sym(k)×Sym(l)) depending on the string type being "Alternating", "AlternatingSymmetric", "SymmetricAlternating", or "Symmetric", respectively.
If type is "Symmetric" then the output is computed by means of Clifford's theory from the character tables of 2.(Sym(k)×Alt(l)), 2.(Alt(k)×Alt(l)), and 2.(Alt(k)×Sym(l)) (see [2, Section 5.2]). These `ingredients' are computed and then stored in the attribute SpinSymIngredients so they can be accessed during the construction (and for the construction of a relative Brauer table too, see SpinSymBrauerTableOfMaximalYoungSubgroup (2.4-2)).
The construction of the character tables of type"Alternating", "AlternatingSymmetric", or "SymmetricAlternating" is straightforward and may be accomplished by first construcing a direct product, for example, the character table of 2.Sym(k)×2.Alt(l), followed by the construction of the character table of the factor group mod <(z,z)>.
However, we use a faster method that builds up the table from scratch, using the appropriate component tables as ingredients (for example, the generic character tables of 2.Sym(k) and 2.Alt(l) ). In this way we can easily build up a suitable list of class parameters that are needed to determine the class fusion in the construction of type"Symmetric".
‣ SpinSymBrauerTableOfMaximalYoungSubgroup( ordtbl, p )
( function )
Returns: the p-modular character table of the ordinary character table ordtbl returned by the function SpinSymCharacterTableOfMaximalYoungSubgroup (2.4-1).
If the rational prime p is odd, then the construction of the irreducible Brauer characters is really the same as in the ordinary case but it depends on the p-modular tables of of ordtbl's `ingredients'. If some Brauer table that is necessary for the construction is not available then fail is returned.
Alternatively, the mod-operator may be used.
For p=2 the Brauer table is essentially constructed as a direct product by standard GAP methods written by Thomas Breuer.
We call a character table returned by SpinSymCharacterTableOfMaximalYoungSubgroup (2.4-1) or SpinSymBrauerTableOfMaximalYoungSubgroup a SpinSym table too. It has lists of class and character parameters whose format is explained in [2, Sections 5.2, 5.3].
gap>SpinSymBrauerTableOfMaximalYoungSubgroup(2AA,3);
BrauerTable( "2.(Alt(8)xAlt(5))", 3 )
gap>2SS mod 5;
BrauerTable( "2.(Sym(8)xSym(5))", 5 )
gap>ct:= 2SS mod 2;
BrauerTable( "2.(Sym(8)xSym(5))", 2 )
gap>ct1:= CharacterTable("Sym(8)") mod 2;;gap>ct2:= CharacterTable("Sym(5)") mod 2;; gap>Irr(ct1*ct2) = Irr(ct);
true
2.5 Class Fusions
The following functions determine class fusion maps between SpinSym tables by means of their class parameters. Such `default' class fusion maps allow to induce characters from various subgroups of 2.Sym(n) or 2.Alt(n) consistently.
2.5-1 SpinSymClassFusion
‣ SpinSymClassFusion( ctSource, ctDest )
( function )
Returns: a fusion map from the SpinSym table ctSource to the SpinSym table ctDest. This map is stored if there is no other fusion map from ctSource to ctDest stored yet.
The possible input tables are expected to be either ordinary or p-modular SpinSym tables of the following pairs of groups
Source
->
Dest
2.Alt(n)
2.Sym(n)
2.Sym(k)
2.Sym(n)
2.Alt(k)
2.Alt(n)
2.Sym(n-2)
2.Alt(n)
2.(Sym(k)×Sym(l))
2.Sym(k+l)
2.(Sym(k)×Alt(l))
2.(Sym(k)×Sym(l))
2.(Alt(k)×Sym(l))
2.(Sym(k)×Sym(l))
2.(Alt(k)×Alt(l))
2.(Sym(k)×Alt(l))
2.(Alt(k)×Alt(l))
2.(Alt(k)×Sym(l))
2.(Alt(k)×Alt(l))
2.Alt(k+l)
The appropriate function (see the descriptions below) is called to determine the fusion map fus. If GetFusionMap(ctSource, ctDest) fails, then fus is stored by calling StoreFusion(ctSource, fus, ctDest).
gap>ctD:= CharacterTable("2.Sym(18)");; gap>ctS:= SpinSymCharacterTableOfMaximalYoungSubgroup(10,8,"Symmetric");;gap>GetFusionMap(ctS,ctD);
fail
gap>SpinSymClassFusion(ctS,ctD);;
#I SpinSymClassFusion: stored fusion map from 2.(Sym(10)xSym(8)) to 2.Sym(18)
gap>GetFusionMap(ctS,ctD) <> fail;
true
2.5-2 SpinSymClassFusion2Ain2S
‣ SpinSymClassFusion2Ain2S( cclSource, cclDest )
( function )
Returns: a fusion map between the SpinSym tables of 2.Alt(n) and 2.Sym(n).
Given lists of class parameters cclSource and cclDest of (ordinary or p-modular) SpinSym tables of 2.Alt(n) and 2.Sym(n), respectively, a corresponding class fusion map is determined. See [2, (5.4.1)].
2.5-3 SpinSymClassFusion2Sin2S
‣ SpinSymClassFusion2Sin2S( cclSource, cclDest )
( function )
Returns: a fusion map between the SpinSym tables of 2.Sym(k) and 2.Sym(n) for k≤ n.
Given lists of class parameters cclSource and cclDest of (ordinary or p-modular) SpinSym tables of 2.Sym(k) and 2.Sym(n) for k≤ n, respectively, a corresponding class fusion map is determined. See [2, (5.4.2)].
Returns: a fusion map between the SpinSym tables of 2.Alt(k) and 2.Alt(n) for k≤ n.
Given lists of class parameters cclSource and cclDest of (ordinary or p-modular) SpinSym tables of 2.Alt(k) and 2.Alt(n) for k≤ n, respectively, a corresponding class fusion map is determined. See [2, (5.4.3)].
2.5-5 SpinSymClassFusion2Sin2A
‣ SpinSymClassFusion2Sin2A( cclSource, cclDest )
( function )
Returns: a fusion map between the SpinSym tables of 2.Sym(n-2) and 2.Alt(n).
Given lists of class parameters cclSource and cclDest of (ordinary or p-modular) SpinSym tables of 2.Sym(n-2) and 2.Alt(n), respectively, a corresponding class fusion map with respect to the embedding of < t_1t_n-2,...,t_n-3t_n-1 > isomorphic to 2.Sym(n-2) in 2.Alt(n) is determined. See [2, (5.4.4)].
2.5-6 SpinSymClassFusion2SSin2S
‣ SpinSymClassFusion2SSin2S( cclSource, cclDest )
( function )
Returns: a fusion map between the SpinSym tables of 2.(Sym(k)×Sym(l)) and 2.Sym(k+l).
Given lists of class parameters cclSource and cclDest of (ordinary or p-modular) SpinSym tables of 2.(Sym(k)×Sym(l)) and 2.Sym(k+l), respectively, a corresponding class fusion map is determined by means of [2, (5.1.6)].
Returns: a fusion map between the SpinSym tables of 2.(Sym(k)×Alt(l)) and 2.(Sym(k)×Sym(l)).
Given lists of class parameters cclSource and cclDest of (ordinary or p-modular) SpinSym tables of 2.(Sym(k)×Alt(l)) and 2.(Sym(k)×Sym(l)), respectively, a corresponding class fusion map is determined. See [2, (5.4.6)].
Returns: a fusion map between the SpinSym tables of 2.(Alt(k)×Sym(l)) and 2.(Sym(k)×Sym(l)).
Given lists of class parameters cclSource and cclDest of (ordinary or p-modular) SpinSym tables of 2.(Alt(k)×Sym(l)) and 2.(Sym(k)×Sym(l)), respectively, a corresponding class fusion map is determined analogously to [2, (5.4.6)].
Returns: a fusion map between the SpinSym tables of 2.(Alt(k)×Alt(l)) and 2.(Sym(k)×Alt(l)).
Given lists of class parameters cclSource and cclDest of (ordinary or p-modular) SpinSym tables of 2.(Alt(k)×Alt(l)) and 2.(Sym(k)×Alt(l)), respectively, a corresponding class fusion map is determined. See [2, (5.4.7)].
Returns: a fusion map between the SpinSym tables of 2.(Alt(k)×Alt(l)) and 2.(Alt(k)×Sym(l)).
Given lists of class parameters cclSource and cclDest of (ordinary or p-modular) SpinSym tables of 2.(Alt(k)×Alt(l)) and 2.(Alt(k)×Sym(l)), respectively, a corresponding class fusion map is determined analogously to [2, (5.4.7)].
2.5-11 SpinSymClassFusion2AAin2A
‣ SpinSymClassFusion2AAin2A( cclSource, cclDest )
( function )
Returns: a fusion map between the SpinSym tables of 2.(Alt(k)×Alt(l)) and 2.Alt(k+l).
Given lists of class parameters cclSource and cclDest of (ordinary or p-modular) SpinSym tables of 2.(Alt(k)×Alt(l)) and 2.Alt(k+l), respectively, a corresponding class fusion map is determined. See [2, (5.4.8)].
The purpose of this GAP package is to make a collection of \(p\)-modular character tables (Brauer tables) of spin-symmetric groups (and some related groups) available in GAP, thereby extending Thomas Breuer's GAP Character Table Library [1]. The SpinSym package is based on [2] which serves as the general reference here. If you are interested in computing with SpinSym I would like to refer you to [2] for further references and a more thorough description of some of the topics below. And, of course, I would like to hear from you about more or less successful attempts in using the present functionalities.
where the relations are imposed for all admissable \(i,j,k\) with \(|j-k|>1\). Provided \(n\geq 4\), these groups are double covers of the symmetric group \(Sym(n)\) on \(n\) letters. Although \(2.Sym(n)\) and \((2^+).Sym(n)\) are non-isomorphic groups for \(n\neq 6\), they are isoclinic and their representation theory is very similar. By choice, we restrict the attention to \(2.Sym(n)\) . (However, if you are interested in character tables of \((2^+).Sym(n)\) then have a look at CharacterTableIsoclinic() in the GAP Reference Manual.)
The natural epimorphism \(\pi: 2.Sym(n) \to Sym(n), t_i\mapsto (i,i+1)\) , whose kernel is generated by the central involution \(z\), gives rise to the double cover \(2.Alt(n)=Alt(n)^{{\pi^{-1}}}\) of the alternating group \(Alt(n)\) as the preimage of \(Alt(n)\) under \(\pi\). Irreducible faithful representations of \(2.Sym(n)\) or \(2.Alt(n)\) are called spin representations and a similar `spin' terminology is used for all related faithful objects, to set them apart from the non-faithful objects that belong esssentially to \(Sym(n)\) or \(Alt(n)\), respectively.
1.1 The data part
The package contains complete Brauer tables of \(2.Sym(n)\) and \(2.Alt(n)\) up to degree \(n=18\) in characteristic \(p=3,5,7\). Thus it includes the corresponding Brauer tables of \(Sym(n)\) and \(Alt(n)\). Moreover, Brauer tables of \(Sym(n)\) and \(Alt(n)\) up to degree \(n=19\) in characteristic \(p=2\) are part of the package too.
Every Brauer table comes with lists of character parameters (row labels) and class parameters (column labels), see 2.2 and 2.3. I would like to mention that only some of the data is `new', large portions date back to the work of James, Morris, Yaseen, and the Modular Atlas Project. Detailed references are to be found in [2]. The \(2\)-modular tables of \(Sym(n)\) and \(Alt(n)\) for \(n=18,19\) were computed jointly by Jürgen Müller and the author.
Please note that some of our Brauer tables differ to some extent from those contained in the GAP Character Table Library [1] (for example, in terms of the ordering of conjugacy classes and characters or in terms of their parameters). Therefore it seemed appropriate to collect these tables in their own package - so here we are.
I'm grateful to Thomas Breuer for supporting the idea of writing this package and for converting my tables into the right GAP Character Table Library format.
1.2 The functions part
Besides Brauer tables, the package provides some related functionalities such as functions that determine class fusions of subgroup character tables and functions that compute character tables of some Young subgroups of \(2.Sym(n)\) .
1.3 Installation and loading
To install this package, download the archive file spinsym-1.5.2.tar.gz and unpack it inside the pkg subdirectory of your GAP installation. It creates a subdirectory called spinsym. Then load the package using the LoadPackage command.
gap>LoadPackage("spinsym");
The SpinSym package banner should appear on the screen. You may want to run a quick test of the installation:
All Brauer tables in this package are relative to a generic ordinary character table obtained by one of the following constructions
CharacterTable( "2.Sym(n)" ), the character table of \(2.Sym(n)\) ,
CharacterTable( "2.Alt(n)" ), the character table of \(2.Alt(n)\) ,
CharacterTable( "Sym(n)" ), the character table of \(Sym(n)\),
CharacterTable( "Alt(n)" ), the character table of \(Alt(n)\).
Note that these are synonymous expressions for
CharacterTable( "DoubleCoverSymmetric", n ),
CharacterTable( "DoubleCoverAlternating", n ),
CharacterTable( "Symmetric", n ),
CharacterTable( "Alternating", n ),
respectively. More detailed information on these tables is to be found in [3]. In this manual, we call such a character table an (ordinary) SpinSym table. If ordtbl is an ordinary SpinSym table, the relative Brauer table in characteristic p can be accessed using the mod-operator (i.e. ordtbl mod p;). Such a Brauer table is called a (\(p\)-modular) SpinSym table in the following.
An ordinary SpinSym table has character parameters, that is, a list of suitable labels corresponding to the rows of ordtbl and therefore the irreducible ordinary characters of the underlying group. See CharacterParameters() in the GAP Reference Manual.
2.2-1 Parameters of ordinary characters
In the following, `ordinary (spin) character' is used synonymously for `irreducible ordinary (spin) character'. It is well known that there is a bijection between the set of ordinary characters of \(Sym(n)\) and the set \(P(n)\) of all partitions of \(n\). Recall that a partition of a natural number \(n\) is a list of non-increasing positive integers (its parts) that sum up to \(n\). In this way, every ordinary character \(\chi\) of \(Sym(n)\) has a label of the form [1,c] where c is a partition of \(n\). The labels of the ordinary characters of \(Alt(n)\) are induced by Clifford theory as follows. Either the restriction \(\psi=\chi|_{Alt(n)}\) of \(\chi\) to \(Alt(n)\) is an ordinary character of \(Alt(n)\), or \(\psi\) decomposes as the sum of two distinct ordinary characters \(\psi_1\) and \(\psi_2\).
In the first case there is another ordinary character of \(Sym(n)\), say \(\xi\) labelled by [1,d], such that the restriction of \(\xi\) to \(Alt(n)\) is equal to \(\psi\). Moreover, the induced character of \(Sym(n)\) obtained from \(\psi\) decomposes as the sum of \(\chi\) and \(\xi\). Then \(\psi\) is labelled by [1,c] or [1,d].
In the second case, both \(\psi_1\) and \(\psi_2\) induce irreducibly up to \(\chi\). Then \(\psi_1\) and \(\psi_2\) are labelled by [1,[c,'+']] and [1,[c,'-']].
If \(\chi\) is an ordinary character of \(2.Sym(n)\) or \(2.Alt(n)\) , then \(\chi(z)=\chi(1)\) or \(\chi(z)=-\chi(1)\). If \(\chi(z)=\chi(1)\), then \(\chi\) is obtained by inflation (along the central subgroup generated by \(z\)) from an ordinary character of \(Sym(n)\) or \(Alt(n)\), respectively, whose label is given to \(\chi\). Otherwise, if \(\chi\) is a spin character, that is \(\chi(z)=-\chi(1)\), then its label is described next.
The set of ordinary spin characters of \(2.Sym(n)\) is parameterized by the subset \(D(n)\) of \(P(n)\) of all distinct-parts partitions of \(n\) (also called bar partitions). If c is an even distinct-parts partition of \(n\), then there is a unique ordinary spin character of \(2.Sym(n)\) that is labelled by [2,c]. In contrast, if c is an odd distinct-parts partition of \(n\), then there are two distinct ordinary spin characters of \(2.Sym(n)\) that are labelled by [2,[c,'+']] and [2,[c,'-']]. Now the labels of the ordinary spin characters of \(2.Alt(n)\) follow from the labels of \(2.Sym(n)\) in the same way as those of \(Alt(n)\) follow from the labels of \(Sym(n)\) (see the beginning of this subsection 2.2-1).
In the following, `\(p\)-modular (spin) character' is used synonymously for `irreducible \(p\)-modular (spin) character'. The set of \(p\)-modular characters of \(Sym(n)\) is parameterized by the set of all \(p\)-regular partitions of \(n\). A partition is \(p\)-regular if no part is repeated more than \(p-1\) times. Now every \(p\)-modular character \(\chi\) of \(Sym(n)\) has a label of the form [1,c] where c is a \(p\)-regular partition of \(n\).
Again, the labels for the \(p\)-modular spin characters of \(Alt(n)\) follow from the labels of \(Sym(n)\). However, comparing subsection 2.2-1, their format is slightly different.
If \(\chi\) and \(\xi\) are distinct \(p\)-modular characters of \(Sym(n)\) that restrict to the same \(p\)-modular character \(\psi\) of \(Alt(n)\), then \(\psi\) is labelled by [1,[c,'0']] where either \(\chi\) or \(\xi\) is labelled by [1,c]. If \(\chi\) is a \(p\)-modular character of \(Sym(n)\) whose restriction to \(Alt(n)\) decomposes as the sum of two distinct \(p\)-modular characters, then these are labelled by [1,[c,'+']] and [1,[c,'-']] where \(\chi\) is labelled by [1,c].
As in the ordinary case, the set of \(p\)-modular characters of \(2.Sym(n)\) is the union of the subset consisting of all inflated \(p\)-modular characters of \(Sym(n)\) and the subset of spin characters characterized by negative integer values on the central element \(z\). The analogue statement holds for \(2.Alt(n)\). The set of \(p\)-modular spin characters of \(2.Sym(n)\) is parameterized by the set of all restricted \(p\)-strict partitions of \(n\). A partition is called \(p\)-strict if every repeated part is divisible by \(p\), and a \(p\)-strict partition \(\lambda\) is restricted if \(\lambda_i-\lambda_{i+1}<p\) whenever \(\lambda_i\) is divisible \(p\), and \(\lambda_i-\lambda_{i+1}\leq p\) otherwise for all parts \(\lambda_i\) of \(\lambda\) (where we set \(\lambda_{i+1}=0\) if \(\lambda_i\) is the last part). If c is a restricted \(p\)-strict partition of \(n\) such that \(n\) minus the number of parts not divisible by \(p\) is even, then there is a unique \(p\)-modular spin character of \(2.Sym(n)\) that is labelled by [2,[c,'0']]. Its restriction to \(2.Alt(n)\) decomposes as the sum of two distinct \(p\)-modular characters which are labelled by [2,[c,'+']] and [2,[c,'-']]. If \(n\) minus the number of parts of c that are not divisible by \(p\) is odd, then there are two distinct \(p\)-modular spin characters of \(2.Sym(n)\) that are labelled by [2,[c,'+']] and [2,[c,'-']]. Both of these characters restrict to the same irreducible \(p\)-modular spin character of \(2.Alt(n)\) which is labelled by [2,[c,'0']].
Let ct be an ordinary SpinSym table. Then ct has a list of class parameters, that is, a list of suitable labels corresponding to the columns of ct and therefore the conjugacy classes of the underlying group. See ClassParameters() in the GAP Reference Manual. If bt is a Brauer table in characteristic \(p\) relative to ct, its class parameters are inherited from ct in correspondence with the \(p\)-regular conjugacy classes of the underlying group.
Let \(P(n)\) denote the set of partitions of \(n\).
The conjugacy classes of \(Sym(n)\) are naturally parameterized by the cycle types of their elements, and each cycle type corresponds to a partition of \(n\). Therefore a conjugacy class \(C\) of \(Sym(n)\) is characterized by its type\(c\) in \(P(n)\). The corresponding entry in the list of class parameters is [1,c]. Assume that \(C\) is a subset of \(Alt(n)\). Then \(C\) is also a conjugacy class of \(Alt(n)\) if and only if not all parts of \(c\) are odd and pairwise distinct. Otherwise, \(C\) splits as the union of two distinct \(Alt(n)\)-classes of the same size, \(C^+\) of type \(c^+\) and \(C^-\) of type \(c^-\). The corresponding entries in the list of class parameters are [1,[c,'+']] and [1,[c,'-']], respectively.
Furthermore, the preimage \(C'=C^{{\pi^-1}}\) is either a conjugacy class of \(2.Sym(n)\) of type \(c\) with class parameter [1,c], or \(C'\) splits as the union of two distinct \(2.Sym(n)\) -classes \(C'_1\) and \(C'_2=zC'_1\) , both of type \(c\) with corresponding class parameters [1,c] and [2,c], respectively. An analogous description applies for the conjugacy classes of \(2.Alt(n)\) .
To each conjugacy class of \(2.Sym(n)\) or \(2.Alt(n)\) a certain standard representative is assigned in the following way. Let \(c=[c_1,c_2,\ldots,c_m]\) be a partition of \(n\). We set \(d_1=0\), \(d_i=c_1+\ldots +c_{i-1}\) for \(i\geq 2\), and
Furthermore, we define the standard representatives of type \(c^+=\)[c,'+'] and \(c^-=\)[c,'-'] to be \(t_{c^+}=t_{c}\) and \(t_{c^-}=t_1^{-1}t_c t_1 \), respectively.
For example, the standard representative of type \(c=[7,4,3,1]\) in \(P(15)\) is
Now \(C'\) is a conjugacy class of \(2.Sym(n)\) or \(2.Alt(n)\) with parameter
[1,c] if and only if \(t_c \) is an element of \(C'\) ,
[2,c] if and only if \(zt_c\) is an element of \(C'\) ,
[1,[c,'+']] if and only if \(t_{c^+}\) is an element of \(C'\) ,
[2,[c,'+']] if and only if \(zt_{c^+}\) is an element of \(C'\) ,
[1,[c,'-']] if and only if \(t_{c^-}\) is an element of \(C'\) ,
[2,[c,'-']] if and only if \(zt_{c^-}\) is an element of \(C'\) .
2.3-1 SpinSymStandardRepresentative
‣ SpinSymStandardRepresentative( c, rep )
( function )
Returns: the image of the standard representative of type c under a given \(2.Sym(n)\)-representation.
Expecting the second entry of a class parameter of \(2.Sym(n)\) or \(2.Alt(n)\) , say c, the standard representative of type c under a given representation of \(2.Sym(n)\) is computed. The argument rep is assumed to be a list \([t_1^R,t_2^R,\ldots,t_{n-1}^R]\) given by the images of the generators \(t_1,\ldots,t_{n-1}\) of \(2.Sym(n)\) under a (not necessarily faithful) representation \(R\) of \(2.Sym(n)\) .
Returns: the image of the standard representative of type c under the natural epimorphism \(\pi:2.Sym({{j,...,j+n-1}}) \to Sym({{j,...,j+n-1}})\).
Given the second entry c of a class parameter of \(2.Sym(n)\) or \(2.Alt(n)\) , and optionally a positive integer j, the image of the standard representative of type c under \(\pi:2.Sym({{j,...,j+n-1}}) \to Sym({{j,...,j+n-1}})\) with \(t_i^\pi=(i,i+1)\) for \(j\leq i\leq j+n-2\) is computed by calling SpinSymStandardRepresentative(c,rep) where rep is the list [(j,j+1),(j+1,j+2),...,(j+n-2,j+n-1)]. By default, j=1.
Returns: a (standard) lift of the element c of \(Sym(n)\) in \(2.Sym(n)\) under a given \(2.Sym(n)\)-representation.
See [2, (5.1.12)] for the definition of the lift that is returned by this function. The permutation c is written as a product of simple transpositions \((i,i+1)\), then these are replaced by the images of their canonical lifts \(t_i\) under a given representation \(R\) of \(2.Sym(n)\) (recall the beginning of Chapter 1 for the definition of \(t_i\)). Here rep is assumed to be the list \([t_1^R,t_2^R,\ldots,t_{n-1}^R]\).
Note that a more efficient computation may be achieved by computing and storing a list of all necessary transpositions once and for all, before lifting (many) elements (under a possibly large representation).
Returns: the Brauer character afforded by a given representation of \(2.Sym(n)\) .
This function is based on a simplified computation of the GAP attribute BrauerCharacterValue(mat) for an invertible matrix mat over a finite field whose characteristic is coprime to the order of mat.
The arguments ccl and ords are expected to be the values of the attributes ClassParameters(modtbl) and OrdersClassRepresentatives(modtbl) of a (possibly incomplete) \(p\)-modular SpinSym table modtbl of \(2.Sym(n)\) .
The argument rep is assumed to be a list \([t_1^R,t_2^R,\ldots,t_{n-1}^R]\) given by the images of the generators \(t_1,\ldots,t_{n-1}\) of \(2.Sym(n)\) under a (not necessarily faithful) \(2.Sym(n)\) -representation \(R\).
gap>ct:= CharacterTable("DoubleCoverSymmetric",15);;gap>bt:= CharacterTableRegular(ct,5);;gap>fus:= GetFusionMap(bt,ct);;gap>ccl:= ClassParameters(ct){fus};;gap>ords:= OrdersClassRepresentatives(bt);;gap>rep:= BasicSpinRepresentationOfSymmetricGroup(15,5);;gap>phi:= SpinSymBrauerCharacter(ccl,ords,rep);;gap>phi in Irr(ct mod 5);
true
2.3-5 SpinSymBasicCharacter
‣ SpinSymBasicCharacter( modtbl )
( function )
Returns: a \(p\)-modular basic spin character of the (possibly incomplete) \(p\)-modular SpinSym table modtbl of \(2.Sym(n)\) .
This is just a shortcut for constructing a basic spin representation of \(2.Sym(n)\) in characteristic \(p\) and computing its Brauer character by calling SpinSymBrauerCharacter (2.3-4) afterwards.
is called a (maximal) Young subgroup of \(2.Sym(n)\) . Similarly, the intersection \(2.(Alt(k){\times}Alt(l))\) of \(2.(Sym(k){\times}Sym(l))\) and \(2.Alt(n)\) is a (maximal) Young subgroup of \(2.Alt(n)\) . Note that \((2.(Sym(k){\times}Sym(l)))^\pi\) is isomorphic to \(Sym(k){\times}Sym(l)\) and \((2.(Alt(k){\times}Alt(l)))^\pi\) is isomorphic to \( Alt(k){\times}Alt(l)\) but only \(2.(Alt(k){\times}Alt(l))\) which is isomorphic to \((2.Alt(k){\times}2.Alt(l))/ <(z,z)>\) is a central product. In between \(2.(Alt(k){\times}Alt(l))\) and \(2.(Sym(k){\times}Sym(l))\) there are further central products \(2.(Sym(k){\times}Alt(l))\) which is isomorphic to \((2.Sym(k){\times}2.Alt(l))/<(z,z)>\) and \(2.(Alt(k){\times}Sym(l)) \) which is isomorphic to \((2.Alt(k){\times}2.Sym(l))/<(z,z)>\) which are \(\pi\)-preimages of \(Sym(k){\times}Alt(l)\) and \(Alt(k){\times}Sym(l)\), respectively. See [2, Section 5.2].
2.4-1 SpinSymCharacterTableOfMaximalYoungSubgroup
‣ SpinSymCharacterTableOfMaximalYoungSubgroup( k, l, type )
( function )
Returns: the ordinary character table of a maximal Young subgroup depending on type.
For integers k and l greater than \(1\) the function returns the ordinary character table of \(2.(Alt(k){\times}Alt(l))\), \(2.(Alt(k){\times}Sym(l))\), \(2.(Sym(k){\times}Alt(l))\), or \(2.(Sym(k){\times}Sym(l))\) depending on the string type being "Alternating", "AlternatingSymmetric", "SymmetricAlternating", or "Symmetric", respectively.
If type is "Symmetric" then the output is computed by means of Clifford's theory from the character tables of \(2.(Sym(k){\times}Alt(l))\), \(2.(Alt(k){\times}Alt(l))\), and \(2.(Alt(k){\times}Sym(l))\) (see [2, Section 5.2]). These `ingredients' are computed and then stored in the attribute SpinSymIngredients so they can be accessed during the construction (and for the construction of a relative Brauer table too, see SpinSymBrauerTableOfMaximalYoungSubgroup (2.4-2)).
The construction of the character tables of type"Alternating", "AlternatingSymmetric", or "SymmetricAlternating" is straightforward and may be accomplished by first construcing a direct product, for example, the character table of \(2.Sym(k){\times}2.Alt(l)\), followed by the construction of the character table of the factor group mod \(<(z,z)>\).
However, we use a faster method that builds up the table from scratch, using the appropriate component tables as ingredients (for example, the generic character tables of \(2.Sym(k)\) and \(2.Alt(l)\) ). In this way we can easily build up a suitable list of class parameters that are needed to determine the class fusion in the construction of type"Symmetric".
‣ SpinSymBrauerTableOfMaximalYoungSubgroup( ordtbl, p )
( function )
Returns: the p-modular character table of the ordinary character table ordtbl returned by the function SpinSymCharacterTableOfMaximalYoungSubgroup (2.4-1).
If the rational prime p is odd, then the construction of the irreducible Brauer characters is really the same as in the ordinary case but it depends on the p-modular tables of of ordtbl's `ingredients'. If some Brauer table that is necessary for the construction is not available then fail is returned.
Alternatively, the mod-operator may be used.
For p\(=2\) the Brauer table is essentially constructed as a direct product by standard GAP methods written by Thomas Breuer.
We call a character table returned by SpinSymCharacterTableOfMaximalYoungSubgroup (2.4-1) or SpinSymBrauerTableOfMaximalYoungSubgroup a SpinSym table too. It has lists of class and character parameters whose format is explained in [2, Sections 5.2, 5.3].
gap>SpinSymBrauerTableOfMaximalYoungSubgroup(2AA,3);
BrauerTable( "2.(Alt(8)xAlt(5))", 3 )
gap>2SS mod 5;
BrauerTable( "2.(Sym(8)xSym(5))", 5 )
gap>ct:= 2SS mod 2;
BrauerTable( "2.(Sym(8)xSym(5))", 2 )
gap>ct1:= CharacterTable("Sym(8)") mod 2;;gap>ct2:= CharacterTable("Sym(5)") mod 2;; gap>Irr(ct1*ct2) = Irr(ct);
true
2.5 Class Fusions
The following functions determine class fusion maps between SpinSym tables by means of their class parameters. Such `default' class fusion maps allow to induce characters from various subgroups of \(2.Sym(n)\) or \(2.Alt(n)\) consistently.
2.5-1 SpinSymClassFusion
‣ SpinSymClassFusion( ctSource, ctDest )
( function )
Returns: a fusion map from the SpinSym table ctSource to the SpinSym table ctDest. This map is stored if there is no other fusion map from ctSource to ctDest stored yet.
The possible input tables are expected to be either ordinary or \(p\)-modular SpinSym tables of the following pairs of groups
Source
\(\to\)
Dest
\(2.Alt(n)\)
\(2.Sym(n)\)
\(2.Sym(k)\)
\(2.Sym(n)\)
\(2.Alt(k)\)
\(2.Alt(n)\)
\(2.Sym(n-2)\)
\(2.Alt(n)\)
\(2.(Sym(k){\times}Sym(l))\)
\(2.Sym(k+l)\)
\(2.(Sym(k){\times}Alt(l))\)
\(2.(Sym(k){\times}Sym(l))\)
\(2.(Alt(k){\times}Sym(l))\)
\(2.(Sym(k){\times}Sym(l))\)
\(2.(Alt(k){\times}Alt(l))\)
\(2.(Sym(k){\times}Alt(l))\)
\(2.(Alt(k){\times}Alt(l))\)
\(2.(Alt(k){\times}Sym(l))\)
\(2.(Alt(k){\times}Alt(l))\)
\(2.Alt(k+l)\)
The appropriate function (see the descriptions below) is called to determine the fusion map fus. If GetFusionMap(ctSource, ctDest) fails, then fus is stored by calling StoreFusion(ctSource, fus, ctDest).
gap>ctD:= CharacterTable("2.Sym(18)");; gap>ctS:= SpinSymCharacterTableOfMaximalYoungSubgroup(10,8,"Symmetric");;gap>GetFusionMap(ctS,ctD);
fail
gap>SpinSymClassFusion(ctS,ctD);;
#I SpinSymClassFusion: stored fusion map from 2.(Sym(10)xSym(8)) to 2.Sym(18)
gap>GetFusionMap(ctS,ctD) <> fail;
true
2.5-2 SpinSymClassFusion2Ain2S
‣ SpinSymClassFusion2Ain2S( cclSource, cclDest )
( function )
Returns: a fusion map between the SpinSym tables of \(2.Alt(n)\) and \(2.Sym(n)\).
Given lists of class parameters cclSource and cclDest of (ordinary or \(p\)-modular) SpinSym tables of \(2.Alt(n)\) and \(2.Sym(n)\), respectively, a corresponding class fusion map is determined. See [2, (5.4.1)].
2.5-3 SpinSymClassFusion2Sin2S
‣ SpinSymClassFusion2Sin2S( cclSource, cclDest )
( function )
Returns: a fusion map between the SpinSym tables of \(2.Sym(k)\) and \(2.Sym(n)\) for \(k\leq n\).
Given lists of class parameters cclSource and cclDest of (ordinary or \(p\)-modular) SpinSym tables of \(2.Sym(k)\) and \(2.Sym(n)\) for \(k\leq n\), respectively, a corresponding class fusion map is determined. See [2, (5.4.2)].
Returns: a fusion map between the SpinSym tables of \(2.Alt(k)\) and \(2.Alt(n)\) for \(k\leq n\).
Given lists of class parameters cclSource and cclDest of (ordinary or \(p\)-modular) SpinSym tables of \(2.Alt(k)\) and \(2.Alt(n)\) for \(k\leq n\), respectively, a corresponding class fusion map is determined. See [2, (5.4.3)].
2.5-5 SpinSymClassFusion2Sin2A
‣ SpinSymClassFusion2Sin2A( cclSource, cclDest )
( function )
Returns: a fusion map between the SpinSym tables of \(2.Sym(n-2)\) and \(2.Alt(n)\).
Given lists of class parameters cclSource and cclDest of (ordinary or \(p\)-modular) SpinSym tables of \(2.Sym(n-2)\) and \(2.Alt(n)\), respectively, a corresponding class fusion map with respect to the embedding of \(< t_1t_{n-2},\ldots,t_{n-3}t_{n-1} >\) isomorphic to \(2.Sym(n-2)\) in \(2.Alt(n)\) is determined. See [2, (5.4.4)].
2.5-6 SpinSymClassFusion2SSin2S
‣ SpinSymClassFusion2SSin2S( cclSource, cclDest )
( function )
Returns: a fusion map between the SpinSym tables of \(2.(Sym(k){\times}Sym(l))\) and \(2.Sym(k+l)\).
Given lists of class parameters cclSource and cclDest of (ordinary or \(p\)-modular) SpinSym tables of \(2.(Sym(k){\times}Sym(l))\) and \(2.Sym(k+l)\), respectively, a corresponding class fusion map is determined by means of [2, (5.1.6)].
Returns: a fusion map between the SpinSym tables of \(2.(Sym(k){\times}Alt(l))\) and \(2.(Sym(k){\times}Sym(l))\).
Given lists of class parameters cclSource and cclDest of (ordinary or \(p\)-modular) SpinSym tables of \(2.(Sym(k){\times}Alt(l))\) and \(2.(Sym(k){\times}Sym(l))\), respectively, a corresponding class fusion map is determined. See [2, (5.4.6)].
Returns: a fusion map between the SpinSym tables of \(2.(Alt(k){\times}Sym(l))\) and \(2.(Sym(k){\times}Sym(l))\).
Given lists of class parameters cclSource and cclDest of (ordinary or \(p\)-modular) SpinSym tables of \(2.(Alt(k){\times}Sym(l))\) and \(2.(Sym(k){\times}Sym(l))\), respectively, a corresponding class fusion map is determined analogously to [2, (5.4.6)].
Returns: a fusion map between the SpinSym tables of \(2.(Alt(k){\times}Alt(l))\) and \(2.(Sym(k){\times}Alt(l))\).
Given lists of class parameters cclSource and cclDest of (ordinary or \(p\)-modular) SpinSym tables of \(2.(Alt(k){\times}Alt(l))\) and \(2.(Sym(k){\times}Alt(l))\), respectively, a corresponding class fusion map is determined. See [2, (5.4.7)].
Returns: a fusion map between the SpinSym tables of \(2.(Alt(k){\times}Alt(l))\) and \(2.(Alt(k){\times}Sym(l))\).
Given lists of class parameters cclSource and cclDest of (ordinary or \(p\)-modular) SpinSym tables of \(2.(Alt(k){\times}Alt(l))\) and \(2.(Alt(k){\times}Sym(l))\), respectively, a corresponding class fusion map is determined analogously to [2, (5.4.7)].
2.5-11 SpinSymClassFusion2AAin2A
‣ SpinSymClassFusion2AAin2A( cclSource, cclDest )
( function )
Returns: a fusion map between the SpinSym tables of \(2.(Alt(k){\times}Alt(l))\) and \(2.Alt(k+l)\).
Given lists of class parameters cclSource and cclDest of (ordinary or \(p\)-modular) SpinSym tables of \(2.(Alt(k){\times}Alt(l))\) and \(2.Alt(k+l)\), respectively, a corresponding class fusion map is determined. See [2, (5.4.8)].
spinsym-1.5.2/doc/chapBib.txt 0000644 0000766 0000024 00000001351 13544575314 015101 0 ustar mhorn staff
[1XReferences[101X
[[20X1[120X] [16XBreuer, T.[116X, [17XCTblLib. The GAP Character Table Library, v1.2.2[117X,
http://www.gap-system.org/Packages/ctbllib.html.
[[20X2[120X] [16XMaas, L.[116X, [17XModular spin characters of symmetric groups[117X (2011),
((http://duepublico.uni-duisburg-essen.de/servlets/DerivateServlet/Derivate-29235/thesis.pdf)),
University of Duisburg--Essen.
[[20X3[120X] [16XNoeske, F.[116X, [17XZur Darstellungstheorie der Schurschen Erweiterungen
symmetrischer Gruppen[117X (2002),
((http://www.math.rwth-aachen.de/~Felix.Noeske/2Sn.pdf)), RWTH Aachen
University.
[32X
spinsym-1.5.2/doc/chap2.xml 0000644 0000766 0000024 00000137124 13544575277 014547 0 ustar mhorn staff
Usage and featuresAccessing the tables
All Brauer tables in this package are relative to a
generic ordinary character table obtained by one of the
following constructions
CharacterTable( "2.Sym(n)" ),
the character table of
2.Sym(n)\tilde{S}_n,CharacterTable( "2.Alt(n)" ),
the character table of
2.Alt(n)\tilde{A}_n,CharacterTable( "Sym(n)" ),
the character table of
S_nSym(n),CharacterTable( "Alt(n)" ),
the character table of
A_nAlt(n).
Note that these are synonymous expressions for
CharacterTable(
"DoubleCoverSymmetric", n ),CharacterTable(
"DoubleCoverAlternating", n ),CharacterTable(
"Symmetric", n ),CharacterTable(
"Alternating", n ),
respectively. More detailed information on these tables is to
be found in .
In this manual, we call such a character table an (ordinary)
SpinSym table.
If ordtbl is an ordinary SpinSym table, the relative
Brauer table in
characteristic p can be accessed using the
mod-operator (i.e. ordtbl mod p;).
Such a Brauer table is called a (p-modular)
SpinSym table in the following.
ordtbl:= CharacterTable( "2.Sym(18)" );
CharacterTable( "2.Sym(18)" )
gap> modtbl:= ordtbl mod 3;
BrauerTable( "2.Sym(18)", 3 )
gap> OrdinaryCharacterTable(modtbl)=ordtbl;
true
]]>
Character parameters
An ordinary SpinSym table has character parameters,
that is, a list of suitable labels corresponding to the rows
of ordtbl and therefore the irreducible ordinary
characters of the underlying group.
See CharacterParameters() in the GAP Reference Manual.
Parameters of ordinary characters
In the following, `ordinary (spin) character' is used
synonymously for `irreducible ordinary (spin) character'.
It is well known that there is a bijection between the
set of ordinary characters of
S_nSym(n)
and the set P(n) of all partitions
of n. Recall that a partition of a natural number
n is a list of non-increasing positive integers
(its parts) that sum up to n.
In this way, every ordinary character \chi of
S_nSym(n)
has a label of the form [1,c] where c is a
partition of n.
The labels of the ordinary characters of
A_nAlt(n)
are induced by Clifford theory as follows.
Either the restriction
\psi=\chi|_{A_n}\psi=\chi|_{Alt(n)}
of \chi to
A_nAlt(n)
is an ordinary character of
A_nAlt(n),
or \psi decomposes as the sum of two distinct
ordinary characters \psi_1 and \psi_2.
In the first case there is another
ordinary character of S_nSym(n),
say \xi labelled by [1,d], such that the
restriction of \xi to
A_nAlt(n)
is equal to \psi. Moreover,
the induced character of
S_nSym(n)
obtained from \psi decomposes as the
sum of \chi and \xi.
Then \psi is labelled by [1,c] or [1,d].
In the second case, both \psi_1 and \psi_2 induce
irreducibly up to \chi.
Then \psi_1 and \psi_2 are labelled by
[1,[c,'+']] and [1,[c,'-']].
ctS:= CharacterTable( "Sym(5)" );;
gap> CharacterParameters(ctS);
[ [ 1, [ 1, 1, 1, 1, 1 ] ], [ 1, [ 2, 1, 1, 1 ] ], [ 1, [ 2, 2, 1 ] ],
[ 1, [ 3, 1, 1 ] ], [ 1, [ 3, 2 ] ], [ 1, [ 4, 1 ] ], [ 1, [ 5 ] ] ]
gap> ctA:= CharacterTable( "Alt(5)" );;
gap> CharacterParameters(ctA);
[ [ 1, [ 1, 1, 1, 1, 1 ] ], [ 1, [ 2, 1, 1, 1 ] ], [ 1, [ 2, 2, 1 ] ],
[ 1, [ [ 3, 1, 1 ], '+' ] ], [ 1, [ [ 3, 1, 1 ], '-' ] ] ]
gap> chi:= Irr(ctS)[1];;
gap> psi:= RestrictedClassFunction(chi,ctA);;
gap> Position(Irr(ctA),psi);
1
gap> xi:= Irr(ctS)[7];;
gap> RestrictedClassFunction(xi,ctA) = psi;
true
gap> InducedClassFunction(psi,ctS) = chi + xi;
true
gap> chi:= Irr(ctS)[4];;
gap> psi:= RestrictedClassFunction(chi,ctA);;
gap> psi1:= Irr(ctA)[4];; psi2:= Irr(ctA)[5];;
gap> psi = psi1 + psi2;
true
gap> InducedClassFunction(psi1,ctS) = chi;
true
gap> InducedClassFunction(psi2,ctS) = chi;
true
]]>
If \chi is an ordinary character of
2.Sym(n)\tilde{S}_n
or
2.Alt(n)\tilde{A}_n,
then \chi(z)=\chi(1) or \chi(z)=-\chi(1).
If \chi(z)=\chi(1), then \chi is
obtained by inflation (along the central subgroup generated by
z) from an ordinary character of
S_nSym(n)
or
A_nAlt(n),
respectively, whose label is given to \chi.
Otherwise, if \chi is a spin character, that is
\chi(z)=-\chi(1), then its label is described next.
The set of ordinary spin characters of
2.Sym(n)\tilde{S}_n
is parameterized by
the subset D(n) of P(n) of all distinct-parts
partitions of n (also called bar partitions).
If c is an even distinct-parts partition of n,
then there is a unique ordinary spin character of
2.Sym(n)\tilde{S}_n
that is labelled by [2,c]. In contrast, if c
is an odd distinct-parts partition of n,
then there are two distinct ordinary spin characters of
2.Sym(n)\tilde{S}_n
that are labelled by [2,[c,'+']] and [2,[c,'-']].
Now the labels of the ordinary spin characters of
2.Alt(n)\tilde{A}_n
follow from the labels of
2.Sym(n)\tilde{S}_n
in the same way as those of
A_nAlt(n)
follow from the labels of
S_nSym(n)
(see the beginning of this subsection
).
ctS:= CharacterTable( "Sym(5)" );;
gap> ct2S:= CharacterTable( "2.Sym(5)" );;
gap> ch:= CharacterParameters(ct2S);
[ [ 1, [ 1, 1, 1, 1, 1 ] ], [ 1, [ 2, 1, 1, 1 ] ], [ 1, [ 2, 2, 1 ] ],
[ 1, [ 3, 1, 1 ] ], [ 1, [ 3, 2 ] ], [ 1, [ 4, 1 ] ], [ 1, [ 5 ] ],
[ 2, [ [ 3, 2 ], '+' ] ], [ 2, [ [ 3, 2 ], '-' ] ],
[ 2, [ [ 4, 1 ], '+' ] ], [ 2, [ [ 4, 1 ], '-' ] ], [ 2, [ 5 ] ] ]
gap> pos:= Positions( List(ch, x-> x[1]), 1 );;
gap> RestrictedClassFunctions( Irr(ctS), ct2S ) = Irr(ct2S){pos}; #inflation
true
gap> ct2A:= CharacterTable( "2.Alt(5)" );;
gap> CharacterParameters(ct2A);
[ [ 1, [ 1, 1, 1, 1, 1 ] ], [ 1, [ 2, 1, 1, 1 ] ], [ 1, [ 2, 2, 1 ] ],
[ 1, [ [ 3, 1, 1 ], '+' ] ], [ 1, [ [ 3, 1, 1 ], '-' ] ], [ 2, [ 3, 2 ] ],
[ 2, [ 4, 1 ] ], [ 2, [ [ 5 ], '+' ] ], [ 2, [ [ 5 ], '-' ] ] ]
]]>
Parameters of modular characters
In the following, `p-modular (spin) character'
is used synonymously for `irreducible p-modular (spin)
character'. The set of p-modular characters of
S_nSym(n)
is parameterized by the set of all p-regular partitions
of n. A partition is p-regular
if no part is repeated more than p-1 times.
Now every p-modular character \chi of
S_nSym(n)
has a label of the form [1,c] where c is a
p-regular partition of n.
Again, the labels for the p-modular spin characters of
A_nAlt(n)
follow from the labels of
S_nSym(n).
However, comparing subsection
,
their format is slightly different.
If \chi and \xi are distinct
p-modular characters of
S_nSym(n)
that restrict to the same p-modular character
\psi of
A_nAlt(n),
then \psi is labelled by [1,[c,'0']]
where either \chi or \xi
is labelled by [1,c].
If \chi is a p-modular character of
S_nSym(n)
whose restriction to
A_nAlt(n)
decomposes as the sum of two distinct
p-modular characters, then these are labelled by
[1,[c,'+']] and [1,[c,'-']] where \chi
is labelled by [1,c].
As in the ordinary case, the set of p-modular
characters of
2.Sym(n)\tilde{S}_n
is the union of the subset
consisting of all inflated p-modular characters of
S_nSym(n)
and the subset of spin characters
characterized by negative integer values on the central element
z. The analogue statement holds for
2.Alt(n)\tilde{A}_n.
The set of p-modular spin characters of
2.Sym(n)\tilde{S}_n
is parameterized by the set of all restricted p-strict
partitions of n.
A partition is called p-strict if every repeated part
is divisible by p, and a p-strict partition
\lambda is restricted if
\lambda_i-\lambda_{i+1}<p whenever \lambda_i
is divisible p, and
\lambda_i-\lambda_{i+1}\leq p otherwise for all parts
\lambda_i of
\lambda (where we set \lambda_{i+1}=0 if
\lambda_i is the last part).
If c is a restricted p-strict partition of n
such that n minus the number of parts not divisible by
p is even, then there is a unique
p-modular spin character of
2.Sym(n)\tilde{S}_n
that is labelled by
[2,[c,'0']]. Its restriction to
2.Alt(n)\tilde{A}_n
decomposes as the sum
of two distinct p-modular characters which are labelled by
[2,[c,'+']] and [2,[c,'-']].
If n minus the number of parts of c that are not
divisible by p is odd,
then there are two distinct p-modular spin characters of
2.Sym(n)\tilde{S}_n
that are labelled by
[2,[c,'+']] and [2,[c,'-']].
Both of these characters restrict to the same irreducible
p-modular spin character of
2.Alt(n)\tilde{A}_n
which is labelled by
[2,[c,'0']].
ctS:= CharacterTable( "Sym(5)" ) mod 3;;
gap> ct2S:= CharacterTable( "2.Sym(5)" ) mod 3;;
gap> ch:= CharacterParameters(ct2S);
[ [ 1, [ 5 ] ], [ 1, [ 4, 1 ] ], [ 1, [ 3, 2 ] ],
[ 1, [ 3, 1, 1 ] ], [ 1, [ 2, 2, 1 ] ],
[ 2, [ [ 4, 1 ], '+' ] ], [ 2, [ [ 4, 1 ], '-' ] ],
[ 2, [ [ 3, 2 ], '0' ] ] ]
gap> pos:= Positions( List(ch, x-> x[1]), 1 );;
gap> RestrictedClassFunctions( Irr(ctS), ct2S ) = Irr(ct2S){pos}; #inflation
true
gap> ct2A:= CharacterTable( "2.Alt(5)" ) mod 3;;
gap> CharacterParameters(ct2A);
[ [ 1, [ [ 5 ], '0' ] ], [ 1, [ [ 4, 1 ], '0' ] ],
[ 1, [ [ 3, 1, 1 ], '+' ] ], [ 1, [ [ 3, 1, 1 ], '-' ] ],
[ 2, [ [ 4, 1 ], '0' ] ], [ 2, [ [ 3, 2 ], '+' ] ], [ 2, [ [ 3, 2 ], '-' ] ] ]
]]>
Class parameters
Let ct be an ordinary SpinSym table. Then ct
has a list of class parameters, that is, a list of suitable
labels corresponding to the columns of ct and therefore
the conjugacy classes of the underlying group.
See ClassParameters() in the GAP Reference Manual.
If bt is a Brauer table in characteristic p
relative to ct, its class parameters are inherited from
ct in correspondence with the p-regular conjugacy
classes of the underlying group.
Let P(n) denote the set of partitions of n.
The conjugacy classes of
S_nSym(n)
are naturally parameterized by the cycle types of
their elements, and each cycle type corresponds to a partition
of n. Therefore a conjugacy class C of
S_nSym(n)
is characterized by its typec\in P(n)c in P(n).
The corresponding entry in the list of
class parameters is [1,c].
Assume that C\subset A_nC is a subset of Alt(n).
Then C is also a conjugacy class of
A_nAlt(n)
if and only if not all
parts of c are odd and pairwise distinct. Otherwise,
C splits as the union of two distinct
A_nAlt(n)-classes of the same size,
C^+ of type c^+ and
C^- of type c^-. The corresponding entries
in the list of class parameters are [1,[c,'+']] and
[1,[c,'-']], respectively.
Furthermore,
the preimage C'=C^{{\pi^-1}}\tilde{C}=C^{\pi^{-1}}\subset\tilde{S}_n
is either a conjugacy class of
2.Sym(n)\tilde{S}_n
of type c with
class parameter [1,c], or
C'\tilde{C}
splits as the union of two distinct
2.Sym(n)\tilde{S}_n-classes
C'_1\tilde{C}_1
and C'_2=zC'_1\tilde{C}_2=z\tilde{C}_1,
both of type c with corresponding
class parameters [1,c] and [2,c], respectively.
An analogous description applies for the conjugacy classes of
2.Alt(n)\tilde{A}_n.
ct:= CharacterTable( "Sym(3)" );;
gap> ClassParameters(ct);
[ [ 1, [ 1, 1, 1 ] ], [ 1, [ 2, 1 ] ], [ 1, [ 3 ] ] ]
gap> ct:= CharacterTable( "Alt(3)" );;
gap> ClassParameters(ct);
[ [ 1, [ 1, 1, 1 ] ], [ 1, [ [ 3 ], '+' ] ], [ 1, [ [ 3 ], '-' ] ] ]
gap> ct:= CharacterTable( "2.Sym(3)" );;
gap> ClassParameters(ct);
[ [ 1, [ 1, 1, 1 ] ], [ 2, [ 1, 1, 1 ] ], [ 1, [ 2, 1 ] ], [ 2, [ 2, 1 ] ],
[ 1, [ 3 ] ], [ 2, [ 3 ] ] ]
gap> ct:= CharacterTable( "2.Alt(3)" );;
gap> ClassParameters(ct);
[ [ 1, [ 1, 1, 1 ] ], [ 2, [ 1, 1, 1 ] ],
[ 1, [ [ 3 ], '+' ] ], [ 2, [ [ 3 ], '+' ] ],
[ 1, [ [ 3 ], '-' ] ], [ 2, [ [ 3 ], '-' ] ] ]
]]>
To each conjugacy class of
2.Sym(n)\tilde{S}_n
or
2.Alt(n)\tilde{A}_n
a certain standard representative is assigned in the
following way. Let c=[c_1,c_2,\ldots,c_m] be a partition
of n. We set d_1=0,
d_i=c_1+\ldots +c_{i-1} for i\geq 2, and
t(c_i,d_i)= t_{d_i+1}t_{d_i+2}\ldots t_{d_i+c_i-1}
for 1\leq i\leq m-1, where t(c_i,d_i)= 1 if
c_i=1. The standard representative of typec is defined as
t_c=t(c_1,d_1)t(c_2,d_2)\cdots t(c_{m-1},d_{m-1}).t_c=t(c_1,d_1)t(c_2,d_2)...t(c_{m-1},d_{m-1}).
Furthermore, we define the standard representatives of type
c^+=[c,'+'] and c^-=[c,'-'] to be
t_{c^+}=t_{c} and
t_{c^-}=t_1^{-1}t_c t_1 , respectively.
For example, the standard representative of type
c=[7,4,3,1]\in P(15)c=[7,4,3,1] in P(15)
is t_c=t_1t_2t_3t_4t_5t_6t_8t_9t_{10}t_{12}t_{13}.
Now C'\tilde{C}
is a conjugacy class of
2.Sym(n)\tilde{S}_n
or 2.Alt(n)\tilde{A}_n
with parameter
[1,c] if and only if
t_c is an element of C't_c\in\tilde{C},[2,c] if and only if
zt_c is an element of C'zt_c\in\tilde{C},[1,[c,'+']] if and only if
t_{c^+} is an element of C't_{c^+}\in\tilde{C},[2,[c,'+']] if and only if
zt_{c^+} is an element of C'zt_{c^+}\in\tilde{C},[1,[c,'-']] if and only if
t_{c^-} is an element of C't_{c^-}\in\tilde{C},[2,[c,'-']] if and only if
zt_{c^-} is an element of C'zt_{c^-}\in\tilde{C}.the image of the standard representative of type c under
a given
\tilde{S}_n2.Sym(n)-representation.
Expecting the second entry of a class parameter of
2.Sym(n)\tilde{S}_n
or
2.Alt(n)\tilde{A}_n, say c,
the standard representative of type c under a given
representation of
2.Sym(n)\tilde{S}_n is computed.
The argument rep is assumed to be a list
[t_1^R,t_2^R,\ldots,t_{n-1}^R]
given by the images of the generators
t_1,\ldots,t_{n-1} of
2.Sym(n)\tilde{S}_n
under a (not necessarily faithful)
representation R of
2.Sym(n)\tilde{S}_n.
ct:= CharacterTable("2.Sym(15)") mod 5;;
gap> cl:= ClassParameters(ct)[99];
[ 1, [ 7, 4, 3, 1 ] ]
gap> c:= cl[2];;
gap> rep:= BasicSpinRepresentationOfSymmetricGroup(15,5);;
gap> t:= SpinSymStandardRepresentative(c,rep);
< immutable compressed matrix 64x64 over GF(25) >
gap> OrdersClassRepresentatives(ct)[99];
168
gap> Order(t);
168
gap> BrauerCharacterValue(t);
0
]]>
the image of the standard representative of type
c under the natural epimorphism
\pi:\tilde{S}_{\{j,\ldots,j+n-1\}}\to S_{\{j,\ldots,j+n-1\}}\pi:2.Sym({{j,...,j+n-1}}) \to Sym({{j,...,j+n-1}}).
Given the second entry c of a class parameter of
2.Sym(n)\tilde{S}_n
or
2.Alt(n)\tilde{A}_n,
and optionally a positive integer j,
the image of the standard representative of type c under
\pi:\tilde{S}_{\{j,\ldots,j+n-1\}}\to S_{\{j,\ldots,j+n-1\}}\pi:2.Sym({{j,...,j+n-1}}) \to Sym({{j,...,j+n-1}}) with
t_i^\pi=(i,i+1) for j\leq i\leq j+n-2
is computed by calling
SpinSymStandardRepresentative(c,rep) where
rep is the list
[(j,j+1),(j+1,j+2),...,(j+n-2,j+n-1)].
By default, j=1.
s1:= SpinSymStandardRepresentativeImage([7,4,3,1]);
(1,7,6,5,4,3,2)(8,11,10,9)(12,14,13)
gap> s2:= SpinSymStandardRepresentativeImage([[7,4,3,1],'-']);
(1,2,7,6,5,4,3)(8,11,10,9)(12,14,13)
gap> s2 = s1^(1,2);
true
gap> SpinSymStandardRepresentativeImage([7,4,3,1],3);
(3,9,8,7,6,5,4)(10,13,12,11)(14,16,15)
]]>
a (standard) lift of the element c of
Sym(n)S_n in
2.Sym(n)\tilde{S}_n
under a given
\tilde{S}_n2.Sym(n)-representation.
See for the
definition of the lift that is returned by this function.
The permutation c is written as a product of simple
transpositions (i,i+1), then these are replaced by
the images of their canonical lifts t_i under a given
representation R of \tilde{S}_n2.Sym(n) (recall the beginning of Chapter
for the definition of t_i).
Here rep is assumed to be the list
[t_1^R,t_2^R,\ldots,t_{n-1}^R].
Note that a more efficient computation may be achieved by
computing and storing a list of all necessary transpositions once and for all,
before lifting (many) elements (under a possibly large representation).
rep:= BasicSpinRepresentationOfSymmetricGroup(15);;
gap> c:= SpinSymStandardRepresentativeImage([5,4,3,2,1]);
(1,5,4,3,2)(6,9,8,7)(10,12,11)(13,14)
gap> C:= SpinSymPreimage(c,rep);
< immutable compressed matrix 64x64 over GF(9) >
gap> C = SpinSymStandardRepresentative([5,4,3,2,1],rep);
true
]]>
the Brauer character afforded by a given representation
of 2.Sym(n)\tilde{S}_n.
This function is based on a simplified computation of the &GAP; attribute
BrauerCharacterValue(mat) for an invertible matrix mat
over a finite field whose characteristic is coprime to the order of
mat.
The arguments ccl and ords are expected to
be the values of the attributes ClassParameters(modtbl) and
OrdersClassRepresentatives(modtbl) of a (possibly incomplete)
p-modular SpinSym table modtbl of
2.Sym(n)\tilde{S}_n.
The argument rep is assumed to be a list
[t_1^R,t_2^R,\ldots,t_{n-1}^R]
given by the images of the generators
t_1,\ldots,t_{n-1} of
2.Sym(n)\tilde{S}_n
under a (not necessarily faithful)
2.Sym(n)\tilde{S}_n-representation R.
ct:= CharacterTable("DoubleCoverSymmetric",15);;
gap> bt:= CharacterTableRegular(ct,5);;
gap> fus:= GetFusionMap(bt,ct);;
gap> ccl:= ClassParameters(ct){fus};;
gap> ords:= OrdersClassRepresentatives(bt);;
gap> rep:= BasicSpinRepresentationOfSymmetricGroup(15,5);;
gap> phi:= SpinSymBrauerCharacter(ccl,ords,rep);;
gap> phi in Irr(ct mod 5);
true
]]>
a p-modular basic spin character of the
(possibly incomplete) p-modular SpinSym table modtbl of
2.Sym(n)\tilde{S}_n.
This is just a shortcut for constructing a basic spin representation of
2.Sym(n)\tilde{S}_n in characteristic p
and computing its Brauer character by calling
afterwards.
SetClassParameters(bt,ccl);
gap> SpinSymBasicCharacter(bt) = phi;
true
]]>
Young subgroups
Let k and l be integers greater than
1 and set n=k+l.
The following subgroup of
2.Sym(n)\tilde{S}_n,
\tilde{S}_{k,l} =
\langle t_1,\ldots,t_{k-1}, t_{k+1},\ldots,t_{n-1}\rangle,2.(Sym(k){\times}Sym(l)) =
< t_1,...,t_{k-1}, t_{k+1},...,t_{n-1} >,
is called a (maximal) Young subgroup of
2.Sym(n)\tilde{S}_n.
Similarly,
\tilde{A}_{k,l}=\tilde{S}_{k,l}\cap\tilde{A}_{n}the intersection 2.(Alt(k){\times}Alt(l))
of 2.(Sym(k){\times}Sym(l)) and 2.Alt(n) is
a (maximal) Young subgroup of
2.Alt(n)\tilde{A}_n.
Note that
(\tilde{S}_{k,l})^\pi \cong S_k\times S_{l}(2.(Sym(k){\times}Sym(l)))^\pi
is isomorphic to Sym(k){\times}Sym(l) and
(\tilde{A}_{k,l})^\pi \cong A_k\times A_{l}(2.(Alt(k){\times}Alt(l)))^\pi
is isomorphic to Alt(k){\times}Alt(l) but only
\tilde{A}_{k,l}\cong (\tilde{A}_k\times\tilde{A}_{l})/\langle(z,z)\rangle2.(Alt(k){\times}Alt(l))
which is isomorphic to
(2.Alt(k){\times}2.Alt(l))/ <(z,z)>
is a central product.
In between
\tilde{A}_{k,l}2.(Alt(k){\times}Alt(l))
and
\tilde{S}_{k,l}2.(Sym(k){\times}Sym(l))
there are further central products
\tilde{S}_k\circ\tilde{A}_{l}\cong
(\tilde{S}_k\times\tilde{A}_{l})/\langle(z,z)\rangle2.(Sym(k){\times}Alt(l)) which is isomorphic to
(2.Sym(k){\times}2.Alt(l))/<(z,z)>
and \tilde{A}_k\circ\tilde{S}_{l}\cong
(\tilde{A}_k\times\tilde{S}_{l})/\langle(z,z)\rangle2.(Alt(k){\times}Sym(l)) which is isomorphic to
(2.Alt(k){\times}2.Sym(l))/<(z,z)>
which are \pi-preimages of
S_k\times A_{l}Sym(k){\times}Alt(l) and
A_k\times S_{l}Alt(k){\times}Sym(l), respectively.
See .
the ordinary character table of a maximal Young subgroup
depending on type.
For integers k and l greater than 1
the function returns the ordinary character table of
\tilde{A}_{k,l}2.(Alt(k){\times}Alt(l)),
\tilde{A}_k\circ\tilde{S}_l2.(Alt(k){\times}Sym(l)),
\tilde{S}_k\circ\tilde{A}_l2.(Sym(k){\times}Alt(l)), or
\tilde{S}_{k,l}2.(Sym(k){\times}Sym(l))
depending on the string type being
"Alternating",
"AlternatingSymmetric",
"SymmetricAlternating", or
"Symmetric", respectively.
If type is "Symmetric" then the output
is computed by means of Clifford's theory from the character
tables of
\tilde{S}_k\circ\tilde{A}_l2.(Sym(k){\times}Alt(l)),
\tilde{A}_{k,l}2.(Alt(k){\times}Alt(l)), and
\tilde{A}_k\circ\tilde{S}_l2.(Alt(k){\times}Sym(l))
(see ).
These `ingredients' are computed and then stored in the
attribute SpinSymIngredients so they can be accessed during
the construction (and for the construction of a relative
Brauer table too, see
).
The construction of the character tables of type"Alternating",
"AlternatingSymmetric", or
"SymmetricAlternating" is straightforward and may be
accomplished by first construcing a direct product,
for example, the character table of
\tilde{S}_k\times\tilde{A}_{l}2.Sym(k){\times}2.Alt(l),
followed by the construction of the character table of the
factor group mod
\langle(z,z)\rangle<(z,z)>.
However, we use a faster method that builds up the table from
scratch, using the appropriate component tables as ingredients
(for example, the generic character tables of
2.Sym(k)\tilde{S}_k
and
2.Alt(l)\tilde{A}_l).
In this way we can easily build up a suitable list of
class parameters that are needed to determine the class fusion
in the construction of type"Symmetric".
2AA:= SpinSymCharacterTableOfMaximalYoungSubgroup(8,5,"Alternating");
CharacterTable( "2.(Alt(8)xAlt(5))" )
gap> SpinSymCharacterTableOfMaximalYoungSubgroup(8,5,"AlternatingSymmetric");
CharacterTable( "2.(Alt(8)xSym(5))" )
gap> SpinSymCharacterTableOfMaximalYoungSubgroup(8,5,"SymmetricAlternating");
CharacterTable( "2.(Sym(8)xAlt(5))" )
gap> 2SS:= SpinSymCharacterTableOfMaximalYoungSubgroup(8,5,"Symmetric");
CharacterTable( "2.(Sym(8)xSym(5))" )
]]>
the p-modular character table of
the ordinary character table ordtbl
returned by the function
.
If the rational prime p is odd, then the construction of the irreducible
Brauer characters is really the same as in the ordinary case
but it depends on the p-modular tables of
of ordtbl's `ingredients'.
If some Brauer table that is
necessary for the construction is not available then
fail is returned.
Alternatively, the mod-operator may be used.
For p=2 the Brauer table is essentially
constructed as a direct product by standard &GAP; methods written by Thomas Breuer.
We call a character table returned by
or
a SpinSym table too. It has lists of class and
character parameters whose format
is explained in .
SpinSymBrauerTableOfMaximalYoungSubgroup(2AA,3);
BrauerTable( "2.(Alt(8)xAlt(5))", 3 )
gap> 2SS mod 5;
BrauerTable( "2.(Sym(8)xSym(5))", 5 )
gap> ct:= 2SS mod 2;
BrauerTable( "2.(Sym(8)xSym(5))", 2 )
gap> ct1:= CharacterTable("Sym(8)") mod 2;;
gap> ct2:= CharacterTable("Sym(5)") mod 2;;
gap> Irr(ct1*ct2) = Irr(ct);
true
]]>
Class Fusions
The following functions determine class fusion maps between
SpinSym tables by means of their class parameters.
Such `default' class fusion maps allow to induce
characters from various subgroups of
2.Sym(n)\tilde{S}_n
or
2.Alt(n)\tilde{A}_n
consistently.
a fusion map from the SpinSym table ctSource
to the SpinSym table ctDest. This map is
stored if there is no other fusion map from
ctSource to ctDest stored yet.
The possible input tables are expected to be
either ordinary or p-modular SpinSym tables
of the following pairs of groups
The appropriate function (see the descriptions below) is called to determine
the fusion map fus. If
GetFusionMap(ctSource, ctDest) fails, then
fus is stored by calling
StoreFusion(ctSource, fus, ctDest).
ctD:= CharacterTable("2.Sym(18)");;
gap> ctS:= SpinSymCharacterTableOfMaximalYoungSubgroup(10,8,"Symmetric");;
gap> GetFusionMap(ctS,ctD);
fail
gap> SpinSymClassFusion(ctS,ctD);;
#I SpinSymClassFusion: stored fusion map from 2.(Sym(10)xSym(8)) to 2.Sym(18)
gap> GetFusionMap(ctS,ctD) <> fail;
true
]]>
a fusion map between the SpinSym tables of
\tilde{A}_n2.Alt(n)
and
\tilde{S}_n2.Sym(n).
Given lists of class parameters cclSource and
cclDest of (ordinary or p-modular)
SpinSym tables of
\tilde{A}_n2.Alt(n) and
\tilde{S}_n2.Sym(n),
respectively, a corresponding class fusion map is determined.
See .
a fusion map between the SpinSym tables of
\tilde{S}_k2.Sym(k)
and
\tilde{S}_n2.Sym(n)
for k\leq n.
Given lists of class parameters cclSource and
cclDest of (ordinary or p-modular)
SpinSym tables of
\tilde{S}_k2.Sym(k)
and \tilde{S}_n2.Sym(n) for k\leq n,
respectively, a corresponding class fusion map is determined.
See .
ctD:= CharacterTable("2.Sym(18)");;
gap> ctS:= CharacterTable("2.Sym(6)");;
gap> cclD:= ClassParameters(ctD);;
gap> cclS:= ClassParameters(ctS);;
gap> fus:= SpinSymClassFusion2Sin2S(cclS,cclD);;
gap> StoreFusion(ctS,fus,ctD);
]]>
a fusion map between the SpinSym tables of
\tilde{A}_k2.Alt(k)
and
\tilde{A}_n2.Alt(n)
for k\leq n.
Given lists of class parameters cclSource and
cclDest of (ordinary or p-modular)
SpinSym tables of
\tilde{A}_k2.Alt(k)
and \tilde{A}_n2.Alt(n)
for k\leq n,
respectively, a corresponding class fusion map is determined.
See .
a fusion map between the SpinSym tables of
\tilde{S}_{n-2}2.Sym(n-2)
and
\tilde{A}_n2.Alt(n).
Given lists of class parameters cclSource and
cclDest of (ordinary or p-modular)
SpinSym tables of
\tilde{S}_{n-2}2.Sym(n-2)
and \tilde{A}_n2.Alt(n),
respectively, a corresponding class fusion map with respect
to the embedding of
\langle t_1t_{n-2},\ldots,t_{n-3}t_{n-1}\rangle\cong\tilde{S}_{n-2}< t_1t_{n-2},\ldots,t_{n-3}t_{n-1} > isomorphic to 2.Sym(n-2)
in
\tilde{A}_n2.Alt(n) is determined.
See .
a fusion map between the SpinSym tables of
\tilde{S}_{k,l}2.(Sym(k){\times}Sym(l))
and \tilde{S}_{k+l}2.Sym(k+l).
Given lists of class parameters cclSource and
cclDest of (ordinary or p-modular)
SpinSym tables of
\tilde{S}_{k,l}2.(Sym(k){\times}Sym(l))
and \tilde{S}_{k+l}2.Sym(k+l),
respectively,
a corresponding class fusion map is determined by means of
.
ctD:= CharacterTable("2.Sym(18)");;
gap> ctS:= SpinSymCharacterTableOfMaximalYoungSubgroup(10,8,"Symmetric");;
gap> cclD:= ClassParameters(ctD);;
gap> cclS:= ClassParameters(ctS);;
gap> fus:= SpinSymClassFusion2SSin2S(cclS,cclD);;
gap> StoreFusion(ctS,fus,ctD);
]]>
a fusion map between the SpinSym tables of
\tilde{S}_k\circ\tilde{A}_l2.(Sym(k){\times}Alt(l))
and
\tilde{S}_{k,l}2.(Sym(k){\times}Sym(l)).
Given lists of class parameters cclSource and
cclDest of (ordinary or p-modular)
SpinSym tables of
\tilde{S}_k\circ\tilde{A}_l2.(Sym(k){\times}Alt(l))
and
\tilde{S}_{k,l}2.(Sym(k){\times}Sym(l)),
respectively,
a corresponding class fusion map is determined.
See .
a fusion map between the SpinSym tables of
\tilde{A}_k\circ\tilde{S}_l2.(Alt(k){\times}Sym(l))
and
\tilde{S}_{k,l}2.(Sym(k){\times}Sym(l)).
Given lists of class parameters cclSource and
cclDest of (ordinary or p-modular)
SpinSym tables of
\tilde{A}_k\circ\tilde{S}_l2.(Alt(k){\times}Sym(l))
and
\tilde{S}_{k,l}2.(Sym(k){\times}Sym(l)),
respectively,
a corresponding class fusion map is determined analogously to
.
a fusion map between the SpinSym tables of
\tilde{A}_{k,l}2.(Alt(k){\times}Alt(l))
and
\tilde{S}_k\circ\tilde{A}_l2.(Sym(k){\times}Alt(l)).
Given lists of class parameters cclSource
and cclDest of (ordinary or p-modular)
SpinSym tables of
\tilde{A}_{k,l}2.(Alt(k){\times}Alt(l))
and
\tilde{S}_k\circ\tilde{A}_l2.(Sym(k){\times}Alt(l)),
respectively,
a corresponding class fusion map is determined.
See .
a fusion map between the SpinSym tables of
\tilde{A}_{k,l}2.(Alt(k){\times}Alt(l))
and
\tilde{A}_k\circ\tilde{S}_l2.(Alt(k){\times}Sym(l)).
Given lists of class parameters cclSource and
cclDest of (ordinary or p-modular)
SpinSym tables of
\tilde{A}_{k,l}2.(Alt(k){\times}Alt(l))
and
\tilde{A}_k\circ\tilde{S}_l2.(Alt(k){\times}Sym(l)),
respectively,
a corresponding class fusion map is determined
analogously to .
a fusion map between the SpinSym tables of
\tilde{A}_{k,l}2.(Alt(k){\times}Alt(l))
and \tilde{A}_{k+l}2.Alt(k+l).
Given lists of class parameters cclSource
and cclDest of (ordinary or p-modular)
SpinSym tables of
\tilde{A}_{k,l}2.(Alt(k){\times}Alt(l))
and \tilde{A}_{k+l}2.Alt(k+l),
respectively,
a corresponding class fusion map is determined.
See .
spinsym-1.5.2/doc/clean 0000644 0000766 0000024 00000000146 13544575277 014026 0 ustar mhorn staff #!/bin/bash
rm -f *.{txt,pdf,css,js,aux,lab,log,dvi,ps,bbl,ilg,ind,idx,out,html,tex,pnr,blg,toc,brf}
spinsym-1.5.2/doc/chap1.xml 0000644 0000766 0000024 00000015140 13544575277 014537 0 ustar mhorn staff
Introduction
The purpose of this &GAP; package is to make a collection of
p-modular character tables (Brauer tables) of
spin-symmetric groups (and some related groups) available in
&GAP;, thereby extending Thomas Breuer's &GAP; Character Table Library
.
The &SpinSym; package is based on which serves as the
general reference here.
If you are interested in computing with &SpinSym; I would like to refer you to
for further references and a more thorough description of
some of the topics below. And, of course, I would like to hear from you
about more or less successful attempts in using the present functionalities.
The term `spin-symmetric' refers to the groups
\tilde{S}_n=\langle\ z,t_1,\ldots,t_{n-1}\ :\
z^2=1,\ t_i^2=(t_it_{i+1})^3=z,\ (t_jt_k)^2=z\ \rangle
2.Sym(n)= < z,t_1,...,t_{n-1} :
z^2=1, t_i^2=(t_it_{i+1})^3=z, (t_jt_k)^2=z >
and
\hat{S}_n=\langle\ z,t_1,\ldots,t_{n-1}\ :\
z^2=1,\ t_i^2=(t_it_{i+1})^3=1,\ (t_jt_k)^2=z,\ zt_i=t_iz\ \rangle
(2^+).Sym(n)= < z,t_1,...,t_{n-1} :
z^2=1, t_i^2=(t_it_{i+1})^3=1, (t_jt_k)^2=z, zt_i=t_iz >
where the relations are imposed for all admissable i,j,k
with |j-k|>1. Provided n\geq 4, these groups are
double covers of the symmetric group S_nSym(n)
on n letters. Although
2.Sym(n)\tilde{S}_n
and
(2^+).Sym(n)\hat{S}_n
are non-isomorphic groups for n\neq 6, they are isoclinic
and their representation theory is very similar.
By choice, we restrict the attention to
2.Sym(n)\tilde{S}_n.
(However, if you are interested in character tables of
(2^+).Sym(n)\hat{S}_n then have a look at
CharacterTableIsoclinic() in the &GAP; Reference Manual.)
The natural epimorphism
\pi: 2.Sym(n) \to Sym(n),
t_i\mapsto (i,i+1)\pi: \tilde{S}_n\to S_n,\
t_i\mapsto (i,i+1),
whose kernel is generated by the central involution z,
gives rise to the double cover
2.Alt(n)=Alt(n)^{{\pi^{-1}}}\tilde{A}_n= A_n^{\pi^{-1}}
of the alternating group
A_nAlt(n)
as the preimage of
A_nAlt(n)
under \pi. Irreducible faithful representations of
2.Sym(n)\tilde{S}_n
or
2.Alt(n)\tilde{A}_n
are called spin representations and a similar `spin' terminology
is used for all related faithful objects, to set them apart from
the non-faithful objects that
belong esssentially to
S_nSym(n)
or
A_nAlt(n),
respectively.
The data part
The package contains complete Brauer tables of
2.Sym(n)\tilde{S}_n
and
2.Alt(n)\tilde{A}_n up to degree
n=18 in characteristic p=3,5,7. Thus it includes
the corresponding Brauer tables of
S_nSym(n)
and
A_nAlt(n). Moreover, Brauer tables of
S_nSym(n)
and
A_nAlt(n) up to degree n=19
in characteristic p=2 are part of the package too.
Every Brauer table comes with lists of character parameters
(row labels) and class parameters (column labels), see
and
.
I would like to mention that only some of the data is `new',
large portions date back to
the work of James, Morris, Yaseen, and the Modular Atlas Project.
Detailed references are to be found in .
The 2-modular tables of
S_nSym(n)
and A_nAlt(n) for n=18,19
were computed jointly by Jürgen Müller and the author.
Please note that some of our Brauer tables differ to some extent
from those contained in the &GAP; Character Table Library
(for example, in terms of the ordering of
conjugacy classes and characters or in terms of their parameters).
Therefore it seemed appropriate to collect these tables
in their own package - so here we are.
I'm grateful to Thomas Breuer for supporting the idea of
writing this package and for converting my tables into the right
&GAP; Character Table Library format.
The functions part
Besides Brauer tables, the package provides some related
functionalities such as functions that determine class fusions
of subgroup character tables and functions that compute
character tables of some Young subgroups of
2.Sym(n)\tilde{S}_n.
Installation and loading
To install this package, download the archive file
spinsym-1.5.2.tar.gz and unpack it inside the pkg
subdirectory of your &GAP; installation. It creates a
subdirectory called spinsym. Then load the package
using the LoadPackage command.
LoadPackage("spinsym");
]]>
The SpinSym package banner should appear
on the screen. You may want to run a quick test of the
installation:
dir:= DirectoriesPackageLibrary( "spinsym", "tst" )[1];;
gap> tst:= Filename( dir, "testall.tst" );;
gap> Test( tst );
true
]]>
spinsym-1.5.2/doc/rainbow.js 0000644 0000766 0000024 00000005336 13544575321 015014 0 ustar mhorn staff
function randchar(str) {
var i = Math.floor(Math.random() * str.length);
while (i == str.length)
i = Math.floor(Math.random() * str.length);
return str[i];
}
hexdigits = "0123456789abcdef";
function randlight() {
return randchar("cdef")+randchar(hexdigits)+
randchar("cdef")+randchar(hexdigits)+
randchar("cdef")+randchar(hexdigits)
}
function randdark() {
return randchar("012345789")+randchar(hexdigits)+
randchar("012345789")+randchar(hexdigits)+
randchar("102345789")+randchar(hexdigits)
}
document.write('\n');
spinsym-1.5.2/doc/manual.pdf 0000644 0000766 0000024 00000701640 13544575321 014766 0 ustar mhorn staff %PDF-1.5
%
54 0 obj
<<
/Length 312
/Filter /FlateDecode
>>
stream
x}1o0w~GpHiUu:JJ!6Q:$:d@ި|FI>#D ~h he<Bx5z{y6ÒDĴet4bVENfIl= _SV:m ]_ A
ikcn\hĉZ{ ʮc
endstream
endobj
64 0 obj
<<
/Length 845
/Filter /FlateDecode
>>
stream
xmUKo:WxHNS#"HuUݹ&$ ߏc0wǁk~7} S, {ē,AIH"?f{9ߧj0[S}Jee|DmR
: ݏexm;QBK*WHDj8Y!^y0B/Fql;UcAs7 z j;L BE%l3f3[A?>>vIo2MV 8թ u+VE/` e,?曇o&mxu\ W @^bg 8_<,gμ~٬st5ix1.-G ȭGn sjSRUݛtR07K 4Jd1D+m x9 k S5ǩGK1k) \>
stream
xMo0+|] Um=T H"lmv6cf
ƻt*@9R" = %`H. Hsum]# Iƺ7 1k G` 8UIy?DJnoͧ{{ 9ň%
@4Ɛvx3LzPt9.3>
stream
x]4}Ex)6F
Ur-uTQ0/W@31)ao +Q~penÂ-{ݳϿf!X$B/&ԋDXlqY}}.WB/b>,?}瀪ؤ#PX,N$x]4j6u_65At8ogqƲZƊ~y- Σ7}aQsOJDc iбfXo
7Kxu4n 8]UFۄ0ѱzXul6_/ᤅUW6?7eb% +. H;ez=vEߖkSC }Gyq]AKQQ}iWK?BGyY!>4]!>L )39.zN m bu߾7e@.Omtu!bn
Q+1.r˲J;)H ^]n1rTS+ -^v1ĹQ> a "*yg9
(PgraW"
3hϳ :z(+zi{z` tDi9 oݢ6 }gZ z"~[%J{ƒʁEs *yU *XN8+X({&IRz_ %XfGvn} Uq6` 4)u[ kaYe, f_>ACve^EyniVU>]6KKm8=b[T<➣Rdn *y6, jl"s
\p qY Ve_pC ^eXb s=FXl_LT (L
Z AA]82(H|ʺytXK# Bi
稞oBJcɧ@S\NvJtzS=$*]4-elX1"m g)6A GF!R[ )G*[32(]AU7 *Pү %rk*D`˼8&mMu :8`Rwy 4(N
O
UO dUS9sU=B,귶KX0j=" P :Az5W-f״-]Ͱ 0"ΎqP87 _]PL 4F[y$z ϰz8MƲa[gNebi r#wjRCWJ&Ӷ4| r3|-^#mSc]8a(nOo /Zo@WN I]t Yb\3_TU/Gԥbt$*T;NhzgbJ{gtOʧ ȄOQ*> !ƫl) $Lbn/&TQ571U~($5 G@W" ˙{#u|{|mt'C?!u7
4]e$Թ /#} Q~ř q Dl=y+i<oWہwOC4cOB?ܥܐ[ toR|v!V\]ҽ:%mħ 2aOWm]8zxv:ASPSHd)8M2굲 ,j
sFly=R 1YP m:^K[ڦO w0V {Q+.,KgS#%z_L< h*iL
7(Af2PeJ^ k/a#?,Xeywhڣ pS%dȬ4y
dzS!w~0⪷I _ WĔjbsX Qsȼ=iG.&q ̻xmqGVh)Ϋ
$
GIP.*J4lg`Ҷ;uS54ay# Q_ T9va}LbwhV ]ѻ-ŎF>o$4"PG{ΰZ ]$+DZm#d {7El+^8A繚n|Tcyj@ D0 ʽTLO? 9_V ,f.Ѯ*X$ 2סա/Im3}{8y460!7; mN3q@**o'kO2v($g9
MUb&n5X5=!<
LR5 NTvw4}Ư b+z{!Xeh]sV F`Z1;B4"5ջ
Gi +fI[$O#OmMV6eX0mS^ Aqvw,2s-禮 aF?pk[~#< PloVk1Qz6HlE er wb? //*w6Uc? bS\U rUҬ5= ڰ
endstream
endobj
109 0 obj
<<
/Length 1969
/Filter /FlateDecode
>>
stream
xڽXKFϯ |Y
:&;Fp XԒGfg}(qafUu= m"yHhxb7IhF b yᡘ}Zn"F &5%>KIX4ZPm6`,j4n+ܸ\W]e^-* 4?dToo6c[nOd6NjmZu66UkF MWuKd*|W6-cع^F `m(
f Sa@.ٶ::l۩cd):H=6>6x=T%3$Bj qC&Xd`XsF)Ŗtͫ2x $i4^b~8QUW:
s/u $۽rb[͚Xx
4+W3>
YWD H0~`ݻUG4GMa&P0;g3wƠԵ L ġ(2h#N$g\Щab =f&#L#D9z$)':IgqA:+6AO&]äe&[ʁ<{avHn*ЯSKZ6w_p#|7cqh 1wc囇|fsNڬ&OOqP!z8}]E\7
;X;a\e@~OL %l
Wy
}tv; 5F|L5j (]h}v{f~mWS'gFs8S& C f u{ըh=}=? Z%Zp`WO?o
ά"8 Q0/O4Z7 " %dIE nR#CGB (g Uf 9G'|N )
Lv
Do q= w.yW`f da N7a㷷6Dco}ߍx)\? '1^z ҋqR]+03NrU? g
@)WJD."t{.>O.Nzti0]Vx11qCFfgx BCk3~*\Ϙ:Z;.`e]'"iA7b"ݷP Iboܽ韲3TP'y}Do$Jk0z3h[I8{6{dw3;YpY Qj w~ڦ}Kӫ/< B35n(}(Plyp)_'Cgd
endstream
endobj
116 0 obj
<<
/Length 1579
/Filter /FlateDecode
>>
stream
xڽYMs6Wp|f, A48iIgNc SũD¤D`G'__L|2 AytqIx# J.eaM^OgN.~`_?{ TcG3PJg͝5]Mm=%io Gk00A-.E9¡rF0YMQIwyUD0RXkM{\HZh$im·u[7<:w|bJy}Jx_7f\zI'HT YWnyEzN8\z^w泅uwoFe>wOCUoTOь$0!`zS-Y];MSo K[DT&0E@GH > OgĴPt~2m%#'捌>ؔ3Dq )E1Jo4C7LKz I$8b`D"]rqAQΨIT ٲyML)08LW]L0T i I1$eET@wAS
U8Ȏ {
@L Ə# D23iB7a vfs_V jqmyM3֧z|=vw~U@A:9uT - |Gu ';g: 5OH1Y?jt$I1J [;jt4 "6
wI duu~*8LHV' Iy3%.F]C$ fo=_ږ^(M)5MUqC _7w`˭^.`'r3M6[;.LL]ͶagHd$uQxgr`; c`} 6} 4hs Ԫ¹v~&+b#EOm"> VCS4Y `EH`ť.
ڞL֭?*U5 8hpkVZ7U&1(Pz63ٛۡe@7_ DR>wt6]Nr |a`) XvbE~OBuuSWHNj?c aR
Gsx)Rvٞ+HaҌ[F?^D[\lMW&?j\ϜPPO羴
ATYP8#1:at! ^=IZGQ%
t
WI TAT]x' |x~ՓïPcwƃHw!5
<N= Gh5 k9}*BPۉF1;G!htfP`EZo=T!&*ϱggPa QD1KWZpQw;G G
endstream
endobj
123 0 obj
<<
/Length 2908
/Filter /FlateDecode
>>
stream
x[]oH}ϯ楱& JVOGl!6I!&{
0pLL[ZC=u- x8W'
aBAԨ'7mp '淟~fB02!
z*Cg5! 1.Z,4 !:+"S%-Bp ɐƴ}}
)HC~aleCE{cun&z*Uy&YDrkgڏYyF uu2I"=(*b|IP_X`#]3% BʙƉ N>_}'ߢ{2/ &pT /QVhEpDP`kgf;pU-C0KDC\zA,m
-baa8(ݕߎs$MDUɗXOh0^9`c pj/{|K8&w⧗ *g#ty
}>3㴸>ZDQx<*q1@}/fQI1Q-NaFdJ0]9GlOE4qp/E%_}"a9ADY5L5
ӹZ%U]]x xݍ5d7IHdæ`+3u=w~C7YXܛlV9:"ƚ LA<\i{[i29:e1Hג& f`jp 棧/\y bl1;`6F.P*ʟo_Pb2(L'~d\Lv*EpiS n)z`[. c`*X7b315.wqo8FuUpF(a0ü)Y&F8 _ue!UHn *./N;Fwe'q%k 0eJ6D7%eVXhT n&'PDqe#Vsa^f_qY7Z'H`(ˌ ]
sK݄mW= ̃Oͫ *uڱj(e*ۮ4r' t.>\ߎ:iSg Ijr.iiaCĈa4Eh\lo7ˁVҭ0
&H Lh]3"a5nMG$oR[ a`u.*FJWև7{l Jsdʨ(|oU+.
xvZB 6x4C TJ:4z9zTP8X#$a2y^t8I^B`\mv2]/N#,mgd2^;)h+J]YL~ۓ1Eg
].̟( "jP:kψ= F 3Y C>[K۬_[ʃ<-b44=͢VEI9UXy[eNvm6F(-
aHa 6!Eș W} Tj4U HTI:1NU}88pqT QTAh¶h@$H嘳{2] M](5gNgjjjGVoHr<6P@jws^A~ SG0$),z ԆjeE]{n~ux(dw Q/
F
,Ծ}ć[>Sh?8 aH^2dF/cj$GR> Bo;@뵒.z>q Si)!|GAѱ{?mE7jqgJuf6H b6Iϟ+ב36"a H3jqb cPRoz0 mLa(j0 zs8HmD.Qq#͡ʨWe'+EDg,<1 @aA3j9@Ԓ}\UG)qLn°=!G; "aj#-`(2EW~E[m;%=E)#rd0NmGQ l8>
stream
x\[o#~҇tl$MPmX #G#= 9I#+N> M ~N ۳??g
*Q3% 2_>廧jf#o2@omp~L"%lRF]{KErh021J\eywr6roK7
=ER͏@ZP?MwM.VI&}rpz a, =I),ۼ
p
IH{?b18 (u_G AQH0r U]4"P71U݀# ŠTT #ۋ#QT1Ck~`'_ns*>'bΥ_?ޮ+C>_e > ~o+}zX0葵 y,#m2b bk{;,RIJY -ٖbQ V+ϊr"4
,Nࠓuiea}3cxCzJF,lUK λd<6݁SK
6dVrBF2XZy!KJ}<,e &8D%Aۇū_} 9)=ʫAe*_
HRznȀP[!C<2!
F ܡ+RV4d%Qj[A&:
҉_I\|FM'^S?ΪO<eHF
kFt
ݏGlXQyKeYOYhS/D0!п .v+ 67ߞ>"H5}3`f
5&@ !jyw#]_fѵ ;_Mp"^g 3??ew?0i9^Y5fW T t{*"yN5Kv`[AMGxF 5/f<V aMMvUTu/Tzܾsw]rW{wgˮZ_kA"
C)R\ 8
_E|2\}mH@^JwknB~ oU
_bI N _J),GBR{ C.[f NjĜ6CC݈nؿ<[Ç %Y| <Ѕ0pb'Tqx|8|Fq8xkzX4[@ e|/~j获-^ t Pj:
V+aτwL8I_;B\?>
rN_erőXyj[WJlQ^T[7o_2:Ӕ_#g// I!e2ㇼn
YlʪꛇrawcEۨ+^w?~_(@CQ v_\!)!.0RCC'' DK HIɛMՇ2D)y!ȩDc!o`~u27'HCG^S)O#-aF2 1r0Sޕt"b3;{b1~^L $` ]!5ԉw4Eڶs
G\ 1yshȠgt l\ ʈXT u(3h)t?A;~^vb xެ(w뫇+ꀛh1 nق .mӺz.}qt8mK|n/ZjatoN]tC[Qu QsTi{N*計arSXhct nk]5ef A V
jhGH9G6{ EJוֹ&&8!s'ĚJ"um~뼰EC ]U=*W ާz i2|oЫJ H>鞂t5:
QIX7iDYHza}gI~}:ϐ`*e]Ys/%Ǟ'R$*>H|$"MC65@7uQ}ˤH*)^]YMt y {crh{&hM3j5⭅=.1Or/G!i} #'kn .]B}Q D'knC-bKr<&fHYGx 0~#<w.g54z1Vk\?BY/)6WCsv[C NV2zJ\rsK*9d!̓I7amKC 0>'CY(,ʭ w o!wD@K<.{6_wp? #M8go!)J (+!#U[7{y^]
H&sY 9yM:ߝcsPք (!s[,rnb^ؖ=k }dZO:{alAILZmR%B#-E +z"i1Nine#Ev|/C:b&{-\/Pt-MQ-ho>!v;3GN;( d5'^ˀĂ)HxƞZDz`jS
6ê3F$q+kyPb sPhܞ+1 z:X2 ށ|ɺËKpʌ-Q mQyH*Eݽ4{S>*Gp9Zߌ u+; uqApWar":Fc->Sْ|c[ ɐLe @!E pOn8C,5?}GŎjWC+Ms\ґa@/(۳eh⓰ )I2Ɨty4֤VmW {L>8c!bAYI:+
endstream
endobj
139 0 obj
<<
/Length 3615
/Filter /FlateDecode
>>
stream
x[Io62ȈL F: }A]%I3>vx(E>#G?o2
! jT$A~}yuR 6=chƶyCь3 ь ֻէ4Q̓}xe֛
Y}Z٧gOm"Hq(Y*u[2.ҵ;;Q[Kh<
`p@m-}MKÖ;״ߔIp՟;(R_F.;4?"Yݐ8dy.vscB#F B{>$5 Equ`""F3ҜE³/6/g[ ~++s`"0E5pDի qo?E1Ϯ*"0[Fw'+P{ =N`,0?˻;2(D@Crd_ nqn"tQgB\>*2#v&?F݊_~ 5(!< #Kcί ^\
00߿q7%*sOA}|lї{,|}M ЌNG#k! `/#B@xfJWז@ $1R|3x.'\6Z[)Y~_'f]
Z"I gAn[<cxk+9^3]5#OfÐY\p # f.ptg졷'9Mq%I`$& њwvg>Dyw`ߏu'ٗsd> Y+EZ#XٷjJϚ= 8!S_&6hscvSTE:Ef7NJ&4 q K}
L5zuɜ
y!aP
6y0~ kta2)'wy]6|{n뷽>$oe7NfP^6_%peKɃ-_Fϰ@:-9 >^/O@\avkO {@Հ 2U)$=rM"P+>."'"|<.: CFJ$aWE\Hه{%A?6~̒!WCRpU(D {u@AZ28,;'HUqA L#E%{tm]_qNŢ"
m3 WX/bnh;XpO>P'5ӏZ?i9q4dq@ua'{MMs/u?m:RK{i1
*gc4Htaq O
Xǖ);=l& YUDŽ~}V % &$VRNuӇM F _6 oDmsJ4٭i|sI&rf煂wi:q)d~KfF
M9:2Mc
>tzW$}&$] d27cU螗C|'; bEdsHq t:sll>vH5? USBl2|OOKꀎDlV!
l(괯;:j
*, jT KuP mf Fky,E+)Y60!`c;F
F ͞@׆ϟk1ZރMCj S!B xNZ%H?XX?sM}r Mf]e 6j釉y M9
ܴ>LQctӋrK8 VeuRd TՖ,U*#^>}1]t]ژHIb 86ղ|ir CmE ZN0<11 hZP=<+;f"Y&/uv66 o| #zaN*+w;W}oz"Ͳ71MYnߖ,ߖ}߳/߾';}-A4 Wq' aÏEr @R Yhg$x4 J 1I7Z"r_[^-5Y8ե !2xK2ԣXKE ^
eɟ%\fe^!kc8X[*(?- Hju
R"ة9 ]~;h;]|Ccoy[nf i*ÕUHK#:0K6 <;Qh0ϴ9ELgϚ
9$gaO̳h 騖$< Zq\^gWGm!'?,cu䔯.;mCp"Fȓ& MNr`m9
G~^"Lds"@X -¶[8DHPЍ) 5x6 dNgw 6<h:1z,kP E>2[AJ'Prr\`@"$ֱƒBjf S xo}$}9d6. ]6]ϧ۹ho]Φb E:-r:{9Ka7rcX[cGӧ#cBxcL#b4En>)I"&!Ȇ
[Hؒ\ C]66 Gy`6F{6!{!KTXbT_ŠM|@}!s?O"[l_M}E&]' ߖ9vqwbxh"a#.{Y6W
0"@TLGZ }mԫB`4 7"(v1#):Es /r/Sz ,n