[Paper Review] FastGPL: a C++ library for fast evaluation of generalized polylogarithms

Yuxuan Wang, Li Lin Yang+1 more|arXiv (Cornell University)|Dec 8, 2021

Particle physics theoretical and experimental studies4 citations

TL;DR

FastGPL is a C++ library that accelerates the numerical evaluation of generalized polylogarithms (GPLs) up to weight 4, using a two-step approach: precomputing optimized expressions via an external program and hard-coding them for fast runtime evaluation. It achieves up to 400× speedup over existing tools like handyG in challenging cases and ensures high accuracy by avoiding floating-point overflow and cancellation errors.

ABSTRACT

We present FastGPL, a C++ library for the fast evaluation of generalized polylogarithms which appear in many multi-loop Feynman integrals. We implement the iterative algorithm proposed by Vollinga and Weinzierl in a two-step approach, i.e., we generate concise expressions using an external program and hard-code them into the numeric library. This allows efficient and accurate numeric evaluations of generalized polylogarithms suitable for Monte Carlo integration and event generation. Floating-point arithmetics are carefully taken care of to avoid loss of accuracy. As an application and demonstration, we calculate the two-loop corrections for Higgs boson production in the vector boson fusion channel at electron-positron colliders. FastGPL is expected to be useful for event generators at the next-to-next-to-leading order accuracy.

Motivation & Objective

• Address the performance bottleneck in evaluating generalized polylogarithms (GPLs) for high-precision quantum field theory calculations.
• Overcome limitations in existing tools like handyG, including slow evaluation for certain GPLs due to redundant iterative computations.
• Prevent accuracy loss from floating-point overflow in series expansions by careful arithmetic handling.
• Enable efficient and precise GPL evaluations suitable for Monte Carlo event generation at next-to-next-to-leading order (NNLO) accuracy.
• Provide a production-ready, high-performance alternative to symbolic libraries like GiNaC and Fortran-based tools like handyG for numerical amplitude computations.

Proposed method

• Implement the iterative algorithm of Vollinga and Weinzierl (2005) in a two-step pipeline: first generate optimized, hard-coded expressions using an external program, then embed them into a C++ library for fast evaluation.
• Use a classification scheme based on index magnitudes (small vs. large) to precompute and cache evaluation paths, reducing redundant calculations.
• Apply careful floating-point arithmetic treatment to prevent overflow and minimize cancellation errors during series summation.
• Leverage the shuffle algebra of GPLs to simplify and optimize the evaluation of products of GPLs.
• Integrate with existing amplitude tools (e.g., FeynArts, Mathematica, FIRE6, LiteRed) to map master integrals to GPL expressions.
• Benchmark performance against handyG and GiNaC across diverse GPL configurations, including high-weight and numerically unstable cases.

Experimental results

Research questions

• RQ1 Can a two-step precomputation and hard-coding approach significantly reduce the evaluation time of generalized polylogarithms compared to naive iterative implementations?
• RQ2 To what extent can numerical instability from floating-point overflow and cancellation be mitigated in GPL evaluations using careful arithmetic design?
• RQ3 How does the performance of FastGPL compare to existing tools like handyG and GiNaC in terms of speed and accuracy across different GPL configurations?
• RQ4 Can FastGPL enable efficient and accurate NNLO calculations in precision Higgs physics at future e+e− colliders?
• RQ5 What is the impact of index classification (e.g., small vs. large indices) on the optimization and performance of GPL evaluations?

Key findings

• FastGPL achieves up to 400× speedup over handyG for specific weight-4 GPLs with many iterative steps, such as G(1.0025,0.989,0.45,0.89+0.24i;1), where evaluation times drop from ~2.2s to ~0.006s.
• On average, FastGPL is approximately 20× faster than handyG across various weight-4 GPL categories, with speedups ranging from ~14× to ~23× depending on index configuration.
• The library maintains high numerical accuracy by avoiding series truncation and carefully managing floating-point operations, preventing accuracy loss common in other implementations.
• In a realistic application, FastGPL enabled the computation of two-loop mixed QCD-EW corrections to Higgs production in vector boson fusion at e+e− colliders, with evaluation times of ~0.5s per amplitude at 350 GeV center-of-mass energy.
• The performance gain is most pronounced for GPLs with complex or clustered indices, where iterative recomputation in naive implementations causes severe slowdowns.
• The library is limited to GPLs up to weight 4, but this covers the majority of amplitudes relevant for NNLO calculations in precision Higgs and electroweak physics.