Source-linked AI summary
FIRE5: a C++ implementation of Feynman Integral REduction
Alexander V. Smirnov
TL;DR
FIRE5 addresses the computational challenge of reducing very large collections of Feynman integrals to master integrals. It retains Mathematica for preparation and result handling while moving the reduction itself to C++. The paper reports substantial speedups, including a reduction from 1453 seconds to 92 seconds in one example, with limitations involving LiteRed conversion and platform support.
Problem
Feynman integral reduction can involve very large numbers of integrals, motivating a more capable implementation than the earlier Mathematica-only FIRE versions.
Method
FIRE5 uses Mathematica for preparing tasks and reading results, while its reduction engine runs in C++ using the same start and rules files.
Results
1453 seconds versus 92 seconds: the C++ reduction was substantially faster than Mathematica for the reported example.
Takeaways & Limitations
FIRE5 preserves backward compatibility and Mathematica interoperability while enabling C++ reductions for problems that earlier versions could not feasibly handle.
Takeaways & Limitations
LiteRed files require conversion before use by C++, and the C++ FIRE has stated platform limitations, especially for Windows and potentially macOS.
Abstract
from arXiv · showhide
In this paper the C++ version of FIRE is presented - a powerful program performing Feynman integral reduction to master integrals. All previous versions used only Wolfram Mathematica, the current version mostly uses Wolfram Mathematica as a front-end. However, the most complicated part, the reduction itself can now be done by C++, which significantly improves the performance and allows one to reduce Feynman integrals in previously impossible situations.
PROGRAM SUMMARY
FIRE5 is a C++ implementation of FIRE, with Mathematica and C++ support for Feynman integral reduction.
- FIRE5 is implemented in C++ and uses Wolfram Mathematica 6.0 or higher as a programming environment.
1. Introduction
Feynman integral reduction addresses the need to simplify thousands or millions of integrals to master integrals. FIRE5 presents a C++ version of an existing Mathematica-based program for this task.
- Thousands or millions of Feynman integrals often need evaluation in modern elementary particle physics.
- Integration-by-parts relations reduce Feynman integrals to a smaller set of master integrals.
- FIRE is one of multiple programs performing Feynman integral reduction, with earlier versions written in Wolfram Mathematica.
- FIRE5 presents a C++ version of FIRE, following earlier reductions involving about 3 billion integrals and applications in numerous projects.
2. Basic definitions
The paper defines Feynman-integral families, integration-by-parts relations, sectors, complexity measures, boundary conditions, and the Laporta reduction algorithm.
- Feynman integrals are functions of integer indices whose denominator factors are linear in loop and external-momentum scalar products, using d = 4 − 2ε dimensional regularization.
- Integration-by-parts relations provide equations used to reduce integrals within a family.
- Sectors classify index sets by whether each index is positive or non-positive, and each sector has a unique corner integral with indices 0 or 1.
- Integral complexity is basically defined by the number of positive indices, together with the nonnegative quantities N+ and N−.
- A sector is trivial when all integrals in it vanish; the conditions determining this are called boundary conditions.
- The Laporta algorithm solves integration-by-parts relations in a sector by Gauss elimination after choosing an ordering.
3. Installation
FIRE5 can be obtained as a binary or built from source, with dependencies and testing steps documented. The Linux-oriented installation has explicit operating-system and external-program limitations.
- FIRE5 can be downloaded as a binary package or built from sources.
- Building from source requires cloning the repository, installing or building dependencies, and running make commands from the fire/FIRE5 directory.
- FIRE includes kyotocabinet 1.2.76 and snappy 1.1.1 as bundled dependencies.
- The compiled binaries can be tested with make test.
- The C++ FIRE is designed primarily for Linux, with separate guidance for 32-bit Linux and possible installation problems on macOS.
- The paper states that making the C++ FIRE work under Windows is not considered possible.
4. Usage of FIRE
FIRE5 prepares Feynman-integral problems through Mathematica start files and can perform the reduction in C++, returning tables that Mathematica can load. LiteRed rules and equivalent-master-integral relations can further improve reductions.
- Preparing a start file: A start file records momenta, propagators, kinematic replacements, boundary conditions, and symmetries for a diagram.It is prepared with commands such as PrepareIBP[], Prepare[], and SaveStart[].
- Mathematica reduction: FIRE loads a start file, assigns a family number, and reduces requested integrals using Mathematica commands such as F[].EvaluateAndSave can reduce selected integrals and save tables for later use.
- Finding equivalents between master integrals: Loading rules found relations among equivalent master integrals and reduced the example from 12 master integrals to 8.FIRE can find or save such relations with MasterIntegrals[], FindRules[], and WriteRules[].
- C++ reduction: C++ FIRE uses the same start and rules files as input and saves reduction tables that can subsequently be loaded into Mathematica.The C++ executable is a direct replacement for EvaluateAndSave and does not require Mathematica for the reduction.
- C++ reduction: The C++ reduction took 92 seconds versus 1453 seconds for Mathematica on the example, while a rules-based configuration took 62 seconds.The 92-second comparison includes Mathematica with and without rules; the 62-second result is reported for the rules-based C++ job.
- Using LiteRed rules: LiteRed files cannot be used directly by C++ FIRE and require conversion before LiteRed rules can accelerate the reduction.The configuration uses converted .sbases and .lbases files together with an integral list and output-table path.
5. Additional options
FIRE exposes Mathematica options and configuration commands for controlling data storage, algebraic processing, parallelism, input constraints, and output. The configuration supports either full reduction or faster master-integral discovery.
- Runtime options: DatabaseUsage controls whether FIRE stores information in a database, while MemoryLimit increases database usage after reaching a memory threshold.DatabaseUsage ranges from 0 to 4; MemoryLimit is specified in megabytes.
- Runtime options: UsingFermat enables the external fermat program for algebraic simplifications, and FactorCoefficients controls coefficient factoring in final output.UsingFermat is False by default, whereas FactorCoefficients is True by default.
- Configuration files: Configuration files specify problems, rules, variables, databases, threads, and input integrals before launching the reduction.The order of some commands is important, and #start follows the preceding configuration lines.
- Database configuration: Database paths, bucket values, and memory mode determine storage behavior and the trade-off between speed, RAM use, and network-drive robustness.The default bucket is 20; complicated tasks may use 27–30, while #memory selects disk mode and changes RAM usage.
- Configuration files: The #output command stores resulting tables, while #masters restricts the task to finding master integrals, which can be faster than full reduction.WriteRules can then identify equivalents before a subsequent full reduction.
6. Optimization hints
The optimization guidance emphasizes using the C++ reducer, supplying boundary and symmetry information, tuning parallelism and databases, and managing redundant masters and cached storage.
- Performance: A sample doubebox integral achieved a speedup by a factor of 20 with C++ FIRE, with larger gains expected for more complicated reductions.The paper recommends performing reductions with the C++ version because it is significantly faster.
- Input and structural information: Correct boundary conditions and symmetry information are important because missing information can substantially slow reduction.AutoDetectRestrictions, LiteRed, and FindSymmetries are suggested sources of such information.
- Parallelization: Parallelization should use threads and fthreads, balancing processor count against RAM consumption.Threads can be reduced when RAM usage is high while fthreads remains higher.
- Storage and memory: Local fast storage, sufficient RAM, and appropriate bucket settings improve database performance, whereas swapping can make reduction fail.For complicated cases, the database may require a terabyte or more of local space.
- Master-integral management: Equivalent master integrals should be identified when substitution is slow, using LiteRed, FindRules, or WriteRules before the final reduction.A partial reduction can first reveal masters and their equivalences.
7. Conclusion
FIRE5 retains Mathematica as the preparation and result interface while moving the reduction itself to C++, producing a substantial speedup over previous versions.
- Conclusion: FIRE5 is backward-compatible with previous Mathematica versions, with tasks prepared in Mathematica and results readable there.The C++ implementation changes the reduction stage while preserving the Mathematica interface.
- Conclusion: The reduction itself can run in C++, yielding a tremendous speedup compared with previous versions.The conclusion presents this C++ reduction capability as the central advance of FIRE5.
- Conclusion: FIRE5 is presented as a powerful program for Feynman integral reduction.The conclusion characterizes the program at the paper level rather than describing a specific benchmark.