**Tutorial on the group representation functions in the GAP package 'reps' for handling representations of groups and categories in positive characteristic.
**

March 2020

In March 2020 there is major new release of the packages reps and catreps in which they are combined as one. Commands common to both groups and categories have been written in objected oriented form by Moriah Elkin. This has been done as a response to the need to interface between the two contexts.

The package has been designed and is maintained by

Peter Webb

School of Mathematics

University of Minnesota

Minneapolis MN 55455

webb@math.umn.edu

http://www.math.umn.edu/~webb

The GAP code is available at: http://www.math.umn.edu/~webb/

The code has been written by Peter Webb, Dan Christensen, Bryan Simpkins, Robert Hank, Brad Froehle, with contributions from several people including Roland Loetscher.

The package 'reps' described here sets up a framework within which matrix representations of finite groups, primarily in positive characteristic, can be stored and examined. Sufficient information is stored so that calculations can be performed, and at the same time little more than this information is stored. It is important that the user should be able to understand quickly the syntax of commands and what the software is doing, and also that the software should not depend unduly on constructions in other parts of GAP that may change.

The basic object of computation is a record with a name such as rep, and fields which include rep.group, rep.genimages, rep.field and rep.dimension. The first of these is the group being represented, and the second is a list of matrices over rep.field which represent the action of the group elements in the list GeneratorsOfGroup(rep.group). Since many of the algorithms used and some of the properties investigated (such as projectivity) depend on the group being represented it is important to store the group. By contrast, the implementation of the meataxe already present in GAP does not store the group. With these record fields it is also possible to distinguish between the zero representation of an arbitrary group and the different representations of the identity group. In the present implementation certain commands will only work when rep.group is a permutation group.

The intention is to make available all algorithms for handling group representations within the above framework. These include the basic meataxe operations for finding a proper invariant subspace and Norton's irreducibility test, but also include many other algorithms, many of them based on the operation of taking fixed points. It is important to understand the limitations of the various algorithms in using them effectively. Thus the meataxe is at its best when given a representation with few, non-isomorphic, composition factors. To find the socle of a representation of a p-group in characteristic p, it may be better to use FixedPoints(rep); which solves some linear equations, rather than SocleRep(rep); which calls the meataxe. The routines which work with spaces of homomorphisms, such as Decompose, tend to be limited by the dimension of the representations; and so on.

The fastest way to become familiar with this package is to read through the worked examples of its use which appear after the list of available commands.

Look at the worked examples that follow to see how to use these commands.

gap> Read("reps");

Sym( [ 1 .. 4 ] )

gap> GeneratorsOfGroup(g);

[ (1,2,3,4), (1,2) ]

gap> comp:=CompositionFactorsRep(reg);;

gap> List(comp,x->x.dimension);

[ 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2 ]

gap> two:=comp[3];

rec( group := Sym( [ 1 .. 4 ] ),

genimages := [ <an immutable 2x2 matrix over GF2>,

<an immutable 2x2 matrix over GF2> ], field := GF(2), dimension := 2,

isRepresentation := true )

gap> PrintRep(two);

Representation( SymmetricGroup( [ 1 .. 4 ] ), Images

[ [ 1, 0 ],

[ 1, 1 ] ]

[ [ 1, 1 ],

[ 0, 1 ] ]

)

gap> RepPrint(four);

Representation( SymmetricGroup( [ 1 .. 4 ] ), Images

[ [ 0, 1, 0, 0 ],

[ 0, 0, 1, 0 ],

[ 0, 0, 0, 1 ],

[ 1, 0, 0, 0 ] ]

[ [ 0, 1, 0, 0 ],

[ 1, 0, 0, 0 ],

[ 0, 0, 1, 0 ],

[ 0, 0, 0, 1 ] ]

)

gap> FixedQuotient(four);

[ <an immutable GF2 vector of length 4>, <an immutable GF2 vector of length 4>,

<an immutable GF2 vector of length 4> ]

gap> three:=SubmoduleRep(four,last);;

gap> RepPrint(three);

Representation( SymmetricGroup( [ 1 .. 4 ] ), Images

[ [ 1, 1, 0 ],

[ 1, 0, 1 ],

[ 1, 0, 0 ] ]

[ [ 0, 1, 0 ],

[ 1, 0, 0 ],

[ 0, 0, 1 ] ]

)

gap> FixedPoints(three);

[ <an immutable GF2 vector of length 3> ]

gap> two:=QuotientRep(three,last);;

gap> RepPrint(two);

Representation( SymmetricGroup( [ 1 .. 4 ] ), Images

[ [ 1, 0 ],

[ 1, 1 ] ]

[ [ 1, 1 ],

[ 0, 1 ] ]

)

true

We now construct a 6-dimensional permutation representation.

[ [ 1, 2 ], [ 2, 3 ], [ 3, 4 ], [ 1, 3 ], [ 1, 4 ], [ 2, 4 ] ]

gap> Action(g,last,OnSets);

Group([ (1,2,3,5)(4,6), (2,4)(5,6) ])

gap> six:=PermutationRep(g,GeneratorsOfGroup(last),GF(2));;

gap> RepPrint(six);

Representation( SymmetricGroup( [ 1 .. 4 ] ), Images

[ [ 0, 1, 0, 0, 0, 0 ],

[ 0, 0, 1, 0, 0, 0 ],

[ 0, 0, 0, 0, 1, 0 ],

[ 0, 0, 0, 0, 0, 1 ],

[ 1, 0, 0, 0, 0, 0 ],

[ 0, 0, 0, 1, 0, 0 ] ]

[ [ 1, 0, 0, 0, 0, 0 ],

[ 0, 0, 0, 1, 0, 0 ],

[ 0, 0, 1, 0, 0, 0 ],

[ 0, 1, 0, 0, 0, 0 ],

[ 0, 0, 0, 0, 0, 1 ],

[ 0, 0, 0, 0, 1, 0 ] ]

)

gap> FixedPoints(six);

[ <an immutable GF2 vector of length 6> ]

gap> DimHom(two,six);

1

gap> Decompose(socle);

[ [ <a GF2 vector of length 3> ],

[ <a GF2 vector of length 3>, <a GF2 vector of length 3> ] ]

gap> IsIrreducibleRep(SubmoduleRep(socle,last[2]));

true

1

gap> FixedQuotient(six);

[ <an immutable GF2 vector of length 6>, <an immutable GF2 vector of length 6>,

<an immutable GF2 vector of length 6>, <an immutable GF2 vector of length 6>,

<an immutable GF2 vector of length 6> ]

[ <an immutable GF2 vector of length 6> ]

gap> quot:=QuotientRep(six,last);;

gap> FixedPoints(quot);

[ ]

gap> FixedQuotient(quot);

[ <an immutable GF2 vector of length 5>, <an immutable GF2 vector of length 5>,

<an immutable GF2 vector of length 5>, <an immutable GF2 vector of length 5> ]

gap> sub:=SubmoduleRep(quot,last);;

gap> DimHom(two,sub);

1

gap> DimHom(sub,two);

1

gap> FixedQuotient(sub);

[ <an immutable GF2 vector of length 4>, <an immutable GF2 vector of length 4>,

<an immutable GF2 vector of length 4>, <an immutable GF2 vector of length 4> ]

gap> FixedPoints(sub);

[ ]

<a 2x6 matrix over GF2>

gap> quot:=QuotientRep(six,last);;

gap> FixedPoints(quot);

[ <an immutable GF2 vector of length 4>, <an immutable GF2 vector of length 4> ]

gap> a5:=AlternatingGroup(5);

Alt( [ 1 .. 5 ] )

gap> reg:=RegularRep(a5,GF(2));;

gap> aug:=SubmoduleRep(reg,FixedQuotient(reg));;

gap> Decompose(aug);;

gap> List(aug.summands,Length);

[ 4, 4, 4, 16, 4, 11, 16 ]

gap> four:=SubmoduleRep(aug,aug.summands[1]);;

gap> PrintRep(four);

Representation( AlternatingGroup( [ 1 .. 5 ] ), Images

[ [ 0, 1, 1, 1 ],

[ 0, 0, 1, 0 ],

[ 1, 0, 0, 0 ],

[ 0, 0, 1, 1 ] ]

[ [ 0, 1, 0, 0 ],

[ 0, 0, 1, 0 ],

[ 1, 0, 0, 0 ],

[ 1, 1, 0, 1 ] ]

)

gap> IsIrreducibleRep(four);

true

gap> IsProjectiveRep(four);

true

gap> sixteen:=SubmoduleRep(aug,aug.summands[4]);;

gap> socle:=SubmoduleRep(sixteen,SocleRep(sixteen));;

gap> IsIrreducibleRep(socle);

true

gap> DimHom(four,socle);

0

true

gap> IsAbsolutelyIrreducibleRep(socle);

false

gap> DimHom(socle,socle);

2

gap> eleven:=SubmoduleRep(aug,aug.summands[6]);;

gap> ten:=QuotientRep(eleven,FixedPoints(eleven));;

gap> ten.dimension;

10

gap> FixedPoints(ten);

[ ]

gap> Length(FixedQuotient(ten));

10