⚛️ phenomenology

pyAmpliCol: fast tree-level matrix elements

The paper introduces pyAmpliCol, a fast public generator that extends the practical reach of colour-resolved tree-level matrix elements to higher multiplicities by utilizing a symmetric group fast Fourier transform to efficiently compute exact full-colour results, thereby bridging high-multiplicity calculations with event generation, merging, and precision applications.

Original authors: Rikkert Frederix, Valentin Hirschi, Lucien Huber, Shahriar Iravanian, Ben Ruijl, Timea Vitos

Published 2026-10-09

📖 5 min read🧠 Deep dive

CC0 1.0

Original authors: Rikkert Frederix, Valentin Hirschi, Lucien Huber, Shahriar Iravanian, Ben Ruijl, Timea Vitos

Original paper dedicated to the public domain under CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the bustling world of high-energy physics, scientists act as cosmic detectives, trying to understand the fundamental rules that govern the universe by smashing particles together at incredible speeds. When these particles collide, they do not simply bounce off one another; they shatter into showers of new particles, creating complex, chaotic sprays that physicists must reconstruct to understand the original event. To make sense of these collisions, researchers rely on mathematical tools called matrix elements. Think of these as precise blueprints that predict exactly how likely a specific outcome is to occur when particles interact. These blueprints are essential for every experiment at the Large Hadron Collider, helping scientists distinguish between ordinary background noise and the rare, exotic signals of new physics. However, as the number of particles produced in a collision increases, the complexity of these blueprints explodes. Calculating the outcome for a few particles is manageable, but adding just a handful more causes the number of possible ways they can interact to grow so fast that even the world's most powerful supercomputers struggle to keep up.

A team of researchers has now introduced a new software tool designed to solve this specific bottleneck. They have developed a program called pyAmpliCol, which acts as a high-speed engine for generating these particle interaction blueprints. The core challenge the team faced was that traditional methods for calculating these interactions become hopelessly slow when dealing with many particles, particularly because of a property called "colour." In particle physics, colour is a type of charge carried by quarks and gluons, similar to electric charge but with more complex rules. When calculating the probability of an event, physicists must account for every possible way these colour charges can connect and interfere with one another. As the number of particles grows, the number of these colour connections grows so rapidly that the calculation time becomes impractical. The researchers found that while previous tools could handle the basic particle interactions, they would get stuck trying to sum up all the possible colour combinations, effectively hitting a wall where the computer time required grew too large to be useful.

To break through this wall, the authors rebuilt the calculation engine from the ground up, using a strategy that avoids listing every single possibility one by one. Instead of trying to write down every possible path a particle could take, their new method builds the answer by reusing smaller, pre-calculated pieces of the puzzle. Imagine constructing a massive wall not by laying every single brick individually, but by assembling pre-made sections and snapping them together. This approach, known as off-shell current recurrence, allows the program to calculate the interactions of many particles by combining simpler currents in a smart, efficient way. Furthermore, to handle the overwhelming number of colour connections, the team employed a mathematical technique that organizes these connections into groups, allowing the computer to process them in bulk rather than one by one. This is akin to sorting a massive pile of mail into neighborhoods before delivering it, rather than walking door-to-door for every single letter.

The results of this new approach are striking. When the researchers tested their tool against existing methods, they found that for processes involving many particles, their program was significantly faster. In some cases, it was dozens of times quicker than the standard tools currently used by the physics community. For example, in a test involving the production of a Higgs boson accompanied by several gluons, the new tool completed the calculation in a fraction of a second, whereas the previous best method took over twenty seconds. This speedup is not just a minor improvement; it is a game-changer that allows physicists to simulate events with many more particles than was previously possible. This capability is crucial because the upcoming upgrades to particle colliders will produce vast amounts of data, and scientists need to be able to simulate these complex, high-particle events to identify what is truly new and what is just background noise.

Beyond raw speed, the new tool offers greater flexibility and precision. It can handle a wide variety of theoretical models, not just the standard rules of particle physics, allowing researchers to test new ideas about how the universe works. It also provides a way to calculate these interactions with different levels of mathematical precision, which is vital for checking the stability of the results in extreme conditions where numbers can become unstable. The researchers validated their work by comparing their results against independent calculations and found that the numbers matched perfectly, confirming that the speed did not come at the cost of accuracy. By making this tool public and easy to use, the team has provided the physics community with a powerful new resource. This tool connects the theoretical predictions of particle physics directly to the data coming out of the world's most powerful machines, ensuring that scientists can continue to push the boundaries of our understanding of the universe, even as the complexity of the collisions they study continues to grow.

Technical Summary: pyAmpliCol – Fast Tree-Level Matrix Elements

1. Problem Statement

Tree-level scattering amplitudes are fundamental to collider phenomenology, serving as the backbone for leading-order event generation, higher-order real-radiation terms, and parton shower improvements. However, their computational cost escalates rapidly with the number of external particles (multiplicity). Two primary bottlenecks exist:

Amplitude Construction: The number of Feynman diagrams grows factorially with multiplicity. While recursive methods (e.g., Berends–Giele) avoid explicit diagram enumeration by reusing off-shell currents, the construction of these currents for high multiplicities remains demanding.
Colour Summation: Even if partial amplitudes are generated efficiently, the exact colour summation involves contracting a dense interference matrix of size $N_{\text{ord}}^2$ , where $N_{\text{ord}}$ is the number of colour orderings (growing factorially). This "factorial-squared" cost often becomes the limiting step, particularly for full-colour calculations required in precision physics and reweighting strategies.

Existing generators often struggle to balance the need for exact colour treatment with the computational feasibility of high-multiplicity processes (e.g., $Z + n$ jets or Higgs + $n$ jets) required for High-Luminosity LHC (HL-LHC) studies.

2. Methodology

pyAmpliCol is a public generator designed to extend the practical reach of colour-resolved matrix elements to higher multiplicities. It builds upon the colour-ordered, off-shell-current strategy of its predecessor, AmpliCol, but introduces significant algorithmic and software engineering improvements.

Core Physics Algorithms

Off-Shell Current Recurrence: The generator utilizes Berends–Giele-like recursion to construct colour-ordered off-shell currents. It shares identical currents across different colour sectors and helicity assignments, reducing the computational load. The framework supports arbitrary models defined in the Universal FeynRules Output (UFO) format.
Contact Interaction Decomposition: To maintain the binary nature of the recursion, multi-point contact interactions (e.g., four-gluon vertices or Higgs effective field theory interactions) are decomposed into sequences of cubic joins using auxiliary fields or tensor factorization. This is handled generically via the Spenso library, which derives component expressions from UFO rules.
Exact Colour Summation via FFT: To address the factorial-squared cost of colour contraction, pyAmpliCol employs Fast Fourier Transforms (FFTs) over the symmetric group $S_m$ $S_{m}$ .
- For pure-gluon amplitudes, it utilizes the Del Duca–Dixon–Maltoni (DDM) basis.
- For processes with open quark lines, it adapts the basis to fundamental chains.
- The FFT reorganizes the dense interference sum into smaller matrix contractions associated with irreducible representations of the symmetric group (Young diagrams), avoiding direct pairwise summation while preserving exact colour results.
- Walsh–Hadamard transforms are used for Abelian subgroups to further reduce work in specific open-quark-line bases.
Correlated Matrix Elements: The generator produces colour- and spin-correlated Born quantities required for local subtraction schemes (NLO, NNLO, etc.). It retains complex partial amplitudes and applies colour insertion matrices (representing soft/collinear limits) without discarding interference terms.

Software Architecture

The implementation relies on a modern, agentic development workflow and a modular Rust/Python stack:

Symbolica: Used for symbolic manipulation, simplifying expressions, and generating optimized numerical evaluators. It handles the translation of model rules into numerical kernels.
SymJIT: A Just-In-Time (JIT) compiler that converts symbolic expressions into highly optimized, vectorized machine code (SIMD), significantly outperforming standard C++ compilers for the monolithic expressions typical of high-multiplicity amplitudes.
Spenso: A tensor contraction library that derives the scalar component expressions for off-shell currents from UFO Lorentz rules.
RustiCol: The Rust backend that efficiently loads process outputs and evaluates matrix elements in batched mode, supporting interfaces in Python, C, C++, Fortran, and Rust.
Precision Control: The framework supports arbitrary-precision arithmetic (via Symbolica) for validation and numerical stability checks in singular limits, while defaulting to double-precision for high-throughput generation.

3. Key Contributions

High-Multiplicity Performance: pyAmpliCol achieves substantial speedups over reference generators (AmpliCol and MadGraph5_aMC@NLO) for full-colour, high-multiplicity processes. Benchmarks show speedups of factors ranging from 1.5 to over 30 for processes like $gg \to H + 6g$ and $d\bar{d} \to Z + 6g$ .
Exact Colour Efficiency: By integrating symmetric-group FFTs, the generator avoids the factorial-squared bottleneck of direct colour contraction, making exact full-colour calculations feasible at multiplicities where they were previously prohibitive.
Generalized Model Support: Unlike many specialized generators, pyAmpliCol supports a broad class of UFO models, including the Standard Model, Higgs Effective Field Theory (HEFT), and generic scalar/vector contact interactions, without hard-coded assumptions.
Correlated Quantities for Subtraction: It provides a generic framework for generating colour- and spin-correlated tree-level quantities at arbitrary perturbative orders, facilitating local subtraction methods for higher-order calculations.
Agentic Development Experiment: The paper documents the use of AI agents (Codex) to port, generalize, and test the implementation. The authors emphasize that while AI accelerated code production, expert human supervision was critical for physics validation, numerical testing, and architectural decisions.

4. Results

Validation: Numerical comparisons against independent calculations (AmpliCol and MadGraph5_aMC@NLO) show relative differences typically below $10^{-11}$ , confirming the correctness of the implementation.
Performance Benchmarks:
- For $d\bar{d} \to Z + (n-1)g$ , pyAmpliCol is consistently faster than AmpliCol for full-colour sums, with speedup ratios increasing with multiplicity (e.g., a factor of ~4 at $n=7$ ).
- For $gg \to H + (n-1)g$ in HEFT, pyAmpliCol demonstrates a speedup of ~36.8 for the $n=7$ full-colour case compared to MadGraph5.
- The choice of colour basis (Adjoint vs. Trace) significantly impacts performance; the adaptive adjoint basis often yields the best results for gluon-dominated processes.
Numerical Stability: The ability to switch to higher precision (e.g., double-double or arbitrary precision) allows for stable evaluation in regions where large cancellations occur, such as in local subtraction counterterms.

5. Significance and Claims

The paper claims that pyAmpliCol connects high-multiplicity matrix elements directly to their use in event generation, merging, parton showers, and precision calculations within a single generator. Its significance lies in:

Extending the Reach: It enables the generation of exact colour-resolved matrix elements at multiplicities (e.g., $Z+7$ jets, $H+6$ jets) that are critical for future LHC analyses but were previously computationally inaccessible for full-colour treatments.
Unifying Framework: By providing a single interface for colour-ordered amplitudes, correlated Born quantities, and arbitrary precision, it bridges the gap between fixed-order calculations and Monte Carlo event generation.
Methodological Proof: The work serves as a proof-of-concept for "agentic scientific software development," demonstrating that AI-assisted coding, when guided by domain experts and rigorously validated against independent physics identities, can produce complex, high-performance scientific software.

The authors remain modest regarding the scope, noting that while the tool addresses specific bottlenecks in tree-level generation, it does not solve all challenges in loop calculations or the full integration of these amplitudes into every existing shower algorithm without further adaptation. The tool is presented as a public resource to facilitate further developments in high-multiplicity phenomenology.