Tutorial on the category functions of the GAP package 'reps' for handling representations of groups and categories.

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, Fan Zhang, and Moriah Elkin.

Overview of the category functions in the package reps

Read P.J. Webb, An introduction to the representations and cohomology of categories, to learn the basics of representations of categories. A representation of a category over a ring is a functor from the category to the category of modules over that ring. This package assumes the ring is a field. Thus a representation consists of a vector space associated to each object of the category, and for each morphism in the category a linear map between the vector spaces associated to its domain and codomain.

In this package a category is stored as a concrete category (i.e. a category where the objects are sets and morphisms are maps of sets) in the same way as for the package 'categories' which computes the homology of nerves of categories. A category is stored as a record (cat, say) with fields cat.objects, cat.generators, cat.domain, cat.codomain. Each object in the list cat.objects is a set, and each morphism in the list of generator morphisms cat.generators is stored as a mapping of sets, which we notate as the list of its values. The numbers of the objects which are the domain and codomain of each generator morphism are listed in cat.domain and cat.codomain.

A representation of a category is stored as a record with a name such as rep, and fields which include rep.category, rep.genimages, rep.field and rep.dimension. The first of these is the category being represented. The second is a list of matrices over rep.field which represent the action of the generator morphisms in the list rep.category.generators.

We need to work with elements of the 'representation space' of the representation, which we take to be the direct sum of the vector spaces associated to the objects of the category, taken in the fixed order in which the objects are always listed. Some of the commands below take as arguments or return a list of lists of vectors. In such a list the nth entry is a list of vectors in the vector space associated to object n and it is frequently a basis for the space it spans.


Commands currently available

Commands for categories:
SupportOfMorphism(mapping) returns the list of positions at which the list 'mapping' is defined.
IdentityMorphism(l) returns the identity morphism on the set l.
Composition(f,g) returns the composition of the functions f and g, expressed as lists of their values.
IsComposable(f,g) returns true if the functions f and g, expressed as lists of their values, can be composed and false otherwise.
Objects(cat) returns the objects of the concrete category cat, as a list of sets.
Origin(cat,m) returns the position in cat.objects of the domain of the morphism m.
Terminus(cat,m) returns the position in cat.objects of the domain of the morphism m.
ConcreteCategory(list of mappings (, list of sets)). . sets up the record of the category which has the list of mappings as its generator morphisms, with the optional second argument as its list of objects. If the second argument is missing, the objects are taken to be the domains of the morphisms.
Morphisms(cat) returns an l x l matrix, where l is the number of objects in the category cat, and where the i,j entry is a list of the morphisms from object i to object j.
EndomorphismGroups(cat) creates a field of the record cat listing the endomorphism groups of objects. It is assumed these are groups, and that their generators appear among the generators of the category.
FI(n). .returns the full subcategory of the category FI of finite sets and injective maps, whose objects are 0,...,n. The empty set 0 is represented as a list [1], and the unique morphism from the empty set to each object is represented as a map sending 1 to the first element in that object, which is otherwise ignored. Thus the first element of each object is a place holder for the empty set.

Commands that return a representation:
CatRep(category, list of matrices, field) returns a representation of the category over the field, where the generators are represented by the matrices in the list.
YonedaRep(category, object number, field) returns the representation of the category on the subspace of the category algebra spanned by the morphisms whose domain is the specified object. The representation is projective, by Yoneda's lemma.
YonedaDualRep(category, object number, field) returns the representation of the category on the dual of the subspace of the category algebra spanned by the morphisms whose codomain is the specified object. The representation is injective, because its dual is projective (for the opposite algebra), by Yoneda's lemma.
DirectSumRep(rep1, rep2) returns the representation that is the direct sum of the representations rep1 and rep2.
TensorProductRep(rep, rep). . returns a representation which is the tensor product of the two representations.
SubmoduleRep(rep, list of lists of vecs) . . returns the representation which gives the action on the submodule spanned at each object by the corresponding list of vectors.
QuotientRep(rep, list of lists vecs). . returns the representation on the quotient module by the submodule spanned by the vectors. Each list of vectors in the list is a basis for the subspace they span of the representation space for the corresponding object.
ZeroCatRep(cat,field) returns the zero representation of the category.
ConstantRep(cat,field) returns the constant (or trivial) representation of the category.

Commands that return lists of vectors:
Spin(rep, list of lists of vectors) . . returns a list of bases for the subrepresentation generated by the vectors in the lists.
CoSpin(rep, list of lists of vectors) . . returns a list of bases for the largest subrepresentation contained in the spaces spanned by the vectors in the lists.
SumOfImages(rep,rep) . . returns a list of bases which give the sum of images of all module homomorphisms A -> B. Term i in the list is a basis for the subspace of the value of representation B at object i which is part of the sum of images.
Decompose(rep) . . returns a list of lists of bases. Each list of bases determines a direct summand of the representation, which is their direct sum. The summands are probably indecomposable.
DecomposeSubmodule(repn, list of bases) . . returns a list of two lists of bases for summands of the submodule of repn spanned by the given list of bases, if this submodule is decomposable, and if the module is indecomposable it returns a list whose only element is the given list of bases. A probabilistic algorithm is used, and it is possible that that a representation which the computer fails to decompose is in fact decomposable. The routine is called by Decompose.
SubConstant(rep) returns a list of bases for the largest subconstant subrepresentation of rep. It calls routines MorphismsRep and GeneratorDomains.

Commands for homomorphisms:
HomBasis(M, N) returns a basis for the space of kC-module homomorphisms M -> N. Each element of the output list is a list of matrices, in which the ith matrix is a map M[i] -> N[i].
DimHom(M, N) returns the dimension of the space of kC-module homomorphisms M -> N.

Commands that interface between categories and groups:
EndomorphismGroup(cat,obj). .returns the group of the endomorphisms of obj in cat. It assumes every endomorphism is invertible and that the generators of the endomorphism group appear among the generators of the category.
EndomorphismGroups(cat)..returns a list of the endomorphism groups of objects in cat. It assumes every endomorphism is invertible and that the generators of the endomorphism groups appear among the generators of the category.
MorphismsRep(rep). .returns a l x l matrix, where l is the number of objects in the category of rep, and where the i,j entry is a list of the matrices of morphisms from object i to object j.
Evaluation(rep, obj). .returns the representation of the endomorphism group of object obj on the value of the representation rep at obj.

Worked Examples

Example 1:

gap> Read("catreps");
We first set up a category with 2 objects and 9 morphisms:
gap> c3c3:=ConcreteCategory([[2,3,1],[4,5,6],[,,,5,6,4]]);
rec( generators := [ [ 2, 3, 1 ], [ 4, 5, 6 ], [ ,,, 5, 6, 4 ] ],
operations := rec( ), objects := [ [ 1, 2, 3 ], [ 4, 5, 6 ] ],
domain := [ 1, 1, 2 ], codomain := [ 1, 2, 2 ] )
The following constructs a representation:
gap> one:=One(GF(3));;
gap> d:=[[1,1,0,0,0],[0,1,1,0,0],[0,0,1,0,0],[0,0,0,1,1],[0,0,0,0,1]]*one;;
gap> e:=[[0,1,0,0],[0,0,1,0],[0,0,0,0],[0,1,0,1],[0,0,1,0]]*one;;
gap> f:=[[1,1,0,0],[0,1,1,0],[0,0,1,0],[0,0,0,1]]*one;;
gap> nine:=CatRep(c3c3,[d,e,f],GF(3));
rec(
category := rec( generators := [ [ 2, 3, 1 ], [ 4, 5, 6 ], [ ,,, 5, 6, 4 ] ]
, operations := rec( ), objects := [ [ 1, 2, 3 ], [ 4, 5, 6 ] ],
domain := [ 1, 1, 2 ], codomain := [ 1, 2, 2 ] ),
genimages := [ [ [ Z(3)^0, Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3) ],
[ 0*Z(3), Z(3)^0, Z(3)^0, 0*Z(3), 0*Z(3) ],
[ 0*Z(3), 0*Z(3), Z(3)^0, 0*Z(3), 0*Z(3) ],
[ 0*Z(3), 0*Z(3), 0*Z(3), Z(3)^0, Z(3)^0 ],
[ 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3), Z(3)^0 ] ],
[ [ 0*Z(3), Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3)^0, 0*Z(3) ]
, [ 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3) ],
[ 0*Z(3), Z(3)^0, 0*Z(3), Z(3)^0 ],
[ 0*Z(3), 0*Z(3), Z(3)^0, 0*Z(3) ] ],
[ [ Z(3)^0, Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, Z(3)^0, 0*Z(3) ]
, [ 0*Z(3), 0*Z(3), Z(3)^0, 0*Z(3) ],
[ 0*Z(3), 0*Z(3), 0*Z(3), Z(3)^0 ] ] ], field := GF(3),
dimension := [ 5, 4 ] )
The dimension vector shows that the space associated to object 1 is 5-dimensional, and the space associated to object 2 is 4-dimensional. The representation is indecomposable:
gap> Length(Decompose(nine));
1
gap> fortyone:=TensorProductRep(nine,nine);;
The output from the last command was suppressed, but the representation it produces has a space of dimension 25 at object 1, and a space of dimension 16 at object 2. We start to examine it by finding its indecomposable summands.
gap> d:=Decompose(fortyone);;
gap> List(d,x->List(x,Length));
[ [ 3, 0 ], [ 3, 1 ], [ 3, 3 ], [ 3, 3 ], [ 0, 3 ], [ 3, 0 ], [ 3, 0 ],
[ 3, 0 ], [ 1, 3 ], [ 3, 3 ] ]
Thus fortyone has 10 indecomposable summands, with dimension lists as above. We examine the structure of the third summand.
gap> six:=SubmoduleRep(fortyone,d[3]);
rec(
category := rec( generators := [ [ 2, 3, 1 ], [ 4, 5, 6 ], [ ,,, 5, 6, 4 ] ]
, operations := rec( ), objects := [ [ 1, 2, 3 ], [ 4, 5, 6 ] ],
domain := [ 1, 1, 2 ], codomain := [ 1, 2, 2 ] ),
genimages := [ [ [ Z(3)^0, Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3)^0, Z(3)^0 ],
[ 0*Z(3), 0*Z(3), Z(3)^0 ] ],
[ [ 0*Z(3), Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3) ],
[ 0*Z(3), 0*Z(3), 0*Z(3) ] ],
[ [ Z(3)^0, Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3)^0, Z(3)^0 ],
[ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ], field := GF(3),
dimension := [ 3, 3 ], isRepresentation := true )
gap> SumOfImages(ConstantRep(c3c3,GF(3)),six);
[ [ [ 0*Z(3), 0*Z(3), Z(3)^0 ] ], [ ] ]
The representation six consists of a module homomorphism for a group of order 3 acting on two spaces of dimension 3. The last calculation shows that it is not an isomorphism between two modules. We do the same test to the Yoneda representation (= representable functor) associated to object 1.
gap> y:=YonedaRep(c3c3,1,GF(3));;
gap> SumOfImages(ConstantRep(c3c3,GF(3)),y);
[ [ [ Z(3)^0, Z(3)^0, Z(3)^0 ] ], [ [ Z(3)^0, Z(3)^0, Z(3)^0 ] ] ]
This shows that six is not isomorphic to the Yoneda representation. We take the opportunity to construct the simple representation associated to object 1.
gap> s1:=SubmoduleRep(six,[ [ [ 0*Z(3), 0*Z(3), Z(3)^0 ] ], [ ] ]);
rec(
category := rec( generators := [ [ 2, 3, 1 ], [ 4, 5, 6 ], [ ,,, 5, 6, 4 ] ]
, operations := rec( ), objects := [ [ 1, 2, 3 ], [ 4, 5, 6 ] ],
domain := [ 1, 1, 2 ], codomain := [ 1, 2, 2 ],
morphisms := [ [ [ [ 1, 2, 3 ], [ 2, 3, 1 ], [ 3, 1, 2 ] ],
[ [ 4, 5, 6 ], [ 5, 6, 4 ], [ 6, 4, 5 ] ] ],
[ [ ], [ [ ,,, 4, 5, 6 ], [ ,,, 5, 6, 4 ], [ ,,, 6, 4, 5 ] ] ] ] ),
genimages := [ [ [ Z(3)^0 ] ], [ [ ] ], [ ] ], field := GF(3),
dimension := [ 1, 0 ], isRepresentation := true )
gap> five:=QuotientRep(six,[ [ [ 0*Z(3), 0*Z(3), Z(3)^0 ] ], [ ] ]);
rec(
category := rec( generators := [ [ 2, 3, 1 ], [ 4, 5, 6 ], [ ,,, 5, 6, 4 ] ]
, operations := rec( ), objects := [ [ 1, 2, 3 ], [ 4, 5, 6 ] ],
domain := [ 1, 1, 2 ], codomain := [ 1, 2, 2 ],
morphisms := [ [ [ [ 1, 2, 3 ], [ 2, 3, 1 ], [ 3, 1, 2 ] ],
[ [ 4, 5, 6 ], [ 5, 6, 4 ], [ 6, 4, 5 ] ] ],
[ [ ], [ [ ,,, 4, 5, 6 ], [ ,,, 5, 6, 4 ], [ ,,, 6, 4, 5 ] ] ] ] ),
genimages := [ [ [ Z(3)^0, Z(3)^0 ], [ 0*Z(3), Z(3)^0 ] ],
[ [ 0*Z(3), Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3) ] ],
[ [ Z(3)^0, Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3)^0, Z(3)^0 ],
[ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ], field := GF(3),
dimension := [ 2, 3 ], isRepresentation := true )
The next calculation shows that the 3-dimensional representation of C_3 associated to object 1 is a single copy of the regular representation of C_3.
gap> SumOfImages(s1,six);
[ [ [ 0*Z(3), 0*Z(3), Z(3)^0 ] ], [ ] ]
The next calculation shows that the quotient representation five maps its module at object 1 monomorphically to the module at object 2, which must either be indecomposable of dimension 3, or else the direct sum of indecomposables of dimension 2 and 1.
gap> SumOfImages(s1,five);
[ [ ], [ ] ]
gap> SumOfImages(ConstantRep(c3c3,GF(3)),five);
[ [ [ 0*Z(3), Z(3)^0 ] ], [ [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ]
The final calculation shows that the module at object 2 for six is indecomposable of dimension 3. We now have sufficient information to describe six completely.
gap> SumOfImages(six,ConstantRep(c3c3,GF(3)));
[ [ ], [ [ Z(3)^0 ] ] ]