|
#############################################################################
##
## 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( <tau> ) ....... { All Parts Distinct }
## INPUT .... a list <tau> of integers
## OUTPUT ... true iff <tau> has pairwise distinct entries
BindGlobal( "SPINSYM_IsAPD", function( tau )
return Length( Set( tau ) ) = Length( tau );
end );
## SPINSYM_IsAPO( <tau> ) ......... { All Parts Odd }
## INPUT .... a list <tau> of integers
## OUTPUT ... true iff all entries of <tau> are odd
BindGlobal( "SPINSYM_IsAPO", function( tau )
return ForAll( tau, IsOddInt );
end );
#############################################################################
## USER FUNCTIONS
## SpinSymClassFusion2Ain2S( <cclX>, <cclY> )
## INPUT .... class parameters <cclX> of 2.Alt(n)
## .......... class parameters <cclY> 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( <cclX>, <cclY> )
## INPUT .... class parameters <cclX> of 2.Sym(k)
## .......... class parameters <cclY> of 2.Sym(n) for k<n
## see \cite{Maas2011}*{(5.4.2)}
## RECALL: the 1\2 split classes of 2.Sym(n) are parameterized by O(n)\cup D^-(n).
InstallGlobalFunction( SpinSymClassFusion2Sin2S, function( cclX, cclY )
local m, fus, x, y, z;
m:= Sum( cclY[1][2] ) - Sum( cclX[1][2] );
m:= ListWithIdenticalEntries( m, 1 );
fus:= [ ];
for x in cclX do
y:= Concatenation( x[2], m );
if SPINSYM_IsAPO( y ) then
## x is split in 2.Sym(k) and y is still split in 2.Sym(n)
z:= [ x[1], y ];
elif SPINSYM_IsAPD( y ) and SignPartition(y)=-1 then
## k=n-1 and no part of x equals 1:
## y is split in 2.Sym(n)
z:= [ x[1], y ];
else
z:= [ 1, y ];
fi;
Add( fus, Position( cclY, z ) );
od;
return fus;
end );
## SpinSymClassFusion2Ain2A( <cclX>, <cclY> )
## INPUT .... class parameters <cclX> of 2.Alt(k)
## .......... class parameters <cclY> of 2.Alt(n) for k<n
## see \cite{Maas2011}*{(5.4.3)}
## 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).
## If x in O(n)\cap D^+(n), then there are the following four classes in 2.Alt(n):
## 1_x+ = [ 1, [ x, '+' ] ]
## 2_x+ = [ 2, [ x, '+' ] ]
## 1_x- = [ 1, [ x, '-' ] ]
## 2_x- = [ 2, [ x, '-' ] ]
InstallGlobalFunction( SpinSymClassFusion2Ain2A, function( cclX, cclY )
local filt, m, fus, x, y, z;
filt:= function(x)
return Flat(Filtered(x,y->not 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( <cclX>, <cclY> )
## INPUT .... class parameters <cclX> of 2.Sym(n-2)
## .......... class parameters <cclY> 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( <cclX>, <cclY> )
## INPUT .... class parameters <cclX> of 2.(Sym(k) x Sym(l))
## .......... class parameters <cclY> 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<i ) );
## number of shuffles (i,j) -> (j,i) with i=j=0 mod 2:
e:= List( tau_e, i-> Number( pi_e, j-> j<i ) );
s:= ( Sum(o) + Sum(e) ) mod 2;
if s = 0 then
y:= [ x[1], mu ];
else ## 1\2_x corresponds to 2\1_mu
y:= [ x[1] mod 2 + 1, mu ];
fi;
else ## mu is not in O(n) or D^-(n)
y:= [ 1, mu ];
fi;
Add( fus, Position( cclY, y ) );
od;
return fus;
end );
## SpinSymClassFusion2SAin2SS( <cclX>, <cclY> )
## INPUT .... class parameters <cclX> of 2.(Sym(k) x Alt(l))
## .......... class parameters <cclY> 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( <cclX>, <cclY> )
## INPUT .... class parameters <cclX> of 2.(Alt(k) x Sym(l))
## .......... class parameters <cclY> 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( <cclX>, <cclY> )
## INPUT .... class parameters <cclX> of 2.(Alt(k) x Alt(l))
## .......... class parameters <cclY> 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( <cclX>, <cclY> )
## INPUT .... class parameters <cclX> of 2.(Alt(k) x Alt(l))
## .......... class parameters <cclY> 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( <cclX>, <cclY> )
## INPUT .... class parameters <cclX> of 2.(Alt(k) x Alt(l))
## .......... class parameters <cclY> 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<i ) ) );
o:= Sum( List( tau, i-> Number( pi_o, j-> j<i ) ) );
f:= Length( pi_e ) + Length( tau_e );
type:= Set( [ sgnpi, sgntau ] ); ## "+-", "+", or "-"
if x[1] = 2 then
e:= e+1; ## second class
fi;
if type = "+" or type = "-" then
if o mod 2 = 0 then
y:= [ e, splittype(mu) ];
elif f > 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( <X>, <Y> )
## INPUT .... (ordinary or modular) 'generic' character table <X> of SOURCE
## .......... (ordinary or modular) 'generic' character table <Y> 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 );
[ Dauer der Verarbeitung: 0.7 Sekunden
(vorverarbeitet)
]
|
