# 71.16 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 module x, `IsNewIndecomposable` returns `true` if it is able to show that x is indecomposable (and this indecomposable is not already listed in d), and `false` otherwise. `IsNewIndecomposable` will also print a brief description of its findings, giving an upper and lower bound on the first decomposition number mu for which it is unable to determine the multiplicity of `S`(mu) in x.

`IsNewIndecomposable` works by running through all of the partitions nu such that `P`(nu) could be a summand of x and it uses various results, such as the q-Schaper theorem of [JM2] (see `Schaper` Schaper), the Mullineux map (see `Mullineux` Mullineux), and inducing simple modules, to determine if `P`(nu) does indeed split off. In addition, if d is the decomposition matrix for 'H'(Sym_n) then `IsNewIndecomposable` will probably use some of the decomposition matrices of 'H'(Sym_m) for m 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 projective H--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 x have changed; this is because `IsNewIndecomposable` was able to determine that the multiplicity of `S`(6,3,1) was at most 2 and so it subtracted one copy of `P`(6,3,1) from x.

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) from x we again use `IsNewIndecomposable` to see if x is 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 mu=[6,3,1].

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

Consequently, <x>='P'(10) and we add it to the decomposition matrix d (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).

GAP 3.4.4
April 1997