Loop Library in Perturbative QFT

• Loop libraries are specialized software frameworks that evaluate scalar integrals, tensor form factors, and loop amplitudes in perturbative quantum field theory.
• They incorporate techniques such as complex mass handling, adaptive precision, and caching to ensure numerical stability and efficient computation.
• These libraries seamlessly integrate with amplitude-level frameworks and Monte Carlo tools, streamlining NLO/NNLO phenomenology and multi-loop analyses.

Searching arXiv for the specified loop-library papers to ground the article in the primary sources. A loop library is a numerical software library for evaluating the scalar integrals, tensor form factors, and related special functions that enter loop amplitudes in perturbative quantum field theory. In the one-loop setting, representative libraries include QCDLoop, golem95C, and COLLIER, each of which provides implementations of master integrals such as $A_0$, $B_0$, $C_0$, and $D_0$, together with support for complex masses, divergent configurations, and interfaces to larger NLO tool chains (Carrazza et al., 2016). Closely related packages extend the notion of a loop library in two directions: amplitude-level frameworks such as NGluon and BlackHat, which reconstruct complete one-loop amplitudes using generalized unitarity, and special-function back ends such as FastGPL, which target generalized polylogarithms appearing in multi-loop master integrals (Badger et al., 2010).

1. Terminological scope and representative libraries

In perturbative relativistic quantum field theory, the term “loop library” is used for software that evaluates loop integrals or provides loop-amplitude building blocks. QCDLoop is presented as “a comprehensive framework for one-loop scalar integrals,” with a modern object-oriented C++ design, extensions to complex masses, simultaneous double and quadruple precision, caching, and interfaces to Monte Carlo programs (Carrazza et al., 2016). golem95C is a Fortran95 library for the numerical evaluation of one-loop scalar integrals and tensor form factors, including arbitrary complex internal masses and tensor ranks exceeding the number of propagators in its later extension (Cullen et al., 2011). COLLIER is a Fortran-based “Complex One-Loop LIbrary in Extended Regularizations” for scalar and tensor integrals up to $N=6$, with complex masses and both dimensional and mass regularization for infrared singularities (Denner et al., 2016).

A broader classification is useful because some libraries operate one level above the master-integral layer. NGluon is a C++ library for the numerical evaluation of colour-ordered one-loop amplitudes with an arbitrary number $n$ of external gluons in massless Yang–Mills theory, using $D$-dimensional generalized unitarity and interfacing to QCDLoop or FF for scalar integrals (Badger et al., 2010). BlackHat likewise targets one-loop amplitudes through on-shell unitarity and generalized cuts, while delegating phase-space sampling and subtraction to SHERPA and related components (Bern et al., 2013). At still higher loop order, FastGPL is a header-only C++ library for fast numerical evaluation of generalized polylogarithms up to weight $4$, together with $\operatorname{Li}_n$, Nielsen’s $S_{2,2}$, and the complete elliptic integrals $B_0$0 and $B_0$1, explicitly for multi-loop Feynman-integral and Monte Carlo applications (Wang et al., 2021).

Library	Primary focus	Notable features stated in the sources
QCDLoop	One-loop scalar integrals	complex masses, double/quad precision, LRU cache, C/Fortran/Python wrappers
golem95C	One-loop scalar integrals and tensor form factors	complex masses, higher ranks, one-dimensional fallback for small Gram determinants
COLLIER	One-loop scalar and tensor integrals	complex masses, dimensional and mass regularization, independent back-ends
NGluon	Colour-ordered one-loop multi-gluon amplitudes	generalized unitarity, QCDLoop/FF interface, optional extended precision
BlackHat	One-loop amplitudes in NLO QCD workflows	generalized cuts, on-shell recursion or $B_0$2-dimensional unitarity, ROOT n-tuples
FastGPL	Generalized polylogarithms for multi-loop integrals	hard-coded decomposition, overflow protection, weight $B_0$3

This landscape suggests that “loop library” is not restricted to a single software architecture. In practice, the phrase spans master-integral libraries, tensor-reduction libraries, amplitude providers, and special-function engines that are coupled into NLO or NNLO computational pipelines.

2. Mathematical objects and regularization conventions

The core one-loop objects are the scalar master integrals in dimensional regularization. QCDLoop defines, in $B_0$4 using the Bjorken–Drell metric and omitting the universal factor $B_0$5, the tadpole, bubble, triangle, and box integrals as

$B_0$6

$B_0$7

with analogous definitions for $B_0$8 and $B_0$9 in terms of shifted loop momenta and invariants such as $C_0$0 (Carrazza et al., 2016). COLLIER defines the general $C_0$1-point scalar function in dimensional regularization with ’t Hooft scale $C_0$2 and uses a covariant decomposition of rank-$C_0$3 tensor integrals into external momenta and metric tensors, returning either coefficient functions or tensor components (Denner et al., 2016).

Tensor libraries generalize these scalar bases through form-factor formalisms. golem95C defines

$C_0$4

and decomposes the result into Lorentz structures built from shift-invariant vectors $C_0$5 and $C_0$6, with scalar form factors $C_0$7, $C_0$8, $C_0$9, and related objects (Guillet et al., 2013). The same library implements closed-form expressions for poles and finite parts of integrals with additional $D_0$0 numerators up to $D_0$1, thereby accounting for rational terms associated with the $D_0$2-dimensional loop-momentum components (Guillet et al., 2013).

Regularization is a defining differentiator among loop libraries. QCDLoop and golem95C are framed in dimensional regularization and return Laurent coefficients corresponding to the finite part, $D_0$3, and $D_0$4 poles (Carrazza et al., 2016). COLLIER explicitly isolates UV and IR poles via coefficients multiplying combinations of $D_0$5, $D_0$6, and logarithms of user-defined scales $D_0$7 and $D_0$8, while also supporting mass regularization for soft and collinear singularities through a list of small regulator masses (Denner et al., 2016). This suggests that loop libraries are not merely numerical evaluators of special functions; they encode a particular regularization and analytic-continuation convention, and downstream amplitude codes depend on those conventions being stable and explicit.

3. Software architecture and programming interfaces

QCDLoop exemplifies a modern templated architecture. All components live in the namespace ql, and three template parameters—TOutput, TMass, and TScale—enforce at compile time which combinations of real or complex arithmetic and double or quadruple precision are allowed (Carrazza et al., 2016). Its core base classes are Topology<TOutput,TMass,TScale>, which defines the integral(...) interface and common argument checking; Tools<TOutput,TMass,TScale>, which supplies type-dependent constants and helper functions; and LRUCache<Key,Value>, which implements a generic least-recently-used cache for stored integral results (Carrazza et al., 2016). Specializations include TadPole, Bubble, Triangle, and Box, while the high-level front end QCDLoop<TOutput,TMass,TScale> inspects argument lengths, selects the correct topology, and dispatches the call (Carrazza et al., 2016).

Fortran-oriented libraries use a different organizational style. In golem95C, a small set of modules hides the core routines: precision_golem, matrice_s, form_factor_type, parametre, form_factor_Np, and ktilde (Guillet et al., 2013). The typical call sequence is initgolem95(N), population of the kinematic matrix $D_0$9, preparesmatrix(), evaluation of form factors, and exitgolem95() (Guillet et al., 2013). COLLIER similarly exposes a global Fortran95 module, COLLIER, with initialization routines such as Init_cll(Nmax,Rmax,...), per-event reset through InitEvent_cll(), and coefficient or tensor calls such as C_cll, TN_cll, and Dten_cll (Denner et al., 2016). Its architecture includes two independent back-ends, COLI and DD, and a TENSORS submodule for full tensor construction and direct tensor-level reduction for $N=6$0 (Denner et al., 2016).

Interoperability is central. QCDLoop provides Fortran77/90 and C wrappers via qlinit(), qlI1, qlI2, qlI3, qlI4, together with complex-mass and quadruple-precision variants, and a Cython-built Python interface qcdloop.QCDLoop with an .integral(mu2, mlist, plist) method (Carrazza et al., 2016). NGluon wraps scalar-integral back ends in LoopIntegrals.{h,cpp} and can be built against QCDLoop or FF, with optional extended precision through the QD library (Badger et al., 2010). BlackHat integrates at the workflow level with SHERPA, COMIX, FastJet, and ROOT, and stores per-event data in ROOT TTree n-tuples containing momenta, helicities, and the partial weights $N=6$1, $N=6$2, $N=6$3, and $N=6$4 (Bern et al., 2013). The common pattern is a separation between numerically delicate loop building blocks and the orchestration layers that handle phase-space generation, subtraction, and analysis.

4. Numerical stability, precision control, and caching

Numerical stability is one of the central technical problems addressed by loop libraries. In the Passarino–Veltman framework, tensor reduction introduces inverse Gram determinants, and small Gram determinants lead to ill-conditioned linear systems and large cancellations in floating-point arithmetic (Denner et al., 2014). COLLIER addresses this by applying default Passarino–Veltman reduction for $N=6$5 and switching near small Gram determinants to dedicated iterative expansions due to Denner and Dittmaier; for $N=6$6 it uses direct algebraic reduction to lower-point and lower-rank integrals without inverse Gram determinants, and for $N=6$7 generalizes the 6-point algorithm (Denner et al., 2016). golem95C takes a related approach: when $N=6$8, it automatically triggers a one-dimensional numerical integration of the relevant Feynman-parameter integral, thereby ensuring stability in exceptional kinematics (Guillet et al., 2013). In the earlier golem95C formulation, reduction stops when $N=6$9 falls below the default threshold $n$0, and the code switches to direct numerical evaluation of the basis integral via a one-dimensional parameter integral (Cullen et al., 2011).

Complex masses are another stability device as well as a physical feature. QCDLoop allows all topologies to accept $n$1 as complex variables so that propagators with $n$2 are handled automatically with the correct analytic continuation (Carrazza et al., 2016). golem95C states that internally all $n$3 may be complex and that no changes to reduction or numerical routines are required (Guillet et al., 2013). COLLIER and golem95C both emphasize that complex masses support the complex-mass scheme for unstable particles and regulate kinematic singularities associated with on-shell loops (Cullen et al., 2011).

Precision management is implemented explicitly rather than implicitly assumed. QCDLoop supports simultaneous double and quadruple precision through its type system and reports that quadruple precision is on average approximately $n$4–$n$5 slower than double, depending on topology (Carrazza et al., 2016). Its benchmarks also record an approximately $n$6 overhead for divergent integrals when complex masses are used, with smaller effects for finite ones (Carrazza et al., 2016). FastGPL uses std::complex<double> with an optional long-double fallback, sums series terms until the incremental term is below $n$7 with $n$8, and temporarily upgrades to long double when intermediate terms may overflow double precision (Wang et al., 2021). This suggests a general design principle: high-performance loop libraries increasingly use adaptive precision only where analytically or numerically necessary, rather than globally promoting all evaluations to a slower format.

Caching is a further layer of numerical engineering. QCDLoop implements a default LU cache of size $n$9, storing only the last result, and an LRU cache of user-defined size via setCacheSize(N) with Murmur hashing and unordered_map lookup (Carrazza et al., 2016). COLLIER provides an optional global cache system and requires a per-event reset when that cache is used in Monte Carlo loops (Denner et al., 2016). NGluon caches Berends–Giele currents to improve the scaling of tree-amplitude subcomputations from naive $D$0 to $D$1 (Badger et al., 2010). In all three cases, the relevant optimization is not abstract memoization but the repeated occurrence of identical or nearly identical subproblems across cuts, reduction identities, or event-generator calls.

5. Performance characteristics and benchmark data

The benchmark literature shows that loop-library performance depends strongly on the object being evaluated. For QCDLoop 2.0, benchmarks on an i7-6500U at $D$2 GHz with -O2 report that, in double precision with real masses and $D$3 calls, the new version is approximately $D$4–$D$5 faster than 1.96 on $D$6, $D$7, and $D$8, and approximately $D$9 faster on finite $4$0 boxes because version 1.96 used ff; for boxes it is comparable to OneLoop (Carrazza et al., 2016). With LU caching of size $4$1, the new cache is again approximately $4$2–$4$3 faster on “lumps” and approximately $4$4 faster on boxes than 1.96, while an LRU cache with size $4$5 yields up to a $4$6 speedup on expensive repeated box calls compared to the uncached case (Carrazza et al., 2016).

golem95C and COLLIER provide timing information for tensor objects rather than only scalar masters. The golem95 extension reports that a single call to a rank-6, five-point form factor with real masses takes approximately $4$7 on an Intel Core i7-3770 at $4$8 GHz (Guillet et al., 2013). The earlier golem95C paper quotes approximately $4$9 for a single call to a rank-6 six-point form factor with complex masses on an Intel Core2 Q9450 at $\operatorname{Li}_n$0 GHz, with default relative accuracy in the direct numerical integrals of $\operatorname{Li}_n$1 and failures logged in error.txt (Cullen et al., 2011). COLLIER lists typical timings on a $\operatorname{Li}_n$2 GHz Intel Xeon of approximately $\operatorname{Li}_n$3–$\operatorname{Li}_n$4 for $\operatorname{Li}_n$5, $\operatorname{Li}_n$6–$\operatorname{Li}_n$7 for $\operatorname{Li}_n$8, $\operatorname{Li}_n$9–$S_{2,2}$0 for $S_{2,2}$1, $S_{2,2}$2–$S_{2,2}$3 for rank-4 tensor $S_{2,2}$4, and up to approximately $S_{2,2}$5 in worst cases for higher $S_{2,2}$6 or rank, with typical numerical precision $S_{2,2}$7 in standard double precision (Denner et al., 2016).

Amplitude-level libraries have a different performance profile. NGluon reports approximately $S_{2,2}$8 per phase-space point for $S_{2,2}$9 gluons, approximately $B_0$00 for $B_0$01 gluons, and approximately $B_0$02 for $B_0$03 gluons, with runtime scaling approximately as $B_0$04 for $B_0$05 and asymptotically as $B_0$06 (Badger et al., 2010). In double precision, it yields reliable results up to $B_0$07 gluons, while only a few percent of points require reevaluation in extended precision; its internal scale test can flag such points automatically (Badger et al., 2010). BlackHat’s process-level benchmark for $B_0$08 at NLO reports generation of approximately $B_0$09 phase-space points at NLO in $B_0$10 CPU-hours on a modern farm, with per-point loop time of order $B_0$11 for the virtual part (Bern et al., 2013). FastGPL, although not a one-loop integral library in the narrow sense, gives useful context for multi-loop back ends: on an Intel Xeon E5-1680v3 with gcc 9.4 under Ubuntu 18.04, generic weight-4 GPLs take $B_0$12 each versus $B_0$13 for handyG, corresponding to an approximately $B_0$14 speedup, and “pathological” GPLs can show an approximately $B_0$15 speedup in worst cases (Wang et al., 2021).

6. Integration into NLO and NNLO phenomenology

Loop libraries are designed to be embedded in automated perturbative workflows rather than used in isolation. QCDLoop 2.0 is explicitly demonstrated in MCFM 7.x by replacing the linked library through the Makefile while preserving backward compatibility through its Fortran wrapper (Carrazza et al., 2016). For the processes $B_0$16 (nproc=61), $B_0$17 (81), and $B_0$18 (289) at $B_0$19 TeV with NNPDF3.0 NLO, inclusive cross-sections and differential distributions agree at sub-per-mille level, and CPU time improves by approximately $B_0$20–$B_0$21 (Carrazza et al., 2016). The same source describes a complex-mass workflow in Sherpa 2.2 in which Ninja’s one-loop reduction calls QCDLoop for master integrals through Ninja $B_0$22 GoSam $B_0$23 Sherpa; for $B_0$24 at NLO and $B_0$25 TeV, the inclusive cross section agrees to $B_0$26 pb ($B_0$27) between OneLoop 3.6 and QCDLoop 2.0, differential shapes are identical within statistical error, and the overall CPU time is approximately $B_0$28 h (Carrazza et al., 2016).

golem95C is structured to support both diagrammatic tensor reduction and unitarity-inspired workflows. It contains routines that accept a reconstructed numerator polynomial in $B_0$29 at the integrand level, with coefficients $B_0$30, and contracts these coefficients with the corresponding tensor form factors (Guillet et al., 2013). The paper describes this “tensorial reconstruction” as a rescue system for points where pure unitarity methods lose precision (Guillet et al., 2013). The earlier golem95C description likewise states two usage modes: an algebraic reduction approach and a unitarity-inspired integrand-reconstruction mode (Cullen et al., 2011). These features place the library at the interface between symbolic reduction and numerical sampling.

At the amplitude and event-generator level, BlackHat and NGluon illustrate two complementary integration models. NGluon is intended to be embedded in event generators such as Sherpa, MadGraph, or POWHEG by calling NGluon::evalAmp() and combining getAtree() and getAfinite() with subtraction frameworks (Badger et al., 2010). BlackHat, by contrast, is presented in conjunction with SHERPA, COMIX, FastJet, and ROOT, with one pass devoted to generating weighted events and saving the Born, virtual, integrated-subtraction, and real-minus-subtraction weights, and a second pass devoted to analysis using ROOT macros (Bern et al., 2013). A plausible implication is that loop libraries influence not only matrix-element evaluation time but also the reproducibility and reusability of collider analyses, especially when their outputs are packaged into portable formats such as ROOT n-tuples.

Multi-loop phenomenology introduces a further back-end layer. FastGPL is designed specifically for cases in which master integrals reduce to generalized polylogarithms up to weight $B_0$31, and a demonstration application computes mixed QCD–EW two-loop corrections to $B_0$32 via $B_0$33 fusion at $B_0$34 GeV (Wang et al., 2021). The two-loop amplitude contains approximately $B_0$35 GPLs of weight $B_0$36, and in a VEGAS integration with $B_0$37 points the wall-time per point is approximately $B_0$38 for FastGPL versus approximately $B_0$39 for handyG, corresponding to an $B_0$40 speedup (Wang et al., 2021). This suggests that the traditional one-loop integral library has a natural extension into a layered ecosystem of reduction libraries, amplitude providers, and transcendental-function engines.

7. Related methodological distinctions and common points of confusion

A common source of ambiguity is whether a loop library should be understood as a master-integral evaluator, a tensor-reduction engine, or a complete amplitude provider. The sources support all three usages. QCDLoop is restricted to one-loop scalar integrals (Carrazza et al., 2016). golem95C and COLLIER add tensor form factors and full tensor components (Guillet et al., 2013). NGluon and BlackHat move beyond integrals to the reconstruction of full one-loop amplitudes from generalized cuts and rational terms (Badger et al., 2010). For this reason, the term “loop library” is best understood as describing a functional role inside perturbative calculations rather than a single standardized API.

Another distinction concerns the analytic basis. Libraries such as QCDLoop, golem95C, and COLLIER are organized around scalar and tensor one-loop integrals in dimensional regularization (Carrazza et al., 2016). FastGPL, by contrast, is organized around generalized polylogarithms, which “appear ubiquitously in the analytic evaluation of multi-loop Feynman integrals” and are evaluated through a hard-coded implementation of the Vollinga–Weinzierl algorithm up to weight $B_0$41 (Wang et al., 2021). The relation is complementary rather than competitive: one-loop libraries typically supply master integrals directly, whereas multi-loop codes often require special-function libraries after reduction to analytic expressions.

Finally, “loop library” can denote something unrelated to Feynman integrals in other research domains. The PyTorch package higher is a library for “Generalized Inner Loop Meta-Learning,” in which one differentiates through an unrolled inner optimization loop via higher.innerloop_ctx, FunctionalModule, and DifferentiableOptimizer abstractions (Grefenstette et al., 2019). This usage concerns nested optimization rather than loop amplitudes. The terminological overlap suggests that disciplinary context is essential: in high-energy phenomenology, a loop library ordinarily refers to one-loop or multi-loop integral and amplitude software; in machine learning, it may refer to tooling for differentiable inner-loop optimization.