Metropolis-Hastings for Lattice Scalar Fields

1. The Monte Carlo Approach: Importance Sampling

The fundamental idea behind using Monte Carlo methods here is importance sampling. Instead of trying to sample the vast space of all possible field configurations uniformly, we want to generate a sequence of configurations $\{{\varphi }_1,{\varphi }_2,\dots ,{\varphi }_M\}$ that are already distributed according to the probability measure $P(\varphi )\propto e^{-S_L[\varphi ]}$.

This means that configurations with a small action (large Boltzmann weight) will appear more frequently in our sequence. If we succeed in generating such a sequence, the expectation value of any observable $O[\varphi ]$ can be approximated by a simple arithmetic mean:

This transforms a difficult integration problem into a much simpler averaging problem. The challenge now becomes: how do we generate this special sequence of configurations? This is where the Metropolis-Hastings algorithm comes in.

2. The Metropolis-Hastings Algorithm

The Metropolis-Hastings algorithm is a Markov Chain Monte Carlo (MCMC) method. It constructs a Markov chain of states (in our case, field configurations) whose stationary distribution is precisely the target distribution $P(\varphi )\propto e^{-S_L[\varphi ]}$ we want to sample.

To build our intuition for how this works, let's watch a video that explains the general algorithm.

Let's summarize the algorithm based on the video, adapting the notation to our physics context. We want to generate a sequence of field configurations ${\varphi }_i$. Given a configuration ${\varphi }_{old}$, we generate the next one, ${\varphi }_{next}$, as follows:

1. Propose: Generate a candidate configuration ${\varphi }_{cand}$ from a proposal distribution $g({\varphi }_{cand}|{\varphi }_{old})$. For lattice field theory, a simple and common choice is a local update:

   • Pick a single lattice site $n$ at random.
   • Propose a new field value at that site: ${\varphi }_{cand}(n)={\varphi }_{old}(n)+\delta$, where $\delta$ is a random number drawn from a symmetric interval, e.g., $[-ϵ,ϵ]$.
   • For all other sites $m\ne n$, ${\varphi }_{cand}(m)={\varphi }_{old}(m)$.
     This proposal is symmetric: the probability of proposing a move from ${\varphi }_A$ to ${\varphi }_B$ is the same as from ${\varphi }_B$ to ${\varphi }_A$. This simplifies the algorithm to the "Metropolis" case, as mentioned in the video.

2. Accept/Reject: Calculate the change in the action, $\Delta S=S_L[{\varphi }_{cand}]-S_L[{\varphi }_{old}]$. The acceptance probability is:

   $$A({\varphi }_{old}\to {\varphi }_{cand})=\min \left(1,\frac{e^{-S_L[{\varphi }_{cand}]}}{e^{-S_L[{\varphi }_{old}]}}\right)=\min (1,e^{-\Delta S})$$

   This is exactly the simplified form from the video for a symmetric proposal.

3. Update: Generate a uniform random number $u\in [0,1]$.

   • If $u<A$, the move is accepted: ${\varphi }_{next}={\varphi }_{cand}$.
   • If $u\ge A$, the move is rejected: ${\varphi }_{next}={\varphi }_{old}$. We keep the old configuration in our sequence.

Notice the intuitive nature of this rule:

• If a proposed change decreases the action ($\Delta S<0$), then $e^{-\Delta S}>1$, and the acceptance probability is 1. The system always accepts moves to lower-action (more probable) configurations.
• If a proposed change increases the action ($\Delta S>0$), then $e^{-\Delta S}<1$. The system might still accept this "uphill" move, but with a probability that is exponentially smaller for larger $\Delta S$. This allows the system to escape local minima and explore the entire configuration space, which is essential for correct sampling.

3. Implementing the Metropolis Algorithm for ${\varphi }^4$ Theory

Now, let's see how this algorithm is put into practice for the scalar field theory we discretized in the last lesson. Your strong background in Python and creating simulations will be very helpful here. We will study a concrete implementation.

The following resource provides a full Python implementation for a simulation of ${\varphi }^4$ theory. It builds directly on the concepts from the previous lesson and is a perfect example of today's learning outcome.

Let's break down the key function scalar_MH_step:

def scalar_MH_step(phi, lamb, kappa, delta):
    # 1. Propose a local update
    site = tuple(rng.integers(0,len(phi),4))         # Pick a random 4D site
    newphi = phi[site] + rng.uniform(-delta,delta)   # Propose a new field value

    # 2. Calculate local change in action
    deltaS = scalar_action_diff(phi, site, newphi, lamb, kappa)

    # 3. Accept/Reject step
    if deltaS < 0 or rng.uniform() < np.exp(-deltaS):
        phi[site] = newphi   # Accept: update the configuration
        return True          # Return status (e.g., for acceptance rate)
    return False             # Reject: do nothing

This code is a direct and elegant translation of the Metropolis algorithm. The run_scalar_MH function simply calls this step function repeatedly, forming the Markov chain.

4. Practical Considerations in MCMC Simulations

Running a real simulation involves a few more practical details:

• Thermalization (or Burn-in): The simulation starts from an arbitrary configuration (e.g., all $\varphi (n)=0$). The first several thousand configurations in the chain will not be representative of the true distribution as the system "relaxes" towards equilibrium. These initial configurations must be discarded. In the provided code, this is handled by equil_sweeps.
• Autocorrelation: By construction, each configuration in the Markov chain is correlated with the previous one. To obtain statistically independent samples for averaging, we should only measure observables every $N_{corr}$ steps (or "sweeps"). This is the measure_sweeps parameter in the code.
• Tuning the Proposal Step ($\delta$): The delta parameter, which controls the size of the proposed change, is crucial.
  • If $\delta$ is too small, nearly every move is accepted, but the field configuration changes very slowly. The simulation explores the space inefficiently.
  • If $\delta$ is too large, proposed moves make large jumps in the action, so $\Delta S$ is large and positive, and most moves are rejected. The simulation gets "stuck".
  • A common rule of thumb is to tune $\delta$ so that the acceptance rate (the fraction of accepted moves) is around 50%. The code in the resource LINK includes a comment to this effect.

Conclusion

Today we have built the engine for our lattice field theory simulations. By understanding and implementing the Metropolis algorithm, we can now generate a statistically representative ensemble of field configurations for a given theory.

Key Takeaways:

• Lattice path integrals are evaluated using Monte Carlo importance sampling.
• The Metropolis-Hastings algorithm generates a Markov chain of configurations that converges to the desired Boltzmann distribution $P(\varphi )\propto e^{-S_L[\varphi ]}$.
• The core of the algorithm consists of a propose-accept/reject cycle, where the acceptance probability $A=\min (1,e^{-\Delta S})$ satisfies detailed balance.
• For lattice theories, local updates make the calculation of $\Delta S$ extremely efficient, enabling simulations on large lattices.
• Practical simulations must account for thermalization and autocorrelation to produce reliable results.

Preview of the Next Lesson:

We are now equipped to run a simulation and generate valid field configurations. In the next lesson, we will put this to use. We will learn how to compute the two-point correlation function $⟨\varphi (x)\varphi (y)⟩$ from our generated configurations and extract a physical observable: the mass of the scalar particle. This will be our first calculation of a physical quantity from a non-perturbative QFT simulation.