PaperlayerView exact revision on arXiv

Source-linked AI summary

Resolution of singularities for multi-loop integrals

Christian Bogner, Stefan Weinzierl

arXiv:0709.4092v2hep-ph

TL;DR

Divergent multi-loop integrals require reliable numerical Laurent expansions, but recursive sector decomposition can fail to terminate and lacks an integrated public implementation. The paper adapts resolution-of-singularities ideas to guarantee termination and combines symbolic and numerical computation in one program. The resulting program computes Laurent coefficients numerically, with strategy efficiency compared through generated sub-sectors.

  • Problem

    Recursive sector decomposition can enter infinite loops, while the algorithm’s symbolic and numerical stages lacked a public integrated program.

  • Method

    The program uses iterated sector decomposition with terminating strategies and combines symbolic algebra with numerical integration.

  • Results

    The program computes Laurent-expansion coefficients of dimensionally regulated divergent multi-loop integrals numerically; generated sub-sectors compare strategy efficiency.

  • Takeaways & Limitations

    The implementation provides a single program for symbolic and numerical evaluation of divergent multi-loop integrals.

  • Takeaways & Limitations

    The heuristic strategy has no proof of termination, and overall problem complexity is limited by available memory and CPU time.

Abstract

from arXiv · show

We report on a program for the numerical evaluation of divergent multi-loop integrals. The program is based on iterated sector decomposition. We improve the original algorithm of Binoth and Heinrich such that the program is guaranteed to terminate. The program can be used to compute numerically the Laurent expansion of divergent multi-loop integrals regulated by dimensional regularisation. The symbolic and the numerical steps of the algorithm are combined into one program.

PROGRAM SUMMARY

sector_decomposition computes divergent multi-loop integrals using sector decomposition, with symbolic and numerical dependencies combined in one GNU-licensed program.

  • The program is distributed under the GNU Public License.
  • It uses GiNaC and the GNU Scientific Library, with no external files required.
  • The program computes divergent multi-loop integrals using sector decomposition.
  • The program’s complexity is limited only by available memory and CPU time.
  • Running time and memory requirements depend on the complexity of the problem.

1 Introduction

The paper addresses divergent multi-loop integrals and the need to disentangle overlapping singularities reliably. It improves sector decomposition with guaranteed termination and provides an integrated symbolic-numerical implementation.

  • Dimensional regularisation expresses divergent Feynman integrals as Laurent expansions in ε around D = 4−2ε.
  • Sector decomposition is used to disentangle overlapping singularities when computing Laurent-series coefficients numerically.
  • The improved algorithm guarantees finite termination, avoiding infinite recursion found in the original Binoth–Heinrich formulation.
  • The program closes the lack of a public sector-decomposition implementation combining symbolic algebra and numerical integration.
  • The C++ implementation uses GiNaC for symbolic manipulation and the GNU Scientific Library for numerical computation.

2 Feynman integrals

The paper represents multi-loop Feynman integrals through graph-dependent polynomials U and F after Feynman parameterisation. Their zeros characterize ultraviolet and infrared divergence conditions, with infrared singularities also depending on kinematics.

  • After Feynman parameterisation, the integral is expressed using Feynman parameters and graph-dependent functions U and F.
  • U is constructed from monomials associated with chords of spanning trees of the l-loop graph.
  • F0 is built from 2-tree monomials multiplied by the negatives of corresponding invariants, while F also includes internal-mass terms.
  • The vanishing of U is related to ultraviolet subdivergences, while the vanishing of F is related to infrared divergences.
  • In the Euclidean region, F is positive semi-definite, but its vanishing is only necessary for an infrared singularity, which additionally depends on external kinematics.

3 A review of the algorithm for sector decomposition

Iterated sector decomposition homogenizes and partitions the integration domain, then monomializes polynomial singularities so ε-poles can be extracted analytically and finite coefficients integrated numerically.

  • The procedure first homogenizes polynomials and decomposes the simplex into primary sectors mapped to unit hypercubes.
  • The algorithm iteratively decomposes sectors until every polynomial is monomialized with a nonzero remainder throughout the integration domain.
  • The improved strategies guarantee recursion termination, resolving the infinite-recursion problem caused by reproducing the original polynomial.
  • Taylor expansion around xj = 0 for variables with aj < 0 extracts possible ε-poles, while the remaining integrals are finite.
  • After Laurent expansion and truncation, finite coefficients Ci are evaluated numerically by Monte Carlo integration.

4 Strategies for choosing the sub-sectors

The section develops strategies for choosing sector-decomposition subsets so iteration terminates, relating the problem to Hironaka’s polyhedra game. Three strategies ensure termination by forcing lexicographically ordered sequences of positive quantities to decrease, while differing in efficiency and construction.

  • A minimal-subset choice can reproduce the original polynomial, causing infinite recursion; termination therefore requires a strategy that works for every subsequent sector choice.The problem is closely related to resolution of singularities and is recast through Hironaka’s polyhedra game.
  • All three winning strategies guarantee termination by decreasing an associated sequence of positive numbers under lexicographical ordering.Because the sequence cannot decrease forever, the corresponding iterated sector decomposition terminates.
  • 4.1 Hironaka’s polyhedra game: Each polyhedra-game move models one sector-decomposition iteration, and reducing the polynomial to monomial form corresponds to reducing the polyhedron to one generated point.Player A chooses a nonempty subset, player B chooses an element from it, and the resulting transformation is iterated.
  • 4.2 Strategy A: Zeillinger’s strategy is conceptually simplest but inefficient because it generates a large number of sub-sectors.Its lexicographically decreasing sequence tracks the number of polyhedron corners and vector-based quantities.
  • 4.3 Strategy B: Spivakovsky’s strategy constructs auxiliary sets from coordinate minima and chooses subsets using a minimal covering condition, while its invariant δ(∆) decreases lexicographically.The strategy is proven to guarantee that player A wins.
  • 4.4 Strategy C: Strategy C resembles Spivakovsky’s approach but changes the companion-set construction and permits a deterministic choice of a subset T_k, producing another decreasing invariant.The added sequence components and deterministic rule distinguish its construction from strategy B.

5 A description of the program

The program exposes sector-decomposition and Monte Carlo routines for computing Laurent-series coefficients of Feynman integrals, with selectable decomposition strategies and structured integrand inputs.

  • Program interface: The main routine accepts integration data, an integrand, Monte Carlo parameters, and an optional verbosity level, then returns numerical integration results.The decomposition strategy is selected globally from STRATEGY_A, STRATEGY_B, STRATEGY_C, or STRATEGY_X.
  • Decomposition strategies: The first three decomposition strategies are guaranteed to terminate, whereas heuristic strategy X has no termination proof or known counterexample.Strategy X selects the smallest set enabling maximal parameter powers to be factored out and may generate fewer sub-sectors if it terminates.
  • Numerical integration: The requested Laurent-series term is selected through the order argument, while the number of Feynman parameters and Monte Carlo iterations and calls define the computation.The epsilon symbol corresponds to dimensional regularisation parameter ε.
  • Program interface: The integrand representation stores Feynman-parameter exponents, polynomials P_j, and their corresponding exponents, with a simpler constructor for missing explicit parameter powers.Exponents generally have the form a + bε.
  • Numerical integration: The Monte Carlo stage uses Vegas with an adaptive grid: a lower-cost phase adapts the grid, followed by a higher-cost phase that computes the numerical result.Results expose the mean, error estimate, and associated χ2.

6 How to use the program

The library is built and linked through standard configuration commands, then used to define Feynman integrals and compute Laurent-series coefficients numerically. Examples validate the implementation and compare decomposition strategies through sub-sector counts and larger-loop calculations.

  • Installation: The package builds a shared library with configure, make, and make install, while sector_decomposition-config supplies compiler and linker flags.Documentation can be generated from source comments with doxygen.
  • Example program: The test program computes Laurent-series terms for the massless double-box graph at (s,t) = (−1,−1).The example defines the U and F polynomials and constructs a seven-parameter integrand.
  • Example program: 2.00001 ± 9.25208e-05 is obtained for the eps^(-4) coefficient, while the example also reports coefficients through the finite term.The reported sequence is −5.99992, −4.91623, 11.4958, and 13.8236 for eps^(-3), eps^(-2), eps^(-1), and 1, respectively.
  • Validation and scale: Independent analytic results for the supplied one- and two-loop examples were used to verify the correctness of the code.For larger integrals, independent sub-sectors can be processed one at a time; the massless on-shell triple box required about two days of CPU time.
  • Performance comparison: The program’s running time is dominated by numerical Monte Carlo integration, and the number of generated sub-sectors measures algorithmic efficiency.Strategies A, B, and C terminate; X terminates on the listed examples and generates the fewest sub-sectors there, so it can be tried first with a guaranteed strategy as fallback.

7 Summary

The paper presents an iterative sector-decomposition program for numerically computing Laurent-expansion coefficients of dimensionally regulated divergent multi-loop integrals.

  • Summary: The program combines terminating iterative blow-up algorithms with symbolic and numerical computation in one implementation.It targets coefficients of Laurent expansions for divergent multi-loop integrals regulated by dimensional regularisation.

A Details on the implementation

The implementation accelerates Monte Carlo integration by compiling numerical functions to C and optimizing their generated expressions.

  • Numerical evaluation: Because Monte Carlo integration evaluates functions repeatedly, the program uses a compiled C function instead of slower arbitrary-precision GiNaC evaluation.Statistical errors generally dominate rounding errors in this setting.
  • Numerical evaluation: Generated C expressions are optimized by replacing repeated subexpressions and splitting large expressions into smaller pieces for compiler processing.These transformations improve the numerical evaluation path used by the Monte Carlo routine.

B Proof of strategy C

The appendix proves termination of strategy C by showing that its associated sequence decreases through a lexicographic argument and that permissible sets are preserved through recursive steps.

  • Proof setup: The appendix organizes strategy C’s proof after Spivakovsky’s proof of strategy B and retains the notation of section 4.Several subsidiary claims are verified by direct calculation or immediate consequences of earlier equations.
  • Inductive bounds: The induction maintains the lower bound d(Δ_k)≥c_k and derives d(Δ_{k+1})≥c_k from the bounds for the relevant T_k.The base case is k=0 with c_{−1}=0.
  • Permissibility: Lemma 1 preserves permissibility when moving from Δ_{k+1} to Δ_k by adjoining T_k to S_{k+1}.The proof establishes the corresponding bound on d_{S_k}, including the separate cases c_k≥c_{k−1} and c_k<c_{k−1}.
  • Permissibility: The set S defined in section 4.4 is shown permissible for Δ by repeated application of the lemma, including the cases Δ_r≠∅ and Δ_r=∅.For the empty case, the argument uses d_{S_{r−1}}≥c_{r−1} to establish permissibility for Δ_{r−1}.
  • Proof of termination: Lemma 2 makes the sequence decrease lexicographically: first d decreases, then #I_k−#H_k, and finally the argument descends in dimension.When these quantities remain constant, Lemma 2(c) gives T_k=T′_k and Lemma 2(d) permits passage to the simpler problem for Δ_{k+1}.
Loading 0709.4092v2…