PaperlayerView exact revision on arXiv

Source-linked AI summary

Integral Reduction with Kira 2.0 and Finite Field Methods

Jonas Klappert, Fabian Lange, Philipp Maierhöfer, Johann Usovitsch

arXiv:2008.06494v2hep-phhep-th

TL;DR

High-precision particle-physics calculations require reducing Feynman integrals to master integrals, while large Laporta systems impose substantial computational costs. Kira 2.0 uses FireFly-assisted finite-field reconstruction, MPI parallelization, and expanded user-equation support. Benchmarks report significantly reduced main-memory consumption and increased performance compared with previous Kira versions.

  • Problem

    Reducing Feynman integrals is central to high-precision calculations, but state-of-the-art Laporta reductions require substantial CPU time and main memory.

  • Method

    Kira 2.0 repeatedly solves reduction systems over finite fields, reconstructs coefficients with FireFly, parallelizes this procedure using MPI, and supports arbitrary homogeneous linear systems.

  • Results

    Benchmarks show significantly increased performance and reduced main-memory consumption compared with previous Kira versions.

  • Takeaways & Limitations

    Kira 2.0 extends finite-field reduction to practical cluster execution and broader user-provided equation systems.

  • Takeaways & Limitations

    Probe computation can limit scaling, while interpolation may dominate runtime and interpolation is performed on a single thread in some examples.

Abstract

from arXiv · show

We present the new version 2.0 of the Feynman integral reduction program Kira and describe the new features. The primary new feature is the reconstruction of the final coefficients in integration-by-parts reductions by means of finite field methods with the help of FireFly. This procedure can be parallelized on computer clusters with MPI. Furthermore, the support for user-provided systems of equations has been significantly improved. This mode provides the flexibility to integrate Kira into projects that employ specialized reduction formulas, direct reduction of amplitudes, or to problems involving linear system of equations not limited to relations among standard Feynman integrals. We show examples from state-of-the-art Feynman integral reduction problems and provide benchmarks of the new features, demonstrating significantly reduced main memory usage and improved performance w.r.t. previous versions of Kira.

NEW VERSION PROGRAM SUMMARY

Kira 2.0 adds finite-field coefficient reconstruction with FireFly, MPI parallelization, improved user-equation support, and lower-memory equation generation. Its reduction strategy generates and solves IBP, Lorentz-invariance, and symmetry relations over finite fields.

  • Kira 2.0 reconstructs final integration-by-parts coefficients using finite-field methods with FireFly.
  • The finite-field reconstruction procedure can be parallelized across computer clusters with MPI.
  • User-provided systems of equations receive expanded support, enabling applications beyond standard relations among Feynman integrals.
  • The release includes a feature that reduces main-memory usage while generating the system of equations.
  • Kira generates equations from integration-by-parts, Lorentz-invariance, and symmetry identities, then identifies master integrals by finite-field system solving.

1 Introduction

High-precision particle-physics calculations rely on reducing many Feynman integrals to master integrals, but state-of-the-art reductions remain computationally demanding. Kira 2.0 addresses this with finite-field reconstruction, MPI parallelization, and broader equation-system support.

  • Feynman-integral reduction expresses integrals through master integrals for high-accuracy scattering calculations and for methods computing the masters themselves.
  • No general target-oriented reduction algorithm is known, so the Laporta algorithm remains the method of choice in most cases.
  • Kira 2.0 reconstructs integral-reduction coefficients with FireFly finite-field methods and can parallelize the reduction across MPI-enabled computer clusters.
  • The article describes new features, benchmarks, and procedures for obtaining, compiling, and installing Kira.

2 Preliminaries

The preliminaries define Feynman-integral sectors, complexity measures, and Laporta reduction, then explain finite-field interpolation and rational reconstruction as alternatives to fully algebraic solving. These methods reduce coefficient-size dependence and enable parallel probe evaluations, while interpolation and probe computation can remain bottlenecks.

  • 2.1 Feynman integral reduction: Feynman integrals are parametrized by propagator powers, loop and external momenta, masses, and a complete independent set of inverse propagators.
  • 2.1 Feynman integral reduction: IBP, Lorentz-invariance, and symmetry identities generate linear relations that express integrals as combinations of master integrals.
  • 2.1 Feynman integral reduction: Complexity is measured using the number of positively powered propagators and the sums of positive and non-positive propagator powers, bounded by rmax and smax.
  • 2.1 Feynman integral reduction: Laporta reductions are costly because of huge equation systems, growing intermediate expressions, and large rational-function coefficients.
  • 2.2 Finite field and interpolation techniques: Finite-field arithmetic maps coefficients to fixed-size modular integers, reducing coefficient memory and making operations independent of original rational-function size.
  • 2.2 Finite field and interpolation techniques: Kira can reconstruct analytic coefficients by repeatedly solving over prime fields, interpolating rational functions, and applying rational reconstruction, with CRT extending size limits.
  • 2.2 Finite field and interpolation techniques: Independent finite-field probe evaluations allow massive parallelization across CPU cores and cluster nodes.
  • 2.2 Finite field and interpolation techniques: FireFly trims irrelevant equations and interpolations, but probe computation and single-threaded interpolation can dominate runtime in some examples.

3 New Features in Kira 2.0

Kira 2.0 adds FireFly-based finite-field reduction, MPI parallelization, expanded user-system support, and memory-oriented improvements. These features extend reduction workflows while imposing specific configuration constraints.

  • Finite-field reduction: FireFly can perform full reductions or only back substitution through the run_firefly option.The true variant imports the full system, whereas back requires a triangular system from run_triangular.
  • Finite-field reduction: Several probes can be combined into coefficient arrays, reducing traversal overhead at the cost of moderately increased main memory usage.The --bunch_size=n option controls FireFly’s maximum bunch size.
  • Parallelization: MPI parallelizes FireFly probes across worker nodes while the main node performs interpolation.MPI should be used for multiple machines; assigning all cores on one machine to a single Kira process generally performs best.
  • User-provided systems: User-provided systems support configurable input options for files, on-the-fly solving, equation counts, and configuration-directory usage.The input_system structure includes files, otf, size, and config fields, all with optional specifications.
  • User-provided systems: User-defined systems accept multiple files, optional compression or directory inputs, and an on-the-fly solver that can reduce memory usage.On-the-fly solving requires equations to be approximately ordered by complexity; the size option can provide the equation count.
  • User-defined weights: User-defined weights use 64-bit unsigned integers, with values from 0 to 2^64 − 2 and 2^64 − 1 reserved internally.Preferred masters cannot be combined with user-defined weights, and sector-based reduction options are unavailable in this mode.

3.3 Iterative reduction

Iterative reduction automates repeated reductions over master integrals or sectors, helping control memory usage in large reductions. Its performance depends on coefficient complexity and the overhead of repeated system solves.

  • Overview: The iterative_reduction option automates iteration over master integrals in two variants.The feature replaces manual selection and merging of partial reductions.
  • Variants: The masterwise variant performs separate reductions for each master integral sequentially.
  • Variants: The sectorwise variant performs separate reductions for all master integrals in each sector sequentially.
  • Execution: Iterative reduction works with both Fermat-based back substitution and FireFly, with MPI parallelizing one master integral or sector per iteration step.Back substitution creates separate partial-reduction databases that are automatically merged.
  • Performance: FireFly may require far fewer probes for master integrals with simple coefficients than for those with complicated coefficients.Equations reducing integrals to zero can also reduce the required probing effort.
  • Trade-offs: The primary use case is reducing main memory, but runtime effects are difficult to predict and can be negative.Sectorwise is usually preferred over masterwise unless the additional memory reduction is necessary to run the calculation.

3.4 Master equations

Master equations let Kira treat linear combinations of integrals as basis elements, supporting convenient bases for coupled differential equations and related systems.

  • Motivation: Linear combinations can serve as basis elements when a convenient basis simplifies coupled differential equations for master integrals.
  • Implementation: Kira represents each linear combination by a new low-weight integral-like object and adds an equation equating it with that combination.These relations are called master equations.
  • Input: Master equations are defined through the same preferred-basis input file used for preferred master integrals.
  • Representation: Kira enumerates master equations from 1 and represents them as BASISLC[n] according to their order in the preferred basis file.

3.5 Sectors in big-endian binary notation

Kira 2.0 adds big-endian binary sector notation and explicit zero-sector handling, alongside support for exporting results for later Kira runs. Prefactor insertion can simplify finite-field interpolation under a suitable basis.

  • Binary sector notation: Sectors can be specified in big-endian binary notation in both job files and integralfamilies.yaml.The notation begins with b, followed by the binary sector representation.
  • Binary sector notation: The example b111111100 denotes a nine-propagator sector with seven denominator propagators and two numerator irreducible scalar products.
  • Zero sectors: The zero_sectors option sets all integrals in specified sectors to zero and adds them to the automatically determined trivial sectors.
  • Export: Kira can export results for Mathematica, FORM, or reuse as input for user-defined systems in subsequent Kira runs.The kira2file format is compatible with the user-defined-system input format.
  • Prefactor insertion: Prefactors can be divided out during FireFly interpolation and restored in the final result, reducing the expressions being interpolated.The factorization usually works only in a specific master-integral basis selected with preferred_masters.
  • Prefactor insertion: FireFly still interpolates a rational function for technical reasons, while identifying trivial denominators adds marginal runtime for multiscale problems.

3.9 General propagators

Kira 2.0 broadens propagator definitions beyond standard quadratic forms, supporting linear loop-momentum propagators and mixed notation while retaining compatibility formats. General propagators remain limited because symmetry relations cannot currently be applied to numerator occurrences.

  • 3.9 General propagators: General propagators allow forms beyond usual quadratic expressions, including propagators with loop momenta appearing only linearly.These forms are relevant, for example, in HQET.
  • 3.9 General propagators: Kira permits combining two propagators into a one-dimensional Feynman-parameter representation.An example uses (x(q1^2−m1^2)+(1−x)(q2^2−m2^2))^2.
  • 3.9 General propagators: The general-propagator example defines all four propagators using the extended notation.The full example is available in examples/general_propagators.
  • 3.9 General propagators: Kira currently cannot apply symmetry relations to integrals containing general propagators in the numerator, so standard unsquared-momentum notation is recommended when possible.The restriction concerns negative propagator powers.
  • 3.9 General propagators: Different general-propagator notations can be mixed within one topology definition.Kira also supports a bilinear notation for compatibility with Reduze 2.

3.10 Add sectors for preferred master integrals

Kira can generate equations for sectors containing preferred master integrals, including higher-sector relations that reduce master-integral counts. It also supports staged equation generation for later user-defined-system reduction, trading memory for generation time.

  • 3.10 Add sectors for preferred master integrals: Kira generates equations in the sector of each preferred master integral, even when that sector is not requested for reduction.The relevant r and s limits are taken from the job file.
  • 3.10 Add sectors for preferred master integrals: This feature can identify magic relations from higher sectors that reduce the number of master integrals in lower topologies.An example for a single topology is provided in examples/magic_relations.
  • 3.10 Add sectors for preferred master integrals: generate_input: {level: 0} selects a linearly independent subsystem for the given seeds and writes it to input_kira for later use as a user-defined system.The generated equations are represented using integer weights and can be read by the on-the-fly solver.
  • 3.10 Add sectors for preferred master integrals: For level values ≥1, Kira generates separate systems for subsectors and remaining sectors, often reducing memory needed for full-system generation by more than 50%.Generation time becomes significantly longer, and subsystem selection for specific integrals must occur in a later run.
  • 3.10 Add sectors for preferred master integrals: amplitude_translate converts integral combinations into weighted equations, allowing multiple amplitudes to be supplied and referenced through select_mandatory_list.Multiple amplitudes are separated by empty lines; weights count down from 264−1.
  • 3.10 Add sectors for preferred master integrals: An example of amplitude translation is provided in examples/aah-nl-sing.

4 Benchmarks

The benchmarks evaluate Kira 2.0's finite-field reduction, MPI parallelization, iterative memory reduction, and algebraic-forward-elimination strategy across demanding topologies. Results show runtime–memory trade-offs, useful MPI speed-ups with diminishing returns, large memory savings from sectorwise reduction, and substantial probe acceleration in a hybrid strategy.

  • Benchmark conditions: Benchmark runtimes vary by cluster node and filesystem workload, so reported timings carry uncertainties of a few percent.The benchmark environment includes nominally equal nodes with differing CPU and thermal behavior, plus fluctuating cluster-filesystem performance.
  • Runtime reduction with bunches and MPI: Increasing FireFly bunch size from 1 to 2 reduces runtime by roughly 25% for about 1 GiB more RAM, while size 4 saves another 20% but costs 5 GiB.Larger bunches provide smaller subsequent runtime gains while memory requirements increase faster; topo5 is mainly limited by pyRed probe computation.
  • Runtime reduction with bunches and MPI: MPI speed-up for topo5 reaches 1.8 with twice the cores, 2.5 with three nodes, 3.1 with four, and 3.3 with five nodes.Additional worker nodes require about 9 GiB of RAM, but further nodes are not worthwhile for this example because probe computation remains limiting.
  • Reducing the memory footprint with iterative reduction: Sectorwise iterative reduction cuts FireFly memory usage by more than a factor of 4, but increases runtime by 80% in the topo5 benchmark.The method reduces the memory footprint by setting master integrals to zero sector by sector.
  • Combining algebraic forward elimination with finite field reduction: For the conformal-integral topology, algebraic forward elimination reduces the system to 572313 equations and 6144971 terms, versus 8922459 equations and 64009470 terms before it.Using the forward-solved system reduces probe time from 370 s to 12 s, despite producing more complicated coefficients.
  • Combining algebraic forward elimination with finite field reduction: The hybrid algebraic–finite-field strategy can be offset when forward elimination makes coefficients much harder to parse and evaluate, especially for multi-scale problems.In the benchmark, coefficient evaluation and back substitution became slower, but remained negligible compared with the time saved by the forward-solved system.

5 Installation

Kira can be installed from prebuilt Linux x86_64 executables, source archives, or Git, with Meson/Ninja or Autotools build paths and optional FireFly, FLINT, MPI, and jemalloc support.

  • Obtaining Kira: A statically linked Linux x86_64 executable is available, while MPI support requires compiling Kira against the cluster’s MPI installation.Source code, release tags, pre-release branches, and compressed release archives are also provided.
  • Requirements: Kira supports Linux x86_64 or macOS and requires a C++14 compiler, a C11 compiler, GiNaC with CLN, and Fermat.Meson 0.46 or later and Ninja are additionally required for the Meson build path.
  • Optional features: MPI is disabled by default, and the Meson option -Dmpi=true enables MPI when FireFly is built as a subproject.OpenMPI is reported to work best, while MPICH is recommended for performance reasons.
  • Dependencies: Meson can automatically build missing yaml-cpp, FireFly, and FLINT subprojects, whereas Autotools requires enabled dependencies to be installed manually.FireFly and FLINT are optional dependencies enabled by default in the Meson configuration.
  • Building and installing: Meson builds Kira with meson, cd, ninja, and ninja install commands, while Autotools uses configure, make, and make install.The installation prefix is optional in both workflows.
  • Optional features: The -Djemalloc=true option enables jemalloc, which can improve performance by often more than 20% when FireFly is used.The authors warn that jemalloc may not work on some systems, especially with certain MPI implementations.

6 Conclusions

Kira 2.0 adds finite-field coefficient reconstruction with FireFly, MPI parallelization, and broader support for user-provided equation systems. Reproduced benchmarks report higher performance and lower main-memory consumption, alongside new state-of-the-art resource benchmarks.

  • New features: Kira 2.0 reconstructs final reduction coefficients with finite-field methods using FireFly and parallelizes this procedure across computer clusters with MPI.Its user-provided equation framework now supports most features available for integration-by-parts reductions.
  • New features: The extended user-equation framework supports specialized reduction formulas, direct amplitude reduction, and linear systems beyond standard Feynman-integral relations.This flexibility is identified as a major extension of the release.
  • Benchmarks: Reproduced benchmarks show significantly increased performance and reduced main-memory consumption compared with previous Kira publications.Additional state-of-the-art benchmark points demonstrate how newly added features affect computing-resource requirements.
Loading 2008.06494v2…