Source-linked AI summary
pySecDec: a toolbox for the numerical evaluation of multi-scale integrals
S. Borowka, G. Heinrich, S. Jahn, S. P. Jones, M. Kerner, J. Schlenk, T. Zirke
TL;DR
Multi-scale higher-order integrals are difficult to evaluate analytically, especially with regulated singularities. pySecDec combines modular Python/FORM algebra with optimized C++ numerical libraries, generally outperforming SecDec 3 in numerical evaluation times and extending use to larger expressions and amplitudes.
Problem
Analytic evaluation of multi-scale two-loop and higher integrals is challenging, while dimensionally regulated singularities require systematic treatment.
Method
pySecDec factorizes regulated singularities in general polynomial integrands using modular Python and FORM algebra, then generates optimized C++ integrand libraries for numerical integration.
Results
pySecDec generally outperforms SecDec 3 in numerical evaluation times and supports evaluating larger expressions containing multiple analytically unknown integrals.
Takeaways & Limitations
Generated libraries can be linked to user-specific amplitude codes, extending numerical evaluation from individual integrals to multi-integral expressions and amplitudes.
Takeaways & Limitations
The geometric and geometric ku strategies require Normaliz, whereas the iterative strategy can be used without it; general polynomial inputs also require suitable regulation and contour deformation.
Abstract
from arXiv · showhide
We present pySecDec, a new version of the program SecDec, which performs the factorisation of dimensionally regulated poles in parametric integrals, and the subsequent numerical evaluation of the finite coefficients. The algebraic part of the program is now written in the form of python modules, which allow a very flexible usage. The optimization of the C++ code, generated using FORM, is improved, leading to a faster numerical convergence. The new version also creates a library of the integrand functions, such that it can be linked to user-specific codes for the evaluation of matrix elements in a way similar to analytic integral libraries.
PROGRAM SUMMARY
pySecDec is a Python, FORM, and C++ toolbox for numerical multi-loop and multi-scale Feynman-integral calculations.
- pySecDec targets perturbation theory, Feynman diagrams, multi-loop calculations, and multi-scale integrals.It is designed to run from a single PC or laptop to a cluster, depending on problem complexity.
1 Introduction
Multi-scale higher-order corrections are increasingly difficult to calculate analytically, motivating automated numerical methods. pySecDec addresses this need by combining Python and FORM algebra with optimized C++ numerical integrands and linkable libraries.
- Multi-scale two-loop and higher integrals become challenging as the number of mass scales increases.Such multi-scale problems are common at high energies, where massive loops and electroweak corrections matter.
- Sector decomposition automatically factorizes dimensionally regulated singularities, after which Laurent-series coefficients can be integrated numerically.This approach extends numerical treatment beyond the Euclidean restriction addressed by earlier SecDec versions.
- pySecDec replaces Mathematica with Python and FORM for algebraic processing, yielding an open-source and modular program.Its modular structure is intended to provide maximal flexibility.
- Generated C++ integrand functions are combined into libraries that can link to amplitude calculations, similarly to analytic one-loop integral libraries.This supports multi-loop amplitudes when analytic results for many master integrals are unavailable.
- The paper presents the program structure, installation and usage, examples, and parameter settings across Sections 2–5 and an appendix.
2 Description of pySecDec
pySecDec separates algebraic processing from numerical integration while exposing modular support for general polynomial integrands and loop integrals. Its new features broaden regulator, numerator, singularity, symmetry, and library capabilities.
- The program combines a Python/FORM algebraic part with C++ numerical code for general polynomial functions and loop integrals.Steps (1)–(6) are performed in Python and FORM; FORM then produces optimized C++ code and compiled integrands are packaged into libraries.
- 2.1 Algebraic part: Its algebra modules generate integrands, perform sector decomposition and contour deformation, and carry out subtraction and regulator expansion.They use SymPy, NumPy, and a sector-decomposition-focused computer algebra system.
- 2.1 Algebraic part: pySecDec accepts products of regulated polynomials beyond loop integrals and can expand in several regulators.Non-endpoint integrable singularities must be treatable by deforming the integration path into the complex plane.
- 2.2 Loop integrals: Loop integrals can be defined from propagator lists or graph adjacency lists, with selectable iterative and algebraic-geometry sector strategies.The geometric strategy is recommended over the original geometric algorithm for general use.
- 2.2 Producing C++ code and numerical results: The code-writer module decomposes, subtracts, and expands polynomial expressions, returning C++ packages with FORM-optimized expressions.Users can also add finite non-polynomial functions and arbitrary C++ code called during numerical integration.
- 2.3 New features: Generated libraries support static and dynamic builds, Python calls, user-specific linking, and evaluation of multiple integrals or amplitudes.These capabilities accompany new regulators, flexible numerators, improved higher-pole treatment, hyperplane-singularity remapping, symmetry finding, and optional diagram drawing.
3 Installation and usage
pySecDec is distributed with dependencies and documentation intended to simplify installation, while Python scripts guide integral definition, code generation, and numerical integration. Its interfaces support both standalone calculations and linkable libraries.
- 3.1 Installation: pySecDec requires Python 2.7 or 3, NumPy, and SymPy, and is distributed from the SecDec website.
- 3.1 Installation: Installation uses extraction followed by make, which builds pySecDec and dependencies including Cuba, FORM, and Nauty.Nauty finds sector symmetries, while Cuba provides multidimensional numerical integration and FORM handles algebraic manipulation and optimized C++ generation.
- 3.1.1 Geometric sector decomposition strategies: Normaliz is required for the geometric and geometric ku strategies, whereas the iterative strategy works without it.The paper lists Normaliz versions 3.0.0, 3.1.0, and 3.1.1 as known to work with pySecDec 1.0.
- Users can combine modular components, with documentation supplied in PDF and HTML formats.
- 3.2 Usage: Standalone scripts define integrals and options, generate C++ libraries with make, and perform numerical integration through Python.The workflow also supports multiple kinematic points and separate library-linked amplitude calculations.
- 3.2 Usage: The algebra package exposes intermediate symbolic objects such as Symanzik polynomials, while numerators and prefactors can be handled flexibly.User-defined prefactors are automatically expanded in the regulator and included in the returned numerical result.
4 Examples
The examples demonstrate pySecDec’s interfaces for defining, generating, compiling, and numerically integrating loop integrals, with Python and C++ usage options.
- Running examples: pySecDec supports Python and C++ interfaces for performing numerical integrations at user-specified kinematic points.The Python interface allows direct editing of kinematic and integration settings, while the C++ interface uses generated source files and inserted parameters.
- Running examples: Parallel builds are available through the make -j option, which runs FORM and compilation jobs concurrently where possible.For example, make -j 8 -C box1L requests eight parallel jobs where possible.
- Generated files: The compiled libraries can be linked to external programs that call the integrals.This supports user-specific numerical evaluation beyond the standalone example executables.
Loop over multiple kinematic points
The examples apply pySecDec to multi-loop integrals with massive, massless, numerator, elliptic, hypergeometric, and multiple-regulator structures. They demonstrate numerical agreement or reduced sector counts, while timing comparisons report generally shorter numerical integration times than SecDec 3.
- Two-loop examples: The box2L numerator example represents the same massless planar on-shell two-loop seven-propagator box using either an inverse propagator or contracted Lorentz vectors.The two results should differ numerically by zero, and the calculation is performed at s = −3, t = −2.
- Three-loop example: The triangle3L example reduces primary sectors from 7 to 3 and total sectors from 212 to 122 using the symmetry finder.For comparison, SecDec 3 produces 448 sectors with strategy X.
- Elliptic integrals: The elliptic2L examples evaluate a two-loop six-propagator integral known to contain elliptic functions at Euclidean and physical kinematic points.The physical-point result is complex, with a reported uncertainty of (2.456 + i 2.662) × 10^-5.
- Special kinematics: The triangle2L split example addresses an integral without a Euclidean region, where F can vanish on a hyperplane and create non-endpoint singularities.pySecDec detects and remaps these hyperplane singularities to the origin through a dedicated splitting procedure.
- Timing comparison: Across the tested examples, pySecDec generally reduces numerical integration times relative to SecDec 3.The paper attributes this mainly to improved algebraic optimization and partly to more efficient contour deformation, while noting that Fiesta 4.1 was fastest for algebraic decomposition when deformation was unnecessary.
5 Conclusions
pySecDec is a publicly available, open-source successor to SecDec that broadens automated pole isolation and numerical integration for general polynomial expressions and multi-loop integrals.
- pySecDec uses Python, FORM, and Cuba, with an algebraic part for isolating regulator poles and a numerical part that creates C++ integrand libraries.The libraries can be linked into calculations containing multiple analytically unknown integrals, including full amplitudes.
- The program generally outperforms SecDec 3 in numerical evaluation times and supports flexible use beyond individual multi-loop integrals.
- pySecDec is intended to support higher-order corrections to multi-scale processes that are inaccessible to semi-analytical approaches.
A.1 Algebraic part
The algebraic part provides documented settings for configuring polynomial processing, sector decomposition, and related symbolic operations.
- The algebraic-part settings are documented in the “Code Writer/Make Package” and “Loop Integral” sections, with the latter covering loop-specific options.
A.1.1 Loop package
The loop package exposes configurable inputs for graph- or propagator-based loop integrals, regulators, numerators, parameters, contour deformation, and algebraic optimization.
- Real and complex parameters, contour deformation, and additional prefactors can be specified for the generated calculation.
- FORM optimization level, workspace, and decomposition method control algebraic-code generation and sector decomposition.
- Optional settings control complex return types, splitting integration domains at singularities, integration-by-parts power goals, and sector-symmetry finding.The default integration-by-parts setting continues until no linear or higher poles remain, while dreadnaut can find sector symmetries.
- Loop integrals can be defined from graph connectivity, propagators, loop momenta, external momenta, and optional numerator and Lorentz-index specifications.
- Users can configure Feynman parameters, regulators, dimensionality, regulator powers, propagator powers, and replacement rules for kinematic expressions.
A.1.2 Make package
The make package configures polynomial integrands for decomposition, regulator expansion, prefactors, additional functions, and optional contour deformation or positivity checks.
- The package accepts integration variables, regulators, requested expansion orders, decomposed polynomials, polynomial names, and additional undecomposed polynomials.
- A prefactor independent of integration variables may depend on the regulators and kinematic invariants, while a remainder expression supplies an additional multiplicative factor.
- Function symbols occurring in the remainder expression can be supplied explicitly; pow and log are defined by default.
- The contour deformation polynomial is continued into the complex plane using an −iδ prescription; for loop integrals, the second Symanzik polynomial F is selected automatically.
- Positive polynomials can be specified to require positive real parts; for loop integrals, this applies to the first Symanzik polynomial U.
- All parameters described for loop package, except the loop-integral input itself, are also available in make package.
A.2 C++ part
The C++ part provides numerical integration controls for generated libraries, including parameters, sector handling, contour deformation, accuracy, evaluation counts, and logging.
- Real parameters, such as kinematic invariants, and complex parameters, such as complex masses, are supplied to the numerical library.
- The together option determines whether all sectors are integrated as a sum or evaluated separately.
- Contour optimization uses a default of 100000 presamples, with deformation parameters bounded by a maximum of 1.0 and a minimum of 10−5.
- If optimized deformation parameters fail the sign check requiring a negative imaginary part, they are repeatedly multiplied by 0.9 until the check passes.
- The integration interface also controls random seeds, minimum evaluations, Cuba logging flags, and whether real and imaginary parts are evaluated together.
- The common numerical defaults request epsrel 0.01, epsabs 10−7, and a maximum of 1000000 evaluations.