Source-linked AI summary
Kira - A Feynman Integral Reduction Program
Philipp Maierhoefer, Johann Usovitsch, Peter Uwer
TL;DR
Higher-order calculations are limited by the difficult, resource-intensive reduction of multi-loop Feynman integrals to master integrals. Kira implements Laporta reduction with modular elimination of dependent equations and optimized back substitution, achieving substantial performance improvements and competitive benchmark results.
Problem
Multi-scale Laporta reductions can require substantial runtime and memory, although reducing Feynman integrals to master integrals is crucial for multi-loop amplitude calculations.
Method
Kira combines modular-arithmetic elimination of linearly dependent IBP and LI equations with optimized back substitution and algebraic coefficient handling.
Results
Kira’s modifications substantially improve performance for complicated topologies, with benchmarks reporting one to two orders of magnitude faster runtimes than Reduze 2 and competitive results against FIRE 5.
Takeaways & Limitations
Kira extends practical Laporta reductions toward problems involving more mass scales and supports independent cross-checks against Reduze 2.
Takeaways & Limitations
The implementation does not yet reconstruct rational functions from finite fields, and reductions are guaranteed only within the chosen seed.
Abstract
from arXiv · showhide
In this article, we present a new implementation of the Laporta algorithm to reduce scalar multi-loop integrals---appearing in quantum field theoretic calculations---to a set of master integrals. We extend existing approaches by using an additional algorithm based on modular arithmetic to remove linearly dependent equations from the system of equations arising from integration-by-parts and Lorentz identities. Furthermore, the algebraic manipulations required in the back substitution are optimized. We describe in detail the implementation as well as the usage of the program. In addition, we show benchmarks for concrete examples and compare the performance to Reduze 2 and FIRE 5. In our benchmarks we find that Kira is highly competitive with these existing tools.
1 Introduction
Multi-loop Feynman-integral computation is a bottleneck for increasingly precise higher-order collider predictions. Kira addresses the resource demands of Laporta reductions by removing redundant equations and optimizing coefficient manipulation, with improved benchmark performance.
- Higher-order collider predictions require evaluating increasingly difficult multi-loop corrections as experimental precision improves.
- Feynman integrals are a major bottleneck because tensor integrals are typically reduced to scalar integrals related by IBP and Lorentz identities.
- The Laporta algorithm solves systems generated from integer propagator powers to reduce scalar integrals to master integrals.
- Multi-scale reductions can impose severe runtime and memory limits in existing implementations.
- Kira uses modular arithmetic to remove linearly dependent equations and improves manipulation of algebraic integral coefficients.
- Kira’s article covers implementation, installation, usage, tuning options, and benchmarks on massive double-box topologies.
2 Preliminaries
The preliminaries define multi-loop scalar integrals and the identities that relate them, then motivate Laporta reduction as a systematic alternative to hand-built ladder operators. They also introduce sectors, zero sectors, symmetries, and mappings used to organize and simplify reductions.
- Multi-loop tensor integrals use loop and external momenta, masses, and dimensionally regulated space-time before reduction to scalar integrals.
- Scalar products involving loop momenta can be represented through propagators and auxiliary propagators, whose powers are collected in an index vector.
- IBP and LI identities produce linear relations among scalar integrals, allowing them to be expressed through a smaller master-integral basis.
- Laporta reduction builds a large seeded system of shifted-index equations and applies Gauss elimination to reduce integrals to master integrals.
- Sectors and sub-sectors: A sector groups integrals by the propagators with positive powers, while its corner integral sets those positive powers to one.
- Sectors and sub-sectors: The sector count is 2^N, and positive and non-positive propagator powers provide complexity measures within a sector.
- Identification of trivial sectors: Scaleless sectors are identified as trivial when their corner integral vanishes, which can simplify reduction at an early stage.
- Symmetry relations between integrals: Loop-momentum shifts and external-momentum permutations generate symmetries that can reduce independent integrals and relate equivalent sectors or topologies.
3 Laporta Algorithm – Implementation
Kira implements the Laporta reduction by ordering equations and integrals, removing linear dependencies with modular arithmetic, and optimizing elimination and back substitution. These steps reduce algebraic overhead and can extract smaller sufficient subsystems for targeted reductions.
- Ordering of integrals and equations: Kira represents the Laporta system as an ordered list of equations whose integrals are ranked by topology, sector, and index-based complexity.Equations are ordered using their most complicated integral and additional criteria when that integral is shared.
- Selection of linearly independent equations: Linearly dependent equations are removed before reduction to avoid redundant algebraic manipulations, expression swell, and unnecessary coefficient simplifications.The dependency-selection stage uses pyRed, a sparse modular-arithmetic implementation that maps coefficients into a finite integer field.
- Selection of linearly independent equations: pyRed substitutes kinematic variables, masses, and the dimension with pseudo-random finite-field values, making coefficient operations constant-complexity modulo a large prime.Its sparse variant of Gaussian elimination retains sparsity to a large degree during forward elimination.
- Selection of linearly independent equations: Backward elimination can identify master integrals and trace equation insertions to extract a smaller subsystem sufficient to reduce a user-specified list of integrals.This backward step is performed by default even though forward elimination alone suffices to identify redundant equations.
- Gauss type forward elimination: Kira brings the retained equations into triangular form, then expresses integrals through master integrals while preserving equation-group ordering during elimination.Equations sharing the most complicated integral are collected into sub-lists and repeatedly substituted until each sub-list contains one equation.
- Back substitution: During back substitution, Kira keeps coefficients as lists and combines them pairwise, avoiding the large intermediate expressions produced by naive one-step combination.The strategy is specifically motivated by the time cost of back substitution in multi-scale problems.
4 Installation
Kira is distributed under GPLv3-or-later and built from several prerequisite libraries plus Fermat. Installation involves unpacking the archive, configuring dependencies, building, installing, and checking command-line usage.
- Kira is distributed under the GNU General Public License, version 3 or later.
- Before compiling, install GiNaC, CLN, yaml-cpp, zlib, and Fermat.GiNaC itself requires CLN.
- Download Kira as kira-<version>.tar.gz, uncompress it, and enter the extracted directory.The documented extraction command is tar -xf kira-version.tar.gz followed by changing into kira-<version>.
- Configure, build, and install Kira, specifying dependency paths through CPATH and LD_LIBRARY_PATH when libraries are not in standard locations.The --prefix option specifies the installation directory.
- Run kira -h to display a brief usage description and supported command-line options.This command assumes the installation bin directory is on PATH.
5 Kira usage
Kira uses YAML configuration files to define integral topologies, kinematics, and reduction jobs, then derives identities and performs the reduction in stages. Its workflow supports multiple topologies, configurable sectors and seeds, and parallel execution.
- Kira accepts YAML input largely compatible with Reduze 2, ignoring unsupported Reduze 2 options with a startup message.
- A reduction requires topology, kinematics, and job configuration files, including integralfamilies.yaml, kinematics.yaml, and a job file.The working directory contains the job file and the two configuration files under config.
- Topology and kinematics: The topology file distinguishes loop from external momenta, lists propagator momentum flows and masses, and can contain multiple named topologies.
- Topology and kinematics: The kinematics file specifies incoming and outgoing momenta, momentum-conservation substitutions, invariants, scalar-product rules, and optional normalization of one mass scale.In the example, q1 is eliminated and m1 is set to one.
- Reduction workflow: Kira generates symbolic IBP and LI equations, prepares sector symmetries, identifies trivial sectors, and then reduces selected sectors in four steps.GiNaC is used to calculate the symbolic IBP and LI equations.
- Reduction workflow: Sector selection can recursively include required subsectors, while identity seeds are controlled through ranges for r and s.Multiple seed-range lists contribute their union.
6 Benchmarks
The benchmarks evaluate Kira on massive double-box topologies and compare its runtime, reduction agreement, and optimization strategies with established tools. Kira reproduces the same master integrals and reduced results while showing substantial speedups, although full mass dependence greatly increases resource demands.
- Kira is 1–2 orders of magnitude faster than Reduze 2 and up to 1 order faster than FIRE 5 for default reductions.
- Only a small fraction of runtime identifies linearly dependent equations, while removing them significantly reduces Kira’s total reduction time.
- For full mass dependence, topo4 requires roughly 10 hours and the most challenging topo5 reductions roughly one week, with about 90 GBytes of RAM plus Fermat memory.
- The --algebra option roughly halves runtime for smax = 1 and yields roughly a factor-4.5 speed-up for smax = 3.
7 Conclusion
Kira implements the Laporta algorithm with modular elimination of dependent equations and optimized back substitution. The authors report improved performance, especially for multi-scale reductions, and successful reproduction of NNLO single-top reductions, with applicability beyond two loops.
- Kira reduces multiloop Feynman integrals to a small set of master integrals using an implementation of the Laporta algorithm.
- Modular arithmetic eliminates linearly dependent IBP and LI equations before Gauss elimination constructs an upper-triangular system.
- An optimized back-substitution procedure delays intermediate-expression swell and improves performance for complicated, particularly multi-scale, topologies.
- The implementation successfully reproduces reductions arising in NNLO corrections to single top-quark production.
- The algorithm is applicable beyond two-loop corrections to higher-loop reductions.