The construction works by constructing a few helpful categories, and using their properties along the way. Especially after unpacking the categorical results G-J rely on, there are quite a few categories floating around. I shall try to be very explicit about which category is which, and how they work.

As we recall, simplicial sets are contravariant functors from the category of ordinal numbers to the category of sets. We introduce the simplex category of a simplicial set with objects (simplices) given by maps and a map from to being given by a map in such that .

Interpreting each simplicial simplex as a simplicial set, this can be thought of as the subcategory of the slice category over spanned by maps from the simplicial simplices. Any map between simplicial simplices is determined completely by a unique ordinal number map that induces it.

Lemma 2.1

The proof of the isomorphism

taken over all simplices in the simplex category of proceeds using the theorem that every functor from a small category to sets is a colimit of representable functors.

To unpack this statement, we turn to, say, Awodey, where this is Proposition 8.10.

Proposition 8.10 (Steve Awodey, Category Theory)
For any small category , every object P in the functor category is a colimit of representable functors using the Yoneda embedding .

Specifically, we can choose an index category and a functor such that .

Proof
We start by introducing the category of elements or Grothendieck category of P. This will be our index category for the colimit, and is often written . This category has objects , and arrows given by arrows in such that .

This is almost like a category of pointed sets, only that we also care about the action of P while we’re at it. Since is a small category, so is , and there is a projection functor given by forgetting about the point, so sending and preserving the arrow forming a morphism of elements.

We also recall the Yoneda embedding in order to progress nicely here:
. The Yoneda lemma tells us that for contravariant , , naturally in and , and works by assigning to the natural transformation which has components . These are defined by their actions on actual maps and we set .

In other words, a contravariant functor to sets corresponds to natural transformations from the Yoneda embedding to the functor itself. An element in the functor image gives rise to a particular such natural transformation by using the element as a test case, and using the functor to make the test runnable.

Now, returning to the proof of 8.10, we need to build a colimit that will work as our colimit presentation of P. We will do this by using and . Indeed, for an object , by the Yoneda lemma this corresponds to some natural transformation . These natural transformations form a subcategory of the slice category of over P by the naturality of the Yoneda construction.

So we can build a cocone by taking the map from to be the natural transformation . This is a colim because if we had some other cocone with components , we can produce the unique natural transformation by defined by and recall that natural transformations are, by the Yoneda lemma, the same as elements of .

But what does all this mean!?

This was probably all about as headache inducing as anything else to do with Yoneda’s lemma. It’s a result that both in its proof and its applications tends to climb the ladder of nested categorical constructs pretty high.

So let’s get back to the simplicial case, and tease out what this implies for our reading. is a simplicial set, hence a contravariant set-valued functor on . So is our small category.

The category of elements, is the category where objects are for . Morphisms track what happens to under faces and degeneracies. Thus, specifically, by the arguments in example 1.7, we can put in bijective correspondence with the collection of all simplicial n-simplices of X, in the sense that we associate to each the simplicial map as defined on page 6.

Thus, the index category is clear. The category of elements for a simplicial set really is “just” the category of simplices . The representable functors are the for , and so are all on the shape . But these are just the collections of standard simplicial n-simplices.

So our simplicial set is the colimit of simplical n-simplices under the conditions that they obey the face and degeneracy maps in the original simplicial set.

Let’s work this all through on an example. Consider the interval I, given by non-degenerate simplices a, b, x, subject to and . Maps from the simplicial n-simplex to I can hit one of these three simplices, or any degeneracy of these.

There are two maps , namely and . Thus, we start the construction of our colimit by introducing cells and . Any degeneracies are adsorbed by the fact that a simplicial simplex is a simplicial map, hence and so on.
There are three maps , namely:

and

These three choices all come with boundary maps that have to be taken into account in the colimit. Specifically, the two first maps here, the ones that hit degenerate simplices, factor through and respectively. There is a map (in the category ) given by . This map corresponds to the map (as a map of simplicial simplices), which embeds the simplex into . Thus, this embedding along degeneracies is a map in the index category of the colimit, and therefore leads to an identification of any simplex with all its degeneracies in the colimit. The non-degenerate case gives us a simplex .
Similarly, the colimit forces the identifications and , finishing the description of as a colimit.

Now, we have a nice candidate for the realization of a single simplicial n-simplex: the topological n-simplex defined in Example 1.1. This is used to define the geometric realization of a simplicial set through “simply” forcing the realization functor to be compatible with this colimit structure. Thus, we define the geometric realization of a simplicial set to be the colimit of the topological n-simplices over the same index category that we used to display as a colimit.

Well, what about adjointness?

The first really nice property about realization is that it is left adjoint to the singular functor. Proving this is a sequence in abstract symbol manipulation and remembering what everything at each step of the way actually means. Thus, say we have a simplicial set X and a topological space Y. Adjointness means there is an isomorphism

which is natural in both X and Y.

Now, let’s consider the left hand side.

by definition of the geometric realization.

because contravariant representable functors map colimits to limits. This is Awodey 5.29, and sits very well with our intuition from sets, vector spaces, and just about anywhere else.
Now, remember that a map in is a simplex in the singular set , and that as we saw above, a simplicial set is the colimit of its simplices. Thus, we get

and then finally, we can re-introduce the colimit inside the morphism set

Each step along the way is natural, which finishes the proof.

In some points, I’ve tried to fill in the most sketchy and un-articulated points with some simile of what I ended up actually saying.

Combinatorial species started out as a theory to deal with enumerative combinatorics, by providing a toolset & calculus for formal power series. (see Bergeron-Labelle-Leroux and Joyal)

As it turns out, not only is species useful for manipulating generating functions, btu it provides this with a categorical approach that may be transplanted into other areas.

For the benefit of the entire audience, I shall introduce some definitions.

Definition: A category C is a collection of objects and arrows with each arrow assigned a source and target object, such that

1. Each object has its own identity arrow 1.
2. Chains of arrows are associatively composable, with 1 the identity of this composition.

Examples: Sets, Finite sets, k-Vector spaces, left and right R-Modules, Graphs, Groups, Abelian groups.

: finite sets with only bijections as morphisms.

Examples:

• Category of a monoid.
• Category generated by a graph
• Category of a group (groupoid version of the category of a monoid)
• Category of a poset
• Category of Haskell types and functions.

Definition: A functor F is a map of categories, in other words, a pair of maps Fo on objects and Fa on arrows, such that the identity arrow maps to identity arrows and compositions of maps map to compositions of their images.

Examples:
Constant functor: sends every object to A, every map to 1.

Identity functor: sends objects and arrows to themselves.

Underlying set functor, free monoid/vector space/module/… functors.

We are now equipped to define Species:
Definition: A species of structures is a functor .

The idea is a set gets mapped to the set of all structures labelled by the elements in the original set. A bijection on labels maps to the transport of structures along the relabeling.

Examples:
: rooted trees, labels on vertices
: simple graphs, labels on vertices
: connected simple graphs, labels on vertices.
: trees, labels on vertices.
: directed graphs, labels on vertices
: subsets, .
: endofunctions
: involutions
: permutations
: cycles
: linear orders
: sets:
: elements:
: singletons: if and otherwise
: empty set: , otherwise
: empty species: .

In enumerative combinatorics, the power of species resides in the association to each species a number of generating functions:

The generating series of a species F is the exponential formal power series

where we use the convention , and .
Thus:

There are a number other in use for combinatorics, but for my purposes, this is the one I’ll focus on.

Operations on species

The real power, though, emerges when we start combining species, and carry over the combinations to actions on the corresponding power series.

Addition

The number of ways to form either, say, a graph or a linear order on a set of labels is the sum of the numbers of ways to form either in isolation.

This corresponds cleanly to the coproduct in Set, and we may write F+G for the species

(where the second + is the coproduct — i.e. disjoint union — of sets)

In the power series, we get .

Examples: We may define the species of all non-empty sets by

This kind of functional equations is where the theory of species starts to really shine.

Multiplication

A tricoloring of a set is a subdivision of the set into three disjoint subsets covering the original set. The number of tricolorings of size n is

A permutation fixes some set of points. The permutation restricted to the non-fixed points is a derangement. Total number of permutations on n elements is

In both of these cases, the total generating series is a product of the component series, and we end up defining

So .

Thus, tricolorings are and permutations are , where the set is that of fixed points, and the derangement captures the actual action of the permutation.

Composition

Endofunctions of sets decompose in their actions on the points as cycles or directed trees leading in to these cycles.

Since a collection of disjoint cycles corresponds to a permutation, we can consider such endofunctions to be permutations decorated with rooted trees attached to points of the permutations; or even permutations of rooted trees.

To form such a structure on a set U, we’d first partition U into subsets, put the structure of a rooted tree on each subset, and then the structure of a permutation on the set of these subsets.

Thus, the number of such structures on n elements is

This corresponds to the power series , and we write, in general, for the species of F-structures of G-structures on subsets.

Examples:
A = X·E(A)
L = 1 + X·L
B = 1 + X·B·B

Pointing

Picking out a single point in a structure on n points can be done in precisely n ways.

Thus the corresponding generating function will be

for f-structures with a single label distinguished.

Since we’re working with exponential power series, we may notice that

and thus that derivatives are shifts.
Furthermore,
so that the generating function for F-structures with a single distinguished are

In species, this process is called pointing.

In functional programming, Conor McBride related this construction to Huet’s Zipper datatypes.

As it turns out, many of the constructions for species make eminent sense outside the category . In fact, species in Hask are known to programming language researchers as container datatypes and the whole calculus translates relatively cleanly.

Functional equations translate to the standard new data type definitions in Haskell.

Examples:
L = 1 + X·L

data List a = Nil | Cons a (List a)


B = 1 + X·B·B

data BinaryTree a = Leaf | Node (BinaryTree a) a (BinaryTree a)


A = X·E(A)

data RootedTree a = Node a (Set (RootedTree a))

usually, we simulate the Set here by a List. If we need for our rooted trees to be planar, we can in fact impose a Linear Order structure instead, and get something like
Ap = X·L(Ap)

The species interpretation of corresponding to leaving a hole in the structure carries over cleanly, so that is the type of T-with-a-hole.

Two derivatives of lists

We can deal with in two different ways:

1.
DL = D(1+X·L) = D1 + D(X·L) = 0 + DX·L+X·DL
and thus
DL-X·DL = 1·L
so (1-X)·DL = L
and thus
DL = L·1/(1-X)

Now, from L=1+X·L follows by a similar cavalier use of subtraction and division — which, by the way, in species theory is captured by the idea of a virtual species, and dealt with relatively cleanly — that
L = 1+X·L
so
L-X·L = 1
and thus
(1-X)·L = 1
so
L = 1/(1-X)

Thus, we can conclude that
DL = L·1/(1-X) = L·L
and thus, a list with a hole is a pair of lists: the stuff before the hole and the stuff after the hole.

2.
We could, instead of using implicit differentiation, as in 1, attack the derivation we had of
L = 1/(1-X) = 1+X+X·X+X·X·X+…

Indeed,
DL = D(1/(1-X)) = D(1+X+X·X+…) = 0+1+2X+3X·X+…
which we can observe factors as
= (1+X+X·X+X·X·X+…)·(1+X+X·X+X·X·X+…) = L·L

Or we can just use the division rule
DL = D(1/(1-X)) = D(1/u)·D(1-X) = -1/(u·u)·(-1) = 1/[(1-X)·(1-X)] = L·L

Gröbner bases for operads

All of this becomes relevant to the implementation of Buchberger’s algorithm on shuffle operads (see Dotsenko—Khoroshkin and Dotsenko—Vejdemo-Johansson) in the step where the S-polynomials (and thereby also the reductions) are defined. With a common multiple defined, we need some way to extend the modifications that take the initial term to the common multiple to the rest of that term.

For this, it turns out, that the derivative of the tree datatype used provides theoretical guarantees that only partially filled in trees of the right size, with holes the right size, can be introduced; and also provides an easy and relatively efficient algorithm for contructing the hole-y trees and later filling in the holes.

In this course, we will teach category theory from first principles with an eye towards its applications to and correspondences with Haskell and the theory of functional programming. We expect students to previously or currently be taking CS242 and to have some level of mathematical maturity. We also expect students to have had contact with linear algebra and discrete mathematics in order to follow the motivating examples behind the theory expounded.

Wednesdays at 4.15.

Online notes will appear successively on the Haskell wiki on http://haskell.org/haskellwiki/User:Michiexile/MATH198

come this fall, I shall be teaching. My first lecture course, ever.

The subject shall be on introducing Category Theory from the bottom up, in a manner digestible for Computer Science Undergraduates who have seen Haskell and been left wanting more from that contact.

And thus comes my question to you all: what would you like to see in such a course? Is there any advice you want to give me on how to make the course awesome?

The obvious bits are obvious. I shall have to discuss categories, functors, (co)products, (co)limits, monads, monoids, adjoints, natural transformations, the Curry-Howard isomorphism, the Hom-Tensor adjunction, categorical interpretation of data types. And all of it with explicit reference to how all these things influence Haskell, as well as plenty of mathematical examples.

But what ideas can you give me to make this greater than I’d make it on my own?

Recall how you would run the Gaussian algorithm on a matrix. You’d take the leftmost upmost non-zero entry, divide its row by its value, and then use that row to eliminate anything in the corresponding column.

Once we have the matrix on echelon form, we can then do lots of things with it. Importantly, we can use substitution using the leading terms to do equation system solving.

The starting point for the theory of Gröbner bases was that the same method could be used – with some modification – to produce something from a bunch of polynomials that ends up being as useful as a row-reduced echelon form.

Basically, the central theorem-definition of Gröbner bases (by Buchberger, named for his thesis advisor Gröbner), says that a Gröbner basis for some ideal in some polynomial ring is a bunch of generators for that ideal such that if we do polynomial division of any element of the polynomial in the ring with the generators, one after the other, until no more divisions could be performed, then what we get out of it all is uniquely determined.

This need not necessarily be the case, even to begin with – we could get weird loops and various kinds of bad behaviour that screws up the concept of dividing, with remainder, by a whole bunch of polynomials. Having a Gröbner basis means this is no longer a problem.

The important bit of the theorem is that we can GET a Gröbner basis by just iteratively trying out combinations of the generators, trying to find overlaps of the leading terms, and generating “bad examples”. Any bad example that doesn’t get completely reduced to 0 by division by the generators is also needed to complete the Gröbner basis, and by adjoining it we grow our generating set, but not the things it generates. And the method works by growing the generating set until anything we can build out of two of the generators really will reduce completely to 0.

And, the central theorem says, if THIS works, then reduction works in general, and we have a tool as good for solving systems of polynomial equations as the echelon form is for linear equation systems.

Losing commutativity

The next interesting step is to look at non-commutative polynomial rings. Here, we suddenly have a deep theoretic issue popping up. We know that the word problem for monoids – i.e. whether a specific string can be reduced with rewriting rules to an empty string – is unsolvable in general. It hooks up to Turing machines and the limits of theoretical computer science, but in essence we can encode problems as Gröbner basis computations for non-commutative algebras that we know cannot possibly be solved in finite time.

So we cannot hope for the situation to be as good as for commutative algebras. However, there is a theorem floating around – the Diamond lemma by Bergman – that says that if we DO get a Gröbner basis computation that halts in finite time, then all the good things that we had in the commutative case – such as reductions modulo the generators being well defined – hold for the things we’ve computed. In other words, the only thing that could go wrong would be that the computation of the Gröbner basis doesn’t finish in finite time.

Operads

Now, what I really wanted to talk about was operads.

Here, an operad is a collection {O(n) : n?1} of vector spaces with permutations attached to them. Hence, for each n, there is a map S_n ← Hom(O(n),O(n)), or in other words, we can apply any permutation of n things to any element in the component O(n) and get something back out of it.

Furthermore, an operad O = {O(n)} has defined on it structure operations. These behave like the composition of multilinear functions – so we have a way of plugging one function into another:
f(a1,a2,…,g(ai,…,aj),…,an)
and this composition is associative, so the order we figure out some sequence of compositions doesn’t matter.

These gadgets show up in modern approaches to universal algebra like questions, and also all over the place in topology; some of the earliest instances were from homotopy theory.

Recently, Dotsenko and Khoroshkin released a paper on Gröbner bases for operads. In the paper, they figure out a way to find the kind of canonical and ordered basis that you need in order to mimic the whole workflow of Gröbner bases above; and specified how one should go about producing a Diamond Lemma for operads. It turns out that Gröbner bases would be useful to prove operads to be Koszul – something I won’t discuss here, but which is important in the operad theory context.

Basically, instead of working in a polynomial ring on some set of variables, we start out with out variables in one of these graded sets {V(n)}. Then we can build rooted trees, whose internal vertices of degree n+1 are labeled by elements from V(n).

The vector space spanned by all such trees forms an operad where the composition operation works by taking a tree and attaching the root to the leaf numbered by whatever position we need to compose at.

The resulting construction is the free operad on the generating set and takes the role that the polynomial ring had in the previous examples. And what Dotsenko and Khoroshkin pointed out was that if we restrict the kinds of actions we allow from permutations on these trees somewhat, we end up with something that has exactly one representative that fits in the restricted context for each tree that occurs as a basis element of the free operad.

So we can impose some sort of ordering on these trees, and use them to mimic the Diamond lemma.

Indeed, what we end up doing is forming the overlaps between leading terms by finding trees that parts of the trees from the leading terms from pairs of operad elements can embed into, and using the resulting procedure to build the same kind of bad cases we need to test for Buchberger’s algorithm.

And again, it turns out that while we may not always get an answer within finite time, if we’re lucky then the answer we DO get has all the properties we could dream of. And not only that – all the previous kinds of Gröbner bases embed as special cases of doing it this way.

I heard of this, and got my hands on the paper, when I first arrived in CIRM in Luminy, outside Marseille, for 2 weeks of operad theory with a master’s course and a conference on the subject. And I got so excited – once upon a time this was essentially my proposal for PhD thesis project – that I decided to sit down and code the whole thing up right away!

And code away I did. Once the two weeks were gone, with the valuable help from Vladimir Dotsenko and Eric Hoffbeck, I had ended up with a working implementation in Haskell of the whole paradigm. It’s now available from the HackageDB, and runs at least in GHC 6.8 and 6.10:

And we see here that with the particular set of generators given, namely using m2 as the variable, and for a generating set, we pick
m2(m2(x1,x2),x3) + m2(x1,m2(x2,x3))
and
m2(m2(x1,x3),x2) – m2(x1,m2(x2,x3))

we get a Gröbner basis almost instantly containing additionally the generator
m2(x1,m2(x2,m2(x3,x4)))

He pointed out that the underlying principle inducing the rule

goes under many names, among those \emph{Inclusion-Exclusion}, favoured among computer scientists (and combinatoricists). He also pointed out that the origin of this principle is the Mayer-Vietoris long exact sequence

In this blog post, I’d like to give more meat to this assertion as well as point out how the general principle of Inclusion-Exclusion for finite sets follows immediately from Mayer-Vietoris.

Inclusion-Exclusion, and the passage from two sets to many

The basic principle of Inclusion-Exclusion says that if we have two sets, and , then the following relationship of cardinalities holds:

A first proof would be performed by referring to an appropriate Venn
diagram, or by pointing out that if we try to count all the elements
of by adding the counts for and , then we’ve overcounted the elements of , and thus need to subtract these.

Now, this is good and convincing for the situation where we have just two sets, but what if we had a whole family? What if we had ? Well, our old friend the complete induction rides to our rescue. Suppose we had already proven that for sets , the following formula holds:

If you think this formula is imposing, let me show you the first few ways it works out, so that you can get a feeling for it:

Here it starts becoming apparent why it is called the Inclusion-Exclusion formula: we include all elements from all sets, but then we’ve gotten too many elements from the pairwise intersections, so we exclude those, but then we’ve gotten too few elements from the triple intersections, so we re-include those, but then we’ve gotten too few elements from the quadruple intersections – and on it goes.

If our assumption holds, we can consider what the appropriate size of the union of different sets should be. We can pick one set, say , and treat it separately. Then, certainly, the union of the rest has size given by the formula, by our induction assumption. So, consider what happens when we add in the elements in . We then overcount all elements in any of the intersections , so we have to subtract those. But we then have undercounted all elements in any intersection on the form , so we need to add those back in. And so we go on, and for each intersection that occurred in the formula for sets, we find ourselves forced to add one new term, of the opposite sign, that counts the intersection of that old term with .

Thus, the new formula takes on the exact guise of the general formula we wanted to prove, since the terms involving are precisely indexed, in that formula, by the terms excluding , but with opposite signs.

Encoding set sizes homologically

So, now that we know that pairwise Inclusion-Exclusion implies the general Inclusion-Exclusion, let us take a look on how we can express Inclusion-Exclusion with homology. We note first of all that counts the number of path-connected components of a space . This follows easily from a few properties. First, a basis for the -chains of is given by the points in . Second, two -chains are homologous precisely if there is a -chain whose boundary is the difference between those -chains. The boundary of a path is the difference of its endpoints, so we end up with two basis elements being homologous precisely if there is a path connecting them.

Thus, two -chain elements are homologous precisely if they’re in the same path-component of . So, the homology classes of -chains are precisely the path-connected components.

So, the -degree homology classes count path-components. How do we use that? Well … if we consider a finite set with the discrete topology – i.e. open sets are single points and any unions of single point sets, then a path is a continuous function , i.e. one where the preimage of any open set is open. Thus, the preimage of any point is an open set. Suppose a path contains more than one point. Then we can partition the interval into two disjoint open sets, by taking one set to be the preimage of one of the points, and the other set to be the preimage of everything else. However, the interval is connected, which means that if there are two such open sets, one of them has to be empty.

Thus, the path-connected components of a discrete topological space are the points themselves. So if is discrete, then .

Long exact sequences in homology and the Mayer-Vietoris sequence

It is a theorem from homological algebra that if we have a short exact sequence of chain complexes

then there is a long exact sequence in homology given by

Almost all interesting long exact sequences in topology are special cases of this particular fact. We will derive one interesting sequence: the Mayer-Vietoris sequence from this.

Take a topological space . The singular chain complex forms a chain complex with the free abelian group of -chains and the differential given by the usual formula.

Suppose we have two spaces: and . Then any -chain on is an -chain on and an -chain on . So we get an inclusion map by . We choose this sign instead of the image to make the next step cleaner. It is an injection because is a free abelian group, and the injections
are set maps on bases for the corresponding chain groups.

Compatibility of this map with the differential is almost as easy. If we first apply the differential and then map into the direct sum, we get the map . If we instead first map into the direct sum, and then apply the differentials, we get the map . These are equal, and thus the map we’ve constructed is a chain map.

So, is an injective map of chain complexes.

If we now have a pair of chains, we can construct a chain on the union of the two spaces. An -chain on is automatically an -chain on . Similarly, an -chain on is automatically an -chain on . So both and inject into by the same kind of argument as with the injection .

The injections we get this way can be put together to a map by, for instance, . I am going to fudge over the issue of whether the -chains on and form a generating set for the -chains on , and just take it on faith that this works. The details are not particularly difficult – they are just obnoxiously long and annoying.

Now, given that we believe we can get a generating set by taking the union of the bases for the -chains on and , then this means that the map I gave above is surjective. Indeed, a basis element is hit by the element , and a basis element is hit by the element .

This argument proves exactness at the first and last term of the short exact sequence

and it remains to prove exactness at the middle term. So we need to prove that

Now, since , the inclusion of the image in the kernel is obvious. So, suppose now that , and . Then, in , we know that . But then, since and similarly since . So and . But then this kernel element really is in the image of the inclusion we gave.

So this is a short exact sequence of chain complexes. It follows from the theorem of long exact sequences in homology that there is an associated long exact sequence, called the Mayer-Vietoris sequence:

Putting it all together

Suppose is a discrete topological space. Then any continuous map from a -simplex to is by necessity constant at one point. So all the singular simplices in are constant maps, and thus a basis for any -chain group is given by just the points in as such. The differential acts on such a constant map by sending it to an alternating sum of identical maps the cardinality of which is one more than the dimension of the simplex. So the differential vanishes at every other point in the chain complex, and is an isomorphism on the rest. But then we have exactly two possibilities for a homology computation:

Case 1:

Here, the kernel is the entire chain group. But so is the image. Thus the homology group is trivial.

Case 2:

Here, the kernel is trivial, but then again, so is the image. Thus, again, so is the homology group.

The only part not really covered by this is the homology group , since this is computed from a diagram on the shape . So behaves like we showed above, and is the only non-trivial homology group of the discrete space.

But then, the only bit that remains non-zero in the Mayer-Vietoris sequence is

If we have a short exact sequence of free abelian groups, then this relates the number of basis elements in each of the groups with the structure of the sequence. Let our short exact sequence be given by . then, by injectivity of the map , the cardinality of a basis of the image in is equal to the cardinality of a basis for . By surjectivity of the map , and by Noether’s theorem, the cardinality of a basis of is equal to the cardinality of a basis of the kernel of this map, plus the cardinality of a basis of . By exactness in the middle, this kernel basis is equal to the image basis from A. So, we have, writing for the cardinality of a basis of the free abelian group , that . Thus, .

And if we apply this to the Mayer-Vietoris sequence fragment we acquired, it follows that

and thus

Next stop is the topology in computer science workgroup at Stanford, where I have accepted an offer for a postdoc research position up to 3 years (conditional on my good behaviour .

I’ll be doing a “US tour” in March / April. For the people who might be interested – here are my whereabouts, and my speaking engagements.

I’m booked at several different seminars to do the following:

Title: On the computation of A-infinity algebras and Ext-algebras
Abstract:

For a ring R, the Ext algebra carries rich information about the ring and its module category. The algebra is a finitely presented k-algebra for most nice enough rings. Computation of this ring is done by constructing a projective resolution P of k and either constructing the complex or equivalently constructing the complex . By diligent choice of computational route, the computation can be framed as essentially computing the homology of the differential graded algebra .

Being the homology of a dg-algebra, has an induced A-infinity structure. This structure, has been shown by Keller and by Lu-Palmieri-Wu-Zhang, can be used to reconstruct R from
.

In this talk, we shall discuss the computation of and methods for computing an A-infinity structure on the Ext algebra. Examples will be drawn from group cohomology, where the computation of the Ext algebra has conditions from Benson and Carlson for recognizing whether a partial computation has the entire structure.

Talk dates are:
March:
19 – Stockholm University
26 – UPenn
27 – Millersville
29/30 – Graduate Student Topology Conference, UIUC
April:
8 – Stanford
11 – U Washington, Seattle
May:
8 – NUI Galway

I will be in Millersville, with occasional visits to UPenn during March 25-28 and April 10-20. I’ll be somewhere in Illinois most of March 28, and at UIUC for the GSTC 29-30. I’ll be at MSRI March 31-April 4, and then at Stanford April 4-10.

Now, first off in this categorical language, I want to nail down exactly what the objects are. In the category the objects are solution sets of systems of polynomial equations. And in the category , the objects are finitely presented Noetherian reduced k-algebras.

The functor acts on objects by sending an algebra R to the solution set of the polynomial equations generating the ideal in a presentation of the algebra.

And the functor takes a variety to the algebra of polynomial functions on the variety. This is a slight modification to the way I’ve introduced I in the previous posts – but the good news is that I(V) is the quotient of the right polynomial ring with the previously defined I(V).

Morphisms on varieties

In order to define a category, it’s not enough with the objects – we want morphisms as well. Since everything else is defined by polynomials, we’re going to define a morphism of varieties to be a map , polynomial in each coordinate, such that the image of the restriction to the variety is contained in .

In other words, it is a map defined by polynomials .

An isomorphism of varieties is exactly what we expect it to be – it is a morphism that has an inverse.

One specific kind of highly interesting isomorphisms are the linear automorphisms of . These are given, essentially, by invertible change-of-coordinate matrices in the way we are used to from linear algebra.

Examples

Recall from the earlier posts the twisted cubic curve . Points on it have the form – and this, incidentially, gives us precisely a map displaying an isomorphism between the twisted cubic curve and the affine line. The inverse is given by .

Consider the parabola . This is also isomorphic to the affine line, over the maps and .

On the other hand, the affine line is not isomorphic to the nodal curve . The easiest way to show this is to go over smoothness of curves and singular points – which I hope to deal with later at some point. Essentially, smoothness is an invariant of varieties under isomorphisms, and since the point (0,0) is singular on the nodal curve, and the affine line has no singular points, the two varieties can not possibly be isomorphic.

Note that images of varieties need not be affine algebraic varieties – they will, however, always be quasi-projective varieties. We’ll see if I get into this later on.

Morphisms of algebras and functoriality of V and I

We really do already know what morphisms look like in . This category is the full subcategory of the category of k-algebras – by which we mean that it picks out objects among k-algebras, and have all k-algebra maps between objects as morphisms.

The really awesome bit happens when we start considering the morphisms we’ve defined. Given a morphism , we define the pullback by . This takes a map and makes a map . Since this is a composition of polynomials, it is also a polynomial function. If , then , and since , it follows that , and thus .

In the other direction, suppose that R and S are reduced finitely generated k-algebras. Then , and . We fix a homomorphism , and we wish to construct a variety morphism such that .

Let be a representative of , and define by . We need to verify that F maps V to W. This follows if we can only show that for every , all polynomials in I vanish on F(a). Let . Then

and since , it represents the zero class of , so and hence . But J is the ideal of all functions vanishing on V. Hence , and the proof is complete.

In essence, what this proves to us is that the operations V and I form a contravariant equivalence of categories between and .

But that’s all a few posts away. For now, recall that we recognized already that any variety is defined by an ideal, and that intersections and unions of varieties are given by sums and intersections or products of ideals.

This is the first page of what is known as the Algebra-Geometry dictionary. The dictionary is made complete by a pair of reasonably famous theorems. I won’t bother proving them – the proofs are a good chunk of any decent commutative algebra course – but I’ll quote the theorems and discuss why they matter.

We call a ring Noetherian if all ideals are finitely generated. If a ring R is Noetherian, then quotients are Noetherian.

Hilbert’s Basis Theorem: If R is Noetherian, then so is R[x].

We define the radical of an ideal I to be the ideal consisting of all elements a such that some power of a is actually in I. We call an ideal I radical if . This concept is relevant for our considerations since if for a point p the function f^n(p) vanishes, then f(p) also vanishes. Thus, the set of points such that f^n vanishes is the same set as the set of points where f vanishes. The relevancy of this is captured in:

Hilbert’s Nullstellensatz: Let k be an algebraically closed field. For any ideal I in , there is an equality of ideals

Note, for the statement of this theorem that we write V(I) for the variety defined by simultaneous vanishing of all elements in I, and we write I(V) for the ideal of all polynomials in that vanish on all of I(V).

So – and here is the beautiful part – affine algebraic varieties correspond bijectively to radical ideals in polynomial rings. For every ideal, there is a variety and for every variety, there is an ideal. But we can push this further.

Coordinate rings

Let’s consider polynomial functions from to k. These are precisely the polynomials in . Given a variety V, we can take a polynomial and restrict it to a function .

Two different polynomials give the same restricted function precisely when their difference vanishes on all of V. So polynomial functions on V are precisely the equivalence classes in the quotient ring . We call the resulting ring the coordinate ring and denote it by k[V].

Conversely, if R is a Noetherian k-algebra such that there are no nilpotent elements in R, then R is a quotient of some polynomial ring with some radical ideal. Hence it is the coordinate ring of some variety in some affine space somewhere. We call a ring lacking nilpotents reduced.

We get, out of all this, a bijective correspondence
{ Noetherian reduced k-algebras } { Affine algebraic varieties }

The really beautiful part will come in my next post. We can introduce homomorphisms of varieties in a reasonably natural way so that this bijective correspondence ends up being functorial – i.e. any homomorphisms on one side gives rise to a corresponding homomorphism on the other side. Thus, the categories of Noetherian reduced k-algebras and of affine algebraic varieties are equivalent.

So, why not learn by teaching? It’s an approach that has been pretty darn good in the past. So I thought I’d write a sequence of posts on algebraic geometry, introducing what it’s supposed to be about and how the main viewpoints develop more or less naturally from the approaches taken.

Varieties

The basic objective of algebraic geometry is to study solution sets to systems of polynomial equations. That is, we take some set of polynomials in some polynomial ring over some field . And we write for the set of all simultaneous roots to all these polynomials:

If we write our polynomials as coming from the ring , then the corresponding solution points will be points in the vector space . In order to emphasize that we do not care for the vector space structure of this space, we shall denote it with , or if we want to emphasize the field, with .

The first observation at this point is that if we take the polynomial , then the solution set over is empty, while the solution set over is not. So, in order to set all solution sets on an equal footing – and also to make the later occurring correspondences work out – we shall require to be an algebraically closed field. In other words, we can always find a root to any polynomial.

We call the solution sets varieties (or – in order to distinguish from everything else we might encounter, we shall call them affine algebraic varieties).

So, the study of solutions to systems of polynomial equations is the study of varieties. And hence geometry. This neatly expands on the classical linear algebra viewpoint – where we study systems of linear equations as intersections of planes. It turns out that the main computational approach – Gr�bner bases – actually specializes to the Gau� algorithm on matrices if we specialize to linear systems of equations.

Examples

The unit circle is an affine variety, given by the vanishing of . The hyperbola and the parabola are also affine varieties.

Another very commonly used example is the twisted cubic curve – given by the simultaneous vanishing of the parabolic sheet and the cubic curve sheet .

Changing the defining equations

The points p at which both f and g vanish are the same points as those where f and f+g vanish. Indeed, if f(p)=0 and g(p)=0, then (f+g)(p)=0 as well, so the points in V(f,g) are all contained in V(f,f+g). On the other hand, suppose that f(p)=0 and (f+g)(p)=0. Then 0=(f+g)(p)=f(p)+g(p)=0+g(p). So g(p)=0 as well. Hence, all points in V(f,f+g) are contained in V(f,g). So the two varieties are equal.

Suppose that . Then for any h=fg we’ll see that h(p)=f(p)g(p)=0g(p)=0. Hence, if f vanishes at p, then every polynomial that f divides will also vanish at p.

Now, a set of polynomials in that is closed under addition and multiplication by elements from is an ideal of the polynomial ring. Thus, these considerations convince us that the set of all polynomials in that all vanish on all points in is in fact an ideal.

So we can define the variety from an ideal – given , we write V(I) for the set of all points such that f(p)=0 for all .

The sum of two ideals I and J are the set of all elements on the form f+g where f is from I and g is from J. If I is generated by and J is generated by , then I+J has generators . And the set of points where all the polynomials in I+J vanish are precisely the points where all polynomials in I vanish and all polynomials in J vanish. Hence .

The product IJ of two ideals I and J is generated by all products of one element from I and one from J. Hence, an element of IJ is on the form with all the coming from I and all the coming from J. Suppose p is in V(IJ). Then for all f in I and all g in J, f(p)g(p)=0. If for all f in I, f(p)=0, then p is in V(I). Otherwise we can find some such that . But then since for all g in J, we must have for all g in J. Hence p is in V(J).
Thus .
On the other hand, if p is in then specifically either p is in V(I) or it is in V(J). Either way, for all f in I and all g in J, f(p)g(p)=0 since one of the factors certainly vanishes. Hence, p is in V(IJ).

We also do have that . Which of the ideal operations works best depends a bit on what we would like to do with it.

Examples

We can use the above discussion to actually compute things geometrically. The intersection of the circle with a line is given by the sum of the ideals – so we need to consider the ideal in . We could try to bash this out by just wrangling the corresponding equations, or we could systematize the wrangling. Systematizing it leads, basically, to the theory of Gr�bner bases – and this is something I tend to avoid doing by hand if I can. Not doing it by hand looks like this:

$ Singular
                     SINGULAR                             /
 A Computer Algebra System for Polynomial Computations   /   version 3-0-2
                                                       0<
     by: G.-M. Greuel, G. Pfister, H. Schoenemann        \   July 2006
FB Mathematik der Universitaet, D-67653 Kaiserslautern    \
> ring R=0,(x,y),dp;
> ideal I=x^2+y^2-1,2*x-y;
> std(I);
_[1]=2x-y
_[2]=5y2-4

So one good set of generators for the ideal would be . This, in turn corresponds to the conditions and . So we get two points – just as expected.

The equation wrangling, on the other hand, begins with recognizing that if both a and b are 0, then V(ax+by+c) is either empty or the entire plane. Both are rather boring, and easy to handle. So one of a and b is non-zero. Let’s say that a isn’t 0. Then we can rewrite ax+by+c=0 to . This can be inserted into the quadratic equation to form the new equation , which in turn expands to

which, in turn, we can easily solve using normal solution techniques for quadratic equations. To get rid of fractions, we’ll multiply the entire equation by yielding the new equation

Now, the discriminant

carries information about the nature of solutions. If , then the line V(ax+by+c) is a tangent to the circle, if , then the intersections are all complex and if , then the intersections are real. In both the non-tangent cases, the circle intersects the line exactly twice.

However, as such, this is not enough to solve the issue. For one thing, we can set Q’=P and P’=Q, and things are the way he asks for.

Now, I wonder whether we can solve this by using PROPs (or possibly di-operads or something like that). Let’s represent a document as a list of some sort of tokens. We’ll set the set of all lists of length , and we’ll set to denote operations that take a list of length n and returns a list of length m.

One operation here is obvious – the identity operation. So we’ll take that into the mix. And we’ll also want to have some manner of composing operations. So, set to be the operation that applies the second argument to the elements i,i+1,…,i+m of the list outputted by the first argument.

This way, we can make patch trees – using the identities to fill out when a patch doesn’t influence everything; and have composition of operations represent composition of patches.

Now, the commutativity that Brent asks for would manifest as an additional relation – on top of those inherent in the definition of a PROP – to rebuild trees. One obvious one pops out immediately – as long as the trees don’t overlap, in other words, as long as the subtree we want to reorganize is contractible (in the topological sense), we can commute patches freely.

When trees -do- overlap, however, the undo operation Brent asks for is much more tricky. Consider the following sequence of edits:

[] -> [a] -> [b] -> [cbd]

Now, undo the insertion of [a].

Sure, taken this way, we cheat a little. Maybe we want to restrict edit descriptions to explicit deletions and additions. So we would have

[] -> [a] -> [] -> [b] -> [cb] -> [cbd]

and here we could probably move things around a bit easier. I don’t quite see how to do it, right now, though.

They have a whole bunch of Really Pretty Images at the exhibition website, and I warmly recommend a visit. If you can get hold of the exhibition, they also have produced real models – with a 3d-printer – of some of the snazzier surfaces, so that one could have a REALLY close encounter with them.

But also, I’d really like to show you some of my own minor experiments with the program.

This is the interior of a Klein Bottle, using the “standard” realization as an algebraic surface given by Mathworld. In other words, I’m using
(x^2+y^2+z^2+2*y-1)*((x^2+y^2+z^2-2*y-1)^2-8*z^2)+16*x*z*(x^2+y^2+z^2-2*y-1)=0
for the defining equation. It kinda looks a bit like a Sousaphone in my opinion.

Roman’s surface, an immersion of the real projective plane into 3-dimensional euclidean space. It is given by the equation
(x^2+y^2+z^2-9)^2-((z-3)^2-2*x^2)*((z+3)^2-2*y^2)=0
and is one of the Steiner projections of the Veronese surface, embedding the real projective plane into projective 5-dimensional space by the homogenous parametrization (x^2,y^2,z^2,xy,xz,yz).

With the defining equation
x^2*y^2-x^2*z^2+y^2*z^2-x*y*z=0
this Steiner surface can be transformed into the Roman surface above if (and only if) you’re allowed to take shortcuts over the points at infinity. As it is, it has two pinches (both visible) and three lines of self-intersections (also all visible, kinda sorta). It’s also unbounded – one of the reasons that you cannot get to the bounded Roman surface easily.

With this as inspiration – go forth and draw surfaces. And when you do, please show them to me too.

Just got accepted for publication in the Journal of Homotopy and Related Structures.

Damn, this feels good!

First off, we’ll start with a definition:

The wreath product is defined for groups G,H and a G-set X by the following data. The elements of are tuples . The trick is in the group product. We define

(or possibly with a lot of inverses sprinkled into those indices)

Consider, first, the case of with the nontrivial G-action defined by gx=1, g1=x. We get 8 elements in the wreath product . Thus, the group is one of the groups with 8 elements – . We shall try to identify the group in question using orders of elements as the primary way of recognizing things. Consider an element ((x,y),z).

If z=1, then this squares to ((x²,y²),1) = ((1,1),1), so all these elements have order 2 (except for ((1,1),1) which has order 1).

If z=g, then the element squares to ((xy,yx),1). So if x=y, then the element squares to the identity, and thus has order 2. Remains two elements where this is nontrivial – namely ((1,h),g) and ((h,1),g) – both of which square to ((h,h),1), which squares to the identity. And thus these two elements have order 4.

Thus, no element of order 8 – and thus the group is not . It has elements of order 4, and thus it’s also not . A reasonable question at this point is whether it’s abelian. Consider the following products.
((1,h),g) * ((1,h),1) = ((h,h),g)
((1,h),1) * ((1,h),g) = ((1,1),g)
thus eliminating .

This leaves . At this point, I’m basically going to make a lucky guess and give an isomorphism . Let .

We send ((1,h),g) = a, giving ((h,h),1) = a² and ((h,1),g) = a³ = a^-1. We then pick any one of the remaining nontrivial elements, say ((1,h),1) = b. We need to verify the relations in the group presentation. a⁴=1 and b²=1 are already reasonably obvious. So we compute
((1,h),g)*((1,h),1)*((1,h),g)*((1,h),1) =
((h,h),g)*((h,h),g) = ((1,1),1). Which concludes the identification.

For a second take, we consider X to have trivial G-action. Then, given , we get the multiplication
((x,y),z)*((a,b),c) = ((xa,yb),zc) – which is precisely the multiplication in . Thus, this wreath product is just .

Finally, for a more challenging group identification, we consider with gx = x². Elements in the wreath product have the form , and we get the multiplication as
((x,y,z),w)*((a,b,c),d) = ((x,y,z)w(a,b,c),wd).

The group will be of order 24, so there’s a few more to choose from. For an elimination of all the abelian groups, consider
((h,1,1),g) * ((1,h,1),g) = ((h,h,1),g²)
((1,h,1),g) * ((h,1,1),g) = ((1,1,1),g²)

Now, all elements ((x,y,z),1) have order 2, so to maximize order, we need something like ((x,y,z),g). Now consider the powers of this element.
((x,y,z),g)
((xz,yx,zy),g²)
((xzy,yxz,zyx),1) – which if exactly two of x,y,z are non-identity vanishes, and otherwise is nontrivial.
((xzyx,yxzy,zyxz),g)
((xzyxz,yxzyx,zyxzy),g²)
((xzyxzy,yxzyxz,zyxzyx),1) = ((1,1,1),1)

So, no element has order more than 6. This, again, rules out many of the candidate groups.

To be specific – we can now partition the elements after order.
((1,1,1),1) – 1 element, order 1
((x,y,z),1) – 7 elements, order 2
((1,1,1),g), ((h,h,1),g), ((h,1,h),g), ((1,h,h),g),
((1,1,1),g²), ((h,h,1),g²), ((h,1,h),g²), ((1,h,h),g²) – 8 elements, order 3
((h,1,1),g), ((1,h,1),g), ((1,1,h),g), ((h,h,h),g),
((h,1,1),g²), ((1,h,1),g²), ((1,1,h),g²), ((h,h,h),g²) – 8 elements, order 6

At this point, I grab Google as a research assistant. It turns up 15 groups of order 24. Using the small groups database enumeration, we find:
24.1: has an element of order 12.
24.2: has an element of order 24. Also is abelian.
24.3: has an element of order 4.
24.4: has an element of order 4.
24.5: has an element of order 4.
24.6: has an element of order 4.
24.7: has an element of order 4.
24.8: has an element of order 4.
24.9: is abelian.
24.10: has an element of order 4.
24.11: has an element of order 4.
24.12: has an element of order 4.
24.13: A₄xC₂
24.14: D₆xC₂
24.15: is abelian.

Now, with the candidate groups narrowed down this far, we consider the two remaining groups, and (in my case, using Magma), and grab the number of elements of each order.

A₄xC₂:
1 element of order 1
7 elements of order 2
8 elements of order 3
8 elements of order 6

D₆xC₂:
1 element of order 1
15 elements of order 2
2 elements of order 3
6 elements of order 6

which seals the deal. The group we’ve constructed is A₄xC₂.

Exhibiting an explicit isomorphism goes beyond what I feel like doing right this evening, and leave it as a nice exercise for the interested reader.