# 68.3 Using the MeatAxe in GAP. An Example

In this example we compute the 2-modular irreducible representations and Brauer characters of the alternating group A_5. Perhaps it will raise the question whether one uses the MeatAxe in GAP or GAP for the MeatAxe.

First we take a permutation representation of A_5 and convert the generators into MeatAxe matrices over the field GF(2).

```    gap> a5:= Group( (1,2,3,4,5), (1,2,3) );;
gap> Size( a5 );
60
gap> f:= GF(2);;
gap> m1:= MeatAxeMat( a5.1, f, [5,5] );
MeatAxeMat( "/var/tmp/tmp.017545/a", GF(2), [ 5, 5 ] )
gap> m2:= MeatAxeMat( a5.2, f, [5,5] );; ```

`m1` and `m2` are records that know about the files where the matrices are stored. Let's look at such a matrix (without reading the file into GAP).

```    gap> Display( m1 );
MeatAxe.Matrix := [
[0,1,0,0,0],
[0,0,1,0,0],
[0,0,0,1,0],
[0,0,0,0,1],
[1,0,0,0,0]
]*Z(2); ```

Next we inspect the 5 dimensional permutation module over GF(2). It contains a trivial submodule `fix`, its quotient is called `quot`.

```    gap> a:= UnitalAlgebra( f, [ m1, m2 ] );;
gap> nat:= NaturalModule( a );;
gap> fix:= FixedSubmodule( nat );;
gap> Dimension( fix );
1
gap> quot:= nat / fix;; ```

The action on `quot` is described by an algebra of 4times 4 matrices, the corresponding module turns out to be absolutely irreducible. Of course the action on `fix` would yield 1times 1 matrices, the generators being the identity. So we found already two of the four absolutely irreducible representations.

```    gap> op:= Operation( a, quot );
UnitalAlgebra( GF(2),
[ MeatAxeMat( "/var/tmp/tmp.017545/t/g.1", GF(2), [ 4, 4 ], a.1 ),
MeatAxeMat( "/var/tmp/tmp.017545/t/g.2", GF(2), [ 4, 4 ], a.2 ) ] )
gap> nm:= NaturalModule( op );;
gap> IsIrreducible( nm );
true
gap> IsAbsolutelyIrreducible( nm );
true
gap> deg4:= nm.ring;; ```

Now we form the tensor product of the 4 dimensional module with itself, and compute the composition factors.

```    gap> tens:= KroneckerProduct( nm, nm );;
gap> comp:= CompositionFactors( tens );;
#I   Name Mult  SF
#I     1a    4   1
#I     4a    1   1
#I     4b    2   2
#I
#I  Ascending composition series:
#I  4a  1a  4b  1a  1a  4b  1a
gap> IsIrreducible( comp[3] );
true
gap> IsAbsolutelyIrreducible( comp[3] );
false ```

The information printed by `CompositionFactors` told that there is an irreducible but not absolutely irreducible factor `4b` of dimension 4, and we will enlarge the field in order to split this module.

```    gap> sf:= SplittingField( comp[3] );
GF(2^2)
gap> new:= UnitalAlgebra( sf, [ comp[3].ring.1, comp[3].ring.2 ] );;
#I  calling 'maketab' for field of size 4
gap> nat:= NaturalModule( new );;
gap> comp:= CompositionFactors( nat );;
#I   Name Mult  SF
#I     2a    1   1
#I     2b    1   1
#I
#I  Ascending composition series:
#I  2a  2b
gap> deg2:= List( comp, x -> x.ring );; ```

Now the representations are known. Let's calculate the Brauer characters. For that, we need representatives of the 2-regular conjugacy classes of A_5.

```    gap> repres:= [ a.1^0, a.1 * a.2 * a.1^3, a.1, a.1^2 ];;
gap> List( repres, OrderMeatAxeMat );
[ 1, 3, 5, 5 ] ```

The expression of the representatives of each irreducible representation in terms of the generators can be got using `MappedExpression`.

```    gap> abstracts:= List( repres, x -> x.abstract );
[ a.one, a.1*a.2*a.1^3, a.1, a.1^2 ]
gap> mapped:= List( [ 1 .. 4 ],
>   x-> MappedExpression( abstracts[x],
>       a.freeAlgebra.generators, deg4.generators ) );;
gap> List( mapped, OrderMeatAxeMat );
[ 1, 3, 5, 5 ]
gap> List( mapped, BrauerCharacterValue );
[ 4, 1, -1, -1 ]
gap> mapped:= List( [ 1 .. 4 ],
>   x-> MappedExpression( abstracts[x],
>       a.freeAlgebra.generators, deg2[1].generators ) );;
gap> List( mapped, BrauerCharacterValue );
[ 2, -1, E(5)^2+E(5)^3, E(5)+E(5)^4 ] ```

The Brauer character of the trivial module is well-known, and that of the other 2-dimensional module is a Galois conjugate of the computed one, so we computed the 2-modular Brauer character table of A_5.

It is advisable to remove all the MeatAxe files before leaving GAP. Call `MeatAxe.Unbind();` (see MeatAxe.Unbind).

GAP 3.4.4
April 1997