Source-linked AI summary
FIRE4, LiteRed and accompanying tools to solve integration by parts relations
A. V. Smirnov, V. A. Smirnov
TL;DR
The paper addresses the need to reduce very large collections of Feynman integrals efficiently. It presents FIRE4 and its use with LiteRed, demonstrating the approach on four-loop massless propagators and discussing improvements and additional master-integral relations.
Problem
Modern particle-physics calculations require reducing thousands or millions of Feynman integrals to a smaller set of master integrals.
Method
The paper presents FIRE4 and combines it with LiteRed, using LiteRed reduction rules and FIRE to apply them while reducing redundant IBP relations.
Results
The combined workflow yields a four-loop variant of MINCER for four-loop massless propagator integrals, while the new FIRE can substantially reduce redundant IBPs and speed reduction.
Takeaways & Limitations
FIRE4 and LiteRed provide a practical workflow for IBP reduction of quite complicated Feynman-integral families.
Takeaways & Limitations
The Mathematica version of FIRE cannot work in parallel mode, so reduction speed does not depend on the number of cores and RAM is more important.
Abstract
from arXiv · showhide
New features of the Mathematica code FIRE are presented. In particular, it can be applied together with the recently developed code LiteRed by Lee in order to provide an integration by parts reduction to master integrals for quite complicated families of Feynman integrals. As as an example, we consider four-loop massless propagator integrals for which LiteRed provides reduction rules and FIRE assists to apply these rules. So, as a by-product one obtains a four-loop variant of the well-known three-loop computer code MINCER. We also describe various ways to find additional relations between master integrals for several families of Feynman integrals.
1 Introduction
FIRE4 updates Mathematica FIRE for integration-by-parts reduction, including collaboration with LiteRed on complicated integral families. The paper illustrates this workflow with four-loop massless propagators and discusses additional master-integral relations.
- Motivation: IBP relations reduce thousands or millions of Feynman integrals to a smaller set of master integrals.The paper notes that the number of master integrals is theoretically finite.
- Purpose: FIRE4 is presented as the current Mathematica version of FIRE2, a program that reduces Feynman integrals to master integrals.FIRE is positioned among publicly available codes for IBP reduction.
- FIRE and LiteRed: FIRE can be applied together with LiteRed to provide IBP reductions for quite complicated families of Feynman integrals.LiteRed supplies reduction rules, while FIRE assists in applying them.
- Example: For four-loop massless propagator integrals, the combined workflow produces a four-loop variant of the three-loop computer code MINCER.The example uses LiteRed reduction rules and FIRE to apply them.
- Additional relations: The paper also describes ways to find additional relations between master integrals for several integral families.
2 Basic definitions
The paper defines Feynman integrals as indexed functions and organizes their IBP relations through sectors, complexity measures, boundary conditions, and ordered elimination. These definitions specify how reductions are structured and simplified.
- Integral notation: A Feynman integral is represented as a function of n integer indices, with denominator factors linear in loop and external-momentum scalar products.Dimensional regularization uses d = 4 − 2ε.
- IBP relations: IBP relations are rewritten as linear combinations of integrals whose indices are shifted by integer vectors.The displayed relation sets the weighted sum of shifted integrals to zero.
- Sectors: Sectors classify index sets by whether each index is positive or non-positive, and each sector has a unique corner integral with indices equal to 0 or 1.There are fewer than 2^n sectors when irreducible-numerator indices are always non-positive.
- Complexity: Reduction complexity is characterized first by the number of positive indices and then by the numbers of dots N+ and negative indices N−.N+ sums excesses above one for positive indices, while N− sums the absolute values of negative indices.
- Boundary conditions: Trivial sectors contain only vanishing integrals, and the all-non-positive sector is always trivial; the associated conditions are boundary conditions.
- Reduction algorithm: A Laporta algorithm solves IBP relations in a sector by Gaussian elimination after choosing an ordering.The ordering and algorithmic details can be modified by the implementer.
3 Combining FIRE with LiteRed
FIRE4 incorporates strategies for combining LiteRed rules with FIRE reduction and for reducing redundant IBP relations. The implementation can automate many boundary conditions, while some trivial sectors still require manual marking.
- Combining tools: FIRE includes ideas developed by Lee and is recommended for use with LiteRed.The paper frames the combination as a way to obtain efficient reductions for complicated families.
- Automatic boundary conditions: FIRE can automatically detect many boundary conditions by testing whether IBP relations applied to a corner integral make it vanish.This criterion follows from the Lie-algebra structure of IBPs.
- Automatic boundary conditions: Automatic boundary-condition detection does not always find all trivial sectors, including cases involving massless light-cone integrals.Such missing sectors can be marked manually after Prepare[].
- IBP selection: The Lie-algebra structure of IBPs allows FIRE to use fewer IBP relations during reduction.
- IBP selection: FIRE sorts IBPs so that they maximally shift indices under the chosen ordering and omits later relations when an integral is already highest in an earlier relation.This strategy is implemented in the new version of FIRE.
- IBP selection: The strategy decreases redundant IBPs substantially and speeds reduction, and it is enabled by default for classical IBPs.It should be disabled only for relations that do not form a Lie algebra.
M61 M62 M63
The section describes combining LiteRed reduction bases with FIRE to handle complicated four-loop propagator families. It also presents implementation steps, performance considerations, and the resulting relationship to MINCER.
- Reduction strategy: LiteRed creates sector-by-sector reduction rules, allowing integrals to be expressed quickly in terms of lower integrals without solving relations anew.These rules form a basis in each sector and reduce non-master integrals efficiently.
- Performance: Reduction performance depends on rule-application strategy: partial substitution can make expressions and coefficients grow, hindering algebraic simplification.FIRE chooses the higher-sector-first strategy followed by a reverse substitution pass.
- Implementation: FIRE requires propagator definitions, kinematic replacements, IBP generation, symmetry settings, and saved start data before applying LiteRed bases.The workflow then loads the start file, bases, and tables to evaluate target integrals.
- Implementation: FIRE can load LiteRed rules and tables on a clean kernel, after which the answer for a target integral can be retrieved immediately.The documented sequence uses LoadStart, LoadLRules, Burn, and LoadTables.
- Performance: The combined workflow is recommended for complicated four-loop massless propagator integrals because applying LiteRed bases through FIRE is more effective than using LiteRed alone.The authors did not attempt FIRE alone on these integrals because it would take too much time.
- Relation to MINCER: LiteRed rules resemble hand-derived rules, making the combined code a four-loop variant of MINCER while reducing directly to true master integrals.The automatically generated rules may be cumbersome, but their application within FIRE can be more effective than with the current LiteRed version alone.
4 Summary of smaller improvements in FIRE since version 3.0 5
FIRE4 adds integration with LiteRed, automatic basis construction, broader index support, configurable resource usage, and master-integral selection. The release also reports speed and memory improvements, bug fixes, and practical examples of basis construction and evaluation.
- FIRE4 can combine with LiteRed, whose bases are more efficient than FIRE’s former Gröbner-basis construction, while FIRE remains useful for missing sectors.LiteRed rules also support a four-loop variant of MINCER, and FIRE can construct rules that work better in some sectors.
- FIRE4 introduces multiple speed and memory improvements, including DatabaseUsage 4 and MemoryLimit-based automatic increases in disk-backed storage.Using more database storage reduces RAM requirements but degrades performance; the Mathematica version cannot run in parallel, so RAM is more important than core count.
- FIRE4 includes multiple bug fixes, and the authors report that it is substantially faster in some cases.
- The release supports more than fourteen indices, although this can be complicated in the Mathematica version.Fourteen indices correspond to families of four-loop propagator integrals.
- Users can choose master integrals with MakeMaster priorities, for example when one candidate is easier to calculate than another.Marked integrals are preferred over unmarked ones and compared using their positive integer priorities.
- Automatic basis construction is available through BuildAll, which searches for reductions that can eliminate all integrals from sectors without master integrals.A massless box example constructs bases in 3 of 11 sectors and then evaluates an integral using the saved bases.
- An evaluation example shows dependence on three master integrals, but FIRE does not automatically identify that two of them are identical without additional symmetry information.Global symmetries can provide this information, although some identical integrals cannot be located through diagram symmetries.
5 Getting rid of extra master integrals
FIRE4 addresses excess master integrals by combining cross-family identification, symmetry, differentiation, and LiteRed-assisted reductions. These tools expose equivalences and additional relations that individual-family reductions may miss.
- Finding extra relations: FIRE cannot generally identify equivalent master integrals beyond global diagram symmetries, so reductions may initially contain too many masters.This motivates combining master-integral sets across families and searching for additional relations.
- 5.1 tsort: tsort canonicalizes alpha-representations to identify equivalent integrals and exports the resulting relations as Mathematica rules or files for later reductions.It can be applied within one family, whereas other tools become more important across multiple families.
- 5.1 tsort: A massless box example shows that rerunning FIRE with loaded bases and rules reduces F[2,{2,2,2,2}] to two master integrals.The required setup supplies the family, propagators, kinematic replacements, bases, and rules.
- Finding extra relations: For the M61, M62, and M63 families, tsort maps 12 of 16 M62 masters and 16 of 21 M63 masters to the M61 family.The passage begins by reporting 18, 16, and 21 masters when the three families are treated individually.
- 5.2 Using symmetries to find extra relations: Symmetry in an auxiliary family reduces I11 through F(1,2,1,1,1) − F(1,1,2,1,1) = 0, although no symmetry reduces the highest-sector count within its original family.The auxiliary diagram is used to relate integrals associated with the massive and massless propagator configuration.
- 5.3 Using differentiation to find extra relations: Differentiating with respect to M^2 and reducing the resulting integrals reproduces the additional relation previously derived for the two-loop mixed-mass diagram.The construction uses F(1,2,1,2) = −∂/∂M^2 F(1,1,1,2) and equates the corresponding reduced expressions.
6 FIRE works slowly. Why?
FIRE4 can become slow because of incomplete input, inefficient basis construction, storage constraints, or excess master integrals. The paper gives configuration and workflow measures to address these causes.
- Input and boundary conditions: Incomplete IBP sets or missing boundary conditions create extra master integrals and can make reduction very slow.Unmarked trivial sectors are eventually detected but may cost substantial time.
- Input and workflow: Specifying all non-trivial global-symmetry permutations and using EvaluateAndSave for multiple integrals can improve FIRE’s reduction workflow.The paper specifically warns against evaluating multiple family integrals one by one with F[...].
- 6.2 Reduction bases: Automatically building reduction bases can substantially speed calculations, with performance also depending on how IBP-generating loops and momenta are chosen.The suggested choice uses partially intersecting loops and multiplies differentiated relations by momenta passing through corresponding loop lines.
- 6.2 Reduction bases: Using LiteRed with FIRE speeds reduction substantially by supplying reduction bases that FIRE can use.LiteRed must be downloaded separately and used to create the bases.
- 6.3 Computer issues: The Mathematica version cannot use parallel mode, so core count does not affect reduction speed; RAM and database settings are more important.When memory is insufficient, the paper recommends adjusting DatabaseUsage or MemoryLimit, or moving to another computer.
- 6.4 Extra master integrals: If reduction is fast but final substitutions are slow, excess master integrals remain the likely issue and require relations among those masters.The paper directs readers to the extra-relation methods for this case.
7 Conclusion
The paper presents FIRE4 as a tool for reducing Feynman integrals to master integrals and recommends using it with tsort and LiteRed. It also notes planned compatibility with a future C++ version.
- 7 Conclusion: FIRE4 is a new version of FIRE for reducing Feynman integrals to master integrals and includes tools such as tsort.The paper also presents the work as a guide to using FIRE and LiteRed efficiently together.
- 7 Conclusion: The approaches described are intended to remain compatible with the C++ FIRE version planned for future release.That C++ version was still under development when the paper was written.