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.

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

Damn, this feels good!

One subject I spent a lot of time thinking about this spring was taking tensor products of A_∞-algebras. This turns out to actually already being solved – having a very combinatorial and pretty neat solution.

Recall that we can describe ways to associate operations and homotopy of associators by a sequence of polyhedra K_n, n=2,3,.., called the associahedra. An A_∞-algebra can be defined as being a map from the cellular chains on the Associahedra to n-ary endomorphisms of a graded vector space.

If this was incomprehensible to you, no matter for this post. The essence is that by figuring out how to deal with these polyhedra, we can figure out how to deal with A_∞-algebras.

A tensor product of algebras is basically the direct product of the polyhedra, and we can get precisely the thing we want if only we find a map from the cellular chains on K_n to the cellular chains on K_nxK_n fulfilling a few neat properties.

This map is what is known in the literature as the Saneblidze-Umble diagonal from the people who presented it in a paper from the late 90s. They describe in that paper, and more clearly in a later paper, how to actually get hold of one map with the right properties. The road goes over basic matrices, derived matrices and connecting matrices to trees describing associations. I’d like to take this opportunity to work through the implementation I just wrote of an enumerator for these, displaying the code and discussing it a little bit.

This post will be written as literate Haskell, so copy the text into a file, and then just save it as SaneblidzeUmble.lhs and you’re ready to go.

So, we will build a module named SaneblidzeUmble that shall contain the code:

We’re going to juggle a lot with lists, and a little with potentially failing calculations, so we’re going to include a couple of standard utility function sets too.

Permutations and staircase matrices

The issue we’ll want to solve in the end is to enumerate all the terms entering into a diagonal on K_nxK_n for one fixed n. These terms are, using the later to be mentioned terms, in correspondence to derived matrices of staircase matrices with entries from [1,..,n-1]. A staircase matrix is one with one entry for each diagonal (parallel to the main diagonal), and such that along each row and column, all entries are adjacent and strictly increasing down and to the right.

As an example, we have the matrix

.14
25.
3..

Given a permutation of [1,..,n-1], we can write the images in the order they occur, and then just take this as a description of the entries from lower left to upper right of a staircase matrix.

It turns out that the basic matrices involved in this process are in bijection to permutations of [1,..,n-1] by placing the digits into the matrix, going up whenever the next entry is lower, and going to the right whenever it is larger.

Thus, the example above is given by the permutation (32514).

So, to handle this, we need to be able to list all permutations as well as pick out all rising and all falling part runs of a permutation

This is almost readable as it stands. The permutations of [1..n] are just the permutations of the list [1..n].
There are no permutations of an empty list, the list with one element has one permutation of itself, and for any larger list we pick out one element at the time, permute the rest and prepend this element. The collected results are compiled into a single long list and returned.

Solves, by recursion, neatly and with a lot of connection to the mathematical thought behind it our problems.

Now, for the chopping permutations into monotonic runs, I’ll solve it all in a manner slightly decreasing the amount of code repetition. We have a “factory function”

and two use cases of this

Using this, we can build the matrix out of a given permutation. The only really interesting thing for the diagonal about such a matrix is the contents of the rows and of the columns, so we shall just use that. This means we can represent a matrix as the list of rows and the list of columns. Since row and columns “look basically the same”, they’ll be represented by the same type. So we have

The reason we use map sort and reverse is to make the result fit with the conventions chosen by Saneblidze and Umble. Note: when actually reading the results, users should take care to read the Columns backwards.

Deriving staircase matrices

Deriving the matrices is done with so called moves. We have a downward move, and a rightward move – both consisting of picking a subset of elements in one row or one column, and pushing them over to the next – given the condition that all the moved elements have to be larger than the largest they move over to. They also have to move to empty positions, but the ordering conditions for the staircase matrices will guarantee that if they really are larger, then the corresponding position is already empty.

So, we can write a a function that gives us all the subsets of the first column/row that might possibly be moved to the second in a given column/row-list of a matrix

This function picks out all the subsets of elements that fulfill the requirement of being larger than the largest element of the next row. But hang on – this subset-function actually isn’t defined yet. No worries – it’s easily done:

Again, we define everything recursively, relying on a base case of “blinding” simplicity, and end up with a very mathematical looking description. Here, the subsets of the empty set is just the empty set itself, and the subsets of any set with one element existing in it consists of the subsets containing that element and those that do not contain it. We simply list first those with and then those without.

Now, for the actual deriving move, we might run into a host of trouble, so we’ll just let it be able to return an error condition. It first checks a few possible error cases, and then writes down the actual move by picking out the rows it needs, modifying those, and putting it all together again in the end.

Supposing we have some set m we want to move, and we have a list of the rows where it could be moved, then we’ll want to first check whether all of m is in a single row together. Thus, for each row, we pick out all elements that are in our set m. But we don’t really care for what the elements are – we only need the number in each. So we compile a list of the lengths of these filtered out pieces.

We shall require the number of rows that have all the pieces we want to move to be 1, and also for that single row to have a good position within the matrix.

That monstrous expression at the end is known as a guard expression. It works through the cases until something actually is true, and then returns whatever is after the equal sign as the value. The conditions I listed weed out all the pathologies, and lets the program pick out something sensible whenever possible.

So, we can list all possibilities of one row, and we can move them. This should be enough to simply generate all derived matrices, right? Let’s start simple. Let’s start with all we can do on one side of the pair – either all possible down moves or all possible right moves (they are essentially the same anyway…)

Guiding you through this piece of code – when encountered with a list of rows, we look at each starting point, list all the possibly movable sets at that point, and move the corresponding sets, placing all the results at the back of a queue that we work through. Once the queue is empty, we know we have worked through all the results from all the moves we could find, and that no others can be found.

So, if we have our pair of row-lists? We first move to the right, and then down. At each point, we keep the other half fixed, and simply add it on to all the results of moving in the first part.

This first works through one direction, taking all derived rows, and tacking on the constant second half, then when that’s done, changes to the same but for the other half of the pair.

Now, we’re almost able to state what a specific diagonal looks like. There is only one more thing to handle: we might not want the results of a particular computation. More specifically, we recognize something we do not want by it having a row that isn’t consecutive, not even when including previously occurring rows. So, we need to check that.

Now it’s just a matter of putting the pieces together

Previously, a student of Ron Umble has done an implementation of the same task in C++. This cannot, according to Umble, handle anything larger than n=5. This Haskell implementation, while being surprisingly short and readable, has on my (64 bit, modern, high memory) workstation been able to meet the following execution parameters:

On Monday, I’ll give a talk on my research into -structures in group cohomology. If you’re curious, I already put the slides up on the web.

I’ll try to blog from T’bilisi, but I don’t know what connectivity I’ll have at all.

A success here would be very good news indeed, since for one it would indicate that such an adaptation should be possible, and for another it would possibly give me a way to lend strength both to the previous calculation and to a conjecture I have in the calculation of group cohomology with A_∞ means.

So, we start. We recover, from the previous post, the structure of the cohomology ring as k[x,y,z]/(xy), with x,y in degree 1, and z in degree 2. Furthermore, we have a higher operation, m₄, with m₄(x,y,x,y)=m₄(y,x,y,x)=z.

Thus, with the theorem, stating that the maps

are actually the duals of the maps

embedding the relators of the original algebra into the tensor algebra over the generators.

So, for our case, we have the maps




and we look to dualizing them. Considering for a while what this all means, and fixing notation, with a,b the generators, dual to x,y, we end up with the maps



from which we may recover a presentation of the group algebra as

As such, this is an unqualified success. We recover our original group algebra presentation from the A_∞-structure, and thus should be able to do similarily as a test for completion of future calculations as well. This, of course, needs to be proven before relied upon, but it lends credence to my hopes.

To do this, I fix the group algebra

and the cohomology ring

with ,

Furthermore, we pick a canonical nice resolution P, continuing the one I calculated previously. This has the i:th component Λⁱ⁺¹, and the differentials looking like

for differentials starting in odd degree, and

for differentials starting in even degree. The first few you can see on the previous calculation, or if you don’t want to bother, they are

Now, armed with this, we can get cracking. By lifting, we get canonical representating chain maps for x,y,z described, loosly, by the following:

x takes an element in , keeps the first, third, et.c. elements and throws out the even ordered elements; so
For an element in , the last element gets extra treatment, so

For the lowest degrees, we also have

This describes the image of our quasi-isomorphism .

For , we get the interleaved effect: every second element, but now with even indices, and some extra treatments at the end. So an element in will behave like

and for an element in we get

The last generator, z, is rather boring. The corresponding chain map only lifts elements to other degrees: shaving off the first two components of whatever it is applied to.

We define on products of the generators by simply composing the corresponding chain maps as long as the product is defined. The interesting stuff, from an A_∞ point of view occurs when the product vanishes, thus for x,y in the first line. A calculation shows us that xy is the only interesting element of the ideal , since , and we define and .

Thus, we’d be curious as to what happens with xy, and yx. Both products are zero in the cohomology ring; but the composition of the corresponding chain maps are not zero.

By calculation, we get given in the first few step by the matrices


and so on, with the lower right entry alternatingly ab and ba.

is the same thing, but with ab and ba interchanged.

We want and to be homotopies between the 0 chain maps, and these two respectively. By juggling the relevant matrices in Magma for a while, I conclude that has lower right entry a for all odd degree map components, and has the entry above that b, same components. All even components vanish.

Thus, for the first nonzero component, we have

for x,y and

for y,x.

Now, if we look at Φ₃, most of the possibilities vanish because of the way we defined f₂ for the non xy, yx cases. Thus, the only interesting entries remaining are xyx and yxy. These are, respectively,


and calculation of these expressions is a matter of composing the chain maps we have a tentative grasp of already. This gives us the case of xyx alternatingly between b in lower right corner for all even degrees and a just to the left of it for odd degrees, thus starting with the matrices


and for the case yxy, we have a similar pattern, but with a in the lower right for odd degrees and b above it for even degrees, giving the first two maps as

So, we can immediately conclude that our m₃ is going to be the zero element of Γ, since none of these chain maps are homotopic to any non-trivial coclass representatives. Thus we’ll need to find homotopies from these to the zero chain maps for our values of f₃.

A homotopy suitable for f₃(x,y,x) would be h with





It goes on, but I have not yet discerned a pattern clear enough to describe a generic element of this chain map. I probably should, at some point.

For f₃(y,x,y), we would need a homotopy for the other sequence, and calculations lead me to put down h with





and here we can discern a pattern to the matrices. They will have a sequence of 1 starting out at the third column, and going down skipping every second place.

Armed with these calculations, we may set out to calculate for our pleasure Φ₄. Due to the heuristic we use in defining the f_i for things “lifted” from the generators we’ve defined above, we shall discard anything except for xyxy and yxyx from study; all other cases will just give the relations we use in calculating f₂ or f₃ from the cases we’ve calculated.

Thus, we’ll be interested in

and

and thus we can, by using the already calculated matrices and a CAS (I use Magma right now) just calculate the matrices. In both these cases we get the same thing: the matrices



and so on; which are precisely the matrices we chose for our .

Thus, we’ll set m₄(x,y,x,y)=m₄(y,x,y,x)=z and f₄=0, and stop calculating right here.

We will find the A_∞-structures on the group cohomology ring by establishing an A_∞-quasi-isomorphism to the endomorphism dg-algebra of a resolution of the base field. We’ll write m_i for operations on the group cohomology, and μ_i for operations on the endomorphism dg-algebra. The endomorphism dg-algebra has μ₁=d and μ₂=composition of maps, and all higher operations vanishing, in all our cases.

Elementary abelian 2-group

Let’s start with the easy case. Following to a certain the notation used in Dag Madsen’s PhD thesis appendix (the Canonical Source of the A_∞-structures of cyclic group cohomology algebras), and the recipe given in A-infinity algebras in representation theory, we may start by stating what we know as we start:

our group algebra. We can resolve using a neat canonical resolution, derived from the tensor products of the resolutions of the field with modules over the cyclic 2-group. This gives us the resolution

where each differential is given by a matrix D with D_i,i=a and D_i+1,i=b.

Recall that . Thus is a dg-algebra, whose homology is precisely the group cohomology.

Now, by the minimality theorem (proven by Kadeishvili first, and reproven by a veritable host of mathematicians), there is a quasi-isomorphism of A_∞-algebras that lifts the identity in homology. This we can use to figure out the A_∞-structure for our cohomology ring: we know that the is an honest-to-glod dg-algebra, and thus has an A_∞-structure with all higher multiplications (by which I mean 3-ary and higher) vanishing. We can also pick representatives for our cohomology ring elements as representatives of homotopy classes of chain maps . This gives us a quasi-isomorphism of dg-algebras , lifting the identity, and which we can augment to an A_∞-quasi-isomorphism.

Which is what we’ll want to do now.

We’ll (at this stage) use the fact that we know what looks like: it’s the algebra . There are two 1-coclasses, both represented by a morphism , namely one composing the projection onto the first factor with the augmentation map, and one composing the projection onto the second factor. We’ll name the first of these x, and the second y, and note that they lift to chain maps that shave off the first and last summand of respectively in each degree.

So for our quasi-isomorphism , we now have sending each to the chain map shaving off the first i and last j components. We also know , namely 0, multiplication, differential and composition respectively. The first axiom we’ll investigate for A_∞-maps states that

But now m₁=0 and so this reduces to

so f₂ is a map such that its differential is equal to the “commutator” of f₁ and multiplication.

Now, pick some coclasses u,v. These will map to shaving maps as described above, and their product will map to a shaving map that does just the same as the composition of the individual shaving maps; so if u is xⁱy^j, and v is x^ky^l, then f₁(u) shaves off i components in the front and j components in the back, and f₁(v) shaves off k in the front and l in the back. So, the composition of these two maps is the map that drops i+k components from the front, and j+l components from the back. On the other hand f₁(uv)=f₁(x^i+ky^j+l) is the map that drops i+k components from the front, and j+l components from the back.

So they are the same. And thus we don’t need to bother with any homotopies, or any higher order operations or higher order maps. We set f² to be the zero map, and consider ourself finished and happy. The cohomology is a dg-algebra in its own right, and this is all there is to it in A_∞-terms. And we’re done.

This result implies, by the way, via a proposition from Keller, that the elementary abelian 2-groups have Koszul group algebras. An argument using restrictions of non-nilpotent coclasses to cyclic subgroups will tell you that these are the only finite groups that have Koszul group algebras.

With this example.

Cyclic 4-group

This is the one canonical example known beforehand in group cohomology. It was calculated by Dag Madsen in his PhD-thesis, and cited ever since. I will perform the same calculation, but in a blinding detail you won’t find in a thesis or a paper on the subject.

So, for starters, we find ourself with the group algebra

and the cohomology ring

quasi-isomorphic to the endomorphism dg-algebra of a neat resolution

where c in Γ represent the morphism m→cm.
Furthermore, as usual, the μ_i are all known, and m₁=0, and m₂ is the multiplication in Γ.

Once we’ve choosen representatives for the coclasses in , we can lift this choice to an A_∞-quasi-isomorphism. In this process, we’ll find and define the relevant higher multiplications for Γ, thus finding the A_∞-structure for that algebra.

Thus f₁ sends

and

and

Working through the coherence axioms, the first we encounter is the one defining . This is the one investigating the relationship between
and . So, we pick , and investigate the two expressions and . Writing it down in detail tells us that the only point where a difference occurs is if both u and v are odd, and this case we can figure out from the case where u=v=ξ since η only translates chainmaps higher up in degree.

Now, , so .
And we can read off the following diagram

and thus we can conclude that in degree 2. We shall be juggling maps a lot, so I will use the notation (x y z w)[i] for the map in that drops i degrees, and where the four last positions are multiplication by x, y, z and w respectively. So, with this notation, we have
f₁(η)=(1 1 1 1)[2]
f₁(ξ)=(1 x² 1 x²)[1]
f₁(ξ)f₁(ξ) = (x² x² x² x²)[2]

Composing the lowest degree component of the map (x² x² x² x²)[2] with the augmentation map, we see that in cohomology, it corresponds to the 0 element. So it is actually homotopic to the image of under f₁, and this particular homotopy is what we’ll want to be.

So we’ll want a homotopy h, defined by that
dh+hd = (x² x² x² x²)[2]
so we can immediately conclude that h needs to be of degree 1, since composition with d will add another degree step. So our h will look something like

and we can check what happens as we chase through the diagram. If we start at an odd-indexed position, we’ll get the two components
hd(o) = h(x o) = x h(o)
dh(o) = x³ h(o)
for o of odd degree. If we instead start in an even degree, we get
hd(e) = h(x³e) = x³h(e)
dh(e) = x h(e)
where e is an element of even degree. By close inspection in the diagram, we note that the expressions involving x³ all involve h applied on elements of odd degree, and so we’ll set those to vanish, and fill in the needed values by letting h(e)=x. Thus we get the chain map
h = (x 0 x 0) [1]
or in diagrammatic form

Thus , and f₂ on odd and odd elements are all translates of this, and all other parameters to f₂ give us a zero map. This brings us to a point where we can start investigating m₃.

We can extract f₁m₃ and m₁f₃ from the 3rd A_∞-morphism axiom, and put the rest into a map of its own. This will end up to be something supposed to be homotopic to the image of m₃, and so we can define m₃ and the homotopy once we have them.

The rest of the axiom is

(where I am using the fact that we’re in characteristic 2 extensively)
Applying this on elements x,y,z gives us a possibility to distinguish between cases.

If only one element is of odd degree, then every f₂ occurring will have at least one even argument, and so will vanish.

If two elements are of odd degree, we get the expressions
for x,y odd
for x,z odd
for y,z odd.
Each of these vanish if we take the behaviour of f₂ for higher odd coclasses into account: these are just translates of the behaviour defined in f₂(ξ,ξ), and so should vanish, since we defined f₂ on pairs of odd classes to just be translates of the value on ξ and ξ.

Remains the case with all three elements of odd degree. Again, higher odd elements behave by translating the behaviour of ξ, and so it is enough to study the behaviour on ξ, ξ, ξ.

In this case, we get

which is the sum of the maps given in the following two diagrams

and

By reading off the diagrams, we note that this sum is the chain map
(x³ x³ x³ x³)[2]
and we can further note that this corresponds to the cocycle 0 of degree 2 (since the augmentation composed with x³ vanishes), so we put m₃=0, to correspond to what this is homotopic to. And f₃(ξ,ξ,ξ) needs to be mapped precisely to this homotopy.

So, a homotopy h between 0 and (x³ x³ x³ x³)[2] is a map h with
dh+hd = (x³ x³ x³ x³)[2]
From the same considerations as above, we can conclude that h will have the two components
hd(o) = h(x o) = x h(o)
dh(o) = x³ h(o)
for o of odd degree. If we instead start in an even degree, we get
hd(e) = h(x³e) = x³h(e)
dh(e) = x h(e)
where e is an element of even degree.

Now, this time, since we want the x³ to occur, we can pick h to be 0 on even degree components and the identity on odd degree components, giving us
h = (0 1 0 1)[1]
and this being the image of f₃(ξ,ξ,ξ).

Going ever onwards, the next axiom we check is the one, that when we leave m₁f₄ and f₁m₄ out of the mix, we’ll get

and again, we can start looking at cases based on number of odd arguments.

For only one odd argument, all the f₂ and f₃ will vanish.

For two odd arguments, the same thing will happen.

For three odd arguments, we get the expressions
for x even
for y even
for z even
for w even
where the expressions vanish since all summands in each are the same translations of .

And for we get

Again, we calculate each summand by using a corresponding diagram, and get the three diagrams

for f₁f₃ and

for f₃f₁ and

for f₂f₂

Thus we can read off that f₂f₂ vanishes, and that the complete expression for is the one we’d write down as
(1 1 1 1)[2]
which we recognize as , so we set and .

And this concludes the calculation of the A_∞-structure on , and also gives a rather clear hint as to how to do it for in general.

It will, however, push through some 100-odd years of mathematical development rather swiftly. Try to keep up – I will keep it as light as I can while not losing what I want to say.

Algebra

In the 19th century, a number of different mathematical efforts ended up using more or less precisely the same structures, though not really recognizing that they were the same. This recognition came with Cayley, who first brought the first abstract definition of a group.

A group is a set G of elements, with a binary operation *, such that the following relations hold:

1. a*(b*c) = (a*b)*c for any a,b,c in G (associativity)
2. There is an element e such that for any a in G e*a=a*e=a (identity element)
3. For any a in G, there is an element a’ in G such that a’*a=a*a’=e (inverses)

This turns out to be just what you needed to merge the studies of symmetries in geometric objects with the study of solvability of polynomial equations, and a number of other various ideas that were floating around. I will put this all on hold for a while, and then return to it at the end of this rant.

Topology

At the end of the 19th century and beginning of the 20th century, Henri Poincaré spent some time thinking about geometry, and formulating his ideas in a way that lay the ground stones to the modern study of topology. This was to a large extent done in his Analysis Situs. In his work he considers closed surfaces – i.e. surfaces without a border, and that are limited in their girth. To be specific, they need to be compact – which rules out things like the plane, but allows spheres, tori, Klein bottles and such entities. Poincaré considered the question of what essentially different surfaces are possible. We’re not interested hereby to distinguish between surfaces just because they happen to be scaled differently, but we are interest in distinguishing if they have differences that are independent of scaling factors.

To attack the question, Poincaré studied closed curves on the surface. A closed curve is something that is parametrized by the interval [0,1] and such that it starts and ends in the same point. So, mathematically, it’s a function , with f(0)=f(1).

The normal way to study these entities is to also require all the curves we’re looking at to start at one specific point x₀, so we require f(0)=f(1)=x₀. Should we have two such functions, f and g, we can compose them by taking h(t)=f(2t) during [0,0.5] and h(t)=g(2t-1) during [0.5,1].

Now, the structure we get this way ALMOST ends up being a group as we stated up at the beginning. It isn’t quite, since we actually see a difference between staying in one place for half the time and then rushing through the race course in double speed for the rest of the time; or for that matter, composing three functions two different ways ends up being different as well; we don’t think it is the same partition when we do

as when we do

However, both this associativity as well as the identity element (racing the course in double speed) and inverses (going first one way, then the other) can all be solved if we view two curves as equal if they can be continuously deformed into each other. So we basically end up with a deformation from f to g being a map H(x,t) parametrized, so that H(0,t)=f(t), H(1,t)=g(t), and everything is continuous in all directions.

In classical algebraic topology, we more or less stop at this point, say that two curves are homotopic if they have a homotopy (such an H) between them, and form a group of equivalence classes of curves, called the fundamental group. That’s all nice, but not quite what I want to go and do.

In fact, I’m very much interested in this homotopy of associativity. We have the two associativity versions (fg)h and f(gh), depicted above with the tables. And some homotopy H between them. However, when we then look at ways to associate four curves, we get chains of homotopies that need not be the same. To be specific, we can use our homotopies guaranteed from the first step to ensure that
((fg)h)i — (f(gh))i — f((gh)i) — f(g(hi))
and that
((fg)h)i) — ((fg)(hi)) — f(g(hi))
where all the — are homotopies between the differently associated thingies. And these two different paths need in no way be equal. But, if things are nice enough, there’s going to be a homotopy between these paths. If that’s the case, then this homotopy will give rise to the faces of a 3-dimensional polygon, where, again, the surface of the polygon represents homotopical paths that need not be equal, but may well be homotopic. This continues on, and on, and on, and a topological space where these homotopies are present all the way up is called an A_∞-space.

Homological algebra

With inspiration from the A_∞-spaces, and because it pops up as the cohomology of such spaces (another, much nicer to calculate invariant than the fundamental group and its cousins, the homotopy groups – since homology and cohomology ends up being mostly linear algebra) there is a theory formulated by Jim Stasheff originally, and revitalized by among others Bernhard Keller dealing with algebras (i.e. algebraic structures where +, -, * and occasionally even / works) that have a set of higher multiplications that take any number of arguments, and not only 2 as normal multiplication does, and then returns something else from the algebra; and that obey axioms that are taken from these homotopies of homotopy paths we had in the last section. There is one axiom built on f(gh) — (fg)h, there is one axiom built on the homotopy between the two different paths between ((fg)h)i and f(g(hi)), and so on.

The really funky bit pops up when we combine this with cohomology. My advisor and I are interested in a way to do topology on groups; if we have a finite group – a finite set with an operation that fulfills the axioms from the beginning; we can build an algebra from it, that in some way represents the topological cohomology of a space that was built from the group in a welldefined manner. This cohomology carries some information about the original group, but loses some, so there may be infinitely many groups that give the same cohomology algebra.

However – if we also know the A_∞ structure on the cohomology, if we know all these higher multiplications in addition to knowing the actual cohomology algebra, then we can reconstruct the original cohomology algebra from this data. This statement is at the core of the work done in the study of A_∞-algebras, and my current plans for my PhD is to see whether I can get all the things the theory promises to work for the specific case of group cohomology. There are theorems proven already that it should, probably, work; but this is a case that simply has not been considered so far. Thus just sitting down and working things through may be a significant advance of the state of knowledge in itself.

If you do enough of a particular brand of homotopy theory, you’ll sooner or later encounter algebras that occur somewhat naturally, but which aren’t necessarily associative as such, but rather only associative up to homotopy. The first obvious example is that of a loop space, viewed as a group: associativity only holds after you impose equivalence between homotopic loops.

In fact, if we start with a based space — the normal situation in original homotopy of topological spaces — and start looking at the space of all loops based in the basepoint of the space. A loop is simply an image of the circle in the topological space, with the circle based in 0 and running up to 2π. Then we know we can compose loops, by just running through first one on half the time, and then the other on the second half the time. So from 0 to π we run through one loop, and then from π to 2π we run through the other.

However, we now get genuinely different loops — seen as functions — from the different ways to compose three loops. Let the loops be called f,g,h. Then f(gh) is a different loop from (fg)h, since in the first loop, f happens from 0 to π and in the second, f happens only from 0 to π/2. But we were doing homotopy! So we have some continuous map, named the homotopy, that goes from f(gh) to (fg)h. So then everything is alright after all. We don’t have strict associativity in the loop space, but we have associativity up to homotopy.

But now, if we look at the different ways to compose four loops, we get odd things happening. We’d have f(g(hi)) and ((fg)h)i as to extremal versions, and then two different ways to move between them. One way is to go
f(g(hi)) → (fg)(hi) → ((fg)h)i and the other one is to go
f(g(hi)) → f((gh)i) → (f(gh))i → ((fg)h)i

So we’re stuck in the same place again, but with a higher level set of problems. Not really a big problem: we’ll simply require there to be a homotopy between these two paths. So we slot in a continuous function that takes care of that.

But then, if we look at the ways to compose five loops, we end up getting homotopies that form a spherical shell, and the same problem that we can do things in different way. But we can always make sure these are homotopical as well. And so on. The different homotopies needed are called associahedra and were introduced by Stasheff. A topological space that admits all these is called an A_∞-space. Moreover, if a topological space admits an A_∞-structure, then it is homotopy equivalent to a loop space of something.

But hang on a second. I’m doing algebra, not topology. What good is this?

Well, we certainly have a concept of associativity for algebras. And we do, once we start juggling the right kind of objects, have a concept of homotopies in an algebraic setting. So, we’ll try to mimic all of this but with a suitable setting to be able to talk about algebras that are simultaneously chain complexes.

A-infinity algebras enter the stage

So, we’ll want an algebra over some field k. We’ll start of gently, introducing it first as a graded vectorspace ; and we’ll call the component of degree p. The category of graded vector spaces come equipped with one rather natural endofunctor: the suspension S. It works by . An n-ary operator of degree k on a graded vector space V is a family of maps .

We want to tune a family of maps corresponding to the composition and higher homotopies in the topological situation, as well as handling the differential; which we want there just because we’re doing homological algebra and see a graded space. So we’ll want a differential
of degree 1, and a multiplication of degree 0. The homotopy of the associativity of the multiplication will be some 3-ary map h such that , whereby the lefthand side has degree 0, and the righthand side has degree 1 more than the degree of h, since the differential has degree 1. Thus, for each of the higher homotopies, we’ll fall one degree step. All in all, the n-ary higher homotopy operator will have degree 2-n.

We note that (just check the degrees on both sides…), and so that this, maybe slightly artificial looking, degree condition on the higher homotopies can be handled rather neatly. Each n-ary homotopy is a map
of degree 2-n. That means, that we can just as well view it as a map
of some degree; since the S operator only changes the degrees within V. We can find the degree of this map by looking at where the degree 0 slice of ends up. This is, in reality the degree n slice of , and thus ends up in degree 2 of V, which is to say that it ends up in degree 1 of SV. So the degree 2-n map defined on V turns into a degree 1 map of SV; which is rather neat.

So, each interesting map — let’s call them all is a degree 1 map . This family of maps is a part of the structure definition of an A_∞-algebra. The rest of its definition is the set of properties we want these maps to fulfill. And what would those be?

First of all, we want it to be a chain complex when we’re done, so that we can use it to do homological stuff. So we’ll want . Next, we’ll want it to fulfill the Leibniz rule, so that it really does behave like a differential. So . And we want the associativity to hold – but only up to homotopy. That f and g are homotopic means that there is some chain map h such that f-g=hd+dh for the differentials on the chain complexes that f and g go between. Now, the differential on V we take to be our , and the differential on is induced from this as the sum . Now, the various versions of associating three elements under this multiplication we’ve defined are and . Both of these are chain maps (chain maps since the Leibniz rule holds). So we’ll want , where the first d is just and the second is . If we go on with all the higher associahedra, and choose our signs in a neat way, we’ll end up with the generic condition that

So that gives us some sort of abstract feel for what an A_∞-algebra is. Do we know any examples? Can we construct any?

Examples

First of all, any algebra is a differential graded algebra concentrated in degree 0. So if for all non-zero i, and is the only non-zero structure map, then we recover the normal associative algebras.

A differential graded algebra is an A_∞-algebra, associative and not only up to homotopy. This is the same as all higher homotopies vanishing, so it is the case where are the only non-zero maps.

Hochschild cohomology

Inspired by the success of simplicial complexes in algebraic topology, the inspiration pops up to try and introduce similar things in other theories. Thus, the idea of simplicial objects appears – which are defined as a functor from the category of finite ordered sets of integers with nondecreasing monotone functions as the arrows. In this setting, face maps and degeneracy maps get introduced: the face maps miss precisely one element, and the degeneracy maps duplicate precisely one element. This corresponds closely to our intuition of faces of simplices and degenerate simplices. With a simplicial objects theory, the differential in a chain complex ends up being just the sum of faces with appropriate signs. The whole theory varies far more than here indicated though.

Suppose now we want to construct a cohomology theory which includes this at its core. One method of arriving there is the theory of Hochschild cohomology. This is built basically the same way as any other cohomology theory, with the salient difference that the differentials and degeneracy maps are chosen differently. So to a bimodule M over a ring R, we set and .
The face maps on this complex is defined as



and the degeneracy maps just slot in a at the appropriate index.

We build a complex from this by just putting . The homology of the resulting chain complex is called the Hochschild homology . Dualizing everything, we get a cochain complex of multilinear maps , and the face maps



and the degeneracy maps again just inserting a 1 at the appropriate position. The homology of the chain complex we get from has homology the Hochschild cohomology .

Now, let’s take some associative algebra B, and look at the graded algebra with . Note to the attentive reader. This construction is very reminiscent of a graded version of what sigfpe is doing with practical synthetic differential geometry. We furthermore pick some multilinear map , and define to be normal multiplication in A, and =0 for all other i. Now, we can get a new A_∞ structure by setting for all and .

Suppose first that we picked our . Then we get, from the A_∞-conditions that
(sure, anyway…)
(no problem. is still 0)
, which we can expand to, and insert values to get


where x(yz)-(xy)z=0 since B is associative anyway, and by multilinearity, we note that c(x,y)z=c(x,yz) and xc(y,z)=c(xy,z), so everything cancels out. Thus this is fulfilled by the preconditions and does not bring any additional information.

Being a Hochschild 2-cocycle, however, only mandates that , which using the definitions means that dc(x,y,z)=xc(y,z)-c(xy,z)+c(x,yz)-c(x,y)z=0, which fits perfectly with our observation. Suppose now that we pick some other . Then, the only relations that survive, since all but two operations vanish, are those where and are combined. This occurs precisely for the relations of degrees N+1 and N(N-1). For the latter case, we combine with , which gives us something multiplied with , thus vanishing. For the first relation, we receive instead
, or if we translate it to something readable, involving an application to elements, it turns into

which looks very much like the Hochschild differential on cochains.

So, this is an A_∞-algebra precisely when the chosen map c is a Hochschild cocycle.

If you’ve read this far, I’m impressed. If you’ve understood what I’ve been saying, I’m even more impressed – and probably will run across you sooner or later at some conference or other.