Source-linked AI summary
ALOHA: Automatic Libraries Of Helicity Amplitudes for Feynman diagram computations
Priscila de Aquino, William Link, Fabio Maltoni, Olivier Mattelaer, Tim Stelzer
TL;DR
Existing HELAS libraries and manual implementation limited the models that could be simulated, especially for arbitrary BSM interactions. ALOHA converts UFO model information into HELAS routines in Fortran, C++, and Python, supporting automated calculations from Feynman rules toward event generation. The paper reports agreement in validation tests and generation times from a few seconds for the SM and MSSM to a few minutes for spin-2 models.
Problem
Existing static HELAS routines and manual implementation did not provide practical coverage for arbitrary new interactions and BSM models.
Method
ALOHA takes UFO model information, contracts Lorentz structures with wavefunctions or propagators, and automatically writes HELAS-compatible routines in multiple languages.
Results
The generated routines show full agreement in the reported RS-I validation tests, while generation takes a few seconds for the SM and MSSM and up to a few minutes for spin-2 models.
Takeaways & Limitations
ALOHA provides an important component of an automated chain from Feynman rules or the Lagrangian level to event generation.
Takeaways & Limitations
ALOHA currently supports spins 0, 1/2, 1, and 2 with canonical propagators and does not generate external-particle routines.
Abstract
from arXiv · showhide
We present an application that automatically writes the Helas library corresponding to the Feynman rules of any Lagrangian, renormalizable or not, in quantum field theory. The code, written in Python, takes the Universal FeynRules Output as an input and produces the complete set of routines (wave-functions and amplitudes) that are needed for the computation of Feynman diagrams at leading as well as at higher orders. The representation is language independent and outputs in Fortran, C++, Python are currently available. A few key sample applications implemented in the MadGraph5 framework are presented.
PROGRAM SUMMARY
ALOHA automatically generates helicity routines from UFO model information, addressing the limited coverage of static HELAS libraries. It produces analytical routines in multiple programming languages, with execution taking seconds for the SM and MSSM and minutes for spin-2 models.
- Motivation: ALOHA addresses HELAS’s limited set of helicity functions by automatically creating routines for arbitrary models.The program targets efficient numerical evaluation of squared matrix elements when existing static routines do not cover an interaction.
- Method: The program takes UFO model information, combines vertex rules with wavefunctions or propagators, and obtains analytical helicity routines.The resulting expressions are then written automatically in the requested language.
- Output: Outputs are available in Fortran, C++, and Python.
- Restrictions: The allowed fields currently have spins 0, 1/2, 1, and 2, with canonical propagators.
- Performance: A few seconds are required for the SM and MSSM, while models with spin-2 particles can take up to a few minutes.
1. Introduction and motivation
The paper situates ALOHA within efforts to automate the path from new Lagrangians to event simulation. Its contribution is automatic helicity-amplitude generation, which broadens model support beyond interactions that existing MadGraph implementations could handle manually.
- Motivation: Manual construction of event simulators for only the SM and a few BSM theories restricts the range of models testable at the LHC.
- Contribution: ALOHA automates a key step between a new model’s Lagrangian and event simulation by creating helicity-amplitude routines for matrix-element calculations.
- Prior limitation: Before ALOHA, MadGraph was restricted to models with the Standard Model’s Lorentz structures.
- Prior limitation: Adding new particles or interactions required identifying, writing, and debugging model-specific helicity amplitudes.The paper notes that the number of physicists able to implement new models is very limited.
2. Helicity amplitudes
Helicity-amplitude methods evaluate matrix elements through wavefunctions and amplitudes rather than traces of squared amplitudes. HELAS organizes these calculations into external-particle, off-shell, and on-shell routines that combine into diagram amplitudes.
- Helicity-amplitude method: Helicity-amplitude methods work at amplitude level, where complexity grows linearly with the number of diagrams instead of quadratically.They also factorize repeated diagram substructures.
- Routine categories: External-particle routines compute wavefunctions from particle type, momentum, and helicity, independently of model interactions.Their inputs depend on the particles’ Lorentz representations.
- Routine categories: Wavefunction/off-shell routines generate internal propagator wavefunctions and return the propagator momentum.The Z-boson call in the example illustrates this category.
- Routine categories: Amplitude/on-shell routines combine known wavefunctions at a vertex to compute the diagram’s matrix element.
- Limitation: Wavefunction and amplitude routines depend explicitly on theory interactions, making a complete library for all BSM models impractical to pre-construct.
3. Automation of the method
ALOHA converts UFO model information into analytical HELAS-compatible wavefunction and amplitude routines, including off-shell, conjugate, and multiple-coupling cases. It emits language-specific code while relying on static libraries for external-particle routines.
- Model representation: ALOHA uses UFO model data to construct Lorentz structures and output wavefunctions and amplitudes using HELAS syntax.The UFO structure supplies information about particles, interactions, and parameters.
- Routine generation: The analytical module contracts model expressions with wavefunctions, expands them component by component, and writes C++, Python, or Fortran output.
- Off-shell routines: ALOHA generates off-shell routines by replacing an on-shell wavefunction with the corresponding propagator and computing its momentum from vertex momentum conservation.
- Scope: ALOHA does not generate external-particle routines and instead uses static routines for these comparatively few cases.It follows the unitary gauge for massive particles and the light-cone gauge for massless particles.
- Special routines: ALOHA supports conjugate routines for Majorana fermions and fermion-flow violation, and wrapper functions combine routines associated with multiple couplings.
4. Tests and validation
ALOHA is validated by comparing its matrix-element calculations with established Helas routines across SM, MSSM, and RS-I processes, including spin-2 interactions and interactions beyond the traditional library. The generated routines show strong agreement and typically remain within a factor of two of optimized Helas routines in speed.
- Validation method: The validation criterion requires Aloha and Helas squared matrix elements to agree to at least five orders of magnitude, with ∆D ≤1 × 10−5.The tolerance accounts for numerical-precision effects rather than requiring exact agreement.
- Model coverage: Great agreement is observed across SM, MSSM, and RS-I processes, with additional gauge- and Lorentz-invariance checks.The RS-I tests include spin-2 particles, extending validation beyond the Standard Model particle content.
- Standard Model processes: Approximately 800 2 →2, 600 2 →3, and 50 2 →4 Standard Model processes are tested to cover all helicity routines.The SM results are summarized in Tables 2 and 3 using process-specific comparisons of ∆D at selected phase-space points.
- RS-I processes: The reduced RS-I implementation tests approximately 500 2 →2 and 2000 2 →3 processes, with the first explicitly defined spin-2 mode coupling to Standard Model particles.The reported results are again in full agreement and are summarized in Tables 6 and 7.
- Beyond the HELAS library: ALOHA-generated routines reproduce validation results for non-Standard-Model interactions, including SILH Higgs decays and chromomagnetic-operator interactions.The SILH partial decay width is compared with known results, while the chromomagnetic case is checked against analytical calculations and a private Helas implementation.
- Performance: Automatically generated routines are typically within a factor of two in speed of optimized Helas routines when computing squared matrix elements.The comparison uses the time ratio Aloha/Helas reported in Table 8.
5. Summary and perspectives
ALOHA extends Helas by automatically generating helicity routines for interactions beyond fixed renormalizable structures, supporting multiple output languages and broader automation of event-generation workflows. Its flexibility also supports extensions toward loop calculations, GPU execution, and other matrix-element generators.
- Automation: ALOHA automatically generates helicity routines in Fortran, C++ and Python, supporting automation from Lagrangian-level rules to event generation.The routines are required for cross-section calculations and event generation at leading and higher orders.
- Extension beyond Helas: ALOHA extends Helas beyond renormalizable interactions and fixed Lorentz structures.This extension addresses limitations of the current Helas library.
- Flexibility: ALOHA’s symbolic and flexible design can accommodate complex-mass calculations and generalization to other even numbers of space-time dimensions.The Lorentz algebra is symbolic, with its representation entering at the final output-writing stage.
- Future extensions: R2 Feynman rules can be obtained for automatic loop computation, while GPU adaptations and automatic Heget generation for BSM models are also identified as feasible extensions.Extensions to matrix-element generators beyond MadGraph are described as straightforward, with work ongoing.
Appendix A. Argument convention
Because Fortran, Python and C++ use distinct calling procedures, the appendix documents language-specific argument types and routine-call examples alongside their analytical formulas.
- Language conventions: Fortran, Python and C++ require different procedures for calling ALOHA functions.The appendix presents the corresponding argument types and examples for each language.
Appendix B. Structure of the computation
Aloha represents analytical expressions with structured Variable and Lorentz objects, then processes those objects through a seven-step computation before generating Helas routines in multiple languages.
- Analytical objects: The Variable object stores a name, prefactor, and power, with defaults of 1 for the latter two properties.Variables with identical names represent the same mathematical variable, allowing standard addition and multiplication.
- Analytical objects: Sums and products of different variables are represented as lists, enabling the representation of arbitrary scalar expressions.For example, adding variables x and y returns a list containing both Variable objects.
- Analytical objects: Non-scalar Lorentz objects extend this structure with Lorentz and spinor indices, while linking each component to a scalar representation.A component may be a number, variable, or expression.
- Computation pipeline: Aloha takes Lorentz objects as input and transforms them through seven computation steps, including convention conversion, multiplication, evaluation, representation construction, simplification, and factorization.The resulting expression is passed to a dedicated routine that writes the corresponding Helas routines.
- Implementation: The implementation is organized into driver, analytical-library, object-definition, and writer files, with writers currently targeting Python, Fortran, and C++.The object definitions can be extended by specifying an object's indices and representation.