This package contains functions for computing the decomposition matrices for Iwahori--Hecke algebras of the symmetric groups. As the (modular) representation theory of these algebras closely resembles that of the (modular) representation theory of the symmetric groups --- indeed, the later is a special case of the former --- many of the combinatorial tools from the representation theory of the symmetric group are included in the package.

These programs grew out of the attempts by Gordon James and myself [JM1]
to understand the decomposition matrices of Hecke algebras of type **A**
when *<q>=-1*. The package is now much more general and its highlights
include:

1. Specht provides a means of working in the Grothendieck ring of a
Hecke algebra `H` using the three natural bases corresponding to the
Specht modules, projective indecomposable modules, and simple modules.

2. For Hecke algebras defined over fields of characteristic zero we have implemented the algorithm of Lascoux, Leclerc, and Thibon [LLT] for computing decomposition numbers and ``crystallized decomposition matrices''. In principle, this gives all of the decomposition matrices of Hecke algebras defined over fields of characteristic zero.

3. We provide a way of inducing and restricting modules. In addition,
it is possible to ``induce'' decomposition matrices; this function is
quite effective in calculating the decomposition matrices of Hecke
algebras for small `n`.

4. The `q`--analogue of Schaper's theorem [JM2] is included, as is
Kleshchev's [K] algorithm of calculating the Mullineux map. Both are
used extensively when inducing decomposition matrices.

5. Specht can be used to compute the decomposition numbers of
`q`--Schur algebras (and the general linear groups), although there is
less direct support for these algebras. The decomposition matrices for the
`q`--Schur algebras defined over fields of characteristic zero for *n<11*
and all `e` are included in Specht.

6. The Littlewood--Richard rule, its inverse, and functions for many of the standard operations on partitions (such as calculating cores, quotients, and adding and removing hooks), are included.

7. The decomposition matrices for the symmetric groups *Sym_n* are
included for *n<15* and for all primes.

**The modular representation theory of Hecke algebras**

The ``modular'' representation theory of the Iwahori--Hecke algebras of
type **A** was pioneered by Dipper and James [DJ1,DJ2]; here we briefly
outline the theory, referring the reader to the references for details.
Iwahori-Hecke algebras; see also Hecke.

Given a commutative integral domain `R` and a non--zero unit `q` in `R`,
let *<H>=<H>_{<R>, <q>}* be the Hecke algebra of the symmetric group
*Sym_n* on `n` symbols defined over `R` and with parameter `q`. For
each partition ` mu` of

`S`

(`rad`

`S`

`S`

`D`

`S`

`rad`

`S`

`D`

`R`

is a field.
Given a non--negative integer *i*, let *[i]_q=1+q+ldots+q^{i-1}*. Define
`e` to be the smallest non--negative integer such that *[<e>]_q=0*; if
no such integer exists, we set `e` equal to *0*. `Many of the functions
in this package depend upon e;` the integer `e` is the Hecke algebras
analogue of the characteristic of the field in the modular representation
theory of finite groups.

A partition *mu=(mu_1,mu_2,ldots)* is ** e--singular** if there exists
an integer

`D`

(`D`

(`S`

(`S`

(
Given two partitions *mu* and *nu*, where *nu* is `e`--regular, let
*d_{munu}* be the composition multiplicity of `D`

(` nu`) in

`S`

(`H`

. When the rows and columns are ordered in a way compatible with
dominance,
The indecomposable `H`-modules `P`

(` nu`) are indexed by

`P`

(`H`

. Similarly,
**Two small examples**

Because of the algorithm of [LLT], in principle, all of decomposition matrices for all Hecke algebras defined over fields of characteristic zero are known and available using Specht. The algorithm is recursive; however, it is quite quick and, as with a car, you need never look at the engine:

gap> H:=Specht(4); # e=4, 'R' a field of characteristic 0 Specht(e=4, S(), P(), D(), Pq()) gap> InducedModule(H.P(12,2)); P(13,2)+P(12,3)+P(12,2,1)+P(10,3,2)+P(9,6)

The [LLT] algorithm was applied 24 times during this calculation.

For Hecke algebras defined over fields of positive characteristic the
major tool provided by Specht, apart from the decomposition matrices
contained in the libraries, is a way of ``inducing'' decomposition
matrices. This makes it fairly easy to calculate the associated
decomposition matrices for ``small'' `n`. For example, the Specht
libraries contain the decomposition matrices for the symmetric groups
*Sym_n* over fields of characteristic 3 for *n<15*. These matrices
were calculated by Specht using the following commands:

gap> H:=Specht(3,3); # e=3, 'R' field of characteristic 3 Specht(e=3, p=3, S(), P(), D()) gap> d:=DecompositionMatrix(H,5); # known for $n\<2e$ 5 | 1 4,1 | . 1 3,2 | . 1 1 3,1^2 | . . . 1 2^2,1 | 1 . . . 1 2,1^3 | . . . . 1 1^5 | . . 1 . . gap> for n in [6..14] do > d:=InducedDecompositionMatrix(d); SaveDecompositionMatrix(d); > od;

The function `InducedDecompositionMatrix`

contains almost every trick
that I know for computing decomposition matrices (except using the spin
groups). I would be very happy to hear of any improvements.

Specht can also be used to calculate the decomposition numbers of the
`q`--Schur algebras; although, as yet, here no additional routines for
calculating the projective indecomposables indexed by `e`--singular
partitions. Such routines will probably be included in a future release,
together with the (conjectural) algorithm [LT] for computing the
decomposition matrices of the `q`--Schur algebras over fields of
characteristic zero.

In the next release of Specht, I will also include functions for
computing the decomposition matrices of Hecke algebras of type **B**, and
more generally those of the Ariki--Koike algebras. As with the Hecke
algebra of type **A**, there is an algorithm for computing the decomposition
matrices of these algebras when `R`

is a field of characteristic zero [M].

**Credits**

I would like to thank Gordon James, Johannes Lipp, and Klaus Lux for their comments and suggestions.

If you find Specht useful please let me know. I would also appreciate hearing any suggestions, comments, or improvements. In addition, if Specht does play a significant role in your research, please send me a copy of the paper(s) and please cite Specht in your references.

The lastest version of **Specht** can be obtained from
http://www.maths.usyd.edu.au:8000/u/mathas/specht/.

Andrew Mathas
mathas@maths.usyd.edu.au

University of Sydney, 1997.

Supported in part by SERC grant GR/J37690

**References**

[A] S. Ariki,
`On the decomposition numbers of the Hecke algebra of G(m,1,n)`,
J. Math. Kyoto Univ.,

[B] J. Brundan,
`Modular branching rules for quantum GL_n and the Hecke algebra
of type A`, Proc. London Math. Soc (3), to appear.

[DJ1] R. Dipper and G. James,
`Representations of Hecke algebras of general linear groups`,
Proc. London Math. Soc. (3), **52** (1986), 20--52.

[DJ2] R. Dipper and G. James,
`Blocks and idempotents of Hecke algebras of general linear groups`,
Proc. London Math. Soc. (3), **54** (1987), 57--82.

[G] M. Geck,
`Brauer trees of Hecke algebras`, Comm. Alg., **20** (1992), 2937--2973.

[J] G. James,
`The decomposition matrices of GL_n(q) for n le 10`,
Proc. London Math. Soc.,~

[JK] G. James and A. Kerber,
`The representation theory of the symmetric group`, **16**,
Encyclopedia of Mathematics, Addison--Wesley, Massachusetts~(1981).

[JM1] G. James and A. Mathas,
`Hecke algebras of type A at q=-1`, J. Algebra,

[JM2] G. James and A. Mathas,
`A q--analogue of the Jantzen--Schaper Theorem`, Proc. London Math.
Soc. (3),

[K] A. Kleshchev,
`Branching rules for modular representations III`,
J. London Math. Soc., **54**, 1996, 25--38.

[LLT] A. Lascoux, B. Leclerc, and J-Y. Thibon,
`Hecke algebras at roots of unity and crystal bases of quantum
affine algebras`, Comm. Math. Phys., **181** (1996), 205--263.

[LT] B. Leclerc and J-Y. Thibon,
`Canonical bases and q--deformed Fock spaces`, Int. Research Notices

[M] A. Mathas,
`Canonical bases and the decomposition matrices of Ariki--Koike
algebras`, preprint~1996.

`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(`

allows calculations in the Grothendieck rings of
the Hecke algebras `e`)`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).

**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.

`H.S`

(` mu`)

`H.P`

(`H.D`

(
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)

`H.S`

(`x`) `H.P`

(`x`) `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.

`H.S`

(`d`, ` mu`)

`H.P`

(`H.D`

(
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

`H.P`

and `H.D`

use `P`

(`D`

(`H.S`

uses `S`

(`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`).

`H.S`

(`d`, `x`) `H.P`

(`d`, `x`) `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(`

and `x`)`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)

`Specht(``p`, `p`)

can be used to consider the group algebras of
the symmetric groups over fields of characteristic `R`

a field of characteristic~
For example, the dimensions of the simple modules of *Sym_6*
over fields of characteristic 5 can be computed as follows:

gap> H:=Specht(5,5);; SimpleDimension(H,6); 6 : 1 5,1 : 5 4,2 : 8 4,1^2 : 10 3^2 : 5 3,2,1 : 8 3,1^3 : 10 2^3 : 5 2^2,1^2 : 1 2,1^4 : 5

`Specht`

must
also be supplied with a
Over fields of characteristic zero, and in the symmetric group case, the
function `val` is automatically defined by `Specht`

. When `R` is a field
of characteristic zero, `val`(*[i]_q*) is *1* if `e` divides ` i` and~

As another example, if *<q>=4* and `R` is a field of characteristic 5
(so *<e>=2*), then the valuation map sends the integer `x` to
*nu_5([4]_x)* where *[4]_x* is interpreted as an integer and *nu_5* is
the usual 5--adic valuation. To consider this Hecke algebra one could
proceed as follows:

gap> val:=function(x) local v; > x:=Sum([0..x-1],v->4^v); # x-${>}$[x]\_q > v:=0; while x mod 5=0 do x:=x/5; v:=v+1; od; > return v; > end;; gap> H:=Specht(2,5,val,"e2q4"); Specht(e=2, p=5, S(), P(), D(), HeckeRing="e2q4")

Notice the string ``e2q4'' which was also passed to `Specht`

in this
example. Although it is not strictly necessary, it is a good idea when
using a ``non--standard'' valuation map `val` to specify the value
of `H.HeckeRing`

=`HeckeRing`. This string is used for internal
bookkeeping by Specht; in particular, it is used to determine filenames
when reading and saving decomposition matrices. If a ``standard''
valuation map is used then `HeckeRing` is set to the string
``*e{<}e{>}p{<}p{>}*''; otherwise it defaults to ``unknown''. The
function `SaveDecompositionMatrix`

will not save any decomposition
matrix for any Hecke algebra `H`

with `H.HeckeRing`

=``unknown''.

The **Fock space** *F* is an (integrable) module for the quantum group
*U_q(widehat{sl}_{<e>})* of the affine special linear group. *F* is a
free **C**[`v`

]--module with basis the set of all Specht modules
`S`

(` mu`) for all partitions

`v`

] `S`

(`v`

=`H.info.Indeterminate`

is an indeterminate over the integers
(or strictly, `Pq`

(`Pq`

(`P`

(`H.Pq`

(To access the elements of the Fock space Specht provides the functions:

`H.Pq`

(` mu`)

`H.Sq`

(
Notice that, unlike `H.P`

and `H.S`

the only arguments which `H.Pq`

and
`H.Sq`

accept are partitions. (Given that our indeterminate is `v`

these
functions should really be called `H.Pv`

and `H.Sv`

; here ``q'' stands
for ``quantum```
.)
```

The function `H.Pq`

computes the canonical basis element `Pq`

(` mu`)
of the Fock space corresponding to the

`S`

(

gap> H:=Specht(4); Specht(e=4, S(), P(), D(), Pq()) gap> H.Pq(6,2); S(6,2)+v*S(5,3) gap> RestrictedModule(last); S(6,1)+(v + v^(-1))*S(5,2)+v*S(4,3) gap> H.P(last); P(6,1)+(v + v^(-1))*P(5,2) gap> Specialized(last); P(6,1)+2*P(5,2) gap> H.Sq(5,3,2); S(5,3,2) gap> InducedModule(last,0); v^(-1)*S(5,3,3)

The modules returned by `H.Pq`

and `H.Sq`

behave very much like elements
of the Grothendieck ring of `H`; however, they should be considered as
elements of the Fock space. The key difference is that when induced or
restricted ``quantum'' analogues of induction and restriction are used.
These analogues correspond to the action of *U_q(widehat{sl}_{<e>})*
on *F*[LLT].

In effect, the functions `H.Pq`

and `H.Sq`

allow computations in
the Fock space, using the functions `InducedModule`

InducedModule and
`RestrictedModule`

RestrictedModule. The functions `H.S`

, `H.P`

, and
`H.D`

can also be applied to elements of the Fock space, in which case
they have the expected effect. In addition, any element of the Fock space
can be specialized to give the corresponding element of the Grothendieck
ring of `H`

(it is because of this correspondence that we do not make a
distinction between elements of the Fock space and the Grothendieck
ring of `H`

).

When working over fields of characteristic zero Specht will
automatically calculate any canonical basis elements that it needs for
computations in the Grothendieck ring of `H`. If you are not interested
in the canonical basis elements you need never work with them directly.
If, for some reason, you do not want Specht to use the canonical basis
elements to calculate decomposition numbers then all you need to do is
`Unbind`

(`H.Pq`

).

`Schur(`

`e`)

`Schur(`

`e`, `p`)

`Schur(`

`e`, `p`, `val` [,`HeckeRing`])

This function behaves almost identically to the function `Specht`

(see
Specht), the only difference being that the three functions in the
record `S`

returned by `Schur`

are called `S.W`

, `S.P`

, and `S.F`

and that they correspond to the q-Weyl modules, the projective
decomposable modules, and the simple modules of the q--Schur algebra
respectively. Note that our labeling of these modules is non--standard,
following that used by James in [J]. The standard labeling can be
obtained from ours by replacing all partitions by their conjugates.

Almost all of the functions in Specht which accept a `Specht`

record `H` will also accept a record `S` returned by `Schur`

In the current version of Specht the decomposition matrices of q--Schur
algebras are not fully supported. The `InducedDecompositionMatrix`

function can be applied to these matrices; however there are no additional
routines available for calculating the columns corresponding to
`e`--singular partitions. The decomposition matrices for the q--Schur
algebras defined over a field of characteristic 0 for *<n> le 10* are in
the Specht libraries.

gap> S:=Schur(2); Schur(e=2, W(), P(), F(), Pq()) gap> InducedDecompositionMatrix(DecompositionMatrix(S,3)); # The following projectives are missing from <d>: # [ 2, 2 ] 4 | 1 # 'DecompositionMatrix'(S,4) returns the 3,1 | 1 1 # full decomposition matrix. The point 2^2 | . 1 . # of this example is to emphasize the 2,1^2 | 1 1 . 1 # current limitations of 'Schur'. 1^4 | 1 . . 1 1

Note that when `S` is defined over a field of characteristic zero then
it contains a function `S.Pq`

for calculating canonical basis elements
(see `Specht`

Specht); currently `S.Pq(`

is implemented only
for ` mu`)

`H.Wq`

.
See also `Specht`

Specht. This function requires the package
``specht'' (see RequirePackage).

`DecompositionMatrix(`

`H`, `n` [,`Ordering`])

`DecompositionMatrix(`

`H`, `filename` [,`Ordering`])

The function `DecompositionMatrix`

returns the decomposition matrix `D`

of
*'H'(Sym_n)* where `H`

is a Hecke algebra record returned by the function
`Specht`

(or `Schur`

). `DecompositionMatrix`

first checks to see whether
the required decomposition matrix exists as a library file (checking first
in the current directory, next in the directory specified by
`SpechtDirectory`

, and finally in the Specht libraries). If `H.Pq`

exists, `DecompositionMatrix`

next looks for **crystallized decomposition
matrices** (see `CrystalDecompositionMatrix`

CrystalDecompositionMatrix).
If the decomposition matrix `d`

is not stored in the library
`DecompositionMatrix`

will calculate `d`

when `H`

is a Hecke algebra with a
base field `R`

of characteristic zero, and will return `false`

otherwise
(in which case the function `CalculateDecompositionMatrix`

CalculateDecompositionMatrix can be used to force Specht to try and
calculate this matrix).

For Hecke algebras defined over fields of characteristic zero, Specht
uses the algorithm of [LLT] to calculate decomposition matrices
(this feature can be disabled by unbinding `H.Pq`

). The decomposition
matrices for the `q`--Schur algebras for *<n> le 10* are contained in the
Specht library, as are those for the symmetric group over fields of
positive characteristic when *<n><15*.

Once a decomposition matrix is known, Specht keeps an internal copy
of it which is used by the functions `H.S`

, `H.P`

, and `H.D`

; these
functions also read decomposition matrix files as needed.

If you set the variable `SpechtDirectory`

, then Specht will also search
for decomposition matrix files in this directory. The files in the current
directory override those in `SpechtDirectory`

and those in the Specht
libraries.

In the second form of the function, when a `filename` is supplied,
`DecompositionMatrix`

will read the decomposition matrix in the file
`filename`, and this matrix will become Specht's internal copy of
this matrix.

By default, the rows and columns of the decomposition matrices are ordered
lexicographically. This can be changed by supplying `DecompositionMatrix`

with an ordering function such as `LengthLexicographic`

or
`ReverseDominance`

. You do not need to specify the ordering you want
every time you call `DecompositionMatrix`

; Specht will keep the same
ordering until you change it again. This ordering can also be set ``by
hand'' using the variable `H.Ordering`

. indexH.Ordering!Specht

gap> DecompositionMatrix(Specht(3),6,LengthLexicographic); 6 | 1 5,1 | 1 1 4,2 | . . 1 3^2 | . 1 . 1 4,1^2 | . 1 . . 1 3,2,1 | 1 1 . 1 1 1 2^3 | 1 . . . . 1 3,1^3 | . . . . 1 1 2^2,1^2| . . . . . . 1 2,1^4 | . . . 1 . 1 . 1^6 | . . . 1 . . .Once you have a decomposition matrix it is often nice to be able to print it. The on screen version is often good enough; there is also a

`TeX`

command which generates a LaTeX version. There are also functions for converting Specht decomposition matrices intoGAPmatrices and visa versa (see`MatrixDecompositionMatrix`

MatrixDecompositionMatrix and`DecompositionMatrixMatrix`

DecompositionMatrixMatrix).Using the function

`InducedDecompositionMatrix`

(see InducedDecompositionMatrix), it is possible to induce a decomposition matrix. See also`SaveDecompositionMatrix`

SaveDecompositionMatrix and`IsNewIndecomposable`

IsNewIndecomposable,`Specht`

Specht,`Schur`

Schur, and`CrystalDecompositionMatrix`

CrystalDecompositionMatrix. This function requires the package ``specht'' (see RequirePackage).## 71.4 CrystalDecompositionMatrix

`CrystalDecompositionMatrix(`

H,n[,Ordering])

`CrystalDecompositionMatrix(`

H,filename[,Ordering])This function is similar to

`DecompositionMatrix`

, except that it returns acrystallized decomposition matrix. The columns of decomposition matrices correspond to projective indecomposables; the columns of crystallized decomposition matrices correspond to the canonical basis elements of the Fock space (see Specht). Consequently, the entries in these matrices are polynomials (in`v`

), and by specializing (i.e. setting`v`

equal to1; see Specialized), the decomposition matrices ofHare obtained (see Specht).Crystallized decomposition matrices are defined only for Hecke algebras over a base field of characteristic zero. Unlike ``normal'' decomposition matrices, crystallized decomposition matrices cannot be induced.

gap> CrystalDecompositionMatrix(Specht(3), 6); 6 | 1 5,1 | v 1 4,2 | . . 1 4,1^2 | . v . 1 3^2 | . v . . 1 3,2,1 | v v^2 . v v 1 3,1^3 | . . . v^2 . v 2^3 | v^2 . . . . v 2^2,1^2| . . . . . . 1 2,1^4 | . . . . v v^2 . 1^6 | . . . . v^2 . . gap> Specialized(last); # set 'v' equal to $1$. 6 | 1 5,1 | 1 1 4,2 | . . 1 4,1^2 | . 1 . 1 3^2 | . 1 . . 1 3,2,1 | 1 1 . 1 1 1 3,1^3 | . . . 1 . 1 2^3 | 1 . . . . 1 2^2,1^2| . . . . . . 1 2,1^4 | . . . . 1 1 . 1^6 | . . . . 1 . .See also

`Specht`

Specht,`Schur`

Schur,`DecompositionMatrix`

DecompositionMatrix, and`Specialized`

Specialized. This function requires the package ``specht'' (see RequirePackage).## 71.5 DecompositionNumber

`DecompositionNumber(`

H,,mu)nu

`DecompositionNumber(`

d,,mu)nuThis function attempts to calculate the decomposition multiplicity of

`D`

() innu`S`

() (equivalently, the multiplicity ofmu`S`

() inmu`P`

()). Ifnu`P`

() is known, we just look up the answer; if notnu`DecompositionNumber`

tries to calculate the answer using ``row and column removal'' (see [J,Theorem~6.18]).

gap> H:=Specht(6);; gap> DecompositionNumber(H,[6,4,2],[6,6]); 0This function requires the package ``specht'' (see RequirePackage).

## 71.6 InducedModule

`InducedModule(`

x)

`InducedModule(`

x,r_1[,r_2, ...])There is an natural embedding of

'H'(Sym_n)in'H'(Sym_{n+1})which in the usual way lets us define aninduced'H'(Sym_{n+1})--module for every'H'(Sym_n)--module. The function`InducedModule`

returns the induced modules of the Specht modules, principal indecomposable modules, and simple modules (more accurately, their image in the Grothendieck ring).There is also a function

`SInducedModule`

(see SInducedModule) which provides a much faster way ofr--inducingstimes (and inducingstimes).Let

be a partition. Then the induced modulemu`InducedModule(S(`

is easy to describe: it has the same composition factors as))musum 'S'(<nu>)whereruns over all partitions whose diagrams can be obtained by adding a single node to the diagram ofnu.mu

gap> H:=Specht(2,2); Specht(e=2, p=2, S(), P(), D()) gap> InducedModule(H.S(7,4,3,1)); S(8,4,3,1)+S(7,5,3,1)+S(7,4,4,1)+S(7,4,3,2)+S(7,4,3,1,1) gap> InducedModule(H.P(5,3,1)); P(6,3,1)+2*P(5,4,1)+P(5,3,2) gap> InducedModule(H.D(11,2,1)); # D(<x>), unable to rewrite <x> as a sum of simples S(12,2,1)+S(11,3,1)+S(11,2,2)+S(11,2,1,1)When inducing indecomposable modules and simple modules,

`InducedModule`

first rewrites these modules as a linear combination of Specht modules (using known decomposition matrices), and then induces this linear combination of Specht modules. If possible Specht then rewrites the induced module back in the original basis. Note that in the last example above, the decomposition matrix forSym_{15}is not known by Specht; this is why`InducedModule`

was unable to rewrite this module in the`D`

--basis.

r--Induction

`InducedModule`

(x,r_1[,r_2, ...])Two Specht modules

`S`

() andmu`S`

() belong to the same block if and only if the corresponding partitionsnuandmuhave the samenue--core [JM2] (see ECore). Because thee--core of a partition is determined by its (multiset of)e--residues, if`S`

() andmu`S`

() appear innu`InducedModule(S(`

, for some partition))tau, thentau`S`

() andmu`S`

() belong to the same block if and only ifnuandmucan be obtained by adding a node of the samenue--residue to the diagram of. The second form oftau`InducedModule`

allows one to induce ``within blocks'' by only adding nodes of some fixede--residuer; this is known asr-induction. Note that0 le r<e.

gap> H:=Specht(4); InducedModule(H.S(5,2,1)); S(6,2,1)+S(5,3,1)+S(5,2,2)+S(5,2,1,1) gap> InducedModule(H.S(5,2,1),0); 0*S() gap> InducedModule(H.S(5,2,1),1); S(6,2,1)+S(5,3,1)+S(5,2,1,1) gap> InducedModule(H.S(5,2,1),2); 0*S() gap> InducedModule(H.S(5,2,1),3); S(5,2,2)The function

`EResidueDiagram`

(EResidueDiagram), prints the diagram of, labeling each node with itsmue--residue. A quick check of this diagram confirms the answers above.

gap> EResidueDiagram(H,5,2,1); 0 1 2 3 0 3 0 2

``Quantized'' inductionWhen

`InducedModule`

is applied to the canonical basis elements`H.Pq`

() (or more generally elements of the Fock space; see Specht), a ``quantum analogue'' of induction is applied. More precisely, the functionmu`InducedModule(*,i)`

corresponds to the action of the generatorF_iof the quantum groupU_q(widehat{sl_e})onF[LLT].

gap> H:=Specht(3);; InducedModule(H.Pq(4,2),1,2); S(6,2)+v*S(4,4)+v^2*S(4,2,2) gap> H.P(last); P(6,2)See also

`SInducedModule`

SInducedModule,`RestrictedModule`

RestrictedModule, and`SRestrictedModule`

SRestrictedModule. This function requires the package ``specht'' (see RequirePackage).## 71.7 SInducedModule

`SInducedModule(`

x,s)

`SInducedModule(`

x,s,r)The function

`SInducedModule`

, standing for ``string induction'', provides a more efficient way ofr--inducingstimes (and a way of inducingstimes if the residueris omitted);r--induction is explained in InducedModule.

gap> H:=Specht(4);; SInducedModule(H.P(5,2,1),3); P(8,2,1)+3*P(7,3,1)+2*P(7,2,2)+6*P(6,3,2)+6*P(6,3,1,1)+3*P(6,2,1,1,1) +2*P(5,3,3)+P(5,2,2,1,1) gap> SInducedModule(H.P(5,2,1),3,1); P(6,3,1,1) gap> InducedModule(H.P(5,2,1),1,1,1); 6*P(6,3,1,1)Note that the multiplicity of each summand of

`InducedModule(x,r,...,r)`

is divisible by<s>!and that`SInducedModule`

divides by this constant.As with

`InducedModule`

this function can also be applied to elements of the Fock space (see Specht), in which case the quantum analogue of induction is used.See also

`InducedModule`

InducedModule. This function requires the package ``specht'' (see RequirePackage).## 71.8 RestrictedModule

`RestrictedModule(`

x)

`RestrictedModule(`

x,[,r_1, ...])r_2

Given a module

xfor'H'(Sym_n)`RestrictedModule`

returns the corresponding module for'H'(Sym_{n-1}). The restriction of the Specht module`S`

() is the linear combination of Specht modulesmusum 'S'(<nu>)whereruns over the partitions whose diagrams are obtained by deleting a node from the diagram ofnu. If only nodes of residuemurare deleted then this corresponds to first restricting`S`

() and then taking one of the block components of the restriction; this process is known asmu(cf.r-restrictionr--induction in InducedModule).There is also a function

`SRestrictedModule`

(see SRestrictedModule) which provides a faster way ofr--restrictingstimes (and restrictingstimes).When more than one residue if given to

`RestrictedModule`

it returns`RestrictedModule`

(x,r_1,r_2,...,r_k)=`RestrictedModule`

(`RestrictedModule`

(x,r_1),r_2,...,r_k) (cf.`InducedModule`

InducedModule).

gap> H:=Specht(6);; RestrictedModule(H.P(5,3,2,1),4); 2*P(4,3,2,1) gap> RestrictedModule(H.D(5,3,2),1); D(5,2,2)

``Quantized'' restrictionAs with

`InducedModule`

, when`RestrictedModule`

is applied to the canonical basis elements`H.Pq`

() a quantum analogue of restriction is applied; this time,mu`RestrictedModule(*,i)`

corresponds to the action of the generatorE_iofU_q(widehat{sl_e})onF[LLT].See also

`InducedModule`

InducedModule,`SInducedModule`

SInducedModule, and`SRestrictedModule`

SRestrictedModule. This function requires the package ``specht'' (see RequirePackage).## 71.9 SRestrictedModule

`SRestrictedModule(`

x,s)

`SRestrictedModule(`

x,s,r)As with

`SInducedModule`

this function provides a more efficient way ofr--restrictingstimes, or restrictingstimes if the residueris omitted (cf.`SInducedModule`

SInducedModule).

gap> H:=Specht(6);; SRestrictedModule(H.S(4,3,2),3); 3*S(4,2)+2*S(4,1,1)+3*S(3,3)+6*S(3,2,1)+2*S(2,2,2) gap> SRestrictedModule(H.P(5,4,1),2,4); P(4,4)See also

`InducedModule`

InducedModule,`SInducedModule`

SInducedModule, and`RestrictedModule`

RestrictedModule. This function requires the package ``specht'' (see RequirePackage).## 71.10 InducedDecompositionMatrix

`InducedDecompositionMatrix(`

d)If

dis the decomposition matrix of'H'(Sym_n), then`InducedDecompositionMatrix(`

attempts to calculate the decomposition matrix ofd)'H'(Sym_{n+1}). It does this by extracting each projective indecomposable fromdand inducing these modules to obtain projective modules for'H'(Sym_{n+1}).`InducedDecompositionMatrix`

then tries to decompose these projectives using the function`IsNewIndecomposable`

(see IsNewIndecomposable). In general there will be columns of the decomposition matrix which`InducedDecompositionMatrix`

is unable to decompose and these will have to be calculated ``by hand''.`InducedDecompositionMatrix`

prints a list of those columns of the decomposition matrix which it is unable to calculate (this list is also printed by the function`MissingIndecomposables(`

).d)

gap> gap> d:=DecompositionMatrix(Specht(3,3),14);; gap> InducedDecompositionMatrix(d);; # Inducing.... The following projectives are missing from <d>: [ 15 ] [ 8, 7 ]Note that the missing indecomposables come in ``pairs'' which map to each other under the Mullineux map (see

`MullineuxMap`

MullineuxMap).Almost all of the decomposition matrices included in Specht were calculated directly by

`InducedDecompositionMatrix`

. Whennis ``small''`InducedDecompositionMatrix`

is usually able to return the full decomposition matrix for'H'(Sym_{n+1}).Finally, although the

`InducedDecompositionMatrix`

can also be applied to the decomposition matrices of theq--Schur algebras (see`Schur`

Schur),`InducedDecompositionMatrix`

is much less successful in inducing these decomposition matrices because it contains no special routines for dealing with the indecomposable modules of theq--Schur algebra which are indexed bye--singular partitions. Note also that we use a non--standard labeling of the decomposition matrices ofq--Schur algebras; see Schur.## 71.11 IsNewIndecomposable

`IsNewIndecomposable(`

d,x[,])mu

`IsNewIndecomposable`

is the function which does all of the hard work when the function`InducedDecompositionMatrix`

is applied to decomposition matrices (see InducedDecompositionMatrix). Given a projective modulex,`IsNewIndecomposable`

returns`true`

if it is able to show thatxis indecomposable (and this indecomposable is not already listed ind), and`false`

otherwise.`IsNewIndecomposable`

will also print a brief description of its findings, giving an upper and lower bound on thefirstdecomposition numberfor which it is unable to determine the multiplicity ofmu`S`

() inmux.

`IsNewIndecomposable`

works by running through all of the partitionssuch thatnu`P`

(nu)could be a summand ofxand it uses various results, such as the q-Schaper theorem of [JM2] (see`Schaper`

Schaper), the Mullineux map (see`MullineuxMap`

MullineuxMap), and inducing simple modules, to determine if`P`

() does indeed split off. In addition, ifnudis the decomposition matrix for'H'(Sym_n)then`IsNewIndecomposable`

will probably use some of the decomposition matrices of'H'(Sym_m)form le n, if they are known. Consequently it is a good idea to save decomposition matrices as they are calculated (see SaveDecompositionMatrix).For example, in calculating the 2--modular decomposition matrices of

Sym_{r}the first projective which`InducedDecompositionMatrix`

is unable to calculate is`P`

(10).

gap> H:=Specht(2,2);; gap> d:=InducedDecompositionMatrix(DecompositionMatrix(H,9));; # Inducing. # The following projectives are missing from <d>: # [ 10 ](In fact, given the above commands, Specht will return the full decomposition matrix for

Sym_{10}because this matrix is in the library; these were the commands that I used to calculate the decomposition matrix in the library.)By inducing

`P`

(9) we can find a projectiveH--module which contains`P`

(10). We can then use`IsNewIndecomposable`

to try and decompose this induced module into a sum of PIMs.

gap> SpechtPrettyPrint(); x:=InducedModule(H.P(9),1); S(10)+S(9,1)+S(8,2)+2S(8,1^2)+S(7,3)+2S(7,1^3)+3S(6,3,1)+3S(6,2^2) +4S(6,2,1^2)+2S(6,1^4)+4S(5,3,2)+5S(5,3,1^2)+5S(5,2^2,1)+2S(5,1^5) +2S(4^2,2)+2S(4^2,1^2)+2S(4,3^2)+5S(4,3,1^3)+2S(4,2^3)+5S(4,2^2,1^2) +4S(4,2,1^4)+2S(4,1^6)+2S(3^3,1)+2S(3^2,2^2)+4S(3^2,2,1^2) +3S(3^2,1^4)+3S(3,2^2,1^3)+2S(3,1^7)+S(2^3,1^4)+S(2^2,1^6)+S(2,1^8) +S(1^10) gap> IsNewIndecomposable(d,x); # The multiplicity of S(6,3,1) in P(10) is at least 1 and at most 2. false gap> x; S(10)+S(9,1)+S(8,2)+2S(8,1^2)+S(7,3)+2S(7,1^3)+2S(6,3,1)+2S(6,2^2) +3S(6,2,1^2)+2S(6,1^4)+3S(5,3,2)+4S(5,3,1^2)+4S(5,2^2,1)+2S(5,1^5) +2S(4^2,2)+2S(4^2,1^2)+2S(4,3^2)+4S(4,3,1^3)+2S(4,2^3)+4S(4,2^2,1^2) +3S(4,2,1^4)+2S(4,1^6)+2S(3^3,1)+2S(3^2,2^2)+3S(3^2,2,1^2) +2S(3^2,1^4)+2S(3,2^2,1^3)+2S(3,1^7)+S(2^3,1^4)+S(2^2,1^6)+S(2,1^8) +S(1^10)Notice that some of the coefficients of the Specht modules in

xhave changed; this is because`IsNewIndecomposable`

was able to determine that the multiplicity of`S`

(6,3,1) was at most2and so it subtracted one copy of`P`

(6,3,1) fromx.In this case, the multiplicity of

`S`

(6,3,1) in`P`

(10) is easy to resolve because general theory says that this multiplicity must be odd. Therefore,x-'P'(6,3,1)is projective. After subtracting`P`

(6,3,1) fromxwe again use`IsNewIndecomposable`

to see ifxis now indecomposable. We can tell`IsNewIndecomposable`

that all of the multiplicities up to and including`S`

(6,3,1) have already been checked by giving it the addition argument=[6,3,1].mu

gap> x:=x-H.P(d,6,3,1);; IsNewIndecomposable(d,x,6,3,1); trueConsequently,

<x>='P'(10)and we add it to the decomposition matrixd(and save it).

`gap> AddIndecomposable(d,x); SaveDecompositionMatrix(d);`

A full description of what

`IsNewIndecomposable`

does can be found by reading the comments in`specht.g`

. Any suggestions or improvements on this function would be especially welcome.See also

`DecompositionMatrix`

DecompositionMatrix and`InducedDecompositionMatrix`

InducedDecompositionMatrix. This function requires the package ``specht'' (see RequirePackage).## 71.12 InvertDecompositionMatrix

`InvertDecompositionMatrix(d)`

Returns the inverse of the (

e--regular part of)d, wheredis a decomposition matrix, or crystallized decomposition matrix, of a Hecke algebra orq--Schur algebra. If part of the decomposition matrixdis unknown then`InvertDecompositionMatrix`

will invert as much ofdas possible.

gap> H:=Specht(4);; d:=CrystalDecompositionMatrix(H,5);; gap> InvertDecompositionMatrix(d); 5 | 1 4,1 | . 1 3,2 | -v . 1 3,1^2| . . . 1 2^2,1| v^2 . -v . 1 2,1^3| . . . . . 1See also

`DecompositionMatrix`

DecompositionMatrix, and`CrystalDecompositionMatrix`

CrystalDecompositionMatrix. This function requires the package ``specht'' (see RequirePackage).## 71.13 AdjustmentMatrix

`AdjustmentMatrix(`

dp,d)James [J] noticed, and Geck [G] proved, that the decomposition matrices

dpfor Hecke algebras defined over fields of positive characteristic admit a factorizationdp=d*awheredis a decomposition matrix for a suitable Hecke algebra defined over a field of characteristic zero, andais the so--calledadjustment matrix. This function returns the adjustment matrixa.

gap> H:=Specht(2);; Hp:=Specht(2,2);; gap> d:=DecompositionMatrix(H,13);; dp:=DecompositionMatrix(Hp,13);; gap> a:=AdjustmentMatrix(dp,d); 13 | 1 12,1 | . 1 11,2 | 1 . 1 10,3 | . . . 1 10,2,1 | . . . . 1 9,4 | 1 . 1 . . 1 9,3,1 | 2 . . . . . 1 8,5 | . 1 . . . . . 1 8,4,1 | 1 . . . . . . . 1 8,3,2 | . 2 . . . . . 1 . 1 7,6 | 1 . . . . 1 . . . . 1 7,5,1 | . . . . . . 1 . . . . 1 7,4,2 | 1 . 1 . . 1 . . . . 1 . 1 7,3,2,1| . . . . . . . . . . . . . 1 6,5,2 | . 1 . . . . . 1 . 1 . . . . 1 6,4,3 | 2 . . . 1 . . . . . . . . . . 1 6,4,2,1| . 2 . 1 . . . . . . . . . . . . 1 5,4,3,1| 4 . 2 . . . . . . . . . . . . . . 1 gap> MatrixDecompositionMatrix(dp)= > MatrixDecompositionMatrix(d)*MatrixDecompositionMatrix(a); trueIn the last line we have checked our calculation.

See also

`DecompositionMatrix`

DecompositionMatrix, and`CrystalDecompositionMatrix`

CrystalDecompositionMatrix. This function requires the package ``specht'' (see RequirePackage).## 71.14 SaveDecompositionMatrix

`SaveDecompositionMatrix(`

d)

`SaveDecompositionMatrix(`

d,filename)The function

`SaveDecompositionMatrix`

saves the decomposition matrixd. After a decomposition matrix has been saved, the functions`H.S`

,`H.P`

, and`H.D`

will automatically access it as needed. So, for example, before savingdin order to retrieve the indecomposable`P`

() frommudit is necessary to type`H.P(`

; onced,)mudhas been saved, the command`H.P(`

suffices.)muSince

`InducedDecompositionMatrix(`

consults the decomposition matrices for smallerd)n, if they are available, it is advantageous to save decomposition matrices as they are calculated. For example, over a field of characteristic~5, the decomposition matrices for the symmetric groupsSym_nwithn le 20can be calculated as follows:

gap> H:=Specht(5,5);; gap> d:=DecompositionMatrix(H,9);; gap> for r in [10..20] do > d:=InducedDecompositionMatrix(d); > SaveDecompositionMatrix(d); > od;If your Hecke algebra record

`H`

is defined using a non--standard valuation map (see Specht) then it is also necessary to set the string ```H.HeckeRing`

'', or to supply the function with afilenamebefore it will save your matrix.`SaveDecompositionMatrix`

will also save adjustment matrices and the various other matrices that appear in Specht (they can be read back in using`DecompositionMatrix`

). Each matrix has a default filename which you can over ride by supplying afilename. Using non--standard file names will stop Specht from automatically accessing these matrices in future.See also DecompositionMatrix

`DecompositionMatrix`

DecompositionMatrix and`CrystalDecompositionMatrix`

CrystalDecompositionMatrix. This function requires the package ``specht'' (see RequirePackage).## 71.15 CalculateDecompositionMatrix

`CalculateDecompositionMatrix(H,n)`

`CalculateDecompositionMatrix(H,n)`

is similar to the function`DecompositionMatrix`

DecompositionMatrix in that both functions try to return the decomposition matrix`d`

of'H'(Sym_n); the difference is that this function tries to calculate this matrix whereas the later reads the matrix from the library files (in characteristic zero both functions apply the algorithm of [LLT] to compute~`d`

). In effect this function is only needed when working with Hecke algebras defined over fields of positive characteristic (or when you wish to avoid the libraries).For example, if you want to do calculations with the decomposition matrix of the symmetric group

Sym_{15}over a field of characteristic two,`DecompositionMatrix`

returns false whereas`CalculateDecompositionMatrix`

; returns a part of the decomposition matrix.

gap> H:=Specht(2,2); Specht(e=2, p=2, S(), P(), D()) gap> d:=DecompositionMatrix(H,15); # This decomposition matrix is not known; use CalculateDecompositionMatrix() # or InducedDecompositionMatrix() to calculate with this matrix. false gap> d:=CalculateDecompositionMatrix(H,15);; # Projective indecomposable P(6,4,3,2) not known. # Projective indecomposable P(6,5,3,1) not known. ... gap> MissingIndecomposables(d); The following projectives are missing from <d>: [ 15 ] [ 14, 1 ] [ 13, 2 ] [ 12, 3 ] [ 12, 2, 1 ] [ 11, 4 ] [ 11, 3, 1 ] [ 10, 5 ] [ 10, 4, 1 ] [ 10, 3, 2 ] [ 9, 6 ] [ 9, 5, 1 ] [ 9, 4, 2 ] [ 9, 3, 2, 1 ] [ 8, 7 ] [ 8, 6, 1 ] [ 8, 5, 2 ] [ 8, 4, 3] [ 8, 4, 2, 1 ] [ 7, 6, 2 ] [ 7, 5, 3 ] [ 7, 5, 2, 1 ] [ 7, 4, 3, 1 ] [ 6, 5, 4 ] [ 6, 5, 3, 1 ] [ 6, 4, 3, 2 ]Actually, you are much better starting with the decomposition matrix of

Sym_{14}and then applying`InducedDecompositionMatrix`

to this matrix.See also DecompositionMatrix

`DecompositionMatrix`

. This function requires the package ``specht'' (see RequirePackage).## 71.16 MatrixDecompositionMatrix

`MatrixDecompositionMatrix(`

d)Returns the

GAPmatrix corresponding to the Specht decomposition matrixd. The rows and columns ofdare ordered by`H.Ordering`

.

gap> MatrixDecompositionMatrix(DecompositionMatrix(Specht(3),5)); [ [ 1, 0, 0, 0, 0 ], [ 0, 1, 0, 0, 0 ], [ 0, 1, 1, 0, 0 ], [ 0, 0, 0, 1, 0 ], [ 1, 0, 0, 0, 1 ], [ 0, 0, 0, 0, 1 ], [ 0, 0, 1, 0, 0 ] ]See also

`DecompositionMatrix`

DecompositionMatrix and`DecompositionMatrixMatrix`

DecompositionMatrixMatrix. This function requires the package ``specht'' (see RequirePackage).## 71.17 DecompositionMatrixMatrix

`DecompositionMatrixMatrix(`

H,m,n)Given a Hecke algebra

H, aGAPmatrixm, and an integernthis function returns the Specht decomposition matrix corresponding tom. If`p`

is the number of partitions ofnand`r`

the number ofe--regular partitions ofn, thenmmust be either<r>times<r>,<p>times<r>, or<p>times<p>. The rows and columns ofmare assumed to be indexed by partitions ordered by`H.Ordering`

(see Specht).

gap> H:=Specht(3);; gap> m:=[ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 1, 0, 1, 0 ], > [ 0, 0, 0, 1 ], [ 0, 0, 1, 0 ] ];; gap> DecompositionMatrixMatrix(H,m,4); 4 | 1 3,1 | . 1 2^2 | 1 . 1 2,1^2| . . . 1 1^4 | . . 1 .See also

`DecompositionMatrix`

DecompositionMatrix and`MatrixDecompositionMatrix`

MatrixDecompositionMatrix. This function requires the package ``specht'' (see RequirePackage).## 71.18 AddIndecomposable

`AddIndecomposable(`

d,x)

`AddIndecomposable(`

inserts the indecomposable moduled,x)xinto the decomposition matrixd. Ifdalready contains the indecomposablexthen a warning is printed. The function`AddIndecomposable`

also calculates`MullineuxMap(`

(see MullineuxMap) and adds this indecomposable tox)d(or checks to see that it agrees with the corresponding entry ofdif this indecomposable is already byd).See

`IsNewIndecomposable`

IsNewIndecomposable for an example. See also`DecompositionMatrix`

DecompositionMatrix and`CrystalDecompositionMatrix`

CrystalDecompositionMatrix. This function requires the package ``specht'' (see RequirePackage).## 71.19 RemoveIndecomposable

`RemoveIndecomposable(`

d,)muThe function

`RemoveIndecomposable`

removes the column fromdwhich corresponds to`P`

(). This is sometimes useful when trying to calculate a new decomposition matrix using Specht and want to test a possible candidate for a yet to be identified PIM.muSee also

`DecompositionMatrix`

DecompositionMatrix and`CrystalDecompositionMatrix`

CrystalDecompositionMatrix. This function requires the package ``specht'' (see RequirePackage).## 71.20 MissingIndecomposables

`MissingIndecomposables(`

d)The function

`MissingIndecomposables`

prints the list of partitions corresponding to the indecomposable modules which are not listed ind.See also

`DecompositionMatrix`

DecompositionMatrix and`CrystalDecompositionMatrix`

CrystalDecompositionMatrix. This function requires the package ``specht'' (see RequirePackage).## 71.21 SimpleDimension

`SimpleDimension(`

d)

`SimpleDimension(`

H,n)

`SimpleDimension(`

H|d,)muIn the first two forms,

`SimpleDimension`

prints the dimensions of all of the simple modules specified bydor for the Hecke algebra'H'(Sym_n)respectively. If a partitionis supplied, as in the last form, then the dimension of the simple modulemu`D`

(mu)is returned. At present the function is not implemented for the simple modules of theq--Schur algebras.

gap> H:=Specht(6);; gap> SimpleDimension(H,11,3); 272 gap> d:=DecompositionMatrix(H,5);; SimpleDimension(d,3,2); 5 gap> SimpleDimension(d); 5 : 1 4,1 : 4 3,2 : 5 3,1^2 : 6 2^2,1 : 5 2,1^3 : 4 1^5 : 1This function requires the package ``specht'' (see RequirePackage).

## 71.22 SpechtDimension

`SpechtDimension(`

)muCalculates the dimension of the Specht module

`S`

(), which is equal to the number of standardmu-tableaux; the answer is given by the hook length formula (see [JK]).mu

gap> SpechtDimension(6,3,2,1); 5632See also

`SimpleDimension`

SimpleDimension. This function requires the package ``specht'' (see RequirePackage).## 71.23 Schaper

`Schaper(`

H,)muGiven a partition

, and a Hecke algebramuH,`Schaper`

returns a linear combination of Specht modules which have the same composition factors as the sum of the modules in the ``Jantzen filtration'' of`S`

(); see [JM2]. In particular, ifmustrictly dominatesnuthenmu`D`

() is a composition factor ofnu`S`

() if and only if it is a composition factor ofmu`Schaper(`

.)mu

`Schaper`

uses the valuation map`H.valuation`

attached toH(see Specht and [JM2]).One way in which the

q--Schaper theorem can be applied is as follows. Suppose that we have a projective modulex, written as a linear combination of Specht modules, and suppose that we are trying to decide whether the projective indecomposable`P`

() is a direct summand ofmux. Then, providing that we know that`P`

() is not a summand ofnuxfor all (e--regular) partitionswhich strictly dominatenu(see Dominates),mu`P`

() is a summand ofmuxif and only if`InnerProduct(Schaper(H,`

is non--zero (note, in particular, that we don't need to know the indecomposablemu),x)`P`

() in order to perform this calculation).muThe

q--Schaper theorem can also be used to check for irreduciblity; in fact, this is the basis for the criterion employed by`IsSimpleModule`

.

gap> H:=Specht(2);; gap> Schaper(H,9,5,3,2,1); S(17,2,1)-S(15,2,1,1,1)+S(13,2,2,2,1)-S(11,3,3,2,1)+S(10,4,3,2,1)-S(9,8,3) -S(9,8,1,1,1)+S(9,6,3,2)+S(9,6,3,1,1)+S(9,6,2,2,1) gap> Schaper(H,9,6,5,2); 0*S(0)The last calculation shows that

`S`

(9,6,5,2) is irreducible whenRis a field of characteristic0and`(cf.`

e=2`IsSimpleModule(H,9,6,5,2)`

).This function requires the package ``specht'' (see RequirePackage).

## 71.24 IsSimpleModule

`IsSimpleModule(`

H,)mu

anmue--regular partition.Given an

e--regular partition,mu`IsSimpleModule(`

returnsH,)mu`true`

if`S`

() is simple andmu`false`

otherwise. This calculation uses the valuation function`H.valuation`

; see Specht. Note that the criterion used by`IsSimpleModule`

is completely combinatorial; it is derived from theq--Schaper theorem [JM2].

gap> H:=Specht(3);; gap> IsSimpleModule(H,45,31,24); falseSee also

`Schaper`

Schaper. This function requires the package ``specht'' (see RequirePackage).## 71.25 MullineuxMap

`MullineuxMap(`

e|H,)mu

`MullineuxMap(`

d,)mu

`MullineuxMap(`

x)Given an integer

e, or a Specht recordH, and a partition,mu`MullineuxMap`

(e,) returns the image ofmuunder the Mullineux map; which we now explain.muThe sign representation

`D`

(1^n) of the Hecke algebra is the (one dimensional) representation sendingT_wto(-1)^{ell(w)}. The Hecke algebraHis not a Hopf algebra so there is no well defined action ofHupon the tensor product of twoH--modules; however, there is an outer automorphism # ofHwhich corresponds to tensoring with`D`

(1^n). This sends an irreducible module'D'(<mu>)to an irreducible'D'(<mu>)^#cong 'D'(<mu^#>)for somee--regular partitionmu^#. In the symmetric group case, Mullineux gave a conjectural algorithm for calculatingmu^#; consequently the map sendingtomuis known as themu^#Mullineux map.Deep results of Kleshchev [K] for the symmetric group give another (proven) algorithm for calculating the partition

mu^#(Ford and Kleshchev have deduced Mullineux's conjecture from this). Using the canonical basis, it was shown by [LLT] that the natural generalization of Kleshchev's algorithm toHgives the Mullineux map for Hecke algebras over fields of characteristic zero. The general case follows from this, so the Mullineux map is now known for all Hecke algebras.Kleshchev's map is easy to describe; he proved that if

gnsis any good node sequence for, then the sequence obtained frommugnsby replacing each residuerby-rbmod eis a good node sequence formu^#(see`GoodNodeSequence`

GoodNodeSequence).

gap> MullineuxMap(Specht(2),12,5,2); [ 12, 5, 2 ] gap> MullineuxMap(Specht(4),12,5,2); [ 4, 4, 4, 2, 2, 1, 1, 1 ] gap> MullineuxMap(Specht(6),12,5,2); [ 4, 3, 2, 2, 2, 2, 2, 1, 1 ] gap> MullineuxMap(Specht(8),12,5,2); [ 3, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1 ] gap> MullineuxMap(Specht(10),12,5,2); [ 3, 3, 3, 3, 2, 1, 1, 1, 1, 1 ]

`MullineuxMap`

(d,)muThe Mullineux map can also be calculated using a decomposition matrix. To see this recall that ``tensoring'' a Specht module

`S`

() with the sign representation yields a module isomorphic to the dual ofmu`S`

(), wherelambdalambdais the partition conjugate to. It follows thatmud_{munu}=d_{lambdanu^#}for alle--regular partitions. Therefore, ifnuis the last partition in the lexicographic order such thatmud_{munu}ne0then we must havenu^#=lambda. The second form of`MullineuxMap`

usesdto calculatemu^#rather than the Kleshchev-[LLT] result.

`MullineuxMap`

(x)In the third form,

xis a module, and`MullineuxMap`

returns<x>^#, the image ofxunder #. Note that the above remarks show that`P`

() is mapped tomu`P`

(mu^#) via the Mullineux map; this observation is useful when calculating decomposition matrices (and is used by the function`InducedDecompositionMatrix`

).See also

`GoodNodes`

GoodNodes and`GoodNodeSequence`

GoodNodeSequence . This function requires the package ``specht'' (see RequirePackage).## 71.26 MullineuxSymbol

`MullineuxSymbol(`

e|H,)muReturns the Mullineux symbol of the

e--regular partition.mu

gap> MullineuxSymbol(5,[8,6,5,5]); [ [ 10, 6, 5, 3 ], [ 4, 4, 3, 2 ] ]See also

`PartitionMullineuxSymbol`

PartitionMullineuxSymbol. This function requires the package ``specht'' (see RequirePackage).## 71.27 PartitionMullineuxSymbol

`PartitionMullineuxSymbol(`

e|H,ms)Given a Mullineux symbol

ms, this function returns the correspondinge--regular partition.

gap> PartitionMullineuxSymbol(5, MullineuxSymbol(5,[8,6,5,5]) ); [ 8, 6, 5, 5 ]See also

`MullineuxSymbol`

MullineuxSymbol. This function requires the package ``specht'' (see RequirePackage).## 71.28 GoodNodes

`GoodNodes(`

e|H,)mu

`GoodNodes(`

e|H,,mur)Given a partition and an integer

e, Kleshchev [K] defined the notion ofgood nodefor each residuer(0 le r<e). Wheneis prime andismue--regular, Kleshchev showed that the good nodes describe the restriction of the socle of`D`

() in the symmetric group case. Brundan~[B] has recently generalized this result to the Hecke algebra.muBy definition, there is at most one good node for each residue

r, and this node is a removable node (in the diagram of). The functionmu`GoodNodes`

returns a list of the rows ofwhich end in a good node; the good node of residuemur(if it exists) is the (r+1)--st element in this list. In the second form, the number of the row which ends with the good node of residueris returned; or`false`

if there is no good node of residuer.

gap> GoodNodes(5,[5,4,3,2]); [ false, false, 2, false, 1 ] gap> GoodNodes(5,[5,4,3,2],0); false gap> GoodNodes(5,[5,4,3,2],4); 1The good nodes also determine the Kleshchev--Mullineux map (see

`GoodNodeSequence`

GoodNodeSequence and`MullineuxMap`

MullineuxMap). This function requires the package ``specht'' (see RequirePackage).## 71.29 NormalNodes

`NormalNodes(`

e|H,)mu

`NormalNodes(`

e|H,,mur)Returns the numbers of the rows of

which end in one of Kleshchev's [K] normal nodes. In the second form, only those rows corresponding to normal nodes of the specified residue are returned.mu

gap> NormalNodes(5,[6,5,4,4,3,2,1,1,1]); [ [ 1, 4 ], [ ], [ ], [ 2, 5 ], [ ] ] gap> NormalNodes(5,[6,5,4,4,3,2,1,1,1],0); [ 1, 4 ]See also

`GoodNodes`

GoodNodes. This function requires the package ``specht'' (see RequirePackage).## 71.30 GoodNodeSequence

`GoodNodeSequence(`

e|H,)mu

`GoodNodeSequences(`

e|H,)mu

anmue--regular partition.Given an

e--regular partitionofmun, agood node sequenceforis a sequencemugnsofnresidues such thathas a good node of residuemur, whereris the last residue ingns, and the firstn-1residues ingnsare a good node sequence for the partition obtained fromby deleting its (unique) good node with residuemur(see`GoodNodes`

GoodNodes). In general,will have more than one good node sequence; however, any good node sequence uniquely determinesmu(seemu`PartitionGoodNodeSequence`

PartitionGoodNodeSequence).

gap> H:=Specht(4);; GoodNodeSequence(H,4,3,1); [ 0, 3, 1, 0, 2, 2, 1, 3 ] gap> GoodNodeSequence(H,4,3,2); [ 0, 3, 1, 0, 2, 2, 1, 3, 3 ] gap> GoodNodeSequence(H,4,4,2); [ 0, 3, 1, 0, 2, 2, 1, 3, 3, 2 ] gap> GoodNodeSequence(H,5,4,2); [ 0, 3, 1, 0, 2, 2, 1, 3, 3, 2, 0 ]The function

`GoodNodeSequences`

returns the list of all good node sequences for.mu

gap> GoodNodeSequences(H,5,2,1); [ [ 0, 1, 2, 3, 3, 2, 0, 0 ], [ 0, 3, 1, 2, 2, 3, 0, 0 ], [ 0, 1, 3, 2, 2, 3, 0, 0 ], [ 0, 1, 2, 3, 3, 0, 2, 0 ], [ 0, 1, 2, 3, 0, 3, 2, 0 ], [ 0, 1, 2, 3, 3, 0, 0, 2 ], [ 0, 1, 2, 3, 0, 3, 0, 2 ] ]The good node sequences determine the Mullineux map (see

`GoodNodes`

GoodNodes and`MullineuxMap`

MullineuxMap). This function requires the package ``specht'' (see RequirePackage).## 71.31 PartitionGoodNodeSequence

`PartitionGoodNodeSequence(`

e|H,gns)Given a good node sequence

gns(see`GoodNodeSequence`

GoodNodeSequence), this function returns the uniquee--regular partition corresponding togns(or`false`

if in factgnsis not a good node sequence).

gap> H:=Specht(4);; gap> PartitionGoodNodeSequence(H,0, 3, 1, 0, 2, 2, 1, 3, 3, 2); [ 4, 4, 2 ]See also

`GoodNodes`

GoodNodes,`GoodNodeSequence`

GoodNodeSequence and`MullineuxMap`

MullineuxMap. This function requires the package ``specht'' (see RequirePackage).## 71.32 GoodNodeLatticePath

`GoodNodeLatticePath(`

e|H,)mu

`GoodNodeLatticePaths(`

e|H,)mu

`LatticePathGoodNodeSequence(`

e|H,gns)The function

`GoodNodeLatticePath`

returns a sequence of partitions which give a path in thee--good partition lattice from the empty partition to. The second function returns the list of all paths in themue--good partition lattice which end in, and the third function returns the path corresponding to a given good node sequencemugns.

gap> GoodNodeLatticePath(3,3,2,1); [ [ 1 ], [ 1, 1 ], [ 2, 1 ], [ 2, 1, 1 ], [ 2, 2, 1 ], [ 3, 2, 1 ] ] gap> GoodNodeLatticePaths(3,3,2,1); [ [ [ 1 ], [ 1, 1 ], [ 2, 1 ], [ 2, 1, 1 ], [ 2, 2, 1 ], [ 3, 2, 1 ] ], [ [ 1 ], [ 1, 1 ], [ 2, 1 ], [ 2, 2 ], [ 2, 2, 1 ], [ 3, 2, 1 ] ] ] gap> GoodNodeSequence(4,6,3,2); [ 0, 3, 1, 0, 2, 2, 3, 3, 0, 1, 1 ] gap> LatticePathGoodNodeSequence(4,last); [ [ 1 ], [ 1, 1 ], [ 2, 1 ], [ 2, 2 ], [ 3, 2 ], [ 3, 2, 1 ], [ 4, 2, 1 ], [ 4, 2, 2 ], [ 5, 2, 2 ], [ 6, 2, 2 ], [ 6, 3, 2 ] ]See also

`GoodNodes`

GoodNodes. This function requires the package ``specht'' (see RequirePackage).## 71.33 LittlewoodRichardsonRule

`LittlewoodRichardsonRule(`

,mu)nu

`LittlewoodRichardsonCoefficient(`

,mu,nu)tauGiven partitions

ofmunandofnumthe module'S'(<mu>) otimes 'S'(<nu>)is naturally an'H'(Sym_ntimesSym_m)-module and, by inducing, we obtain an'H'(Sym_{n+m})-module. This module has the same composition factors as sum_nu a_munu^lambda`S`

(lambda), where the sum runs over all partitionslambdaofn+mand the integersa_{munu}^lambdaare the Littlewood--Richardson coefficients. The integersa_{munu}^lambdacan be calculated using a straightforward combinatorial algorithm known as the Littlewood--Richardson rule (see [JK]).The function

`LittlewoodRichardsonRule`

returns an (unordered) list of partitions ofn+min which each partitionoccurslambdaa_{munu}^lambdatimes. The Littlewood-Richardson coefficients are independent ofe; they can be read more easily from the computation`S(`

.)*S(mu)nu

gap> H:=Specht(0);; # the generic Hecke algebra with 'R'=*C*['q'] gap> LittlewoodRichardsonRule([3,2,1],[4,2]); [ [ 4, 3, 2, 2, 1 ],[ 4, 3, 3, 1, 1 ],[ 4, 3, 3, 2 ],[ 4, 4, 2, 1, 1 ], [ 4, 4, 2, 2 ],[ 4, 4, 3, 1 ],[ 5, 2, 2, 2, 1 ],[ 5, 3, 2, 1, 1 ], [ 5, 3, 2, 2 ],[ 5, 4, 2, 1 ],[ 5, 3, 2, 1, 1 ],[ 5, 3, 3, 1 ], [ 5, 4, 1, 1, 1 ],[ 5, 4, 2, 1 ],[ 5, 5, 1, 1 ],[ 5, 3, 2, 2 ], [ 5, 3, 3, 1 ],[ 5, 4, 2, 1 ],[ 5, 4, 3 ],[ 5, 5, 2 ],[ 6, 2, 2, 1, 1], [ 6, 3, 1, 1, 1 ],[ 6, 3, 2, 1 ],[ 6, 4, 1, 1 ],[ 6, 2, 2, 2 ], [ 6, 3, 2, 1 ],[ 6, 4, 2 ],[ 6, 3, 2, 1 ],[ 6, 3, 3 ],[ 6, 4, 1, 1 ], [ 6, 4, 2 ], [ 6, 5, 1 ], [ 7, 2, 2, 1 ], [ 7, 3, 1, 1 ], [ 7, 3, 2 ], [ 7, 4, 1 ] ] gap> H.S(3,2,1)*H.S(4,2); S(7,4,1)+S(7,3,2)+S(7,3,1,1)+S(7,2,2,1)+S(6,5,1)+2*S(6,4,2)+2*S(6,4,1,1) +S(6,3,3)+3*S(6,3,2,1)+S(6,3,1,1,1)+S(6,2,2,2)+S(6,2,2,1,1)+S(5,5,2) +S(5,5,1,1)+S(5,4,3)+3*S(5,4,2,1)+S(5,4,1,1,1)+2*S(5,3,3,1)+2*S(5,3,2,2) +2*S(5,3,2,1,1)+S(5,2,2,2,1)+S(4,4,3,1)+S(4,4,2,2)+S(4,4,2,1,1)+S(4,3,3,2) +S(4,3,3,1,1)+S(4,3,2,2,1) gap> LittlewoodRichardsonCoefficient([3,2,1],[4,2],[5,4,2,1]); 3The function

`LittlewoodRichardsonCoefficient`

returns a single Littlewood--Richardson coefficient (although you are really better off asking for all of them, since they will all be calculated anyway).See also

`InducedModule`

InducedModule and`InverseLittlewoodRichardsonRule`

InverseLittlewoodRichardsonRule. This function requires the package ``specht'' (see RequirePackage).## 71.34 InverseLittlewoodRichardsonRule

`InverseLittlewoodRichardsonRule(`

)tauReturns a list of all pairs of partitions [

mu,nu] such that the Littlewood-Richardson coefficienta_{munu}^tauis non-zero (see LittlewoodRichardsonRule). The list returned is unordered and [mu,nu] will appeara_{munu}^tautimes in it.

gap> InverseLittlewoodRichardsonRule([3,2,1]); [ [ [ ],[ 3, 2, 1 ] ],[ [ 1 ],[ 3, 2 ] ],[ [ 1 ],[ 2, 2, 1 ] ], [ [ 1 ],[ 3, 1, 1 ] ],[ [ 1, 1 ],[ 2, 2 ] ],[ [ 1, 1 ],[ 3, 1 ] ], [ [ 1, 1 ],[ 2, 1, 1 ] ],[ [ 1, 1, 1 ],[ 2, 1 ] ],[ [ 2 ],[ 2, 2 ] ], [ [ 2 ],[ 3, 1 ] ],[ [ 2 ],[ 2, 1, 1 ] ],[ [ 2, 1 ],[ 3 ] ], [ [ 2, 1 ],[ 2, 1 ] ],[ [ 2, 1 ],[ 2, 1 ] ],[ [ 2, 1 ],[ 1, 1, 1 ] ], [ [ 2, 1, 1 ],[ 2 ] ],[ [ 2, 1, 1 ],[ 1, 1 ] ],[ [ 2, 2 ],[ 2 ] ], [ [ 2, 2 ],[ 1, 1 ] ],[ [ 2, 2, 1 ],[ 1 ] ],[ [ 3 ],[ 2, 1 ] ], [ [ 3, 1 ],[ 2 ] ],[ [ 3, 1 ],[ 1, 1 ] ],[ [ 3, 1, 1 ],[ 1 ] ], [ [ 3, 2 ],[ 1 ] ],[ [ 3, 2, 1 ],[ ] ] ]See also

`LittlewoodRichardsonRule`

LittlewoodRichardsonRule.This function requires the package ``specht'' (see RequirePackage).

## 71.35 EResidueDiagram

`EResidueDiagram(`

H|e,)mu

`EResidueDiagram(`

x)The

e--residue of the(i,j)--th node in the diagram of a partitionismu(j-i)bmod <e>.`EResidueDiagram(`

prints the diagram of the partitione,)mureplacing each node with itsmue-residue.If

xis a module then`EResidueDiagram(`

prints thex)e--residue diagrams of all of thee--regular partitions appearing inx(such diagrams are useful when trying to decide how to restrict and induce modules and also in applying results such as the ``Scattering theorem'' of [JM1]). It is not necessary to supply the integerein this case becausex``knows'' the value ofe.

gap> H:=Specht(2);; EResidueDiagram(H.S(H.P(7,5))); [ 7, 5 ] 0 1 0 1 0 1 0 1 0 1 0 1 [ 6, 5, 1 ] 0 1 0 1 0 1 1 0 1 0 1 0 [ 5, 4, 2, 1 ] 0 1 0 1 0 1 0 1 0 0 1 1 # There are 3 2-regular partitions.This function requires the package ``specht'' (see RequirePackage).

## 71.36 HookLengthDiagram

`HookLengthDiagram(`

)muPrints the diagram of

, replacing each node with its hook length (see [JK]).mu

gap> HookLengthDiagram(11,6,3,2); 14 13 11 9 8 7 5 4 3 2 1 8 7 5 3 2 1 4 3 1 2 1This function requires the package ``specht'' (see RequirePackage).

## 71.37 RemoveRimHook

`RemoveRimHook(`

,murow,col)Returns the partition obtained from

muby removing the (row,col)--th rim hook from (the diagram of).mu

gap> RemoveRimHook([6,5,4],1,2); [ 4, 3, 1 ] gap> RemoveRimHook([6,5,4],2,3); [ 6, 3, 2 ] gap> HookLengthDiagram(6,5,4); 8 7 6 5 3 1 6 5 4 3 1 4 3 2 1See also

`AddRimHook`

AddRimHook. This function requires the package ``specht'' (see RequirePackage).## 71.38 AddRimHook

`AddRimHook(`

,mur,h);Returns a list [

,nul] whereis the partition obtained fromnuby adding a rim hook of lengthmuhwith its ``foot'' in ther--th row of (the diagram of)andmulis the leg length of the wrapped on rim hook (see, for example,[JK]). If the resulting diagramis not the diagram of a partition thennu`false`

is returned.

gap> AddRimHook([6,4,3],1,3); [ [ 9, 4, 3 ], 0 ] gap> AddRimHook([6,4,3],2,3); false gap> AddRimHook([6,4,3],3,3); [ [ 6, 5, 5 ], 1 ] gap> AddRimHook([6,4,3],4,3); [ [ 6, 4, 3, 3 ], 0 ] gap> AddRimHook([6,4,3],5,3); falseSee also

`RemoveRimHook`

RemoveRimHook. This function requires the package ``specht'' (see RequirePackage).## 71.39 ECore

`ECore(`

H|e,)muThe

e-core of a partitionis what remains after as many rimmue-hooks as possible have been removed from the diagram of(that this is well defined is not obvious; see [JK]). Thus,mu`ECore(`

returns the)mue--core of the partition,mu

gap> H:=Specht(6);; ECore(H,16,8,6,5,3,1); [ 4, 3, 1, 1 ]The

e--core is calculated here using James' notation of anabacus; there is also an`EAbacus`

function; but it is more ``pretty'' than useful. indexEAbacusSee also

`IsECore`

IsECore,`EQuotient`

EQuotient, and`EWeight`

EWeight. This function requires the package ``specht'' (see RequirePackage).## 71.40 IsECore

`IsECore(`

H|e,)muReturns

`true`

ifis anmue--core and`false`

otherwise; see`ECore`

ECore.See also

`ECore`

ECore. This function requires the package ``specht'' (see RequirePackage).## 71.41 EQuotient

`EQuotient(`

H|e,)muReturns the

e-quotient of; this is a sequence ofmuepartitions whose definition can be found in [JK].

gap> H:=Specht(8);; EQuotient(H,22,18,16,12,12,1,1); [ [ 1, 1 ], [ ], [ ], [ ], [ ], [ 2, 2 ], [ ], [ 1 ] ]See also

`ECore`

ECore and`CombineEQuotientECore`

CombineEQuotientECore. This function requires the package ``specht'' (see RequirePackage).## 71.42 CombineEQuotientECore

`CombineEQuotientECore(`

H|e,Q,C)A partition is uniquely determined by its

e-quotient and itse-core (see EQuotient and ECore).`CombineEQuotientECore(`

returns the partition which hase,Q,C)e--quotientQande--coreC. The integerecan be replaced with a recordHwhich was created using the function`Specht`

.

gap> H:=Specht(11);; mu:=[100,98,57,43,12,1];; gap> Q:=EQuotient(H,mu); [ [ 9 ], [ ], [ ], [ ], [ ], [ ], [ 3 ], [ 1 ], [ 9 ], [ ], [ 5 ] ] gap> C:=ECore(H,mu); [ 7, 2, 2, 1, 1, 1 ] gap> CombineEQuotientECore(H,Q,C); [ 100, 98, 57, 43, 12, 1 ]See also

`ECore`

ECore and`EQuotient`

EQuotient. This function requires the package ``specht'' (see RequirePackage).## 71.43 EWeight

`EWeight(`

H|e,)muThe

e--weight of a partition is the number ofe--hooks which must be removed from the partition to reach thee--core (see`ECore`

ECore).

gap> EWeight(6,[16,8,6,5,3,1]); 5This function requires the package ``specht'' (see RequirePackage).

## 71.44 ERegularPartitions

`ERegularPartitions(`

H|e,n)A partition

mu=(mu_1,mu_2,ldots)isif there is no integere--regularisuch thatmu_i=mu_{i+1}=cdots=mu_{i+<e>-1}>0. The function`ERegularPartitions(`

returns the list ofe,n)e--regular partitions ofn, ordered reverse lexicographically (see Lexicographic).

gap> H:=Specht(3); Specht(e=3, S(), P(), D(), Pq()); gap> ERegularPartitions(H,6); [ [ 2, 2, 1, 1 ], [ 3, 2, 1 ], [ 3, 3 ], [ 4, 1, 1 ], [ 4, 2 ], [ 5, 1 ], [ 6 ] ]This function requires the package ``specht'' (see RequirePackage).

## 71.45 IsERegular

`IsERegular(`

H|e,)muReturns

`true`

ifismue--regular and`false`

otherwise.This functions requires the package ``specht'' (see RequirePackage).

## 71.46 ConjugatePartition

`ConjugatePartition(`

)muGiven a partition

,mu`ConjugatePartition(`

returns the partition whose diagram is obtained by interchanging the rows and columns in the diagram of)mu.mu

gap> ConjugatePartition(6,4,3,2); [ 4, 4, 3, 2, 1, 1 ]This function requires the package ``specht'' (see RequirePackage).

## 71.47 BetaSet

`BetaSet(`

)muThis function returns a

setof beta numbers (i.e. first column hook lengths; see [JK]) corresponding to the partition.mu

gap> BetaSet([5,4,2,2]); [ 2, 3, 6, 8 ]See also

`PartitionBetaSet`

PartitionBetaSet. This function requires the package ``specht'' (see RequirePackage).## 71.48 PartitionBetaSet

`PartitionBetaSet(`

bn)Given a

setof beta numbersbn(see`BetaSet`

BetaSet), this function returns the corresponding partition. Note in particular thatbnmust be a set of integers.

gap> PartitionBetaSet([ 2, 3, 6, 8 ]); [ 5, 4, 2, 2 ]This function requires the package ``specht'' (see RequirePackage).

## 71.49 ETopLadder

`ETopLadder(`

H|e,)muThe ladders in the diagram of a partition are the lines connecting nodes of constant

e--residue, having slope<e>-1(see [JK]). A new partition can be obtained fromby sliding all nodes up to the highest possible rungs on their ladders.mu`ETopLadder(`

returns the partition obtained in this way; it is automaticallye,)mue--regular (this partition is denotedin [JK]).mu^R

gap> H:=Specht(4);; gap> ETopLadder(H,1,1,1,1,1,1,1,1,1,1); [ 4, 3, 3 ] gap> ETopLadder(6,1,1,1,1,1,1,1,1,1,1); [ 2, 2, 2, 2, 2 ]This function requires the package ``specht'' (see RequirePackage).

## 71.50 Dominates

`Dominates(`

,mu)nuThe dominance ordering is an important partial order in the representation theory of Hecke algebra because

d_{munu}=0unlessdominatesnu.mu`Dominates(`

returns,mu)nu`true`

if either=muor for allnui ge 1,sum_{j=1}^imu_j ge sum_{j=1}^inu_j, and`false`

otherwise.

gap> Dominates([5,4],[4,4,1]); trueThis function requires the package ``specht'' (see RequirePackage).

## 71.51 LengthLexicographic

`LengthLexicographic(`

,mu)nu

`LengthLexicographic`

returns`true`

if the length ofis less than the length ofmuor if the length ofnuequals the length ofmuandnu`Lexicographic(`

.,mu)nu

gap> p:=Partitions(6);;Sort(p,LengthLexicographic); p; [ [ 6 ],[ 5, 1 ],[ 4, 2 ],[ 3, 3 ],[ 4, 1, 1 ],[ 3, 2, 1 ],[ 2, 2, 2 ], [ 3, 1, 1, 1 ],[ 2, 2, 1, 1 ],[ 2, 1, 1, 1, 1 ],[ 1, 1, 1, 1, 1, 1 ] ]This function requires the package ``specht'' (see RequirePackage).

## 71.52 Lexicographic

`Lexicographic(`

,mu)nu

`Lexicographic(`

returns,mu)nu`true`

ifis lexicographically greater than or equal tomu.nu

gap> p:=Partitions(6);;Sort(p,Lexicographic); p; [ [ 6 ],[ 5, 1 ],[ 4, 2 ],[ 4, 1, 1 ],[ 3, 3 ],[ 3, 2, 1 ], [ 3, 1, 1, 1 ],[ 2, 2, 2 ],[ 2, 2, 1, 1 ],[ 2, 1, 1, 1, 1 ], [ 1, 1, 1, 1, 1, 1 ] ]This function requires the package ``specht'' (see RequirePackage).

## 71.53 ReverseDominance

`ReverseDominance(`

,mu)nuThis is another total order on partitions which extends the dominance ordering (see Dominates). Here

is greater thanmuif for allnui>0sum_jge imu_j sum_jge inu_j.

gap> p:=Partitions(6);;Sort(p,ReverseDominance); p; [ [ 6 ], [ 5, 1 ], [ 4, 2 ], [ 3, 3 ], [ 4, 1, 1 ], [ 3, 2, 1 ], [ 2, 2, 2 ], [ 3, 1, 1, 1 ], [ 2, 2, 1, 1 ], [ 2, 1, 1, 1, 1 ], [ 1, 1, 1, 1, 1, 1 ] ]This is the ordering used by James in the appendix of his Springer lecture notes book.

This function requires the package ``specht'' (see RequirePackage).

## 71.54 Specialized

`Specialized(x [,q]);`

`Specialized(d [,q]);`

Given an element of the Fock space

x(see Specht), or a crystallized decomposition matrix (see CrystalDecompositionMatrix),`Specialized`

returns the corresponding element of the Grothendieck ring or the corresponding decomposition matrix of the Hecke algebra respectively. By default the indeterminate`v`

is specialized to1; however`v`

can be specialized to any (integer)qby supplying a second argument.

gap> H:=Specht(2);; x:=H.Pq(6,2); S(6,2)+v*S(6,1,1)+v*S(5,3)+v^2*S(5,1,1,1)+v*S(4,3,1)+v^2*S(4,2,2) +(v^3 + v)*S(4,2,1,1)+v^2*S(4,1,1,1,1)+v^2*S(3,3,1,1)+v^3*S(3,2,2,1) +v^3*S(3,1,1,1,1,1)+v^3*S(2,2,2,1,1)+v^4*S(2,2,1,1,1,1) gap> Specialized(x); S(6,2)+S(6,1,1)+S(5,3)+S(5,1,1,1)+S(4,3,1)+S(4,2,2) +2*S(4,2,1,1)+S(4,1,1,1,1)+S(3,3,1,1)+S(3,2,2,1)+S(3,1,1,1,1,1) +S(2,2,2,1,1)+S(2,2,1,1,1,1) gap> Specialized(x,2); S(6,2)+2*S(6,1,1)+2*S(5,3)+4*S(5,1,1,1)+2*S(4,3,1)+4*S(4,2,2)+10*S(4,2,1,1) +4*S(4,1,1,1,1)+4*S(3,3,1,1)+8*S(3,2,2,1)+8*S(3,1,1,1,1,1)+8*S(2,2,2,1,1) +16*S(2,2,1,1,1,1)An example of

`Specialize`

being applied to a crystallized decomposition matrix can be found in CrystalDecompositionMatrix. This function requires the package ``specht'' (see RequirePackage).## 71.55 ERegulars

`ERegulars(`

x)

`ERegulars(`

d)

`ListERegulars(`

x)

`ERegulars(`

prints a list of thex)e--regular partitions, together with multiplicities, which occur in the modulex.`ListERegulars(`

returns an actual list of these partitions rather than printing them.x)

gap> H:=Specht(8);; gap> x:=H.S(InducedModule(H.P(8,5,3)) ); S(9,5,3)+S(8,6,3)+S(8,5,4)+S(8,5,3,1)+S(6,5,3,3)+S(5,5,4,3)+S(5,5,3,3,1) gap> ERegulars(x); [ 9, 5, 3 ] [ 8, 6, 3 ] [ 8, 5, 4 ] [ 8, 5, 3, 1 ] [ 6, 5, 3, 3 ] [ 5, 5, 4, 3 ] [ 5, 5, 3, 3, 1 ] gap> H.P(x); P(9,5,3)+P(8,6,3)+P(8,5,4)+P(8,5,3,1)This example shows why these functions are useful: given a projective module

x, as above, and the list ofe--regular partitions inxwe know the possible indecomposable direct summands ofx.Note that it is not necessary to specify what

eis when calling this function becausex``knows'' the value ofe.The function

`ERegulars`

can also be applied to a decomposition matrixd; in this case it returns the unitriangular submatrix ofdwhose rows and columns are indexed by thee--regular partitions.These function requires the package ``specht'' (see RequirePackage).

## 71.56 SplitECores

`SplitECores(`

x)

`SplitECores(`

x,)mu

`SplitECores(`

x,y)The function

`SplitECores(`

returns a listx)`[`

where the Specht modules in eachb_1,...,b_k]b_iall belong to the same block (i.e. they have the samee-core). Similarly,`SplitECores(`

returns the component ofx,)muxwhich is in the same block as, andmu`SplitECores(`

returns the component ofx,y)xwhich is in the same block asy.

gap> H:=Specht(2);; gap> SplitECores(InducedModule(H.S(5,3,1))); [ S(6,3,1)+S(5,3,2)+S(5,3,1,1), S(5,4,1) ] gap> InducedModule(H.S(5,3,1),0); S(5,4,1) gap> InducedModule(H.S(5,3,1),1); S(6,3,1)+S(5,3,2)+S(5,3,1,1)See also

`ECore`

ECore,`InducedModule`

InducedModule, and`RestrictedModule`

RestrictedModule.This function requires the package ``specht'' (see RequirePackage).

## 71.57 Coefficient

`Coefficient(`

x,)mu

If

xis a sum of Specht (resp. simple, or indecomposable) modules, then`Coefficient(`

returns the coefficient ofx,)mu`S`

() inmux(resp.`D`

(), ormu`P`

()).mu

gap> H:=Specht(3);; x:=H.S(H.P(7,3)); S(7,3)+S(7,2,1)+S(6,2,1^2)+S(5^2)+S(5,2^2,1)+S(4^2,1^2)+S(4,3^2)+S(4,3,2,1) gap> Coefficient(x,5,2,2,1); 1This function requires the package ``specht'' (see RequirePackage).

## 71.58 InnerProduct

`InnerProduct(`

x,y)Here

xandyare some modules of the Hecke algebra (i.e. Specht modules, PIMS, or simple modules).`InnerProduct(`

computes the standard inner product of these elements. This is sometimes a convenient way to compute decomposition numbers (for example).x,y)

gap> InnerProduct(H.S(2,2,2,1), H.P(4,3)); 1 gap> DecompositionNumber(H,[2,2,2,1],[4,3]); 1This function requires the package ``specht'' (see RequirePackage).

## 71.59 SpechtPrettyPrint

`SpechtPrettyPrint(true)`

`SpechtPrettyPrint(false)`

`SpechtPrettyPrint()`

This function changes the way in which Specht prints modules. The first two forms turn pretty printing on and off respectively (by default it is off), and the third form toggles the printing format.

gap> H:=Specht(2);; x:=H.S(H.P(6));; gap> SpechtPrettyPrint(true); x; S(6)+S(5,1)+S(4,1^2)+S(3,1^3)+S(2,1^4)+S(1^6) gap> SpechtPrettyPrint(false); x; S(6)+S(5,1)+S(4,1,1)+S(3,1,1,1)+S(2,1,1,1,1)+S(1,1,1,1,1,1) gap> SpechtPrettyPrint(); x; S(6)+S(5,1)+S(4,1^2)+S(3,1^3)+S(2,1^4)+S(1^6)This function requires the package ``specht'' (see RequirePackage).

## 71.60 SemiStandardTableaux

`SemiStandardTableaux(`

,mu)nu

a partition,mua composition.nuReturns a list of the semistandard

--tableaux of typemu[JK]. Tableaux are represented as lists of lists, with the first element of the list being the first row of the tableaux and so on.nu

gap> SemiStandardTableaux([4,3],[1,1,1,2,2]); [ [ [ 1, 2, 3, 4 ], [ 4, 5, 5 ] ], [ [ 1, 2, 3, 5 ], [ 4, 4, 5 ] ], [ [ 1, 2, 4, 4 ], [ 3, 5, 5 ] ], [ [ 1, 2, 4, 5 ], [ 3, 4, 5 ] ], [ [ 1, 3, 4, 4 ], [ 2, 5, 5 ] ], [ [ 1, 3, 4, 5 ], [ 2, 4, 5 ] ] ]See also

`StandardTableaux`

StandardTableaux. This function requires the package ``specht'' (see RequirePackage).## 71.61 StandardTableaux

`StandardTableaux(`

)mu

a partition.muReturns a list of the standard

--tableaux.mu

gap> StandardTableaux(4,2); [ [ [ 1, 2, 3, 4 ], [ 5, 6 ] ], [ [ 1, 2, 3, 5 ], [ 4, 6 ] ], [ [ 1, 2, 3, 6 ], [ 4, 5 ] ], [ [ 1, 2, 4, 5 ], [ 3, 6 ] ], [ [ 1, 2, 4, 6 ], [ 3, 5 ] ], [ [ 1, 2, 5, 6 ], [ 3, 4 ] ], [ [ 1, 3, 4, 5 ], [ 2, 6 ] ], [ [ 1, 3, 4, 6 ], [ 2, 5 ] ], [ [ 1, 3, 5, 6 ], [ 2, 4 ] ] ]See also

`SemiStandardTableaux`

SemiStandardTableaux. This function requires the package ``specht'' (see RequirePackage).## 71.62 ConjugateTableau

`ConjugateTableau(`

tab)Returns the tableau obtained from

tabby interchangings its rows and columns.

gap> ConjugateTableau([ [ 1, 3, 5, 6 ], [ 2, 4 ] ]); [ [ 1, 2 ], [ 3, 4 ], [ 5 ], [ 6 ] ]This function requires the package ``specht'' (see RequirePackage).

## 71.63 ShapeTableau

`ShapeTableau(`

tab)Given a tableau

tabthis function returns the partition (or composition).

gap> ShapeTableau( [ [ 1, 1, 2, 3 ], [ 4, 5 ] ] ); [ 4, 2 ]This function requires the package ``specht'' (see RequirePackage).

## 71.64 TypeTableau

`TypeTableau(`

tab)Returns the type of the (semistandard) tableau

tab; that is, the compositionsigma=(sigma_1,sigma_2,ldots)wheresigma_iis the number of entries intabwhich are equal toi.

gap> List(SemiStandardTableaux([5,4,2],[4,3,0,1,3]),TypeTableau); [ [ 4, 3, 0, 1, 3 ], [ 4, 3, 0, 1, 3 ], [ 4, 3, 0, 1, 3 ], [ 4, 3, 0, 1, 3 ], [ 4, 3, 0, 1, 3 ] ]This function requires the package ``specht'' (see RequirePackage).

Specht 2.4

September 1997