manobes

I’m much more enamoured of blogger, so I’m moving operations over there. I’m now at

http://latticeqcd.blogspot.com

See you there, where I’ll continue the discussion of modern lattice QCD

One of the most interesting calculations in Lattice QCD is the determination of the strong coupling constant. This calculation also nicely demonstrates the need for perturbation theory in lattice QCD in a context outside of improving actions, which I talked about previous postings.

Okay, so what do we want to do? Well, we want to determine the strong coupling constant \alpha renormalized in the MS-bar scheme and at the scale set by the Z mass (M_Z ~ 90 GeV). So we fire up our computers, and get to work. The first thing we want to do is a non-perturbative simulation of QCD, using lattice Monte-Carlo methods. In order to do this, we need to tune 5 input parameters in our simulation.

1) The light quark mass (we take the up and down quarks to have the same mass

2) The strange quark mass

3) The charm quark mass

4) The bottom quark mass

5) The lattice spacing

To do this we proceed in exactly the same way as any other field theory. We pick 5 measurements, and tune our inputs (the “bare” quantities) until the 5 results we get agree with the 5 measurements. In our case, we’ll use the pion mass to fix the light quark mass and the K mass for the strange. For the other three we use some combination of spin splittings in heavy quark bound states. We don’t use meson masses, as they are more sensitive to lattice errors. The important point here is that we have 5 measured quantities, and we tune the inputs to agree with them. After that, no other input from experiment is needed. That is, this is a first principles QCD calculation.

With our parameters tuned, we run the simulation, go away for some period of time (a long time if we are using dynamical fermions), and finally get our result. The result of a Monte-Carlo simulation is a set of gauge fields {A} which we can measure quantities. There are lots of quantities we can measure, for example, the self energy of a static quark, sitting at the spatial origin boils down to computing

U(x=0,t=0)U(0,1)U(0,2)...U(0,L)

where

U = exp(iA)

and L is the length of the lattice. Obviously if we had a bunch of different sets of gauge fields we could average over them. It’s this average which would be the result we want. The more sets of gauge fields we have the more accurate our results.

Now the static quark self energy is interesting, but it is not quite what we want to measure for our purposes. What we want to do is measure some short distance quantity. Why? Well, recall that QCD is perturbative at short distances, so if we measure a short distance quantity *and* have a perturbative expansion for it, we can solve for the coupling. At one loop it looks like this: we measure the average <Om> on the lattice, then we compute in perturbation theory <O> = 1 + \alpha O1 + ... Set them equal, and solve

\alpha = [<Om> - 1 ] / O1

We have now determined the strong coupling on the lattice!

In practice, the short distance quantity of choice has been the average plaquette, which is the product of gauge fields on a 1x1 square on the lattice. Often one also uses large squares and rectangles in order to get a few different determinations, as a check. As well, one loop is not enough, you need at least second order calculations. My supervisor Howard Trottier, and a colleague Quentin Mason, have calculated these short distance quantities out to three loops, which greatly improves the accuracy.

We now have in hand a value for the strong coupling. The value we have depends on what we used in our perturbative expansion. Normally, one uses a definition based on the perturbative expression for the static quark potential (this will be the subject of another posting). The coupling has been evaluated at a scale that is close to the lattice cutoff pi/a but not quite. We’ll call that scale q* (more about this in a later posting as well, for now, think of q* as being within 10% of pi/a). So what we have extracted is

\alpha_{V}(q*)

and what we want is \alpha_{MS-bar}(M_Z).

We go from point a to point b in two steps. First we convert
\alpha_{V}(q*) to \alpha_{MS-bar}(q*), then we run that number up to M_Z using the known three loop running. The latter step is well known (and not lattice specific) so I’ll just say how to do the former.

To convert from \alpha_{V} to \alpha_{MS-bar} means computing some quantity perturbativly in both schemes, and matching them. In practice, the quantity that is used is the two point function for background field gluons. This quantity is used because the combination of the background field and the coupling is not renormalized. So you can compute this in the MS-bar scheme and with a lattice regulator, and equate the two, solving for \alpha_{V} as a series in \alpha_{MS-bar}.

And that’s how it’s done! The results are pretty good, using a modern, unquenched simulation, a preliminary number is

\alpha_{MS-bar}(M_Z) = 0.1181(15)

which agrees with, and has lower errors than, the PDG average.

Well, I cleaned up the old entries, which were mostly test messages. From here out I hope to post more substantive stuff, preferably daily. Later today, I’ll write up an outline of one of the mose interesting calculations in Lattice QCD, the determination of the strong coupling constant.

The lack of equation support will likly shine through on this post. Someday, when I get the time, I’ll move to Moveable Type with Jacques’s mathML support. Of course, I’ll never really have the time :)

Well, the whole “work” thing is not really going well today, so I guess I’ll continue my little story.

Recall that we were worried about finite spacing errors in lattice field theory. As an example we were using a scalar field coupled to gluons. The basic action was

\phi D^{2} \phi

and this has a^2 errors. I said that we could use

\phi (D^2 + C a^2 D^4) \phi

to reduce these errors. Clearly this involves picking some value for C, but how do we do that?

It pays to remember what the lattice is doing for us. It’s cutting the theory off at the small distance a, or in momentum space at high energy/momentum. So the spacing errors are reflecting a problem with the high energy (short distance) part of the theory. Now way back at the start of the first post we noted that QCD is perturbative at high energy. So we ought to be able to correct for the spacing errors perturbativly, by matching our lattice theory to the continuum theory to some order in perturbation theory. We pick some scattering amplitude, and fiddle with C, order by order. Done properly, this lowers the spacing errors, at a modest performance cost.

That’s where I come it. The trouble is doing perturbation theory on a lattice is rather hard. The vertex rules in lattice gauge theory are miserably complicated, so even *deriving* them is hard. Then you have to compute something, which is hard because the lattice cutoff violates Poincare symmetry, so you can’t use all the textbook tricks.

Our group is developing tools to do these calculations to one, two and (for a special operator) three loop order. It’s a daunting task, my rule of thumb is that lattice perturbation theory is “one-loop” more complicated than continuum. That is a two loop lattice calculation is roughly as much effort as a three loop continuum one. One reason for this is that the toolkit for continuum perturbation theory has a lot more tools in it.

These calculations are absolutely crucial for getting high precision results from lattice simulations. The reason is the coupling constant is around 0.2 at current lattice spacings. So a one loop calculation corrects a 20% error, and a two loop calculation corrects a 4% error. If you want to produce 5% accurate results, you must have two loop perturbation theory.

Well, I’ve been mentioned by Jacques Distler (http://golem.ph.utexas.edu/~distler/blog/archives/000452.html), so in the Physics blog world that means I’ve hit the big time. In celebration, I suppose I ought to say something about my current work, and the state of the art in Lattice QCD in general.

QCD is the theory of quark-gluon interactions. It ought to be able to provide precise answers to questions in hadron physics (like “what is the mass of the proton”). There is a significant snag though, related to this years Nobel prize. Politzer, Gross and Wilczek showed that at high energies (or momentum transfers) QCD is perturbative. And the higher the energy, the more perturbative it gets. This is a happy fact, since you can use perturbative QCD to make predictions as to what you ought to see in high energy collisions. The unfortunate flipside is that at low energy QCD is strongly coupled, and you cannot use perturbation theory. As a result, we know a lot more about something obscure like the parton distribution functions at high energy (measured very precisely at HERA) then we do about the classic problems in hadron physics (like the aforementioned mass of the proton).

Without perturbation theory, it is difficult to work with QCD. It’s fairly straightforward to show that in the limit of vanishing u and d quark mass, you can recover the old current algebra framework. So all those results remain valid. You can develop effective field theory descriptions in certain limits (Chiral perturbation theory, heavy quark effective theory) but these have low energy bits that must be either fixed by experiments, or matched to a QCD calculation. In practice, the only first principles way to compute general things in low energy QCD is Lattice QCD.

Lattice QCD was invented in the mid-seventies by Kenneth Wilson. He was thinking about quantum field theory in general and decided that to understand it better it would be helpful to have a formulation of it that could be put on a computer. What he did was take infinite continuous spacetime and approximate it by a hypercubic grid with volume L^4 and grid spacing a. Remarkably he found a way to preserve the exact local gauge invariance in this approximation. Up to some troubles with the quarks (more about that below) he found that he could write down an action that describes QCD in the naive limit a->0 and L->Infinity.

With the problem discretized it was now amenable to solution on a computer, just as Wilson planned. However it quickly became apparent that the numerical cost of this method was huge. Working on very expensive supercomputers in the early 80s the first lattice gauge theorists were able to derive some interesting results, but precision QCD predictions remained out of reach.

There are a number of reasons for the failure to get high precision results. The most important one is the difficulties with Fermions. There are actually two difficulties in simulating fermions on a computer. The first is something known as the doubling problem. Basically if you start with the Dirac action describing a quark, and naively discretize it, you end up introducing a 16fold symmetry, which produces 16 degenerate types of quarks (these are called (unfortunately) tastes of quark). This is a disaster, since you only want 1 “taste” of quark.

There are three general ways around this problem. The first solution was proposed by Wilson. He added an extra term to the fermion action, which vanishes in the continuum (a->0) limit but lifted the degeneracy of the quarks. In the continuum only one taste has a small mass, the others acquire a mass M/a, and so decouple as a goes to zero. Another solution to this problem, proposed by Kogut and Susskind is to spin-diagonalize the Dirac action. Doing this reduces the 16 tastes to 4, so you’ve gained a bit. A further theoretical trick can reduce the number of tastes to one. The final method, called overlap, is to construct a much more complicated operator to approximate the fermions.

Each of these methods suffers from some set of problems, and each has its own advantages. Before discussing them I’ll mention the second problem with simulating fermions: It’s extremely slow. The problem is that one cannot represent anticommuting numbers in a computer. Fortunately most fermion actions have the form

\bar{\psi} M[A] \psi

Where M[A] is some functional of the gauge fields. Actions of this form can be exactly path-integrated, you just get

det(M[A]).

Simple, no? All you have to do is calculate the determinant at each step, and you’re good to go. Alas, that’s numerically very (very very very ...) expensive. It involves inverting the matrix M, which is large and sparse. So you need supercomputers to do it. This problem was so intensive that until very recently (late 90s) most people would just set det(M[A]) =1. This amounts to neglecting dynamical fermions in your calculation and is known as the quenched approximation.

With the quenched approximation going away the strengths and weaknesses of the various fermion actions really show. For example, the Wilson approach suffers from a problem known as exceptional configurations. These occur when the matrix M acquires a very small eigenvalue. The overlap fermions, while theoretically very nice, are many times (hundreds) slower than any other approach. The fastest option is the Kogut-Susskind one. Since we’ve spin diagonalized the problem, it’s automatically 4 times faster than the others, and because of the problems with the other two approaches, it ends up being 50 or more times faster than the Wilson approach. The problem is the “theoretical trick” I mentioned above. Recall that the KS approach reduced the number of tastes from 16 to 4. To get down to 1 you take the 4th root of the determinant in your numerical simulations. This is not a well defined procedure, though in works in several limits (free field, weak coupling, chiral). Despite this problem, the most accurate lattice results to date have been generated using these KS fermions.

Where do I come in? Well, the problems with fermions are only the beginning of the difficulties with lattice QCD. Another substantial problem is the errors induced by finite lattice spacing. The difficultly here is that reducing the lattice spacing in numerical simulations is very expensive (everything in this game is very expensive). This means that brute force reducing your spacing from current values (around 0.1 fm) to values where the naive finite spacing errors would be around 1% (roughly a=0.005fm) would take another 10 years. If we want timely results, this will not do.

There is a better way of compensating for this problem, proposed by Symanzik. A simple example is provided by the finite difference approximation to the ordinary derivate. I could write

df/dx ~ 1/a [f(x a) - f(a)]

which has linear errors in a. Alternatively, and for almost no extra cost, I could use

df/dx ~ 1/(2a) [f(x a) - f(x-a)]

which has quadratic errors in a. If my problem scaled poorly with a, I would be foolish not to use the latter approximation.

Symanzik’s idea for lattice theories is similar. Say I have an action for a scalar field

\phi D^2 \phi

where D^2 is some lattice laplacian operator. This action has a^2 errors. I can make them a^4 by using the action

\phi (D^2 C a^2 D^4) \phi.

In this action C is a constant, which we need to determine. How do we do that?

Well, I’ll tell you how we do that, but later :) This post is getting long, so I’ll pick it up later today, or tomorrow...