Source-linked AI summary
FIRE6: Feynman Integral REduction with Modular Arithmetic
A. V. Smirnov, F. S. Chukharev
TL;DR
FIRE6 presents the substantially updated current version of FIRE, addressing the need to handle increasingly demanding Feynman-integral reductions. It combines parallelization, modular arithmetic, coefficient reconstruction, and master-integral management, delivering about twice the speed on small tests and improved feasibility for memory-intensive problems.
Problem
The paper addresses the need to update FIRE after multiple changes since its 2014 C++ version, including multi-computer reductions and modular arithmetic.
Method
FIRE6 combines parallelization through multiple nodes and level threads with modular-arithmetic reduction, coefficient reconstruction, and tools for identifying equivalent master integrals.
Results
About twice as fast as the previous public version on small tests, FIRE6 also provides memory economy and stability features that distinguish feasible from infeasible edge-of-science problems.
Takeaways & Limitations
FIRE6's memory economy and stability features can make calculations feasible that would otherwise be beyond the practical capabilities of earlier versions.
Takeaways & Limitations
The MPI version cannot currently run jobs with more than two variables substituted with different values.
Abstract
from arXiv · showhide
FIRE is a program performing reduction of Feynman integrals to master integrals. The C++ version of FIRE was presented in 2014. There have been multiple changes and upgrades since then including the possibility to use multiple computers for one reduction task and to perform reduction with modular arithmetic. The goal of this paper is to present the current version of FIRE.
PROGRAM SUMMARY
FIRE6 is a cross-platform, parallelized program for Feynman-integral reduction, combining Wolfram Mathematica and C++ implementations.
- FIRE6 is licensed under GPLv2 and supports Wolfram Mathematica 6.0 or higher and C++.
- The program is designed for Linux 64-bit and Mac OS X 10.6 or higher 64-bit systems.
- FIRE6 targets hardware ranging from desktop PCs to supercomputers.
- FIRE6 is parallelized, with typical RAM requirements depending on problem complexity.
1. Introduction
FIRE6 addresses the reduction of millions of Feynman integrals by extending FIRE with modular arithmetic, distributed execution, recovery, and other functionality. The release was successfully applied to demanding calculations and is reported as about twice as fast as the previous public version on small tests.
- Feynman-integral calculations can involve millions of integrals reduced through integration-by-parts relations to master integrals.
- Existing reduction programs include public and private implementations based mainly on the Laporta algorithm, alongside explicit-rule approaches such as LiteRed.
- Modular arithmetic fixes variable values and computes over large-prime remainder fields, using machine-size integers but requiring many reduction jobs for coefficient recovery.
- FIRE6 is presented as a major release whose applications include calculations probably unachievable with previous FIRE versions.
- About twice as fast as the previous public version on small tests.
- Memory economy and stability features distinguish FIRE6 especially on problems at the edge of science.
- New functionality includes internal sector symmetries, crash recovery, multiple nodes, modular arithmetic, and MPI tasks on supercomputers.
- The paper covers FIRE6 usage, internals, modular arithmetic, configuration options, and documentation for users and contributors.
2. Basic definitions
Feynman integrals are functions of integer indices and are reduced using integration-by-parts relations organized by sectors and boundary conditions. Sectors are ordered by their corner integrals, with lower sectors generally representing simpler integrals.
- Feynman integrals are functions of integer variables called indices.
- Integration-by-parts relations are rewritten as linear relations among integrals with shifted indices.
- 2^n sectors are defined by specifying which indices are positive and which are non-positive.
- Each sector has a unique corner integral whose indices are all 0 or 1.
- Lower sectors are defined by smaller corner indices and generally contain simpler integrals targeted during reduction.
- A sector is trivial when all its integrals vanish, and the conditions identifying such sectors are called boundary conditions.
3. Installation
FIRE6 is distributed through Bitbucket, with source compilation recommended and optional binary packages available. Its build supports configurable compressors, debugging and memory-allocation options, parallel and MPI versions, tests, documentation, and distinct modular-arithmetic binaries.
- FIRE6 is distributed via Bitbucket, with binary packages for Ubuntu 16.04 and openSUSE 15.0, although building from sources is recommended.
- The installation begins by cloning the repository and entering the resulting fire/FIRE6 directory.
- FIRE is configured through a script that sets preprocessor variables and makefiles rather than using the autoconf system.
- Optional configuration enables zlib, Snappy, zstandard, debugging symbols, and tcmalloc-based memory allocation.
- The build creates FIRE6, FLAME6, and FTool6 binaries, while binaries ending in p provide modular-arithmetic versions.
- FIRE6 includes tests, an MPI build for supercomputers, gitflow-based development updates, and generated HTML, LaTeX, and PDF documentation.
4. Basic usage of FIRE
FIRE6 uses Mathematica to prepare integral-family start files and C++ to perform complicated reductions, producing tables that Mathematica can load and evaluate. Its workflow supports automatic boundary detection, optional symmetries and restrictions, table reuse, and conversion of reduction results into rules.
- Workflow: For complicated problems, users create a Mathematica start file, run the reduction with C++, and read the resulting tables in Mathematica.The authors recommend using LiteRed to produce symmetries before reduction.
- Preparing a start file: A start file records one integral family's dimension, sectors, and integration-by-parts relations, together with internal and external momenta, propagators, and kinematic replacements.Restrictions are optional because FIRE can detect boundary conditions automatically in most cases.
- Preparing a start file: The preparation stage uses PrepareIBP[] and Prepare[], optionally enabling automatic-restriction control or parallel execution, then saves the file with SaveStart[].The example saves a massless doublebox setup as doublebox.start.
- Using Mathematica: FIRE can load start files with LoadStart[], initialize a family number, and use Burn[] before reducing integrals with F.The family number distinguishes integral families and supports finding equivalents between them.
- Loading and using tables: Reduction results express input integrals as combinations of irreducible master integrals, while EvaluateAndSave and the C++ version create reusable tables.Tables can be loaded with LoadTables or converted directly into Mathematica rules with Tables2Rules, without loading a start file.
5. Internals of FIRE
FIRE6 organizes reductions as parallel sector jobs coordinated through independent databases, followed by substitutions and lower-level propagation. Its parallel modes trade speed, memory, and database overhead, with some features depending on separate Fermat workers.
- Sector processing: FIRE6 enumerates sectors, stores each sector in its own database, and launches sector jobs rather than using one shared database.This independent-database design is intended to improve parallelization.
- Sector processing: Sector jobs run from higher to lower levels, while completed levels pass required integrals to lower-sector databases.After the lowest level, FIRE6 reverses direction and performs substitutions while increasing levels.
- Resource management: Memory usage is almost linearly proportional to the number of sectors reduced or substituted simultaneously.Thread and job options should therefore be chosen with concurrent sector count in mind.
- Sector processing: Integrals mapped by global symmetries are assigned to the lowest points in their orbits before reduction, and lower-sector integrals are masked during sector work.Masking delays substitutions to prevent substitution growth.
- Distributed execution: FIRE6 can run one reduction across multiple machines through a storage folder, with slave FLAME6 processes connecting to the main FIRE6 job.The storage mechanism also supports crash recovery by preserving database copies.
- Parallelization: Level threads process similarly complex integrals in parallel within a sector, but require separate Fermat mode and may reduce performance through database locks.The potential speedup depends on the problem and computer structure; lock overhead is more noticeable in prime mode.
6. Modular arithmetic
FIRE6 uses modular arithmetic to reduce coefficient growth by evaluating over large prime fields and reconstructing rational or variable-dependent coefficients afterward. The workflow supports massively parallel jobs, but reconstruction and multidimensional substitutions impose practical limits.
- Modular reduction: Modular reduction replaces integers by remainders modulo a large prime, whose nonzero elements have unique inverses.This moves calculations into a finite field and avoids the number growth encountered with direct rational reduction.
- Modular reduction: FIRE6 modular runs use FIRE6p, assign values to all variables, and select a prime through the #prime setting.A hint run can record the integration-by-parts relations actually used for later runs.
- Reconstruction limits: More than one variable can be substituted, but FIRE6 currently has no stable reconstruction procedure for that case.This is a scope limitation of the reconstruction workflow rather than of modular evaluation itself.
- Massive parallelization: MPI distributes runs over primes and variable ranges, producing many tables that are later used for coefficient reconstruction.The approach is most suitable for supercomputers because the required number of jobs can be very large.
- Massive parallelization: The MPI version cannot run jobs with more than two variables substituted with different values.Non-MPI concurrent runs require modified paths and semaphores to avoid database conflicts.
- Reconstruction: Rational reconstruction first recovers rational coefficients from modular values, then reconstructs formulas whose variables may still need interpolation.The first stage stabilizes as additional prime evaluations stop changing the reconstructed numbers.
- Reconstruction: One-variable formulas can use Newton reconstruction, while two-variable reconstruction combines Newton or Thiele forms and exploits factorizing denominator structure.After denominator factors are cleared, Newton-Newton reconstruction can recover polynomial coefficients.
Appendix: config files for C++
The C++ configuration exposes controls for execution, storage, parallelism, database tuning, variable substitution, and reduction behavior. Several options encode resource, filesystem, and compatibility constraints.
- Database tuning: #compressor selects among database compression engines, with none potentially speeding prime-mode runs when sufficient RAM is available.#bucket trades database reopening overhead against RAM use, while #wrap reduces the number of files.
- Execution and parallelism: #threads controls parallel reduction of sectors at the same level, while #fthreads controls Fermat processes and #sthreads controls substitution threads.Separate Fermat mode is enabled by prefixing the #fthreads value with s.
- Execution and parallelism: #lthreads enables level threads only when FIRE is compiled with level-thread support.These threads parallelize nearly independent integration-by-parts work within a sector.
- Variables and arithmetic: #prime selects the evaluation prime in the prime version, while #variables defines reduction variables and may provide numeric replacements.The prime setting uses an index into FIRE’s hard-coded prime list rather than the prime value itself.
- Storage: #database selects the data path, while #memory stores active databases in RAM instead of using disk mode.Network-drive paths are especially discouraged in disk mode, whereas RAM mode uses more memory.
- Storage: #storage preserves database files and can support recovery or distributed execution, but is incompatible with differing #threads and #sthreads settings.The incompatibility arises because FIRE cannot distinguish local and remote threads reliably in that configuration.
- Reduction behavior: #allIBP restores integration-by-parts relations omitted by default when special cases might invalidate the usual dependency logic.This option is needed when those relations may contain missing information for non-standard IBPs.
Conclusion
FIRE6 is presented as a public major release of FIRE for Feynman integral reduction, adding distributed, parallel, modular, crash-recovery, and supercomputer-oriented functionality. The authors report successful use in multiple projects and invite further improvements and error reports.
- Conclusion: FIRE6 extends FIRE with crash recovery, multi-machine reductions, intra-sector parallelization, modular arithmetic, and supercomputer support.The release also incorporates functionality requested by users and reduction problems.
- Conclusion: The authors report that FIRE6 was successfully applied in multiple projects and that some results were probably unachievable with earlier public versions.They identify modular arithmetic as enabling at least one previously impractical calculation.