|
#############################################################################
##
## mtx.gi The SpinSym Package Lukas Maas
##
## Some MeatAxe-related functions for 2.Sym(n)
## Copyright (C) 2012 Lukas Maas
##
#############################################################################
## SpinSymStandardRepresentative( <c>, <rep> )
## INPUT .... the second component of a parameter <c> of a conjugacy class
## .......... of 2.Sym(n) or 2.Alt(n), i.e.
## .......... <c> = lambda or <c> = [ lambda, sign ] where
## .......... lambda is a partition of n, and sign is either '+' or '-';
## .......... a representation <rep> of 2.Sym(n) (n-1 generators)
## OUTPUT ... the standard representative of the first class of type <c>
## .......... under the representation <rep>, see \cite{Maas2011}*{(5.1.2)}
## NOTE ..... if <c> = [ lambda, '-' ], then t^<rep>[1] is returned, where t denotes
## .......... the standard representative of type [ lambda, '+' ] = lambda
## .......... under <rep>
## .......... <rep> is not required to be faithful
InstallGlobalFunction( SpinSymStandardRepresentative, function( c, rep )
local lambda, sign, pos, t, a, b, i;
lambda:= c;
if '+' in lambda or '-' in lambda then
sign:= lambda[2];
lambda:= lambda[1];
else
sign:= '+';
fi;
pos:= Position( lambda, 1 );
if pos = 1 then ## <c> parameterizes one of the trivial classes {1} or {z}
t:= rep[1]^0;
else
if pos <> fail then
pos:= pos-1;
else ## pos=fail: 1 is not a part of lambda
pos:= Length( lambda );
fi;
a:= List( [1..pos], i-> Sum( lambda{ [1..i] } )-1 );
b:= [1 .. a[1]];
t:= Product( rep{ b } );
for i in [2..pos] do ## pos = Length( a )
b:= [ a[i-1]+2 .. a[i] ];
t:= t * Product( rep{ b } );
od;
fi;
if sign = '-' then
t:= rep[1]^-1 * t * rep[1];
fi;
return t;
end );
## SpinSymStandardRepresentativeImage( <c> [, <j> ] )
## INPUT .... a class parameter <c> of a conjugacy class of 2.Sym(n) or 2.Alt(n), i.e.
## .......... <c> = lambda or <c> = [ lambda, sign ] where
## .......... lambda is a partition of n and sign is either '+' or '-';
## .......... OPTIONAL: an integer <j> such that 0<j<n; by default, <j>=1.
## OUTPUT ... the image of the 2.Sym(n)-standard representative of type <c> in Sym(n)
## .......... under the epimorphism t_i -> (i,i+1) for i=<j>,...,n-1.
## NOTE ..... if <c> = [ lambda, '-' ], then s^(<j>,<j>+1) is returned, where s denotes
## .......... the image of the standard representative of type [ lambda, '+' ] = lambda
InstallGlobalFunction( SpinSymStandardRepresentativeImage, function( arg )
local j, lambda, rep, s;
if Length(arg) = 2 then
lambda:= arg[1];
j:= arg[2];
else
lambda:= arg[1];
j:= 1;
fi;
if '+' in lambda or '-' in lambda then
lambda:= lambda[1];
fi;
rep:= List( [j..j+Sum(lambda)-2], i-> (i,i+1) );
s:= SpinSymStandardRepresentative( arg[1], rep );
return s;
end );
## SpinSymBrauerCharacter( <ccl>, <ords>, <rep> )
## INPUT .... the list of class parameters <ccl> and the list of orders <ords>
## .......... of a modular SpinSym table of 2.Sym(n), and a list <rep> of
## .......... images [t_1^R,...,t_(n-1)^R] of the generators of 2.Sym(n) under
## .......... a representation R of 2.Sym(n)
## OUTPUT ... the Brauer character afforded by R
InstallGlobalFunction( SpinSymBrauerCharacter,
function( ccl, ords, rep )
local brauercharactervalue, pos1, pos2, i, t, phi;
## slightly changed version of Thomas Breuer's
## original function BrauerCharacterValue
brauercharactervalue:= function( mat, order )
local n, p, info, value, pair, f, nullity;
n:= order; # the only change
if n = 1 then
return Length( mat );
fi;
p := Characteristic( mat );
if n mod p = 0 then
return fail;
fi;
info := ZevData( p ^ DegreeFFE( mat ), n );
value := 0;
for pair in info do
f := pair[1];
nullity := Length( NullspaceMat( ValuePol( f, mat ) ) );
if nullity <> 0 then
nullity := nullity / (Length( f ) - 1);
Assert( 1, IsInt( nullity ),
"degree of <f> must divide <nullity>" );
value := value + nullity * pair[2];
fi;
od;
return value;
end;
pos1:= Filtered( [1 .. Length( ccl ) ], i-> ccl[i][1] = 1 );
phi:= [];
for i in pos1 do
t:= SpinSymStandardRepresentative( ccl[i][2], rep );
phi[i]:= brauercharactervalue( t, ords[i] );
pos2:= Position( ccl, [ 2, ccl[i][2] ] );
if pos2 <> fail then
phi[ pos2 ]:= - phi[i];
fi;
od;
return phi;
end );
## SpinSymBasicCharacter( <modtbl> )
## INPUT .... the head <modtbl> of a regular character table of 2.Sym(n)
## OUTPUT ... a <p>-modular basic spin character of <modtbl>
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( <i>, <j>, <rep> )
## returns the transposition t_<i>,<j> under the matrix representation <rep>
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( <pi> )
## writes a permutation <pi> 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( <pi>, <rep> )
## returns a (standard) preimage of the element <pi> of Sym(n)
## in 2.Sym(n) under the representation <rep>
## <pi> : an element of Sym(n)
## <rep> : 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 );
[ Dauer der Verarbeitung: 0.7 Sekunden
(vorverarbeitet)
]
|
