> < ^ Date: Thu, 04 Jan 2001 15:28:18 GMT
> < ^ From: Derek Holt <dfh@maths.warwick.ac.uk >
> < ^ Subject: Re: Symmetric powers of representations

Dear GAP Forum

Martin Roetteler & Chris Charnes wrote:

we would like to compute the multiplicities of the trivial character in the
k-fold symmetric power of a representation of a finite group G over
the finite field GF(2). Could anyone guide us for the appropriate routines
in GAP for doing this.

I can partially answer this question. As far as I can tell, there is no
existing function for finding the k-fold symmetric power of a representation
of a group. There is a function SymmetricPower in the library, but
this appears to be intended for use with modules over Lie Algebras.

If that is right, then the required symmetric power function would need to
be written. That should not be too difficult - it would just be a matter
of working out the entries of the matrices for the symmetric power in
terms of those of the original representation. Note that there is a
function KroneckerProduct, which takes two matrices as arguments, and
can be used to produce tensor products (and hence tensor powers) of
representations.

Once you have produced the matrices for the group generators for the
symmetric power, finding the multiplicity of the trivial character
should be possible using the MeatAxe.

The so-called "Smash Meataxe" is available in GAP4 (see chapter "The Meataxe"
in manual), and could be used for this purpose. Its user-interface is a
little primitive, so I include an example below. If you need to deal with
modules of very large dimension (more than a thousand, say), then the
standalone Meataxe of Lux and Ringe would be faster, particularly over
GF(2). That is available as a share package in GAP3, but not yet in GAP4
as far as I know.

Example of Smash Meataxe:

#Define matrices for permutation representation of A6 over GF(2).
gap> G:=AlternatingGroup(6);;
gap> mats := List(GeneratorsOfGroup(G),x->PermutationMat(x,6,GF(2)));;

#Now define the corresponding module
gap> M := GModuleByMats(mats,GF(2));
rec( field := GF(2), isMTXModule := true, dimension := 6,
generators := [ <an immutable 6x6 matrix over GF2>,
<an immutable 6x6 matrix over GF2> ] )
gap> MTX.Dimension(M);
6
gap> MTX.IsIrreducible(M);
false;

#MTX.CollectedFactors finds composition factors with multiplicities
gap> cf := MTX.CollectedFactors(M);

#These are ordered by dimension. cf[i][1] is the irreducible module
#and cf[i][2] its multiplicity.

```gap> MTX.Dimension(cf[1][1]);
1

#Since the field is GF(2), this must be the trivial module.
#So cf[1][2] is what we want.
gap> cf[1][2];
2
```