# 71.1 Specht

`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
April 1997