GLoop: A Monte Carlo program to construct higher-loop integrals from lower-loop structures

The paper introduces GLoop, a Fortran90 Monte Carlo framework that computes specific higher-loop integrals from lower-loop building blocks by utilizing $i\epsilon$ deformations on single pole singularities to avoid explicit analytic contour deformation.

The Gist

Imagine you are trying to solve a massive, incredibly complex jigsaw puzzle. In the world of particle physics, these puzzles are mathematical formulas called "integrals" that describe how particles interact at the highest levels of energy. The bigger the puzzle (the more "loops" or interactions involved), the harder it is to solve.

For a long time, scientists had two main ways to solve these puzzles:

1. The Analytic Way: Trying to write down the perfect, exact mathematical formula for the whole picture at once. This is like trying to solve the whole puzzle in your head without touching the pieces. It's brilliant but often impossible for the most complex puzzles.
2. The Numerical Way: Using a computer to guess and check millions of times to build the picture. This is like picking up pieces randomly and seeing if they fit.

The paper introduces a new tool called GLoop. Think of GLoop as a smart, specialized glue gun that helps you build the big puzzle by sticking together smaller, already-solved puzzle pieces.

Here is how the paper explains GLoop in simple terms:

1. The "Gluing" Strategy

Instead of trying to solve a giant, 3-loop or 4-loop puzzle all at once, GLoop takes a different approach. It looks at the big picture and sees that it is made of two smaller, simpler pictures (let's call them the "Left Blob" and the "Right Blob") connected by just two lines.

GLoop's job is to take these two smaller, known pieces and "glue" them together. It calculates the connection point by running a massive simulation (called a Monte Carlo method) that tries billions of different ways to connect them, eventually finding the average result. It's like building a skyscraper by stacking pre-fabricated floors rather than pouring concrete for the whole building from the ground up.

2. The "Smoothie" Problem (Dealing with Singularities)

The biggest headache in these calculations is a mathematical glitch called a "singularity" or a "threshold." Imagine trying to blend a smoothie, but there's a hard, sharp rock in the middle. If you try to blend it normally, the machine breaks (or the math explodes).

In physics, these "rocks" are points where the math goes to infinity. Usually, to fix this, scientists have to bend the rules of math, twisting their path through a "complex" world to avoid the rock. This is very difficult and prone to errors.

GLoop uses a clever trick described in the paper: The $i\epsilon$ Deformation.
Instead of trying to walk around the rock, GLoop puts a tiny, invisible cushion (represented by a tiny number called $\epsilon$) under the rock. This lifts the rock just a hair's breadth off the ground.

• The Magic: Because the rock is now slightly floating, the math doesn't break. The computer can calculate the result smoothly.
• The Catch: The cushion is so tiny (almost invisible to the computer's precision) that it doesn't change the actual answer, but it makes the calculation possible without needing to take a complicated detour.

3. How It Works in Practice

The paper provides a "toolkit" (written in a computer language called Fortran90) that allows researchers to:

• Plug in their own smaller puzzle pieces (lower-loop structures).
• Set the parameters (like the mass of particles or energy levels).
• Run the simulation, which glues the pieces together and averages out the results.

The authors tested this by building a specific, complex 3-loop puzzle (a "self-energy" diagram). They showed that GLoop could calculate the answer with high precision, matching known mathematical results. They also showed it could handle "divergent" puzzles (where the numbers go to infinity) by subtracting out the infinite parts carefully, leaving only the finite, useful answer.

4. What It Can and Cannot Do

• What it does: It is excellent at gluing two structures together if they are connected by exactly two lines (propagators). It is modular, meaning if you want to add a new type of puzzle piece, you can write a small routine and plug it in.
• What it doesn't do yet: The paper admits a limitation. If you have a puzzle where three or more lines connect two blobs at the same time, GLoop's current "glue" isn't strong enough. It would require a major redesign to handle those more complex connections.

Summary

GLoop is a new, modular computer program that helps physicists solve the hardest math problems in particle physics. Instead of solving the whole problem at once, it breaks the problem down, uses a clever "cushion" trick to avoid mathematical explosions, and glues smaller, known solutions together to build the final answer. It is designed to be a reference guide and a starting point for other scientists to build their own calculations.

Technical Summary

1. Problem Statement

High-energy particle physics experiments require theoretical predictions with extreme precision, necessitating the calculation of multi-loop radiative corrections. While analytic methods (based on differential equations) and fully numerical techniques exist, calculating higher-loop integrals directly in Minkowski space remains challenging due to:

• Threshold Singularities: The presence of $i\epsilon$ prescriptions in propagators creates single-pole singularities on the real integration axis.
• Contour Deformation Complexity: Traditional numerical methods often require deforming the integration contour into the complex plane to avoid these poles. This is computationally expensive and difficult to automate for complex multi-loop topologies, especially regarding branch cuts and Riemann sheets.
• Modularity: Existing tools often lack a flexible framework for "gluing" lower-loop substructures to build higher-loop integrals without re-deriving the entire analytic structure.

2. Methodology

The paper introduces GLoop, a Fortran90 computational framework that computes higher-loop integrals by numerically integrating over lower-loop building blocks. The core methodology relies on three pillars:

A. Numerical Integration over $\epsilon$-Deformed Contours

Instead of explicitly deforming the integration contour into the complex plane, GLoop utilizes a method (from previous works [1, 2]) that keeps the integration variables real but parameterizes the singularity handling via a complex variable transformation.

• The Transformation: For an integral of the form $\int \frac{F(x)}{x+i\epsilon} dx$, the method introduces a complex variable $z = \alpha + i\beta$ related to $x$ by $x + i\epsilon = e^{i\pi(1-z)}$.
• Real Axis Integration: The path is fixed such that $x$ remains real. This transforms the singular integral into a regular integral over $\alpha$ and $\beta$.
• Advantage: This approach avoids explicit contour deformation, automatically selects the correct Riemann sheet for branch cuts, and allows the use of very small $\epsilon$ values (close to machine precision, e.g., $10^{-12}$) without numerical instability.

B. Gluing Substructures

GLoop constructs higher-loop diagrams by "gluing" two lower-loop substructures ($L$ and $R$) via two propagators sharing a loop momentum $q$.

• Structure: The integral is formulated as $G = \int d^4q \frac{L(q)R(q)T(q)}{D_0 D_1}$, where $D_0, D_1$ are the propagators.
• Dimensionless Variables: The code maps the loop momentum to dimensionless variables ($\sigma_j$) to handle the integration limits ($-\infty$ to $+\infty$) and the Källén function $\lambda$ arising from angular integration.
• Modularity: The user defines the substructures ($L$ and $R$) as functions of the loop momentum. These can be computed analytically or semi-numerically using existing libraries (OneLOop, QCDLoop).

C. Monte Carlo (MC) Variance Reduction

To address large cancellations and slow convergence when integrands do not vanish rapidly at infinity, GLoop employs a subtraction strategy:

• Asymptotic Approximation: An approximation $\tilde{G}$ is constructed that matches the asymptotic behavior of the integrand as $|\sigma_i| \to \infty$.
• Zero-Integral Subtraction: This approximation is designed such that its integral is zero. It is subtracted point-by-point from the original integrand during the MC integration.
• Multi-channel Sampling: The code uses a multi-channel MC approach, combining flat distributions and distributions peaked near singularities to flatten the integrand behavior.

3. Key Contributions

• GLoop Framework: A highly modular Fortran90 code that allows users to construct complex multi-loop integrals by combining lower-loop components without needing to derive new analytic formulas for the full topology.
• Contour-Free Algorithm: Implementation of a robust algorithm that handles $i\epsilon$ singularities numerically without complex contour deformation, simplifying the implementation of multi-loop calculations.
• Integration with Existing Libraries: Seamless integration with OneLOop and QCDLoop, allowing the user to leverage pre-computed one-loop results as building blocks.
• Handling Divergences: Demonstrated capability to handle both infrared (IR) finite and IR divergent integrals by implementing local subtractions (e.g., for the one-loop box with massless particles).
• Educational Resources: The paper provides fully worked-out examples (1D to 4D integrals, one-loop boxes, and three-loop self-energies) with source code routines to serve as a template for user implementations.

4. Results and Validation

The authors validated GLoop against known analytic results across various test cases:

• Test Integrals: Successfully computed 1D, 2D, 3D, and 4D integrals involving logarithms and step functions, matching analytic results within MC statistical errors (e.g., $I_1$ matched to $\sim 10^{-4}$ relative precision).
• One-Loop Examples:
  • Triangle Diagram: Computed a rescaled one-loop triangle, matching the analytic value $3.34507 - i 2.98595$ with MC result $3.345(6) - i 2.988(4)$.
  • Box Diagram (Finite): Computed an IR-finite box diagram, matching analytic results within errors.
  • Box Diagram (Divergent): Computed a subtracted IR-divergent box. Using $32 \times 10^9$ MC shots, the result $2.489(1) \times 10^2 + i 3.246(1) \times 10^2$ matched the analytic value $2.48871 \times 10^2 + i 3.24697 \times 10^2$.
• Three-Loop Self-Energy: Demonstrated the construction of a three-loop scalar self-energy diagram by gluing two one-loop triangles. The code successfully averaged results over multiple iterations to produce stable real and imaginary parts.

5. Significance and Outlook

• Accessibility: GLoop lowers the barrier to entry for multi-loop calculations by allowing physicists to focus on the topology and substructures rather than the complex machinery of contour deformation.
• Flexibility: The modular design allows for the extension to new cases and dimensions.
• Limitations: Currently, GLoop is limited to diagrams where substructures are connected by exactly two propagators. Diagrams with more complex connections (e.g., three or more shared propagators) require substantial code modifications, which the authors reserve for future work.
• Impact: The tool provides a practical, numerical alternative to purely analytic methods for specific classes of multi-loop integrals, particularly those where analytic solutions are intractable or where numerical cross-checks are required for precision physics.

In summary, GLoop represents a significant step forward in the numerical evaluation of multi-loop Feynman integrals, offering a robust, modular, and user-friendly framework that bypasses the complexities of explicit contour deformation.