[Updated, 6/12; various errors fixed]
I’ve just uploaded to arXiv my paper (submitted to J. of Algebra) “Categories parametrized by schemes and representation theory in complex rank,” an outgrowth of my RSI project started last summer, where I worked with Pavel Etingof and Dustin Clausen. I will devote this post to talking about some of the story surrounding it. In short, the project is about looking at this program of studying representation theory when the dimension is complex (admittedly nobody has ever seen a vector space of dimension ; I will explain this precisely below) in the simplest possible case. But the categories of interest in the project are built out of certain symmetric tensor categories that Deligne defined back in 2004, and I’ll talk a bit about those today. I could have just jumped straight into my paper, but I figured this would make things potentially more accessible, and would be more fun.
I also recommend looking at these posts of David Speyer and Noah Snyder, which talk about some of Deligne’s work as well (and which I learned a lot from). Also, cf. this talk of Pavel Etingof. The talk goes further (into the non-semisimple analogs of Deligne’s categories) that I will cover in a later post. Finally, the paper of Deligne is available here.
The whole story behind this starts with the representation theory of the classical groups—these are objects like , etc. And in particular, I’m going to zoom in on the symmetric group—or more precisely, the family of symmetric groups .
The symmetric group is a very complicated object (indeed, any finite group is a subgroup of a symmetric group, by Cayley’s theorem), but its representation theory has been understood for 100 years and has many interesting combinatorial facets.
In the modern language, we can package the entire representation theory of into a category (depending on the nonnegative integer ). This is a very interesting category for several reasons. The first, and most obvious, part of its structure is that it is a -linear abelian category.
More interestingly, it’s semisimple: every exact sequence splits. This is because the group algebra is semisimple, by Maschke’s theorem. In addition, it is a tensor category: we can define the tensor product of any two representations of a group in a natural way, and is no exception. It is even a symmetric tensor category because we have a nice isomorphism for any two representations .
Technically, all this works for any finite group. What’s special about the symmetric group is, for instance, the very nice way the simple objects of (i.e. irreducible representations) are parametrized. Namely, (as for every finite group) they are in bijection with the conjugacy classes of , but (unlike for other groups) we have an explicit map between such conjugacy classes and irreducible representations. Since each conjugacy class of corresponds to a partiton of (a well-known fact easily seen because any permutation can be written as a product of disjoint cycles),
The whole idea behind Deligne’s work is that, while there isn’t any such thing as a symmetric group on elements, there is nevertheless a category (or more generally for ) that has much of the same structure. Deligne constructed these categories via an interpolation procedure.
At first glance, there seems to be no obvious way to interpolate these categories. It is not that they have any object in common (). Rather, it turns out that certain crucial objects in these categories can be described “uniformly” in the rank , and this is what I shall explain.
First of all, we know that there is a nice, canonical representation of , the so-called regular representation. This is an -dimensional vector space with basis vectors permuted in the obvious manner by the symmetric group.
Since the regular representation is faithful, it follows (by a lemma of Burnside), that every representation is a direct factor of some direct sum of tensor powers . These representations involve no symbols depending on , and form a “substantial” chunk of the category , which suggests that these might be useful in interpolation.
We can thus try defining the category by adding the formal objects . Of course, this is insufficient; we need to describe morphisms.
So, fix some , which should fade into the background insofar as possible, since we want to make this -independent (and thus interpolable). What does
look like, we ask?
The way to handle this is to use a simple trick. First, as a -module because it is a representation defined over ; more simply, we have an -invariant bilinear form
sending . (Note that denotes the trivial representation, i.e. the unital object in the tensor category .)
Whence, we have
So we need to look for -invariant elements of . There is, however, a very nice basis for these.
For an integer , denote by a set containing elements. The -module can be viewed as the permutation representation on the -set , and the space of invariant elements has a basis of the -orbits on this set.
Now we suppose that is really, really large. Say larger than . (We wanted it to fade into the background, but its being super large is important here.) Then an equivalence relation on is precisely the same thing as an -orbit in ; it is easy to see, indeed, that a function induces an equivalence relation on (by identifying points with the same image) and that the hypothesis on the size of ensures that any equivalence relation corresponds to some -orbit. Let be the associated morphism.
So, it is becoming clearer now how to define the category for arbitrary. The objects are formal symbols , and the morphisms between form the vector space on the basis of equivalence relations on . Oh, and taking the tensor product is clear: just add the exponents!
But, ok. We aren’t there yet. The most basic problem is that we don’t yet know how to take the composition of . Let’s try to see how this works out in the standard setting before we define the interpolation. (This bit of combinatorics can be omitted by readers; just skip to the result below.)
We know that the ‘s necessarily span , but they are not a basis. They are, however, “asymptotically linearly independent” in that they become linearly independent when .
Now let’s describe the law of composition. Suppose we have equivalence relations on , and on . We want to describe via such relations. We have, necessarily,
where the range over equivalence relations on . It can be shown, though I will not do it here, that the can be taken as polynomial in . Since the for large are uniquely determined (by the asymptotic linear independence of the ), these polynomials are uniquely determined. It is not important for us to know what they are, though. You could look at the paper of Comes and Ostrik for the calculations.
OK. So why the heck does this matter? Well, notice that this formula is almost entirely independent of , except for the part about —but that’s a polynomial in , and we can obviously plug in something that’s not a nonnegative integer into a polynomial. Actually, this is the key to defining the law of composition in Deligne’s categories.
3. The definition
Well, we’ve come a long way since before; we now know that we want our categories to be endowed with objects for . We also know that our morphism space to be the free vector space on equivalence classes on .
Now, using the formula we discovered earlier in the natural number case, it becomes a little more obvious as to how we may define the law of composition in :
In a similar way, we may define the tensor product of two morphisms , by taking the product equivalence relation—it is even easier. So we have defined a category and a monoidal structure. Right?
Not yet. There are a few problems. First, we don’t actually know that our law of composition is associative, or that it has an identity element. There is a nifty trick to take care of these questions.
The key idea is that associativity now just means that certain 1-variable polynomials are equal for all : indeed, we just need to check that , and these compositions are given by polynomial equations. But we know that these polynomial equations must hold for sufficiently large integers (which obviously implies they hold for all ). Indeed, when is super large relative to , then the morphisms of -representations associated to different equivalence classes are actually linearly independent. So the fact that holds as maps of vector spaces means that the coefficients of equivalence classes are the same.
The identity map is given by the trivial euqivalence relation on that identifies corresponding elements in the two copies of ; one checks using a similar polynomial argument that this is indeed an identity map.
Moreover, remember how we said way back when that the regular representation (and consequently any tensor power) was self-dual because of the symmetric bilinear form? It turns out that the same thing is true in . Let . Then we can define maps
in (exercise) that interpolate the usual bilinear forms. This, however, is not the formal definition of a dual in a tensor category; one also has to have a coevaluation map (a categorification of the Casimir element), that satisfies certain conditions. It turns out that in , these coevaluation maps can be interpolated too, and every object is its own dual. (The existence of duals is a big deal, in fact.) I’ll spare the details though.
All right, so we have Deligne’s categories —monoidal -linear categories that interpolate the usual representation categories in a nice manner, right? Wrong. Actually, the problem is somewhat silly: not every -representation is a tensor power of the regular representation. Our interpolation doesn’t take that into account. Moreover, our category does not even admit direct sums. This must be fixed.
Fortunately, there is a clean way of doing so, namely the pseudo-abelian envelope. This general procedure takes a -linear category (where is some commutative ring) and produces a pseudo-abelian category whose objects are formal direct summands of formal direct sums of objects of . Simulating formal direct sums is pretty easy to do, because if , we just add an object and prescribe homs into and out of it using the universal property of the direct sum.
Suppose we’ve already done this, call the new category (the so-called additive envelope becauase it is now an additive category) and now we just need to do the second part. Simulating formal images of idempotents is a little harder.
We adjoin formal pairs . Here be an object of and is an idempotent. The morphisms between are precisely maps making a certain diagram commutative. I don’t want to go into details, but it is in this paper of Bar-Natan and Morrison.
So, if we apply this whole pseudo-abelization procedure to the initial interpolated category and throw out what we previously called , we FINALLY get Deligne’s . The monoidal structure descends to the pseudo-abelianization, and it is now a -linear rigid (i.e. duals exist) monoidal, pseudo-abelian category (where pseudo-abelian means that idempotents have images).
It should now be clear that we have a complex object. But we have only defined it, not proven any properties whatsoever. Here is the principal one:
Theorem 1 (Deligne) For , is semisimple. For , reduces modulo a tensor ideal to the usual category .
You might be wondering where these categories got off course and didn’t become equivalent to the usual ones for . That’s because the morphisms of -representations associated to equivalence classes aren’t really linearly independent when is small (relative to , which are fixed).
Anyway, this post is already kinda long, so I’ll pick this up tomorrow.