Michi’s blog » Modular representation theory: Simple and semisimple objects

Modular representation theory: Simple and semisimple objects

• April 2nd, 2007
• 3:56 pm

Representations of categories

The basic tenet of representation theory is that we have some entity – the group representation theory takes a group, the algebra representation theory most often a quiver, and we look at ways to view the elements of the structure as endomorphisms of some vectorspace. The attentive reader remembers my last post on the subject, where was given a group action by the rotations and reflections of a polygon surrounding the origin.

There is a way, suggested to me by Miles Gould in my last post, to unify all these various ways of looking at things in one: groups – and quivers – and most other things we care to look at are in fact very small category. For groups, it’s a category with one object, and one morphism/arrow for each group element, and such that the arrow you get by composing two arrows is the one corresponding to a suitable product in the group. A quiver is just a category corresponding to the way the quiver looks – with objects for all vertices, and arrows for all edges.

Given a category C, we can represent it, by just forming a functor F:C->Vectk – which is to say we choose a vector space over the field k for each object in the category, and a linear map for each arrow.

For the case of group representations, the group as a category has just the one object, and so we choose one single vector space. Then the group has a whole bunch of arrows – and these all need to correspond to linear maps within this vector space.

So, in the end, since all representations theories are in some way the same, and indeed, there’s a bunch of features that carry across several theories.

The structure of modules

As we saw above, representations are more or less the same thing. Which thing this same thing is, becomes apparent if we introduce some more algebraic terminology.

Suppose A is some algebraic structure over a field k, which is to say that A is a vectorspace over k, with some set of operations. Typical instances are associative algebras, Lie algebras, A- or L-structures et.c. Then, we say that a module M over the algebra A is a vectorspace over k, with the operations of the algebra A adjusted to work as operations on the module as well.

This, however, is formulated now to a generality that kills off the statement, so I’m going to specialise in order to have something decent to talk about.

So, a module over the associative algebra A is a vectorspace M, together with a multiplication that ends up being associative, and distributive, in comfortable ways.

But this is nothing other than saying that we can apply the elements of the associative algebra to the elements of the module in order to get new elements of the module. Thus, being a module over an algebra means that the algebra transforms the module, and so a module is a representation of the algebra.

This means that in order to understand group representations, we want to understand modules over the group algebra – instead of considering embeddings of the group as linear maps within a vector space, we consider linear combinations of group elements as objects acting on a vector space, forming a module.

Building blocks of modules

So, our grand question thus is: if we know that a certain vector space is a module over something or other, what can we do? What can we say about the way this works?

First of all, we could try to figure out what kind of building blocks they might have. One obvious first step is given through the Krull-Schmidt theorem. This states that if A is an associative algebra, and M is an A-module, then the decomposition of M into a direct sum of submodules that cannot be further decomposed that way is unique.

So, any module is a direct sum of indecomposable modules. And the module action of the ring, thus, is given by block matrices with (possibly) nonzero blocks on the diagonal, corresponding to the indecomposable submodules, and zeroes everywhere else. The proof of this theoerm follows by induction, reasoning with dimensions of vector spaces and with juggling the a few linear maps back and forth until everything fits.

As a corollary, we also can cancel modules in direct sum expressions. That is, if , then .

Under good circumstances, any such building block – any indecomposable module – would also be simple, which is to say that it has no subspace invariant under the action. If that is the case, then the fun ends right about here, and all we need to care about is the structure of simple modules, and then everything is done.

For the modular case though – such as group representations over a field of characteristic p, where p divides the group order, we’re not that lucky. We end up with a situation where simples and indecomposables are different. We can still use Krull-Schmidt, and reduce down to indecomposable modules, but the indecomposable modules may very well be quite complex in terms of simple modules. So we’d need to study both. We’ll start, however, with the part that’s reasonably easy to study.

Simple modules

A simple module is a module without submodules – that is, a vectorspace with some action of the algebra, that doesn’t have invariant subspaces.

If we figure out what these look like, we’re a good step forward on our path to understanding what modules can look like. In the ordinary case, we’re in some ways done – since simples are indecomposables, and any other module a direct sum of such. For the modular case, though, there’s still work to be done.

But let us start with the very basics. Suppose A is a finite-dimensional algebra with unit over a good enough field of characteristic p. A module M is said to be simple if the only submodules of M are M and 0. It is said to be semisimple if it is a direct sum of simple modules. An algebra is simple or semisimple if it is this as a module over itself.

Now, submodules of semisimple modules are just selections of the simple modules that make out the supermodule – since otherwise, we could intersect the submodule with a summand, and get a submodule. This is impossible, since the smallest summands are simple.

In semisimple modules, every submodule is a direct summand. This means that simple modules cannot glue together within semisimple modules – all building blocks are distinct and have well defined boundaries.

There are two important tools we use to analyze algebras. One is the radical, and the other is the socle. Both of these are given by a bunch of equivalent descriptions:

• The smallest submodule I in A such that A/I is semisimple
• The intersection of all the maximal submodules of A
• The largest nilpotent ideal of A

And the socle soc(M) of a module M is

• The set of m in M such that rad(A)·m=0
• The largest semisimple submodule
The sum of all simple submodules

The radical of a module is a new module, thus has a radical. So we can form a series of radicals

where . Since rad(A) is a nilpotent ideal, this series has finite length, called the radical length, and each quotient is semisimple by the property of the radical.

Using the socle, we can get a similar description as a layering of semisimple modules, but from the other direction. Consider a module M. Now the quotient M/soc(M) is a module, so this has a socle, and we let soc2(M) be the submodule such that soc2(M)/soc(M) is the socle of M/soc(M). Thus rad(A)2soc2(M)=0. We can carry on, making socn(M) be the elements in M that are annihilated by rad(A)n. This gives us a new series

and again, by the nilpotency of rad(A), we notice that at some point r, socr(M)=M. The smallest such r we call the socle length of M, and again, we describe M as a layering with semisimple elements.

Since both these series terminate due to the nilpotency of rad(A), the radical length of M is equal to the socle length, and we call this the Loewy length.

Schur’s Lemma

This lemma, which’ll help us get a structure theorem for simple and semisimple algebras and modules off the ground, is central in all representation theory and got presented early on as I studied ordinary representation theory. To use it, we consider endomorphism rings of various things. An endomorphism is just a homomorphism from a module to itself that respects all the structure we have.

Schur’s Lemma: If S is a simple A-module, then End(S) consists of scalar multiples of the identity matrix.

Proof: Pick some ρ in End(S). So ρ is a linear transformation of S. Pick an eigenvalue λ of ρ, so that ρ-λI is a singular linear transformation. So the image of this is a properly contained (by singularity) submodule (since both ρ and λI are endomorphisms, and thus their difference too). But since S is simple, the only properly contained submodule is 0, and so we know that ρ-λI=0, and thus ρ=λI.

The endomorphism algebra of a given algebra is isomorphic to the algebra you get by changing the direction of multiplication. Let ρa(x)=xa. Then ρa is an endomorphism, and ρabba for any a,b in the algebra. Moreover, is ρ is any endomorphism, then we let c=ρ(1), and for any x in A we get
ρ(x)=ρ(x·1)=xρ(1)=xc=ρc(x).

Now, we come to the meatier results.

Theorem: If A is simple, then A is the algebra of all nxn matrices over a field k for some n and some k.

For the proof, we pick a simple submodule S of A, and let U be the sum of all submodules isomorphic to S. Then U is semisimple, and any endomorphism of this U is a matrix with entries from End(S). We can represent each entry in End(S) with an element out of k, by Schur’s lemma, and so End(U) is a matrix algebra as expected.

Now, if ρ is an endomorphism of A, then because each of the summands of U either goes to another copy of some submodule isomorphic to S or to 0. So thus U is an ideal, thus a submodule, and thus by the simplicity of A either 0 or A itself. It cannot be 0, so A=U, and then we have End(A)=End(U) is the matrix ring. The matrix ring reverses multiplication by taking transposes, so this way we can get from the isomorphism to End(A) to the isomorphism to A.

If A instead is a semisimple algebra, then A is given as
, where each is a direct sum of isomorphic simple modules, and the component simple modules are different whenever the indices are different.

Thus, if we have a map , with , then the image is a submodule of and a quotient module of . But this means that it simultaneously has to be a direct sum of the component simple modules in and in , and we had assumed these to be different. Thus .

This means that , since there are no endomorphisms that can go between these summands: all endomorphisms send each summand into itself.

This all tells us how simple and semisimple algebras work: simple algebras are just matrix algebras. Semisimple algebras are direct sums of matrix algebras.

For the next post, I’ll take one look at how this argument works out for Lie algebras, and I shall take a closer look at the structures of modules, and the ways we can understand those.