HyperFORM -- a FORM package for parametric integration with hyperlogarithms

This paper presents HyperFORM, a new computer algebra package for the FORM system that implements algorithms for the symbolic integration of hyperlogarithms multiplied by rational functions, thereby enabling efficient computation of complex Feynman integrals by leveraging FORM's superior handling of large symbolic expressions.

The Gist

Imagine you are trying to solve a massive, multi-layered jigsaw puzzle. But this isn't a normal puzzle; the pieces are constantly changing shape, and the picture you are trying to build represents the fundamental forces of the universe (quantum physics).

This paper introduces a new, super-powered tool called HyperFORM designed to help physicists solve these "puzzles" (known as Feynman integrals) much faster and more efficiently than before.

Here is the breakdown of what they did, using simple analogies:

1. The Problem: The "Mathematical Mountain"

In quantum physics, to predict how particles interact, scientists have to calculate complex integrals. Think of these integrals as a long, winding mountain path.

• The Old Way (HyperInt): Previously, scientists used a tool called HyperInt (written in a language called MAPLE). It was like hiking up that mountain with a heavy backpack. It worked, but it was slow. As the puzzles got bigger (more loops in the particle diagrams), the backpack got so heavy that the hiker (the computer) would get stuck or take days to finish.
• The Bottleneck: The mountain path is full of "hyperlogarithms" (a fancy type of mathematical function). When you multiply these by rational functions (fractions), the expressions become gigantic. The old tool struggled to carry these heavy loads.

2. The Solution: The "High-Speed Train" (HyperFORM)

The authors built HyperFORM. They didn't invent a new way to climb the mountain; they just built a high-speed train to get there.

• The Engine (FORM): They switched the underlying computer language from MAPLE to FORM. Imagine FORM as a super-efficient, open-source engine designed specifically to handle massive amounts of data without breaking a sweat. It's like swapping a bicycle for a bullet train.
• The Result: Because FORM is built to handle huge lists of numbers and symbols very quickly, HyperFORM can solve problems that the old tool took hours or days to do, often in a fraction of the time.

3. How It Works: The "Assembly Line"

The paper describes a step-by-step process to solve these integrals:

• Input: You feed the computer the "recipe" for the particle interaction (the integrand).
• Regularization (The Safety Net): Sometimes the math explodes into infinity (like dividing by zero). The program has a built-in safety net that catches these explosions, fixes them, and turns them into manageable numbers before proceeding.
• The Assembly Line: The program breaks the big mountain path into small, manageable steps. It integrates one variable at a time, converting the complex shapes into simpler ones (like turning a wild vine into a straight rope).
• The Output: Finally, it spits out the answer, which is usually a combination of famous mathematical constants (like $\pi$ or $\zeta$ values) that physicists use to describe the universe.

4. Real-World Proof: The "Zigzag" Race

To prove their new tool works, they tested it on a specific, notoriously difficult set of puzzles called Zigzag diagrams.

• The Challenge: These are like a 6-loop knot that gets incredibly tangled as you add more loops.
• The Race: They compared their new tool (HyperFORM) against the old tool (HyperInt) and a few other specialized tools.
  • HyperInt: Took 28 hours to solve the 6-loop puzzle.
  • HyperFORM: Took only 8 hours.
  • The Takeaway: They made it 3.5 times faster just by changing the engine. For even bigger puzzles (7 loops and up), the old tool simply gave up, while HyperFORM kept chugging along.

5. Why This Matters

• Speed: In science, time is money. Being able to calculate these interactions 20 times faster means scientists can test more theories and design better experiments.
• Scalability: As computers get more powerful (with more cores), HyperFORM scales up perfectly. It's like having a team of 16 people working together perfectly, whereas the old tool was like one person trying to do the work of 16.
• Open Source: The tool is free for everyone to use, which encourages collaboration and faster progress in the field of physics.

In a Nutshell

The authors took a difficult mathematical task (calculating particle interactions) that was previously slow and clunky, and they rewrote the software using a high-performance engine (FORM). The result is a tool that is faster, lighter, and capable of solving much bigger puzzles than before, helping physicists understand the universe a little bit better, a little bit quicker.

Technical Summary

1. Problem Statement

The computation of Feynman integrals at high loop orders is a cornerstone of perturbative quantum field theory (QFT). While analytic results provide deep mathematical insight, their calculation is computationally demanding.

• Current Limitations: The state-of-the-art tool for parametric integration of hyperlogarithms is HyperInt, implemented in the computer algebra system (CAS) MAPLE by Erik Panzer.
• Bottlenecks:
  • Expression Size: Parametric integration is a "brute-force" algorithm that generates massive intermediate expressions. MAPLE, while capable, is not optimized for handling expressions of this magnitude efficiently.
  • Scalability: HyperInt development stalled after its initial release, lacking further optimizations. It does not fully exploit modern multicore/multi-CPU architectures.
  • Scope: Many mathematical structures that could make parametric integration more powerful were not integrated into HyperInt.
• Goal: To develop a more powerful, scalable, and efficient implementation of parametric integration algorithms capable of handling the large symbolic expressions encountered in high-loop QFT calculations.

2. Methodology

The authors implemented the HyperFORM package within the CAS FORM, chosen for its superior performance in handling large symbolic expressions and its ability to scale across many CPU cores.

Core Mathematical Framework

The package relies on parametric integration (developed by Francis Brown), which requires the integrand to be linearly reducible. This means that after each integration step, the result must remain expressible in terms of hyperlogarithms (Goncharov polylogarithms).

• Hyperlogarithms ($L$): Defined recursively via iterated integrals. They are multivalued functions where the path of integration is fixed (typically the positive real axis).
• Regularization: The package handles singularities (e.g., $\lim_{x\to 0} \log(x)$) using a regularization scheme where $\log(0)$ and $\log(\infty)$ are treated as formal constants that cancel out in finite integrals.
• Multiple Zeta Values (MZVs): The package includes a tabulated reduction of MZVs up to weight 10 (sufficient for 6-loop calculations) to simplify results.

Implementation Strategy in FORM

• Input Handling: Users define integrands as products of rational functions raised to powers involving the dimensional regularization parameter $\epsilon$ (e.g., $f(x)^{n+m\epsilon}$).
• Workflow:
  1. Parsing: HypParseInputExpr converts user-defined syntax to internal FORM notation.
  2. Regularization: HypAutoRegularize recursively detects and removes divergences using integration-by-parts techniques (based on Ref. [13]), converting singularities into $\epsilon$-poles.
  3. Expansion: HypEpExpand expands the integrand in powers of $\epsilon$.
  4. Projective Reduction: HypApplyChenWu sets one integration variable to 1 (Chen-Wu theorem) for projective integrals.
  5. Integration: HypIntegrationStep performs the actual integration over a specified sequence of variables.
  6. Fibration Basis: HypFibrationBasis converts hyperlogarithms evaluated at infinity into a basis where letters depend only on remaining integration variables.
  7. Finalization: HypFinalizeResult formats the output, applying MZV reductions and expanding $\Gamma$-functions.

3. Key Contributions

• Porting to FORM: Successfully translated the core functionality of HyperInt from MAPLE to FORM, leveraging FORM's speed and memory efficiency.
• Parallelization: The implementation is designed to run efficiently on multicore and multi-CPU servers, addressing the scalability issues of previous tools.
• New Features:
  • Implementation of a specific regularization procedure for divergent integrals.
  • Automatic detection of coefficients that trivially equal zero to prune intermediate terms.
  • Integration of MZV reduction tables directly into the package.
• Open Source: The package is released as open-source software (GitHub), ensuring transparency and community accessibility.

4. Results and Benchmarks

The authors validated HyperFORM using several test cases, demonstrating significant performance improvements over existing tools.

• Three-Loop FA Topology:

  • HyperFORM completed the calculation in 360 seconds (single core).
  • HyperInt required 900 seconds.
  • HyperlogProcedures (a different mathematical approach) took 10 seconds, but is limited to specific graph topologies.
  • Mincer/Forcer (table lookups) were faster but do not perform the actual symbolic integration.
  • Conclusion: HyperFORM is ~2.5x faster than HyperInt for this complex topology.

• Zigzag Diagrams (High Loop Orders):

  • The authors tested the Zigzag family of diagrams, which are linearly reducible but have high polynomial complexity.
  • Z6 (6-loop): HyperFORM took 8 hours, compared to 28 hours for HyperInt (a ~3.5x speedup).
  • Scalability: The package successfully handled the Z6 diagram, which involves 12 integration variables and 368 monomials in the Symanzik polynomial.
  • Parallel Scaling: Benchmarks on an AMD Ryzen 9 5900XT (16 cores) showed that while speedup is not perfectly linear due to term distribution overhead, significant gains are achieved. CPU frequency scaling also showed near-linear speed improvements.

• Non-QFT Example: The package successfully computed a generic parameter integral (Eq. 15) from Ref. [21], confirming its applicability beyond standard QFT propagator integrals.

5. Significance and Outlook

• Universality: Unlike the "graphical functions" method (HyperlogProcedures), which is restricted to specific massless theories with few external legs, HyperFORM retains the universality of parametric integration. It can be applied to a wide variety of Feynman integrals, including those with massive particles or complex topologies.
• Enabling Higher Loops: By significantly reducing computation time and memory usage, HyperFORM makes it feasible to tackle Feynman integrals at loop orders previously considered computationally prohibitive (e.g., 6-loop and beyond).
• Future Developments:
  • Polynomial Handling: Current limitations on term size will be addressed by restructuring the code.
  • Singularities: A more efficient regularization method (avoiding term proliferation) is planned.
  • Algebraic Extensions: Future versions aim to handle integrands with square roots (quadratic in integration variables) via direct methods, extending beyond strictly linearly reducible cases.
  • Hybrid Approaches: Combining analytic pre-integration steps with computer calculation to handle high-dimensional Symanzik polynomials.

In summary, HyperFORM represents a major step forward in the computational toolkit for high-energy physics, bridging the gap between the mathematical elegance of parametric integration and the practical necessity of handling massive symbolic expressions in modern QFT.