Source-linked AI summary
Reduze - Feynman Integral Reduction in C++
C. Studerus
TL;DR
Feynman-integral reductions require solving large systems of identities whose algebraic prefactors need computer-algebra simplification. Reduze implements Laporta reduction in C++ with GiNaC, supports parallel execution, and expresses selected integrals through master integrals, subject to documented range, output, and resource constraints.
Problem
Reductions involve thousands of equations with rational-polynomial prefactors, requiring computer algebra to solve systems of related Feynman integrals.
Method
Reduze generates IBP and optional LI identities, applies a Laporta algorithm, simplifies prefactors using GiNaC, and can run reductions in parallel.
Results
Selected integrals in the constructed system are expressed as linear combinations of master integrals.
Takeaways & Limitations
Reduze provides an open-source, low-memory implementation for reducing Feynman integrals, including parallel reductions of multiple diagrams.
Takeaways & Limitations
Reduze cannot solve a single integral independently and is limited to N = 16 propagators, R = 16 numerator-plus-denominator exponent sum, and S = 8 denominator exponent sum.
Abstract
from arXiv · showhide
Reduze is a computer program for reducing Feynman Integrals to master integrals employing a Laporta algorithm. The program is written in C++ and uses classes provided by the GiNaC library to perform the simplifications of the algebraic prefactors in the system of equations. Reduze offers the possibility to run reductions in parallel.
1. Introduction
Loop amplitudes produce large systems of related dimensionally regularized Feynman integrals, making computer algebra essential. Reduze addresses their reduction to master integrals with a C++ implementation, GiNaC simplification, Laporta reduction, and parallel execution.
- Motivation: Loop amplitudes contain many dimensionally regularized integrals related by Integration by Parts and Lorentz Invariance identities.
- Motivation: Thousands of equations and rational-polynomial prefactors make computers and computer algebra systems indispensable for reductions.
- Reduze: Reduze is a C++ program that generates IBP and optionally LI identities, reduces integrals to master integrals, and simplifies prefactors with GiNaC.
- Reduze: Reduze applies a Laporta algorithm after defining a restricted integral set, generating identities, and solving the resulting system.
- Parallelization: Reductions for different diagrams with the same number of propagators can be launched simultaneously across available cores or processors.
- Advantages: Reduze is presented as open source, low-memory software capable of parallel reductions.
2. Theoretical background
The paper defines propagators, sectors, and integral representations, then constructs IBP and LI identities and uses them to reduce bounded systems to master integrals. Symmetries and zero-sector detection can simplify the systems, while reductions remain subject to finite-range and sub-sector constraints.
- 2.1 Propagators, Sectors and Integrals: A propagator is q^2 − m^2, with q a linear combination of loop and external momenta under the stated Minkowski metric.
- 2.1 Propagators, Sectors and Integrals: An auxiliary topology contains propagators sufficient to express all scalar products involving at least one loop momentum.
- 2.1 Propagators, Sectors and Integrals: Every subset of t propagators defines a sector, while all 2^n − 1 sectors form the sector structure of an n-propagator auxiliary topology.
- 2.1 Propagators, Sectors and Integrals: Reduze represents an integral by the vector of propagator exponents, with positive, negative, and zero entries denoting denominator, numerator, and absent propagators.
- 2.2 Integration By Parts (IBP) Identities: IBP identities arise because integrals of total derivatives vanish in dimensional regularization, yielding l(l + m) equations from one seed integral.
- 2.3 Lorentz Invariance (LI) Identities: LI identities are generated from Lorentz invariance and can accelerate reduction convergence even though they add no new linear-independent equations beyond IBPs.
- 2.4 Symmetries: Declared propagator permutations let Reduze identify equivalent integrals, use one representative for equation generation, and sometimes eliminate entire equivalent sectors.
- 2.5 Zero Sectors: A sector is set to zero when the relevant IBP solutions include the equation I = 0 for its minimal r and s values.
3. Reduction Algorithm
Reduze reduces sector-defined systems of equations by ordering integrals and equations, triangularizing the system, and applying back substitution. Large reductions are partitioned into smaller equation sets, while sector reductions proceed through sub-sectors before the target sector.
- Sector reduction order: Reduze reduces a sector and its sub-sectors from the smallest-propagator sub-sectors upward until the desired sector is reached.Results from dependent sub-sectors are inserted into equations for larger sectors before those sectors are reduced.
- Equation construction: Reduze builds equations from user-defined ranges of r and s because it cannot solve for a single integral of a sector.The complete resulting system is reduced together rather than solving one integral independently.
- System partitioning: Large sector systems are divided into smaller equation sets, sorted by the most complicated integral in each equation.The default number of equations per set can be adjusted by the user.
- Ordering: Integral complexity is defined lexicographically using the vector {t, r, s, ID, v1, . . . , vn}.The first differing vector component determines the ordering between two integrals.
- Laporta-style reduction: The algorithm first triangularizes the equation system and then performs back substitution.Triangularization selects equations solved for the most complicated integrals and replaces matching integrals in the remaining equations.
4.1 Finding an Auxiliary Topology
Before reduction, Reduze requires an auxiliary topology containing the diagram topologies as sub-sectors. Its propagator and momentum choices should maximize coverage and symmetry relations.
- Topology selection: The auxiliary topology must contain the topologies of the given Feynman diagrams as sub-sectors.It should cover as many diagrams as possible while allowing many symmetry relations to minimize the number of sectors.
- Topology design: Additional auxiliary propagators and momentum-flow choices can be used to construct a topology with as many symmetries as possible.These choices are needed when a diagram has fewer propagators than the auxiliary topology requires.
4.2 Reduction
Running a Reduze reduction consists of setting up an auxiliary topology, preparing the reduction, and launching the generated run script. The workflow initializes topology data, checks inputs, controls parallel processes, and stores sector results.
- Workflow: A Reduze reduction is performed in three steps: set up an auxiliary topology, prepare the reduction, and run the reduction.Because Reduze reads and writes many files, the program should be run on a local hard disc.
- Setup: Setting up an auxiliary topology derives propagator rules, identifies symmetry-equivalent sectors, and finds most zero sectors through a small reduction.The setup creates directories for reduction data and results, plus a setup log.
- Preparation: Preparing a reduction specifies target sectors, the integral classes used to build equations, and the maximum number of parallel processes.The prepare command checks consistency and creates the run.sh script.
- Execution: The run script starts reductions for the declared sectors and controls how many processes run in parallel.Each sector receives a reduction directory for logs and temporary data, while completed results are written to the results directory.
- Process control: Stopping the main script allows already-started sector reductions to continue while preventing additional reductions from starting.Individual reduction processes can also be stopped by sector identification number.
4.3 Manipulating the Results
Reduze can select requested integral solutions, convert them to Mathematica or FORM formats, and optionally expand prefactors in a Laurent series around d −4. Its internal result format and symmetry handling require explicit extraction for complete outputs.
- Output limitations: Reduze’s internal result format is not well suited for processing by another algebra system.Conversion to Mathematica- or FORM-readable output is available after selecting the desired integrals.
- Solution selection: Users must provide a list of integrals to extract all desired solutions or generate solutions using symmetry relations.When symmetry relations are used, result files contain solutions for only one of the equivalent integrals.
- Format conversion: Selected results can be converted to FORM or Mathematica-readable files with the corresponding output options.The generated files use .inc for FORM and .m for Mathematica.
- Selecting solutions: The --select option extracts solutions for user-defined integrals into a .sol file, while unsolved integrals are written to a .rest file.Integrals without solutions include master integrals.
- Series expansion: Reduze can expand prefactors in a Laurent series around d −4 while creating Mathematica and FORM outputs.The expansion must be declared in the reduction input file.
5. Input Files
Reduze input files define auxiliary topologies, kinematics, propagators, symmetries, sector selections, and reduction settings. Recursive reductions proceed through sub-sectors before reducing target sectors.
- File structure: Input files use keyword-value lines ending with semicolons, while comments begin with double slashes and empty lines are ignored.The file must have the suffix .in.
- Topology and kinematics: Declarations identify loop and external momenta, symbols, and the dimension used by the reduction.The default dimension name is d if no Dimension declaration is provided.
- Topology and kinematics: Propagator declarations specify momentum flow and mass, with declaration order determining integral-vector positions.A propagator with momentum q and mass m is represented as q^2−m^2.
- Special declarations: Cut propagators restrict nonzero contributions to sectors retaining every cut propagator in the denominator.Integrals missing cut propagators or containing them only in numerators are set to zero.
- Topology and kinematics: Kinematic rules must replace external scalar products with algebraic expressions, or Reduze aborts.The example uses Mandelstam invariants s and t together with the mass m.
- Special declarations: Permutation declarations identify symmetry transformations that can equate integrals differing by loop-momentum shifts or permutations.The transformations preserve the auxiliary sector's propagator set and may exploit invariant Mandelstam variables.
- Sector control: Reduze can automatically determine zero sectors, while users can explicitly declare zero or non-zero sectors.SetupZeroTopos and SetupNonZeroTopos take sector identification numbers as arguments.
- Reduction control: Recursive reduction first processes lower-propagator sub-sectors and inserts their results before reducing dependent sectors.For sectors 182 and 387, sector 384 is reduced before three- and four-propagator sectors, followed finally by sector 182.
6. Installation
Installation requires obtaining the Reduze source, configuring and building it with standard commands, checking the build, and exposing the installation directory on PATH.
- Dependencies: Reduze depends on GiNaC version 1.4.1 or higher for algebraic manipulations.GiNaC and its headers can be installed through a package manager or compiled manually.
- Build: The source package is downloaded from the Reduze site and unpacked with tar -xzf.The archive name uses the current Reduze version.
- Build: The standard build sequence is configure, make, make check, and make install.The --prefix option selects a non-default installation directory.
- Invocation: The installation directory must be appended to the PATH environment variable before invoking Reduze.The documentation gives .bashrc as the profile file for bash users.
7. Performance
Reduze performance is shaped by rational-polynomial algebra, where extra variables enlarge expressions, and by redundant equations that symmetries can remove.
- Limits: N = 16 propagators, R = 16 numerator exponents, and S = 8 denominator exponents are the stated memory-related limits.These bounds constrain the size of reductions Reduze can handle.
- Algebraic manipulation: Putting one scale to one reduces the number of variables in rational-polynomial prefactors and can make calculations faster.The algebraic manipulation of prefactors consumes most reduction time.
- Equation reduction: Symmetry transformations can identify integrals within a sector and remove whole sectors, drastically reducing the equation count.The generated IBP system otherwise contains many redundant equations that produce 0 = 0 during reduction.
8. Applications
Reduze was applied to NNLO top-quark pair production in the quark-antiquark channel, including reductions for planar two-loop box diagrams.
- NNLO application: The program calculated the leading-color coefficient and fermionic corrections to top-quark pair production at NNLO.The application concerns the quark-antiquark channel.
- NNLO application: The leading-color calculation requires reducing two planar box diagrams for q¯q → t¯t.These four-point functions depend on s, t, the top mass m, and the dimension d.