Our beloved Dr. Mathochist just gave me the task of taking care of any readers prematurely interested in it while telling us all just a tad too little for satisfaction about Khovanov homology.

And I received a letter from the Haskellite crowd – more specifically from alpheccar, who keeps on reading me writing about homological algebra, but doesn’t know where to begin with it, or why.

I have already a few times written about homological algebra, algebraic topology and what it is I do, on various levels of difficulty, but I guess – especially with the carnival dry-out I’ve been having – that it never hurts writing more about it, and even trying to get it so that the non-converts understand what’s so great about it.

So here goes.

Alpheccar writes that to his understanding, the idea is to build topological spaces out of algebraic gadgets, and then do topology on them. This is a part of the story, and certainly historically very important, but it is far from all of it.

Motivations

The revolution for homological algebra pretty much started with Eilenberg-MacLane – who wrote an articlebook that did the constructions necessary for the very topological versions of homological algebra – but without ever involving the actual topological spaces.

The point is that the way you do algebraic topology is that you tend to set up a functor Top → R-ChMod that assigns a chain complex of R-modules to each (nice enough) topological space, and then you add functors R-ChMod → R-Mod that extract informations from these. Typical examples are cellular chain complexes with coefficients somewhere nice for the first functor, and then homology or cohomology for the second functor – depending on what viewpoint is the most obvious.

The revolution was that we simply throw out that first functor.

In order to study (co)homology, we don’t really need to care that there was a topological space somewhere to begin with. We only, really, need a nice enough category of chain complexes (if it’s abelian, then that’s fine – we get the long exact sequences in homology and other niftiness easily then, but if it’s not, triangulated will do…) and we study certain types of functors from these to module categories.

Homological algebra as a tool for algebraic topology

Since, in the viewpoint introduced above, homological algebra is a part of the process used in algebraic topology, it turns out to be really neat to sit down and just prove a lot of neat results in homological algebra – with the background that at some later point, these might be useful once you sit down with the topology. I got hold of this particular point early – I had started my MSc thesis work in homological algebra before I took my first real topology course, and during that course, the less pointset topology and the more algebraic topology we did, the easier everything got. The fundamental results we needed to grasp to do algebraic topology in any amount of seriosity were basically just applications of all the cornerstone results in homological algebra, and thus perfectly obvious to my clique of arrogant undergrads.

This particular piece goes far. Why don’t we need to worry about whether we’re doing homology or cohomology? Answer: since Ext and Tor are dual in certain specific ways, which ends up meaning that although internal algebraic structures might be finicky, the module structure is very neat, and in k-Mod = Vect_k, we end up with no worries anywhere.

Testing grounds

The viewpoint of homological algebra as a tool for algebraic topology goes pretty deep. When I ask my advisor what to put in texts where I motivate why our field is important, in the standard answer he gives me the following pops up:

Group cohomology is important, since it is a field where topological methods can be tested reasonably safely, since we have the group theoretic attack vectors in addition to the purely topological.

On the other hand, group cohomology also turns out to be important, since we get important information for the study of groups out of the homological algebra side of things.

Low order Ext

The area where this is most notable is in representation theory. This field comes in several flavours: group representations, where we study kG-Mod for some (sometimes finite) group G; Lie algebra representations, where we study g-Mod for some Lie algebra g; quiver representations, where we study kQ-Mod for some (finite) quiver algebra kQ – and so on. One question that tends to crop up here, and with a high degree of importance for the non-homological algebraists around me – is what happens if we know only parts of our group? Can we say something about the entire group based on that?

It turns out that we can. There are very neat correspondences between the lower order Ext groups over kG and the behaviour of G itself. I’m going to stick to group representations here, since that’s the area I know best – however, this is something that pops up analogously all over the place.

Extensions

Suppose you have some R-module K that you know embeds, in some specific way, into some larger R-module M. And suppose you find the quotient L=M/K in some manner. What could, then, M be? One obvious answer is , but is this enough? This ends up depending on Ext¹_R(L,K), with each element of this particular Ext group indexing precisely one such extension.

This is at the core of Maschke’s theorem, by the way, which says that if the characteristic of the field k doesn’t divide the group order |G|, then by a specific construction, the only extensions possible for any kG-modules are the split extension – the one where we just take the direct sum.

This all leads to a wealth of useful information and ideas in representation theory. For instance, there is a way to describe modules proposed by Dave Benson and some co-authors, where you draw diagrams with each vertex being a simple module, occupying that spot in a composition series, and the edges being taken from the relevant Ext¹.

Invariants and coinvariants

Suppose you have a group acting on a vector space. This can be taken extremely physical – quantum mechanics is all about this kind of situation, or so I’ve heard. Then it might be interesting to figure out the invariant subspace: {a|ga=a for all g in G}. This is Ext⁰. Or we might want a basis for the complement: representatives for every way that things can move. This is the coinvariant vector space, defined as A/(ga-a), and this is just Tor⁰.

Simples, projectives and the stable module category

Simple modules are nice. They don’t have invariant subspaces. In the best of all worlds – which is when Maschke holds – simple modules are precisely the irreducible modules. However, when Maschke doesn’t hold, we can have non-trivial Ext¹, and thus we can build larger modules out of simples by a kind of gluing: they aren’t just a nice direct sum of simples, but something ickier.

Thus, unless Maschke holds, there will be weird things happening in the module category.

These weird things, though, are controllable. To be specific, we can consider the smallest possible irreducible modules. These will end up being building blocks, and for nice enough worlds, these will also end up corresponding closely to the simples – in the way that we can allocate a simple to an irreducible projective in a bijective manner.

So … what is this projective I keep throwing around? Take a free module. This is a direct sum of a finite number of copies of the ring R. This will have direct summands. By picking apart all summands into further direct summands, at some point we hit bottom: we cannot pick anything apart any longer. This is, by the theorem of Krull-Schmidt, a well-defined state of being. We can permute things, but in essence, a module is just its decomposition into irreducibles.

So, anything that is a direct sum of a free module is a projective. We can lose projectivity by taking quotients – so if we add relations, we may well get lost. But as long as we just look for direct summands, we’re pretty much home free. Now, the irreducible projectives have to be summands of the ring R itself, so they end up actually being (left) ideals in the ring. And each of them corresponds intimately to a simple module.

One trick that’s very beloved among the people who worry about these things is to get rid of anything projective, and look at the stable module category. In this, we just quotient away anything projective – morphism sets are taken modulo morphisms that factor through a projective… This way, we only have the “essential”, or as it is known to the experts of the field “difficult” information left. Then Extⁿ(M,N)=Hom(ΩⁿM,N), where Ωⁿ is the nth syzygy – see below for more on this.

So, homological algebra lets us understand the stable module category, which in turn lets us understand the parts that are essential to the module category structure.

Resolutions

I just promised you I’d tell you about syzygies. First off, some personal information – because readers always love that!

If you find me on IRC, on EFNet or on Freenode, you’ll find me under the nick Syzygy-. The – is there because there is someone who’s been using Syzygy for years and years on EFNet and because I’m not deliberately trying to be a bastard if I can help it. The rest of the nick is there to a certain extent because I like the way I write it in longhand.

And to a certain extent because it is an epitome of why homological algebra is interesting in my eyes.

Suppose we are interested in a finitely presented module, which we might be for many reasons, including being interested in algebraic geometry and in solving systems of polynomial equations. We might then just figure out what relations hold within a set of generators, which gives us a generating set, and some relation set.

These, relations, though are far from guaranteed to be the whole story. It’s probable that there are non-trivial relations between the relations. What do we do? We figure out what these are. They span the first syzygy module of the module we started with, denoted by ΩM. But this is unlikely to be free, so we can keep on going.

This way, we get a sequence of modules, all of which are free – since we just choose a generating set in each step – and with maps between them adding all the extra relations. But this is nothing other than a free resolution of the starting module. And here comes the candy that hooked me for this discipline: studying modules over their resolutions is the same thing as studying what chain complexes are, deep down, which in turn is the same thing as studying homological algebra.

Want to figure out what a module map means for the family of syzygies? What you really want is a chain map in the chain complex category. But some of these maps – or even portions of maps – will not carry relevant information. So we factor those away, and we get a slightly weirder category. But here, equality doesn’t quite mean what it should, so we add in more equality relations. And suddenly, we live in a derived category – and in here, the Hom sets are Ext groups, and the tensor products are Tor groups.

Number theory, geometry, and computation!

To continue this tour de force, consider the theorems in vector calculus relating various triple and double integrals. (note – I never dealt with this. I rode on technicalities to root out calculus from my curriculum so it would fit more algebra….) These theorems, in the end, only state that , which is at the core of what homological algebra is all about.

If we formalize this particular recognition a bit, and tug at the corners, we end up with de Rham cohomology, which deals with what you can do with differential forms on manifolds (layman speak: things you can integrate. The f(x)dx after the integral sign is a typical differential form) – and this is one of the many many places where cohomology rather than homology ends up being the “right” way to view things just because you started out as a geometer instead of .. well .. topologist or algebraist.

The same kind of thing happens in algebraic geometry as well. You start out happily with your varieties, you conclude that as soon as things get interesting, the nice and pretty concepts of coordinate rings don’t hold up, and you’re forced to go to coordinate sheaves. And then you try to figure out what you can do with sheaves of functions on a variety – and before you know it, you reconstructed sheaf cohomology. This, by the way, a quick look at wikipedia told me, lets you define euler characteristics for varieties in a way consistent with the classical uses of it.

I am no geometer, and I’m not the person to tell you about the intricacies of these things. If you understand them, though, I’d love to figure them out at some point.

The discussion of Khovanov homology is a slightly (though not very) similar thing to this. Again, I have no real idea, and am treading on thin ice here.

So, alpheccar. Is this what you asked for? Please tell me what more you want covered, and I’ll write up some more! This was fun writing!

We had, in my first representation theory post, a mention of Maschke’s theorem. This states that if the characteristic of our field doesn’t divide the group order, then simple and irreducible mean the same thing.

Now, obviously, the actual proof you normally see first deals with a construction that works for when the characteristic doesn’t divide the group order – which uses 1/|G| at one point. So, what happens when this is impossible to work with? When the conditions of Maschke simply do not hold?

The very simplest answer is that then we can get modules that are glued together by simple modules with some meshing. Such that they aren’t direct sums any more. The ways we can glue together modules are through extensions – i.e. we can glue together A,C by forming a short exact sequence
0 → C → B → A → 0
and we’ll have that B is a module such that B/C=A. Now, the typical such module is the direct sum of A and C – and if Maschke holds, this is indeed all there is.

If Maschke does not hold, then the set of all such B forms an abelian group, called Ext¹(A,C), with addition formed in a slightly messy way called Bair summation. This is actually the same Ext as in all my cohomology posts. So the dimension 1 cohomology actually measures what kind of modules you can have at all.

Suppose the field k has characteristic p and the group order is pⁿ for some n. Then an order argument, and a few properties of modules will yield that there is only one simple module: the trivial module k. So the only extensions really interesting will be in Ext¹(k,k).

And at this point I can bring in my knowledge of group cohomology: if the characteristic is 2, and the group is C₄, then the cohomology ring was mentioned in my post on the higher multiplication structure of the cohomology rings of groups of order 4. It is – so each degree has dimension 1, so there are precisely two extensions of the trivial module over the cyclic 4-group. One is the direct sum, and the other is an irreducible, but not simple module.

Precisely this example, however, I feel I won’t quite explore to the potential it is worth right now, so I’ll pick an example where I know that I won’t be telling anything wrong.

Consider the symmetric group S₃. This has order 6, so the interesting cases are mod 2 and mod 3. For the 3-case, we have the trivial representation and the sign representation – since these always occur when they have a chance to. These are both 1-dimensional, simple, and irreducible.

At this point, we’ll start needing various theorems for the analysis. First off, we can count simple modules over the group algebra by counting conjugacy classes in the group where the order of the elements isn’t divided by the field characteristics. This way, we’ll know how many simples we have.

Furthermore, there is a theorem that states that regardless of Maschke, we certainly have a bijection between simples and irreducibles. I’m not going to go into how this is established, but if you’re interested, the relevant keyword is the radical of a module. Furthermore, if we decompose the algebra itself into a sum of irreducible modules, then each module occurs with a multiplicity corresponding to the dimension of the simple module it belongs to.

I’ve tried three times now to start writing out in painful detail precisely what’s going on here – but I can’t really, today, get a single example worked through from start to end. For S₃, though, we know the conjugacy classes: the identity, the transpositions and the 3-cycles. For each of the modular cases one of these disappears, and so for the 2-case, we get the trivial module and one 2-dimensional simple; and for the 3-case, we get the trivial module and the sign representation. These correspond to irreducibles, that make up the group algebra – in both cases two kinds of irreducibles, and for the 2-case, one occuring once, and one occuring twice, and for the 3-case both occuring just once.

Writing down the irreducibles just doesn’t seem to work out for me today. I blame the flu.

Edit: Fixed a typo pointed out by Dylan Thurston in the comments. Again, I blame the flu.

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->Vect_k – 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 radical rad(A) of the algebra A is

• 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

The radical of a module M is rad(A)·M.

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 soc²(M) be the submodule such that soc²(M)/soc(M) is the socle of M/soc(M). Thus rad(A)²soc²(M)=0. We can carry on, making socⁿ(M) be the elements in M that are annihilated by rad(A)ⁿ. This gives us a new series

and again, by the nilpotency of rad(A), we notice that at some point r, soc^r(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 ρ_a.ρ_b=ρ_ba 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.