Specht(e)
Specht(e, p)
Specht(e, p, val [,HeckeRing])
Let R be a field of characteristic 0, q a non--zero element of
R, and let e be the smallest positive integer such that
1+q+ldots+q^e-1=0 (we set <e>=0 if no such integer
exists). The record returned by Specht(e) allows calculations in
the Grothendieck rings of the Hecke algebras H of type A which are
defined over R and have parameter q. (The Hecke algebra is
described in Chapter Iwahori-Hecke algebras; see also Hecke
Hecke.) Below we also describe how to consider Hecke algebras
defined over fields of positive characteristic.
Specht returns a record which contains, among other things,
functions S , P, and D which correspond to the Specht modules,
projective indecomposable modules, and the simple modules for the
family of Hecke algebras determined by R and q. Specht allows
manipulation of arbitrary linear combinations of these ``modules'',
as well as a way of inducing and restricting them, ``multiplying''
them, and converting between these three natural bases of the
Grothendieck ring. Multiplication of modules corresponds to taking a
tensor product, and then inducing (thus giving a module for a larger
Hecke algebra).
gap> RequirePackage("specht"); H:=Specht(5);
Specht(e=5, S(), P(), D(), Pq())
gap> H.D(3,2,1);
D(3,2,1)
gap> H.S( last );
S(6)-S(4,2)+S(3,2,1)
gap> InducedModule(H.P(3,2,1));
P(4,2,1)+P(3,3,1)+P(3,2,2)+2*P(3,2,1,1)
gap> H.S(last);
S(4,2,1)+S(3,3,1)+S(3,2,2)+2*S(3,2,1,1)+S(2,2,2,1)+S(2,2,1,1,1)
gap> H.D(3,1)*H.D(3);
D(7)+2*D(6,1)+D(5,2)+D(5,1,1)+2*D(4,3)+D(4,2,1)+D(3,3,1)
gap> RestrictedModule(last);
4*D(6)+3*D(5,1)+5*D(4,2)+2*D(4,1,1)+2*D(3,3)+2*D(3,2,1)
gap> H.S(last);
S(6)+3*S(5,1)+3*S(4,2)+2*S(4,1,1)+2*S(3,3)+2*S(3,2,1)
gap> H.P(last);
P(6)+3*P(5,1)+2*P(4,2)+2*P(4,1,1)+2*P(3,3)
The way in which the partitions indexing the modules are printed can
be changed using SpechtPrettyPrint SpechtPrettyPrint.
There is also a function Schur Schur for doing calculations with
the q--Schur algebra. See DecompositionMatrix
DecompositionMatrix, and CrystalDecompositionMatrix
CrystalDecompositionMatrix.
This function requires the package ``specht'' (see RequirePackage). medskip
The functions H.S, H.P, and H.D
The functions H.S, H.P, and H.D return records which correspond
to Specht modules, projective indecomposable modules, and simple
modules respectively. Each of these three functions can be called in
four different ways, as we now describe.
bigskip
H.S(mu) qquad H.P(mu) qquad H.D(mu)
In the first form, mu is a partition (either a list, or a sequence of integers), and the corresponding Specht module, PIM, or simple module (respectively), is returned.
gap> H.P(4,3,2); P(4,3,2)
bigskip
H.S(x) qquad H.P(x) qquad H.D(x)
Here, x is an H--module. In this form, H.S rewrites x as a
linear combination of Specht modules, if possible. Similarly, H.P
and H.D rewrite x as a linear combination of PIMs and simple
modules respectively. These conversions require knowledge of the
relevant decomposition matrix of H; if this is not known then
false is returned (over fields of characteristic zero, all of the
decomposition matrices are known via the algorithm of [LLT]; various
other decomposition matrices are included with Specht). For example,
H.S(H.P(mu)) returns sum_nu d_numu S(nu), or
false if some of these decomposition multiplicities are not known.
gap> H.D( H.P(4,3,2) ); D(5,3,1)+2*D(4,3,2)+D(2,2,2,2,1) gap> H.S( H.D( H.S(1,1,1,1,1) ) ); -S(5)+S(4,1)-S(3,1,1)+S(2,1,1,1)
As the last example shows, Specht does not always behave as
expected. The reason for this is that Specht modules indexed by
e--singular partitions can always be written as a linear combination
of Specht modules which involve only e--regular partitions. As such,
it is not always clear when two elements are equal in the Grothendieck
ring. Consequently, to test whether two modules are equal you should
first rewrite both modules in the D--basis; this is not done by
Specht because it would be very inefficient.
bigskip
H.S(d, mu) qquad H.P(d, mu) qquad H.D(d, mu)
In the third form, d is a decomposition matrix and mu is a
partition. This is useful when you are trying to calculate a new
decomposition matrix d because it allows you to do calculations
using the known entries of d to deduce information about the unknown
ones. When used in this way, H.P and H.D use d to rewrite
P(mu) and D(mu) respectively as a linear combination of
Specht modules, and H.S uses d to write S(mu) as a linear
combination of simple modules. If the values of the unknown entries in
d are needed, false is returned.
gap> H:=Specht(3,3); # e = 3, p = 3 = characteristic of 'R'
Specht(e=3, p=3, S(), P(), D())
gap> d:=InducedDecompositionMatrix(DecompositionMatrix(H,14));;
# Inducing....
The following projectives are missing from <d>:
[ 15 ] [ 8, 7 ]
gap> H.P(d,4,3,3,2,2,1);
S(4,3,3,2,2,1)+S(4,3,3,2,1,1,1)+S(4,3,2,2,2,1,1)+S(3,3,3,2,2,1,1)
gap> H.S(d,7, 3, 3, 2);
D(11,2,1,1)+D(10,3,1,1)+D(8,5,1,1)+D(8,3,3,1)+D(7,6,1,1)+D(7,3,3,2)
gap> H.D(d,14,1);
false
The final example returned false because the partitions (14,1) and
(15) have the same 3--core (and P(15) is missing from d).
bigskip
H.S(d, x) qquad H.P(d, x) qquad H.D(d, x)
In the final form, d is a decomposition matrix and x is a
module. All three functions rewrite x in their respective basis
using d. Again this is only useful when you are trying to calculate
a new decomposition matrix because, for any ``known'' decomposition
matrix d, H.S(x) and H.S(d, x) are equivalent (and
similarly for H.P and H.D).
gap> H.S(d, H.D(d,10,5) ); -S(13,2)+S(10,5)
GAP 3.4.4