I’ve written here before about building topological quantum field theories using groupoidification, but I haven’t yet gotten around to discussing a refinement of this idea, which is in the most recent version of my paper on the subject.  I also gave a talk about this last year in Erlangen. The main point of the paper is to pull apart some constructions which are already fairly well known into two parts, as part of setting up a category which is nice for supporting models of fairly general physical systems, using an extension of the  concept of groupoidification. So here’s a somewhat lengthy post which tries to unpack this stuff a bit.

Factoring TQFT

The older version of this paper talked about the untwisted version of the Dijkgraaf-Witten (DW for short) model, which is a certain kind of TQFT based on a gauge theory with a finite gauge group.  (Freed and Quinn put it as: “Chern-Simons theory with finite gauge group”).  The new version gets the general – that is, the twisted – form in the same way: factoring the theory into two parts. So, the DW model, which was originally described by Dijkgraaf and Witten in terms of a state-sum, is a functor

Z : 3Cob \rightarrow Vect

The “twisting” is the point of their paper, “Topological Gauge Theories and Group Cohomology”.  The twisting has to do with the action for some physical theory. Now, for a gauge theory involving flat connections, the kind of gauge-theory actions which involve the curvature of a connection make no sense: the curvature is zero.  So one wants an action which reflects purely global features of connections.  The cohomology of the gauge group is where this comes from.

Now, the machinery I describe is based on a point of view which has been described in a famous paper by Freed, Hopkins, Lurie and Teleman (FHLT for short – see further discussion here) in terms in which the two stages are called the “classical field theory” (which has values in groupoids), and the “quantization functor”, which takes one into Hilbert spaces.

Actually, we really want to have an “extended” TQFT: a TQFT gives a Hilbert space for each 2D manifold (“space”), and a linear map for a 3D cobordism (“spacetime”) between them. An extended TQFT will assign (higher) algebraic data to lower-dimension boundaries still.  My paper talks only about the case where we’ve extended down to codimension 2, whereas FHLT talk about extending “down to a point”. The point of this first stopping point is to unpack explicitly and computationally what the factorization into two parts looks like at the first level beyond the usual TQFT.

In the terminology I use, the classical field theory is:

A^{\omega} : nCob_2 \rightarrow Span_2(Gpd)^{U(1)}

This depends on a cohomology class [\omega] \in H^3(G,U(1)). The “quantization functor” (which in this case I call “2-linearization”):

\Lambda^{U(1)} : Span_2(Gpd)^{U(1)} \rightarrow 2Vect

The middle stage involves the monoidal 2-category I call Span_2(Gpd)^{U(1)}.  (In FHLT, they use different terminology, for instance “families” rather than “spans”, but the principle is the same.)

Freed and Quinn looked at the quantization of the “extended” DW model, and got a nice geometric picture. In it, the action is understood as a section of some particular line-bundle over a moduli space. This geometric picture is very elegant once you see how it works, which I found was a little easier in light of a factorization through Span_2(Gpd).

This factorization isolates the geometry of this particular situation in the “classical field theory” – and reveals which of the features of their setup (the line bundle over a moduli space) are really part of some more universal construction.

In particular, this means laying out an explicit definition of both Span_2(Gpd)^{U(1)} and \Lambda^{U(1)}.

2-Linearization Recalled

While I’ve talked about it before, it’s worth a brief recap of how 2-linearization works with a view to what happens when you twist it via groupoid cohomology. Here we have a 2-category Span(Gpd), whose objects are groupoids (A, B, etc.), whose morphisms are spans of groupoids:

A \stackrel{s}{\leftarrow} X \stackrel{t}{\rightarrow} B

and whose 2-morphisms are spans of span-maps (taken up to isomorphism), which look like so:

span of span maps

(And, by the by: how annoying that WordPress doesn’t appear to support xypic figures…)

These form a (symmetric monoidal) 2-category, where composition of spans works by taking weak pullbacks.  Physically, the idea is that a groupoid has objects which are configurations (in the cause of gauge theory, connections on a manifold), and morphisms which are symmetries (gauge transformations, in this case).  Then a span is a groupoid of histories (connections on a cobordism, thought of as spacetime), and the maps s,t pick out its starting and ending configuration.  That is, A = A_G(S) is the groupoid of flat G-connections on a manifold S, and X = A_G(\Sigma) is the groupoid of flat G-connections on some cobordism \Sigma, of which S is part of the boundary.  So any such connection can be restricted to the boundary, and this restriction is s.

Now 2-linearization is a 2-functor:

\Lambda : Span_2(Gpd)^{U(1)} \rightarrow 2Vect

It gives a 2-vector space (a nice kind of category) for each groupoid G.  Specifically, the category of its representations, Rep(G).  Then a span turns into a functor which comes from “pulling” back along s (the restricted representation where X acts by first applying s then the representation), then “pushing” forward along t (to the induced representation).

What happens to the 2-morphisms is conceptually more complicated, but it depends on the fact that “pulling” and “pushing” are two-sided adjoints. Concretely, it ends up being described as a kind of “sum over histories” (where “histories” are the objects of Y), which turns out to be exactly the path integral that occurs in the TQFT.

Or at least, it’s the path integral when the action is trivial! That is, if S=0, so that what’s integrated over paths (“histories”) is just e^{iS}=1. So one question is: is there a way to factor things in this way if there’s a nontrivial action?

Cohomological Twisting

The answer is by twisting via cohomology. First, let’s remember what that means…

We’re talking about groupoid cohomology for some groupoid G (which you can take to be a group, if you like).  “Cochains” will measure how much some nice algebraic fact, such as being a homomorphism, or being associative, “fails to occur”.  “Twisting by a cocycle” is a controlled way to force some such failure to happen.

So, an n-cocycle is some function of n composable morphisms of G (or, if there’s only one object, “group elements”, which amounts to the same thing).  It takes values in some group of coefficients, which for us is always U(1)

The trivial case where n=0 is actually slightly subtle: a 0-cocycle is an invariant function on the objects of a groupoid. (That is, it takes the same value on any two objects related by an (iso)morphism. (Think of the object as a sequence of zero composable morphisms: it tells you where to start, but nothing else.)

The case n=1 is maybe a little more obvious. A 1-cochain f \in Z^1_{gpd}(G,U(1)) can measure how a function h on objects might fail to be a 0-cocycle. It is a U(1)-valued function of morphisms (or, if you like, group elements).  The natural condition to ask for is that it be a homomorphism:

f(g_1 \circ g_2) = f(g_1) f(g_2)

This condition means that a cochain f is a cocycle. They form an abelian group, because functions satisfying the cocycle condition are closed under pointwise multiplication in U(1). It will automatically by satisfied for a coboundary (i.e. if f comes from a function h on objects as f(g) = \delta h (g) = h(t(g)) - h(s(g))). But not every cocycle is a coboundary: the first cohomology H^1(G,U(1)) is the quotient of cocycles by coboundaries. This pattern repeats.

It’s handy to think of this condition in terms of a triangle with edges g_1, g_2, and g_1 \circ g_2.  It says that if we go from the source to the target of the sequence (g_1, g_2) with or without composing, and accumulate f-values, our f gives the same result.  Generally, a cocycle is a cochain satisfying a “coboundary” condition, which can be described in terms of an n-simplex, like this triangle. What about a 2-cocycle? This describes how composition might fail to be respected.

So, for instance, a twisted representation R of a group is not a representation in the strict sense. That would be a map into End(V), such that R(g_1) \circ R(g_2) = R(g_1 \circ g_2).  That is, the group composition rule gets taken directly to the corresponding rule for composition of endomorphisms of the vector space V.  A twisted representation \rho only satisfies this up to a phase:

\rho(g_1) \circ \rho(g_2) = \theta(g_1,g_2) \rho(g_1 \circ g_2)

where \theta : G^2 \rightarrow U(1) is a function that captures the way this “representation” fails to respect composition.  Still, we want some nice properties: \theta is a “cocycle” exactly when this twisting still makes \rho respect the associative law:

\rho(g_1) \rho( g_2 \circ g_3) = \rho( g_1 \circ g_2) \circ \rho( g_3)

Working out what this says in terms of \theta, the cocycle condition says that for any composable triple (g_1, g_2, g_3) we have:

\theta( g_1, g_2 \circ g_3) \theta (g_2,g_3) = \theta(g_1,g_2) \theta(g_1 \circ g_2, g_3)

So H^2_{grp}(G,U(1)) – the second group-cohomology group of G – consists of exactly these \theta which satisfy this condition, which ensures we have associativity.

Given one of these \theta maps, we get a category Rep^{\theta}(G) of all the \theta-twisted representations of G. It behaves just like an ordinary representation category… because in fact it is one! It’s the category of representations of a twisted version of the group algebra of G, called C^{\theta}(G). The point is, we can use \theta to twist the convolution product for functions on G, and this is still an associative algebra just because \theta satisfies the cocycle condition.

The pattern continues: a 3-cocycle captures how some function of 2 variable may fail to be associative: it specifies an associator map (a function of three variables), which has to satisfy some conditions for any four composable morphisms. A 4-cocycle captures how a map might fail to satisfy this condition, and so on. At each stage, the cocycle condition is automatically satisfied by coboundaries. Cohomology classes are elements of the quotient of cocycles by coboundaries.

So the idea of “twisted 2-linearization” is that we use this sort of data to change 2-linearization.

Twisted 2-Linearization

The idea behind the 2-category Span(Gpd)^{U(1)} is that it contains Span(Gpd), but that objects and morphisms also carry information about how to “twist” when applying the 2-linearization \Lambda.  So in particular, what we have is a (symmetric monoidal) 2-category where:

  • Objects consist of (A, \theta), where A is a groupoid and $\theta \in Z^2(A,U(1))$
  • Morphisms from A to B consist of a span (X,s,t) from A to B, together with \alpha \in Z^1(X,U(1))
  • 2-Morphisms from X_1 to X_2 consist of a span (Y,\sigma,\tau) from X, together with \beta \in Z^0(Y,U(1))

The cocycles have to satisfy some compatibility conditions (essentially, pullbacks of the cocycles from the source and target of a span should land in the same cohomology class).  One way to see the point of this requirement is to make twisted 2-linearization well-defined.

One can extend the monoidal structure and composition rules to objects with cocycles without too much trouble so that Span(Gpd) is a subcategory of Span(Gpd)^{U(1)}. The 2-linearization functor extends to \Lambda^{U(1)} : Span(Gpd)^{U(1)} \rightarrow 2Vect:

  • On Objects: \Lambda^{U(1)} (A, \theta) = Rep^{\theta}(A), the category of \theta-twisted representation of A
  • On Morphisms: \Lambda^{U(1)} ( (X,s,t) , \alpha ) comes by pulling back a twisted representation in Rep^{\theta_A}(A) to one in Rep^{s^{\ast}\theta_A}(X), pulling it through the algebra map “multiplication by \alpha“, and pushing forward to Rep^{\theta_B}(B)
  • On 2-Morphisms: For a span of span maps, one uses the usual formula (see the paper for details), but a sum over the objects y \in Y picks up a weight of \beta(y) at each object

When the cocycles are trivial (evaluate to 1 always), we get back the 2-linearization we had before. Now the main point here is that the “sum over histories” that appears in the 2-morphisms now carries a weight.

So the twisted form of 2-linearization uses the same “pull-push” ideas as 2-linearization, but applied now to twisted representations. This twisting (at the object level) uses a 2-cocycle. At the morphism level, we have a “twist” between “pull” and “push” in constructing . What the “twist” actually means depends on which cohomology degree we’re in – in other words, whether it’s applied to objects, morphisms, or 2-morphisms.

The “twisting” by a 0-cocycle just means having a weight for each object – in other words, for each “history”, or connection on spacetime, in a big sum over histories. Physically, the 0-cocycle is playing the role of the Lagrangian functional for the DW model. Part of the point in the FHLT program can be expressed by saying that what Freed and Quinn are doing is showing how the other cocycles are also the Lagrangian – as it’s seen at higher codimension in the more “local” theory.

For a TQFT, the 1-cocycles associated to morphisms describe how to glue together values for the Lagrangian that are associated to histories that live on different parts of spacetime: the action isn’t just a number. It is a number only “locally”, and when we compose 2-morphisms, the 0-cocycle on the composite picks up a factor from the 1-morphism (or 0-morphism, for a horizontal composite) where they’re composed.

This has to do with the fact that connections on bits of spacetime can be glued by particular gauge transformations – that is, morphisms of the groupoid of connections. Just as the gauge transformations tell how to glue connections, the cocycles associated to them tell how to glue the actions. This is how the cohomological twisting captures the geometric insight that the action is a section of a line bundle – not just a function, which is a section of a trivial bundle – over the moduli space of histories.

So this explains how these cocycles can all be seen as parts of the Lagrangian when we quantize: they explain how to glue actions together before using them in a sum-over histories. Gluing them this way is essential to make sure that \Lambda^{U(1)} is actually a functor. But if we’re really going to see all the cocycles as aspects of “the action”, then what is the action really? Where do they come from, that they’re all slices of this bigger thing?

Twisting as Lagrangian

Now the DW model is a 3D theory, whose action is specified by a group-cohomology class [\omega] \in H^3_{grp}(G,U(1)). But this is the same thing as a class in the cohomology of the classifying space: [\omega] \in H^3(BG,U(1)). This takes a little unpacking, but certainly it’s helpful to understand that what cohomology classes actually classify are… gerbes. So another way to put a key idea of the FHLT paper, as Urs Schreiber put it to me a while ago, is that “the action is a gerbe on the classifying space for fields“.

What does this mean?

This map is given as a path integral over all connections on the space(-time) S, which is actually just a sum, since the gauge group is finite and so all the connections are flat.  The point is that they’re described by assigning group elements to loops in S:

A : \pi_1(M) \rightarrow G

But this amounts to the same thing as a map into the classifying space of G:

f_A : M \rightarrow BG

This is essentially the definition of BG, and it implies various things, such as the fact that BG is a space whose fundamental group is G, and has all other homotopy groups trivial. That is, BG is the Eilenberg-MacLane space K(G,1). But the point is that the groupoid of connections and gauge transformations on S just corresponds to the mapping space Maps(S,BG). So the groupoid cohomology classes we get amount to the same thing as cohomology classes on this space. If we’re given [\omega] \in H^3(BG,U(1)), then we can get at these by “transgression” – which is very nicely explained in a paper by Simon Willerton.

The essential idea is that a 3-cocycle \omega (representing the class [\omega]) amounts to a nice 3-form on BG which we can integrate over a 3-dimentional submanifold to get a number. For a d-dimensional S, we get such a 3-manifold from a (3-d)-dimensional submanifold of Maps(S,BG): each point gives a copy of S in BG. Then we get a (3-d)-cocycle on Maps(S,BG) whose values come from integrating \omega over this image. Here’s a picture I used to illustrate this in my talk:

Now, it turns out that this gives 2-cocycles for 1-manifolds (the objects of 3Cob_2, 1-cocycles on 2D cobordisms between them, and 0-cocycles on 3D cobordisms between these cobordisms. The cocycles are for the groupoid of connections and gauge transformations in each case. In fact, because of Stokes’ theorem in BG, these have to satisfy all the conditions that make them into objects, morphisms, and 2-morphisms of Span^{U(1)}(Gpd). This is the geometric content of the Lagrangian: all the cocycles are really “reflections” of \omega as seen by transgression: pulling back along the evaluation map ev from the picture. Then the way you use it in the quantization is described exactly by \Lambda^{U(1)}.

What I like about this is that \Lambda^{U(1)} is a fairly universal sort of thing – so while this example gets its cocycles from the nice geometry of BG which Freed and Quinn talk about, the insight that an action is a section of a (twisted) line bundle, that actions can be glued together in particular ways, and so on… These presumably can be moved to other contexts.

About these ads