In my workgroup at Stanford, we focus on topological data analysis — trying to use topological tools to understand, classify and predict data.

Topology gets appropriate for qualitative rather than quantitative properties; since it deals with closeness and not distance; also makes such approaches appropriate where distances exist, but are ill-motivated.

These approaches have already been used successfully, for analyzing

• physiological properties in Diabetes patients
• neural firing patterns in the visual cortex of Macaques
• dense regions in of 3×3 pixel patches from natural (b/w) images
• screening for CO₂ adsorbative materials

In a project joint with Gunnar Carlsson (Stanford), Anders Sandberg (Oxford) (and more collaborators), we act on the belief that political data can be amenable to topological analyses.

1st: What do we mean by political data?

We currently look at 3 types of data:

1. Vote matrices from parliament:
   each column is a member of parliament
   each row is a rollcall
   we codify votes numerically: +1/-1 for Yea/Nay

   And then we can do data analysis either on the set of members of parliament in the space of rollcalls, or on the set of rollcalls in the space of members of parliament.

2. Co-sponsorship graphs
   Nodes are members of parliament.
   A directed edge goes from each co-sponsor to the main sponsor of a particular bill, for all bills.
   For Swedish politics, parties end up being strongly connected internally, with coalition mediators appearing in the data.
3. Shared N-gram graphs
   Some turns of phrase, some talking points, get introduced and then re-used by other members of parliament.
   We believe that an analysis of N-grams of parliamentary speeches may well give a data analyst tools to capture memetic drift and spread within partliament.

The project is still at an early stage, and the great challenge for us right now is to find value to add — in political science, the grand entrance of classical data analysis was a few decades ago, and much of what can be said about politics with classical data analysis tools has already been said.

2nd: What has already been done?

Political science discovered data analysis in the 90s, and a flurry of political science data analysis papers followed.

Thus, while illustrative, doing things like a PCA on political vote data is not quite novel.

Doing these PCAs, though, shows us, for instance, that the US house & senate are essentially linear,

and that the votes point cloud sits on most of the boundary of a unit square (above right): at least one party backs every bill that comes to a vote, and the main difference between bills is in how many of the other party join in too.

Already in this kind of analysis, we notice a difference over time — the party line is a much stronger factor in 2009 than it was in 1990:

We can perform similar analyses for the UK:

Here we may notice that the regional parties are pretty much included with the ideologically closest major party. This is a phenomenon we’re going to revisit later on.

With Swedish vote data, we’ve been able to both locate the blocks as essentially grouped under the first two coordinates of a PCA; with lower coordinates seemingly issues-oriented — it’s worth noticing component 5 which separates out C and MP from the other parties, and thus seems to be the axis of environmentalism in Swedish politics.

image courtesy of Anders Sandberg

3rd: How do we bring in topology?

There are several techniques developed at Stanford for topological data analysis. While my own research has been centered around persistent homology, the one I want to present here is different.

Mapper was developed by Gurjeet Singh, Facundo Memoli and Gunnar Carlsson. It builds on combining nerves with parameter spaces.

Definition:
Suppose is a family of open sets. Then the nerve is a simplicial complex with vertices the index set I, and a k-simplex if .

Lemma: [Nerve Lemma]
If covers a paracompact space X, and all finite intersections are contractible, then X is homotopy equivalent to the nerve of the covering.

Now, if X is a topological space with a coordinate function and Z is (paracompact and) covered by some family of , then the collection of preimages covers X.

So, by subdividing each preimage of a set in the covering of Z into its connected components, we get a covering of X subdividing the cover induced from Z.

Thus, if f is sufficiently wellbehaved and the covering is fine enough, the nerve of these subdivided preimages is homotopy equivalent to X, and we have found a triangulation (up to homotopy) of X.

This particular line of reasoning can be translated into a statistical/data analytic setting. The main difference is that by virtue of persistent topology, connected components correspond to clusters, and so we may start with a point cloud, and then pick out preimages of the cover of our target space, cluster these, and let each cluster correspond to a point, and then introduce simplices according to the intersections.
The process is illustrated in a PDF “animation” here.

This technique has been used already to recover the difference between diabetes type I and II as lobes in the data, apparent in blue here:

We hope to be able to use these techniques to better understand the way parliaments are structured internally.

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.

First, Second, …

1st, 2nd, …

And, because this chart is kinda tricky to read, here’s the log-scaled version of the same chart:

For the log-chart, I stopped stacking the numbers.

ETA: Changed the log-chart from a line-chart to a bar-chart after feedback from the readership of bOINGbOING. Hello and welcome!

Coordinatization

First off, a few words on what we mean by coordinatization: as in algebraic geometry, we say that a coordinate function is some or possibly some , with all the niceness properties we’d expect to see in the context we’re working.

A particularly good example is Principal Component Analysis which yields a split linear automorphism on the ambient space that maximizes spread of the data points in the initial coordinates.

Topological coordinatization

The core question we’re working with right now is this:
Given a space (point cloud) X, and a (persistent) view of , can we use some map to generate a map inducing that map?

In topology there are ways around to compute spaces of maps directly from available homological information. The key phrase here is the Eilenberg-Moore spectral sequence, by which we compute using . We note that with the compact open topology.

We fix a field k of coefficients. We can find a spectral sequence that computes

Variations of this spectral sequence allow us to compute . A homotopy class of maps thus corresponds to a cohomology element from .

Monad approximation

Define
(unordered pairs)
and similarily unordered tuples

we can get a map, for pointed spaces

In the limit, we get the union .

The Dold-Thom theorem tells us:

Suppose we are really looking for maps .

We pick chain complexes . There is a hom chain complex consisting of graded maps with the homotopy/induced boundary

For this complex, we get
is the family of chain homotopy classes of chain maps .

Recall: are chain homotopic if there is a family such that .

Homotopic space maps yield homotopic chain complex maps. And thus

How, though, do we get from to ?

Cosimplicial spaces

A simplicial space is a contravariant . It has a total space or realization given by

In the dual setting of cosimplicial spaces, the total space is a subspace of .

There is a cosimplicial space

whose total space is .

Furthermore, there is a spectral sequence starting at (well understood space!)
going through

which recovers for us.

The mapping space maps to , which sends to chain maps. Differentials give us conditions on chain maps to come from actual maps on the topological level .

Suppose now that is a simplicial complex, and is known, say isomorphic to .

We pick as a model space, and work in . We pick out conditions form the spectral sequence above to pick out chain maps that might come from topological maps.

Suppose we had some chain map that sends .

We look for a chain homotopic map such that is a simplex (this will be WAY too optimistic, usually) or at least for small and close together in graph distances.

Yi Ding: there are likely many simplicial maps inducing any given . This makes optimizations on quality of maps (as measured in smallness properties of preimages of given simplices) troublesome, since we have a large search space and are likely to get stuck in local minima.

The topological approach creates very many maps, but we just want ONE – albeit with quality assurances. The big question is how to get there:

Shrinking the space? Homotopy collapses to reduce the number of generators?

Ask for more side conditions? If so, which?

Minimize the size of preimages and kernels – smoothing the resulting map?

Run with one condition until we reach a minimum, then change conditions to get out of that particular sink, repeat until it all looks stable?

Thus we need to search for strategies to improve convergence to actually good maps.

The questions we pose are similar to:

Jeff Ericksson, et al.: Given X, , how do we find a good representative ?

Finding good maps is really about finding good representatives in . Given simplicial bases we can pick out a first basis
(Kronecker ) for .

Finally: many problems in data analysis call for analyzing contractible spaces. So if we pick out the notion of a boundary, doing all of this relative to a boundary would give us increased power to use the resulting methods in data analysis.

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)))

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

Damn, this feels good!

Suffice to say, the report did not, as some I’ve seen blogged about, tear me a new one. Far from it – it was civil, kind, and pointed out several areas where my article text overlapped known arguments from other people and was generally superfluous as well as several areas where my article was too curt and didn’t actually spell out the new ideas sticking in it.

Also, making the relation of my results and those I rely on to the results of the Grand Old Man in applying -techniques in group cohomology explicit and discuss these in more detail was requested.

I know I couldn’t expect to write The Perfect Article as my first submission ever. And it’s not a flat out denial. And it brings constructive comments about how to make this a better article. Still, I think my ego needs a little bit of training to learn to cope with this part of the review process.

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.

It divides neatly into two different sections: the months as a commercial programmer and the months as PhD student and academic careerist.

The year began still working for Teleca Systems, and with security consulting for Stockholm-based firms and frequent trips back home.

Then as the year went on and my PhD applications grew more and more, I started getting results. I got invited to Bonn for an interview with the Homology and Homotopy graduate school program – which was in the end turned down because I was more of a homological algebraist than a topologist. And the week after that, I was invited to Jena for an interview for a position doing PhD work on computational homological algebra. The interview went well, the potential advisor was nice (and a once-roleplaying gamer to sweeten the deal more) and I got the position just a few days later.

While in Switzerland.

Skiing.

On a weeklong luxurious conference in operad theory at a skiing resort in the western part of the swiss alps. Lots of skiing, fantastic food, lots of REALLY COOL people (I’m looking at you, pozorvlak, among others) and lots of fascinating mathematics.

As I returned there, it was time to wrap up my position with Teleca, disengage from all my duties, document everything I had done, train everyone else in my stuff, and get out of there. Preferably before the summer term started. Oh, and get through the bureaucracy involved in getting hired at a German university. It’s a fascinating experience, I can tell you. Especially when you get asked whether you were involved with the Stasi during communist east Germany.

Freshly hired, I had a week to get my affairs in order, and then got thrown on my first bunch of students. Teaching and reading up on cooooool mathematics for several months, leaving a little bit for visits to Sweden, and then hitting the vacation hard with a long relaxing visit to Sweden, and a marriage proposal.

The summer also saw the Pirate Bay raid, my heightened interest in the politics of privacy, and membership in the Pirate Party, the election, and following the election results explicitly with attention to the Pirate Party results.

After the vacation came conference summer, stretching August through September, with between 2 and 4 conferences depending on how you count them, and a little bit of research. At the end of this, a new term started and with that a new direction for my PhD research. This was, at the same time, the period when I got enamoured with Haskell, read up on it, grew more and more interested, fascinated, captivated.

During the time in Jena, I got involved in a roleplaying troupe, in a mathematical magazine (with two articles published by now!), in a group organizing math camps (participating in one camp), and getting hold, slowly, of a decently sized social circle.

And then the end of the year hit before I knew what happened. It ends tomorrow – and I have things hanging in idle loops swarming my head like angry bees and waiting to be channeled through my consciousness out on paper and code, and get me running with my research.

That’s my year in review. How was your?

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.

He, as I, is a mathematician, spending his time thinking, finding patterns, and trying to formulate (more or less) absolute proof that his patterns hold all the time, alternatively ways to demonstrate that they may not be universal.

In the post linked above, he starts by a neat little exercise, gets interested, and goes out to look at more examples. These show a very clear pattern, and after following this pattern quite some way out, he finally believes the pattern enough to start searching for a proof: which he also finds.

Now, this is one central heuristic pattern in mathematics. Calculate examples. Look at the examples. All of a sudden a pattern appears, and you think up a reason why such a pattern could be there. While proving the “correctness”, if you may, of the pattern, you’ll either end up formulating in enough detail what’s going on so that you may possibly expand the statement to cover even more — or you may realize that it does not hold and find a way to construct a counterexample. Either way, the mass of knowledge increases.

Now, what does this have to do with programming languages?

I started looking at Haskell due to a sequence of blogposts from sigfpe, who was describing Haskell programming from a highly algebraic point of view. And even after my involving myself in the subject, one thing that stands out is the relatively low distance between thought expressed in my ordinary day-to-day mathematical discourse, and thought expressed in Haskell code. For the ubiquitous example, let’s take the factorial function. Mathematically, I think about factorials as
“n! is the product of all integers from 1 to n”
or
“n!=Γ(n-1)” (though this not so often, I must admit)

Then again, “the product of all”, when I introduce it strictly for the first time tends to be expressed along the lines of
“Π_n=1^k f(n) is f(k)*Π_n=1^k-1” or something along those lines.

So, what happens if I want to start playing around a bit with factorials, and see whether I can say anything interesting about them?

In C or similar languages, I’ll fire up an editor, and a command shell, and start writing code that looks something like

and I will spend more time writing scaffolding and reworking the problem into something I can write in C than I will actually working with my mathematical intuition about it.

C++, Java, PHP, Perl — it won’t be much different in any of these. None of them have an interpreter I like, none of them differ all too much from the mindset of C. (Yes, I say this knowing full well the difference between imperative and object-oriented programming…)

In functional languages, the way I write the code is very much more reminiscent of the way I define it in my head. I could dig out enough Lisp or Scheme from the back of my mind to give you an example, but it’s getting late and I couldn’t be bothered. So instead I’ll go straight on to the thingie I want to praise.

In Haskell, I’ll fire up my interpreter, and write at the prompt something very much like

and then start firing off actual calculations into the box.

During my time so far, I’ve used Haskell quite a bit in my research to generate lists of testcases. Not necessarily because Haskell is the best possible language for it, but because I could very quickly write down my thoughts, get working code out of it, and just go ahead and do what I wanted. Most languages I’ve worked with have their uses – and I’m not out to bash anything right now. But with Haskell, I’ve had a much lower threshold thought-to-code, and much less distance between my coder head and my mathematician head, than with anything else I’ve seen so far.

Based on research I have done during my time as a PhD student.

Wish me luck.

Update:If you want to read the paper, I suggest you go look at arXiv:math.GR/0610374.

Don’t laugh. This is less embarrassing for me than asking my advisor point blank.

We say that a (graded) commutative ring R has depth k if we can find a sequence of elements with not a zero-divisor, each not a zero-divisor in the quotient and a ring without non-zero divisors. This definition, of course, being the first obvious point where I may have screwed up.

Now, we know (from looking it up in Atiyah-MacDonald), that for SR the localisation of R in a multiplicatively closed subset S, S(R/I)=SR/SI, that injections carry over to injections, and that the annihilator over SR of an element is the localisation of the annihilator of the element.

We now take S=R-p for p a prime ideal in R. So SR is the localisation in a prime ideal in the usual sense (by slight abuse of notation). Since p doesn’t intersect S, Sp is prime in SR. Suppose we have an R-sequence of length k, demonstrating the depth of R to be at least k.

The first element, of the R-sequence, is regular in R, and thus multiplication by this element is an injection . Injections carry over to injections after localisation, so this induces an injection , given by . Since this is injective, the element is regular in SR. So we can go to . Now, localisation commutes with quotients, so this is really .

Now, is regular in , and thus induces an injective map. This injective map carries over to an injective map of localisations, and thus, with the same argument as above, is regular over . So we can carry over all of our regular sequence from R to SR.

The only problem visible to me being that we may end up dividing out the entire ring and ending up with a trivial ring earlier than we thought we would. What would make that happen? Well, if our ideal in the quotient at some point includes the ring, we lost the game. What could make this happen? Then we’d need to have either 1 in the ideal, or 0 in the localisation set. 0 in the localisation set, we get if a zerodivisor and its annihilator both end up in there at the same time. I’m not going to touch this case quite yet. Possibly not at all in this post. 1 in the ideal, we get if one of the ends up being in S. So, for everything to be perfectly fine this far, we REALLY want to avoid straying outside of p.

And this’d, y’know, limit our choices of R-sequences a bit. But still, we can get an R-sequence the depth of SR this way, I think. And then there is the question of what happens outside this realm – and it would seem that we can use the Krull dimension bound for that, thus arriving at

(which incidentially, with a certain set of conditions, is a theorem I found in a set of notes that sqrt linked me to)

• I am done with the coursework for the past semester. Sent off the TeXed up solution sheets to the webmaster today.
• My pattern observation seems to hold up surprisingly well – there seems to be a theorem to fetch out there somewhere.
• I have done most of the dishes. Go me!

Todo:

• FOCUS! I need to learn triangulated categories. Preferably now. I need to stop playing with Haskell and reading up on group cohomology calculations. Preferably now.
• After triangulated categories, there’s a wealth of things to look into. High priority are spectral sequences, further group cohomology, diamond lemma, path algebra quotients, A_∞, Massey products, return to model categories. Which order these are done might influence the contents of my PhD thesis significantly.
• I really need to talk to the university sysadmins about the WLan network.

Progress may be found. Just around the corner. I need a donut.