Particle Mass from Two-Point Correlation

Hello! Welcome back to our journey into Quantum Field Theory.

In our last session, we developed the computational engine for our lattice QFT simulations: the Metropolis-Hastings algorithm. You learned how to generate a Markov chain of field configurations ${ϕ_{i}}$ that are distributed according to the Boltzmann weight $e^{- S_{L} [ϕ]}$ , effectively creating a representative statistical ensemble of the quantum vacuum.

Today, we will use that ensemble to do physics. Our goal is to compute the two-point correlation function from the generated lattice configurations and extract the particle mass from its exponential decay. This is a monumental step, as it marks our first non-perturbative calculation of a physical, measurable property of a particle from first principles.

1. The Two-Point Correlation Function and Particle Mass

First, let's establish the crucial link between a correlation function and a particle's mass. In canonical quantization, the two-point correlation function, or propagator, describes the amplitude for a particle to travel from one spacetime point to another. In Euclidean spacetime (after a Wick rotation, $t \to - i τ$ ), this function has a particularly revealing structure.

7. Lattice field theory — Monte Carlo Techniques

The resource '7. Lattice field theory — Monte Carlo Techniques' provides a clear derivation of the Euclidean two-point function's structure. It starts from the quantum mechanical case, which provides a solid foundation.

Please read the subsections '7.1.1. Correlation functions' and '7.1.2. Wick rotation'. Focus on Equation (7.1) and the paragraph following the Wick rotation. These show that the Euclidean two-point function is a sum of decaying exponentials, where the decay rates are the energy levels of the system.

As the reading explains, by inserting a complete set of energy eigenstates $∣ n ⟩$ with energies $E_{n}$ , the two-point function in Euclidean time $τ$ can be written as:

⟨ ϕ (τ) ϕ (0)⟩ = n \sum ∣ ⟨ 0∣ ϕ^(0) ∣ n ⟩ ∣^{2} e^{- E_{n} τ}

Here, $∣0 ⟩$ is the vacuum state (which we assume has $E_{0} = 0$ ). The states $∣ n ⟩$ are the excited states of the theory. The lowest-energy excitation above the vacuum is a single-particle state. For a particle at rest (zero momentum), its energy is simply its mass, $E_{1} = m$ .

For large time separations $τ$ , the exponential term with the smallest non-zero energy $E_{1} = m$ will dominate the sum:

⟨ ϕ (τ) ϕ (0)⟩ \approx ∣ ⟨ 0∣ ϕ^(0) ∣1 ⟩ ∣^{2} e^{- m τ} (for large τ)

This is the central result: the two-point correlation function decays exponentially with a rate given by the mass of the lightest particle in the theory. Our task is to measure this decay rate on the lattice.

On the lattice, we typically compute the correlator projected to zero momentum to isolate the rest mass. This is done by averaging the field over all spatial sites at a given time slice. The discrete version of the correlator at a time separation of $n_{t}$ lattice units is:

C (n_{t}) = ⟨ (\frac{1}{L ^{3}} n \sum ϕ (n, n_{t})) ϕ (0, 0) ⟩

Due to translational invariance, this simplifies to an average over all starting points:

C (n_{t}) = \frac{1}{L ^{3}} n \sum ⟨ ϕ (n, n_{t}) ϕ (0, 0)⟩

This quantity is expected to behave as $C (n_{t}) \propto e^{- m \cdot n_{t}}$ for large $n_{t}$ , where $m$ is now the dimensionless mass in lattice units.

2. From Configurations to Correlators

In our simulation, the expectation value $⟨ \dots ⟩$ is replaced by an average over the $M$ configurations generated by our Metropolis algorithm (after thermalization and decorrelation):

C (n_{t}) \approx \frac{1}{M} i = 1 \sum M C^{(i)} (n_{t})

where $C^{(i)} (n_{t})$ is the correlator calculated on a single configuration $ϕ^{(i)}$ . To improve statistics, we can average over all possible starting points $(m, m_{t})$ within that single configuration:

C^{(i)} (n_{t}) = \frac{1}{L ^{4}} m_{x}, m_{y}, m_{z}, m_{t} \sum ϕ^{(i)} (m, m_{t}) \cdot ϕ^{(i)} (m, m_{t} + n_{t})

(All spatial indices are modulo $L$ , and time indices are modulo $T$ , leveraging the periodic boundary conditions).

A practical implementation of this averaging is shown in the harmonic oscillator example from the resource LINK.

7. Lattice field theory — Monte Carlo Techniques

Let's examine a concrete implementation. The resource '7. Lattice field theory — Monte Carlo Techniques' includes Python code for a 1D harmonic oscillator. The function two_point_function demonstrates exactly how to average over an ensemble of states to get the final correlator.

Focus on the Python code block in section '7.1.3. Example: Simple harmonic oscillator in imaginary time'. Analyze the two_point_function(states) function. It takes a list of states (our configurations) and computes the correlator for each time separation t by averaging states * np.roll(states,t,axis=1). This roll operation efficiently implements the correlation calculation using periodic boundaries. The final plot shows the resulting exponential decay.

3. Extracting the Mass from Correlator Data

Once we have computed the array of correlator values $C (n_{t})$ , how do we extract the mass $m$ ? There are two common methods.

Lattice Field Theory: An Undergraduate Introduction

The textbook 'Lattice Field Theory: An Undergraduate Introduction' by Leon Hostetler provides an excellent, practical guide to this process, which it calls 'Lattice Spectroscopy'.

Please read Section 6.2, 'Lattice Spectroscopy' (pages 25-28). This section is the core of today's lesson. Pay close attention to: The '1-mass fit' (Eq. 3 and Fig. 16): This is a direct non-linear fit of the correlator to an exponential function A*exp(-m*z). The 'ratio fit' (Eq. 4 and Fig. 17): This involves computing what is known as the effective mass. The discussion on why initial and final points of the correlator data are often excluded from the fit.

Let's summarize the key technique from the reading: the effective mass plot.

For a pure exponential decay $C (n_{t}) = A e^{- m n_{t}}$ , the ratio of successive points is constant:

\frac{C ( n _{t} )}{C ( n _{t} + 1 )} = \frac{A e ^{- m n_{t}}}{A e ^{- m (n_{t} + 1)}} = e^{m}

Taking the natural logarithm gives us the mass. We can define the effective mass $m_{e f f}$ at each time separation $n_{t}$ as:

m_{e f f} (n_{t}) = ln (\frac{C ( n _{t} )}{C ( n _{t} + 1 )})

Why is this so useful?

For small $n_{t}$ , higher energy states $e^{- E_{k} n_{t}}$ contribute to $C (n_{t})$ , so $m_{e f f} (n_{t})$ will be larger than the true ground-state mass $m$ and will vary with $n_{t}$ .
For large $n_{t}$ , the correlator is dominated by the ground state, so the effective mass $m_{e f f} (n_{t})$ will approach a constant value: the true mass $m$ . This constant region is called the effective mass plateau.
For very large $n_{t}$ , the correlator becomes dominated by statistical noise, and the effective mass plot will look erratic.

Our job is to plot $m_{e f f} (n_{t})$ versus $n_{t}$ , identify the stable plateau region, and extract the mass by fitting a constant value to that plateau.

This is an example of an effective mass plot, taken from the Hostetler resource. The y-axis is the effective mass $m (z)$ and the x-axis is the time separation $z$ . You can clearly see the initial drop-off due to excited states, a stable 'plateau' region in the middle, and then the onset of noise. The mass is estimated from the value of this plateau.

Test your understanding!

Suppose you perform a lattice simulation and compute the effective mass plot. You observe a clear plateau, from which you extract a mass $m = 0.25$ . What does this value represent physically? Is it in units of GeV?

Show answer

The value $m = 0.25$ is a dimensionless quantity. It represents the particle's mass in lattice units, i.e., $m_{p h y s} \cdot a$ , where $a$ is the lattice spacing. To convert this to physical units like GeV, one must perform a scale-setting procedure. This typically involves calculating another physical observable on the same lattice (e.g., the string tension or the mass of another known particle like the rho meson in QCD) and using its experimental value to determine the value of $a$ in physical units (e.g., fm or GeV $^{- 1}$ ).

4. A Practical Implementation

Let's outline how you would add this analysis to the simulation code from our last lesson. You have already implemented the Metropolis algorithm to generate configurations. Now, you need to add the measurement part.

Here is a Python function to compute the effective mass, which you can add to your code. It assumes you have already run your simulation and stored the decorrelated configurations in a NumPy array called configurations of shape (M, L, L, L, T), where M is the number of configurations.

import numpy as np

def calculate_effective_mass(configurations):
    """
    Calculates the zero-momentum two-point correlator and effective mass.

    Args:
        configurations (np.array): An array of field configurations with shape 
                                  (num_configs, L, L, L, T).

    Returns:
        tuple: (correlator, effective_mass)
    """
    num_configs, L, _, _, T = configurations.shape
    
    # We will compute the correlator for time separations up to T/2
    # to avoid wrap-around effects from the periodic boundary.
    max_nt = T // 2
    
    # Array to store the correlator, averaged over all configs
    avg_corr = np.zeros(max_nt)
    
    # Fourier transform over spatial dimensions for zero-momentum projection
    # We do this for all configurations at once for efficiency.
    # phi_p0 is shape (num_configs, T)
    phi_p0 = np.mean(configurations, axis=(1, 2, 3))
    
    for i in range(num_configs):
        # The correlator for a single configuration
        # using all possible starting time slices t0
        corr_single_config = np.zeros(max_nt)
        for nt in range(max_nt):
            # C(nt) = <phi(t0+nt) * phi(t0)>
            # Average over all possible t0
            rolled_phi = np.roll(phi_p0[i], -nt)
            corr_single_config[nt] = np.mean(phi_p0[i] * rolled_phi)
        
        avg_corr += corr_single_config

    avg_corr /= num_configs
    
    # Calculate effective mass from the averaged correlator
    # We avoid log(0) or division by zero
    # Ensure correlator is positive before taking the log
    # This might require checking your parameters if it is not
    effective_mass = np.zeros(max_nt - 1)
    for nt in range(max_nt - 1):
        if avg_corr[nt] > 0 and avg_corr[nt+1] > 0:
            ratio = avg_corr[nt] / avg_corr[nt+1]
            if ratio > 0:
                 effective_mass[nt] = np.log(ratio)

    return avg_corr, effective_mass

# --- You would call this after your simulation ---
# correlator, eff_mass = calculate_effective_mass(stored_configs)

# And then plot it
# import matplotlib.pyplot as plt
# plt.figure()
# plt.plot(range(len(eff_mass)), eff_mass, 'o-')
# plt.xlabel("Time separation (n_t)")
# plt.ylabel("Effective Mass (lattice units)")
# plt.grid(True)
# plt.show()

This code precisely follows the logic we've discussed:

It performs a zero-momentum projection by averaging over spatial dimensions.
It calculates the correlation function $C (n_{t})$ for each configuration, averaging over all time origins $t_{0}$ .
It averages these correlators over the entire ensemble of configurations.
Finally, it computes and returns the effective mass array.

Conclusion

Today, we have connected our simulation framework to physical reality. You've learned how the exponential decay of the Euclidean two-point correlation function reveals the mass of the lightest particle in a theory.

Key Takeaways:

The Euclidean two-point correlator has a spectral decomposition $\sum_{n} c_{n} e^{- E_{n} τ}$ .
For large time separations, this correlator is dominated by the lightest particle mass: $C (n_{t}) \sim e^{- m n_{t}}$ .
In a lattice simulation, we compute $C (n_{t})$ by averaging correlation measurements over an ensemble of field configurations.
The effective mass, $m_{e f f} (n_{t}) = ln (C (n_{t}) / C (n_{t} + 1))$ , is a powerful tool that should plateau to the ground state mass $m$ for intermediate time separations.
By identifying and fitting this plateau, we can perform a non-perturbative calculation of the particle's mass.

Preview of the Next Lesson:

We have now established a complete pipeline for studying scalar field theory on the lattice. The next step in our journey is to move from scalar fields to more realistic theories, like QED. This requires us to understand how to formulate gauge theories on a lattice. In the next lesson, we will learn how to discretize a U(1) gauge theory on the lattice by defining link variables and the Wilson plaquette action, which is the key to preserving gauge invariance in a discrete spacetime.

Recommended resources

1. The Two-Point Correlation Function and Particle Mass

2. From Configurations to Correlators

3. Extracting the Mass from Correlator Data

4. A Practical Implementation

Conclusion