Physics Stack Exchange is a question and answer site for active researchers, academics and students of physics. It's 100% free.

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

My question is to do with lattice QCD. In the lattice action there is a parameter, 'a', the lattice spacing in physical units.

However, if we want to generate a configuration with a certain lattice spacing, we don't just set a=some number. We take the roundabout route of setting some dimensionless parameters (with some dependence on 'a') equal to some value and then extracting what 'a' must have been afterwards.

My question is why do we have to do this? Why can't I just go into the code and set a=something and simulate? I know that for other computational problems it makes sense to only simulate dimensionless quantities, but the reasons for this are to do with stability and reducing the computational time.

share|cite|improve this question
up vote 3 down vote accepted

The reason is that changes in the scale a and changes in the coupling g can compensate for each other. Two simulations, one with a small lattice spacing a and gauge couling g and another with an even smaller lattice spacing a' and coupling g' give the same results at long distances when g' is adjusted properly. This is the statemen that the theory is renormalizble, so that you can take the limit a goes to zero, g' changes correspondingly, and extract a good limit. Further, as the lattice spacing a' gets smaller, to keep the physics the same, g' gets weaker. This is the statement that QCD is asymptotically free (free at short distances).

But the dependence of g on a for not-so-small lattices is annoying to calculate, because it only is simple in covariant regulators, and the log-running means it is never that small at any reasonable scale. So instead of fixing a and calculating what g should be, you use the known existence of the scaling continuum limit to fix your physics. So you just set your length scale to make a=1 and you adjust g to be approximately .5 (this makes ${g^2\over 2\pi} = .04$, and this is the perturbative parameter), and then you look to see if the gauge field randomizes over your box with this choice.

If you make g too small, the gauge field will be nearly constant in the box, if you make g too big, the typical gauge field configuration will be random from point to point, with a large SU(3) matrix for plaquettes. You want to make sure that your g is in the good spot so that the box is not too small to see the long-distance randomness, and not too big to make the lattice coarse to see the interior structure of a hadron bag.

Because the choice of g and a are intertwined in a nontrivial way, it is best to fix the simulation parameters by using the output masses. The dependence of g and a cannot be extracted from traditional dimensional analysis, because it is logarithmic in a. Classically, g is independent of a.

share|cite|improve this answer

I'll try to explain what is meant by "putting $a = 1$".

You always simulate a finite volume $V = L^D$, where $L$ is usually of the order of a few particle radii. Let's say you choose $L = 10^{-10} \text{ m}.$ You then choose how fine or coarse your lattice will be. For example, you could take $N = 100$ points in $L$, such that $a = L/N = 10^{-12} \text{ m},$ and your lattice sites are at $$x = 0,a,\ldots,(N-1)a = L-a.$$

The process you're looking at will have some (physical) length scale $\xi = \mathcal{O}(L)$. We already introduced $a$ and $L$, so in total we have three length scales. By the Buckingham Pi theorem, only two meaningful dimensionless quantities remain, which can be choosen to be $\xi/a =: \hat{\xi}$ and $L/a =: \hat{L}$, which both are real numbers. All lengths are thus rescaled through $l \mapsto l/a =: \hat{l}.$ This rescaling is known as passing from physical units to (dimensionless) lattice units. Now, the lattice sites are at

$$\hat{x} = 0,1,...,N-1 = \hat{L}-1.$$

In your simulation you find a (dimensionless) value for $\hat{\xi}$, which can be converted back to a physical length $\xi$.

As you've understood above, the parameter $a$ doesn't appear in your program at all; you only need it to define where your lattice sites are, which you scale away by passing to lattice units. Afterwards, you can however always convert dimensionless numbers back to physical lengths.

Another way to look at things: computers only work with dimensionless numbers. You can only feed real (floating point) numbers to your simulation. This rules out explicitly using physical quantities. In a way, simulation some physics means that you've already used the Pi theorem in order to eliminate all dimensionful quantities.

share|cite|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.