Source-linked AI summary
Algorithms for the symbolic integration of hyperlogarithms with applications to Feynman integrals
Erik Panzer
TL;DR
Symbolic integration of hyperlogarithms lacked a complete practical treatment of integration constants and publicly available software. The paper supplies algorithms and a Maple implementation, enabling exact calculations for many linearly reducible Feynman integrals, while remaining limited to that graph class.
Problem
Existing hyperlogarithm methods lacked publicly available programs, and a crucial method for obtaining integration constants was not provided simply.
Method
The paper provides a complete Maple implementation of symbolic integration using hyperlogarithms and resolves the integration-constant problem.
Results
The program computes hyperlogarithmic Feynman integrals and supports polynomial reduction that can significantly speed up computations.
Takeaways & Limitations
The implementation makes symbolic hyperlogarithm integration available for applications including non-trivial Feynman integrals with divergences and complicated kinematics.
Takeaways & Limitations
The method applies only to the small class of linearly reducible graphs, excluding Feynman integrals requiring broader function spaces such as elliptic integrals.
Abstract
from arXiv · showhide
We provide algorithms for symbolic integration of hyperlogarithms multiplied by rational functions, which also include multiple polylogarithms when their arguments are rational functions. These algorithms are implemented in Maple and we discuss various applications. In particular, many Feynman integrals can be computed by this method.
Program summary
HyperInt is a Maple implementation for exact, symbolic hyperlogarithm computations, with broad support for linearly reducible Feynman-integral expansions and tensor integrals.
- For linearly reducible Feynman graphs, ε-expansions can be computed to arbitrary order near any even space-time dimension.This remains subject to time and memory restrictions.
- The implementation supports arbitrarily ε-dependent propagator powers with integer values at ε = 0.
- HyperInt computes arbitrary tensor integrals directly, not only scalar integrals.
- Running time depends strongly on integrations, remaining variables, ε-order, and graph geometry.Simple examples finish in seconds, while sufficiently high ε-orders or many-edge graphs can exceed practical bounds.
1. Introduction
The paper develops symbolic hyperlogarithm algorithms and a public Maple implementation to address missing integration constants and compute linearly reducible Feynman integrals.
- Foundations: Hyperlogarithms provide a combinatorial representation of polylogarithms that supports symbolic algorithms and computer implementation.
- Linear reducibility: Linear reducibility requires each partial integral to remain a hyperlogarithm in the next integration variable.This criterion covers an infinite family of non-trivial Feynman integrals, although explicit results had been missing.
- Contribution: The paper closes a gap by providing a complete Maple implementation of symbolic hyperlogarithm integration.The program was used for several non-trivial Feynman integrals involving divergences and complicated kinematics.
- Contribution: The main original contribution solves the determination of integration constants in an intermediate step of the algorithm.
- Implementation and applications: HyperInt includes applications to integration, polylogarithm argument transformations, multiple integrals, polynomial reduction, and Feynman graphs.Examples, demonstrations, tests, and function references are supplied through the manual, test file, and appendices.
2. Algorithms for hyperlogarithms
The paper develops combinatorial algorithms for manipulating and integrating hyperlogarithms, including regularized limits and integration constants. It also addresses parameter-dependent alphabets and exceptional positive singularities through symbolic limit and contour procedures.
- Integration algorithm: Symbolic integration proceeds by expressing the integrand as a hyperlogarithm, finding a primitive, and evaluating its limits at zero and infinity.The main computational difficulty is obtaining integration constants and handling the first step when variables are dependent.
- Algebraic framework: Hyperlogarithms are represented in a shuffle algebra of words over an alphabet, with iterated-integral identities capturing their analytic properties.The framework uses differential forms, path integrals, concatenation, shuffle products, and deconcatenation.
- Regularization: Shuffle-regularization projects words onto components that neither begin nor end with letters from specified sets, enabling finite regularized limits at singular endpoints.Words are decomposed using shuffle products, and the resulting regularized expressions can be evaluated linearly even when individual limits diverge.
- Endpoint limits: Expansions at infinity are obtained by splitting the integration at an intermediary point and expressing hyperlogarithms as polynomials in log z with power series in 1/z.This expansion suffices to compute the limit of primitives at infinity.
- Exceptional limits: When letters approach positive real values, the naive limiting procedure can fail, so the algorithm computes regularized limits symbolically and deforms the contour around singularities.The contour is split at a point before the first positive branch point, with recursive splitting for subsequent positive letters.
3. The implementation HyperInt
HyperInt implements the section 2 algorithms in Maple, prioritizing Feynman-integral computation over general-purpose symbolic support. It omits numeric evaluation facilities and requires cache invalidation when global parameters change.
- The section 2 algorithms are implemented in Maple, with supplementary procedures aimed primarily at computing Feynman integrals.
- HyperInt is flexible but is not intended as a general-purpose package for arbitrary symbolic hyperlogarithm and polylogarithm calculations.
- Numeric evaluation of hyper- and polylogarithms is excluded because it is unnecessary for the algorithms and established programs already provide it.
- Changing a global parameter requires calling forgetAll() to invalidate Maple's lookup tables; otherwise the program may behave inconsistently.
- The program requires no installation and can be loaded during a Maple session when HyperInt.mpl is available on Maple's search path.
HyperInt.mpl
HyperInt.mpl contains the implementation of the section 2 algorithms and supplementary procedures for handling Feynman graphs and integrals.
- HyperInt.mpl implements the section 2 algorithms and includes supplementary procedures for handling Feynman graphs and Feynman integrals.
periodLookups.m
periodLookups.m stores reductions of multiple zeta values and alternating Euler sums to conjectured bases for efficient high-weight calculations.
- periodLookups.m stores multiple zeta value reductions through weight 12 and alternating Euler sum reductions through weight 8.
- The lookup table is optional for running the program but necessary for efficient calculations involving high weights.
Manual.mw
Manual.mw explains practical HyperInt usage and provides extensive explicit Feynman-integral computations with accompanying explanations and comments.
- Manual.mw explains the practical usage of HyperInt and includes many explicit Feynman-integral computations.
- The worksheet provides numerous explanations, details, and comments alongside its computational examples.
HyperTests.mpl
HyperInt provides symbolic basis transformations and exact period reductions that support hyperlogarithm integration and applications to Feynman integrals. Its tests illustrate functional relations, basis dependence, linear reducibility, and algebraic-letter handling.
- Representation: HyperInt represents polylogarithms as lists and converts among hyperlogarithm, multiple-polylogarithm, and related target formats.The native convert function supports human-readable and implementation-oriented representations.
- Basis transformations: The fibrationBasis function expresses polylogarithms in a unique basis for a chosen variable order, enabling relation detection and simplification.Different variable orders define different true bases, and a function vanishes exactly when the returned basis representation is zero.
- Functional relations: Examples recover classical dilogarithm identities, the five-term relation, and an inversion relation for Li5 through basis conversion.The identities are obtained for both single-variable and multivariable polylogarithms.
- Periods: Period lookup tables reduce multiple zeta values and alternating Euler sums, while additional tables support periods involving fourth roots of unity.The supplied reductions include multiple zeta values up to weight 12 and alternating Euler sums up to weight 8; fourth-root periods use ln 2, i, π, and Catalan’s constant.
- Applications: For linearly reducible examples, HyperInt yields exact results for Ising-type integrals and can integrate rational-letter functions after factorization over the full algebraic closure.The Ising-type integrals are rational combinations of alternating Euler sums, and exact results are available through n = 8.
4. Polynomial reduction and linear reducibility
Polynomial reduction analyzes singularities to establish linear reducibility and restricts the hyperlogarithm alphabet during iterated integration. Variable ordering and, when needed, algebraic changes of variables determine whether integrations remain within hyperlogarithms.
- Linear reducibility: Linear reducibility requires an ordering in which every partial integral is a hyperlogarithm in the next integration variable.The successive alphabets must be rational functions of the variables remaining after that integration.
- Integration order: In the example, integrating over x introduces algebraic letters −1 ± i√y, whereas integrating over y first preserves rational letters and hyperlogarithmic structure.The example demonstrates why integration order is central to maintaining linear reducibility.
- Polynomial reduction: Polynomial reduction computes polynomial sets that bound Landau varieties and can certify linear reducibility when they are linear in each next variable.The relevant sets are formed for subsets of integrated variables and provide candidate singularities for subsequent integrations.
- Performance: Polynomial reduction can discard letters outside the reduced alphabet because their total contributions are proven to vanish.This pruning substantially reduces the exponentially growing hyperlogarithm space at higher weight.
- Implementation: Compatibility-graph reduction is implemented in HyperInt through cgReduction, which produces polynomial tables used to identify integration sequences.The example starts from denominator factors and reports the resulting reduced sets for integrated-variable subsets.
- Limitations and transformations: The polynomial sets are only upper bounds, so they may contain spurious nonlinear polynomials even when the integrand is actually linearly reducible.When linear reducibility fails, a change of variables can sometimes restore it.
5. Application to Feynman integrals
The paper applies HyperInt’s symbolic hyperlogarithm algorithms to parametric Feynman integrals, including ε-expansions and divergent cases. A four-loop massless propagator illustrates graph construction, reducibility checking, expansion, integration, and reduction to multiple zeta values.
- Scope of applications: HyperInt computes many linearly reducible Feynman integrals, including massless propagators up to six loops and divergent integrals with up to seven kinematic invariants.The reported applications include both single-scale and multi-scale examples.
- Scope boundary: The method applies only to the small class of linearly reducible graphs, excluding many polylogarithmic and non-polylogarithmic Feynman integrals.The paper specifically notes elliptic integrals and generalizations in massive and massless settings.
- ε-expansions: In dimensional regularization, the parametric integrand is expanded in ε, and each coefficient can be integrated when the relevant graph polynomials yield a linearly reducible hyperlogarithm.The setup uses D = 4 − 2ε and ε-dependent propagator powers expanded near integer values.
- Divergent integrals: Divergent parametric integrals are treated by partial integrations that implement analytic regularization and produce a convergent representation.This procedure is implemented in HyperInt for subsequent symbolic integration.
- Four-loop example: The four-loop massless propagator example is linearly reducible because it has vertex-width three, and the implementation verifies this with polynomial reduction.The graph and its first and second Symanzik polynomials are constructed from the graph specification.
- Four-loop example: The example expands the assembled convergent integrand to second order in ε, integrates all but the last Schwinger parameter, and reduces the result to a basis of MZVs.The displayed final expression is a combination of ζ7, ζ5, ζ2ζ5, ζ2^3, ζ3^2, and ζ2^2ζ3.
Appendix A. Tests of the implementation
The implementation is tested against known polylogarithmic, MZV, period, and Feynman-integral results. Cross-checks include analytic references, graph symmetries, numerical evaluations, and independent programs, while the tests also expose published misprints.
- Test suite: HyperTests.mpl contains diverse applications and is expected to run without errors as a broad implementation test suite.The tests include parametric integrals with known polylogarithmic and MZV results.
- Formula validation: Functional and integral-equation tests identify multiple misprints in reference formulas, including incorrect signs, factors, and polylogarithm arguments.The appendix records specific corrections to equations from the cited literature.
- Formula validation: A correction to equation (8.80) replaces (1 − v) with (1 + v) in a dilogarithm argument.The corrected identity is stated after incorporating the listed corrections.
- Additional examples: Additional tests cover bubble-chain graphs with subdivergences and a massless hexagon integral.The bubble-chain results are compared with standard momentum-space calculations and previously derived parametric periods.
- Period checks: HyperInt reproduces known period results through n = 4 and agrees numerically with published E5 and E6 values.The comparison covers simple period integrals and transformations of polylogarithms into hyperlogarithms.
- Feynman-integral checks: ε-expansions of single-scale and multi-scale Feynman integrals were cross-checked against references, graph symmetries, and numerical evaluations from established programs.The authors describe these as among the strongest tests of the implementation.
- Literature comparisons: The implementation confirms published operator matrix elements and Benz-graph results while correcting mistakes in cited equations.Examples of the checked integrals are included in the manual.
Appendix B. Proofs
The appendix proves algebraic identities used by the hyperlogarithm algorithms through induction, shuffle-product manipulations, regularization, and Hopf-algebra operations.
- Lemma 2.2: Lemma 2.2 is proved by induction after decomposing the outer shuffle product according to its last letter.The remaining contribution vanishes through the antipode of the tensor Hopf algebra.
- Lemma 2.5: Lemma 2.5 is established by applying an earlier identity and simplifying a finite sum whose coefficients reduce to a Kronecker-delta condition.The proof separates contributions and evaluates them using the induction hypothesis.
- Regularization: Regularized words are decomposed into factors with controlled endpoint letters so that the contributions to the relevant identity can be organized by their split point.The proof uses words that do not end or begin with the distinguished letter.
Appendix C.1. Options and global variables
The appendix documents global options and Maple functions for configuring hyperlogarithmic integration, divergence checks, polynomial reduction, graph calculations, and related symbolic operations.
- Options and global variables: Integration options control verbosity, progress frequency, return formats, divergence checking, pole-order limits, and divergence handling.Progress output can be disabled or throttled, while integrationStep can return tables for very large calculations; endpoint singularities and potential divergences can also be tracked.
- Options and global variables: The radical set R defines the field k = Q(R) used for all factorizations, while nonlinear-polynomial handling determines whether algebraic letters are retained.Dropping nonlinear polynomials is permissible under linear reducibility; factoring all polynomials linearly can introduce algebraic functions that later computations do not support.
- Options and global variables: Singularity restrictions project hyperlogarithmic rewritings onto letters specified by allowed polynomial roots, potentially speeding integration.The restriction is controlled by _hyper_restrict_singularities and _hyper_allowed_singularities.
- Symbolic functions: Core symbolic routines rewrite polylogarithms, differentiate hyperlogarithms, expand at z → 0, integrate hyperlogarithms, and compute word decompositions and primitives.The package supports list and Hlog representations, general differentiation including variable-dependent words, and primitives satisfying ∂zF(z) = f(z).
- Symbolic functions: Fibration and reduction routines represent functions in tensor products of hyperlogarithm algebras, project onto selected letter sets, and collect coefficients sparsely.The available routines also test linearity, manage compatibility graphs, and check possible integration orders.