Nested-GPT for variable-multiplicity parton showers: A case study in the resummation of non-global logarithms

This paper introduces Nested-GPT, a hierarchical autoregressive Transformer that dynamically simulates variable-multiplicity parton showers and successfully resums non-global logarithms, offering a physically consistent alternative to flow-matching baselines that require fixed emission multiplicities.

The Gist

The Big Picture: Teaching a Computer to Simulate a Cosmic Dance

Imagine you are trying to predict the path of a chaotic dance party. In the world of high-energy physics, this "dance" is what happens when particles smash into each other at the Large Hadron Collider (LHC). When two particles collide, they don't just bounce off; they burst into a shower of new particles, which then burst into even more particles, creating a complex, branching tree of events.

Physicists call this a parton shower. To understand the results of these collisions, they need to simulate millions of these "dance histories" to see what usually happens and what is rare. However, doing this mathematically is incredibly slow and computationally expensive, like trying to calculate the trajectory of every single person in a stadium crowd in real-time.

This paper introduces a new tool called Nested-GPT. Think of it as a highly trained AI that has watched enough of these particle dances to learn the rhythm and can now generate new, realistic dance histories instantly, without needing to do the heavy math every time.

The Problem: The "Gap" in the Dance Floor

The researchers focused on a specific, tricky scenario called Non-Global Logarithms (NGLs).

The Analogy: Imagine a dance floor with a "No-Go Zone" (a gap) in the middle.

• Global Rules: If you just want to know how many people are dancing overall, it's easy.
• The Tricky Part: What if you want to know the probability that no one steps into that specific "No-Go Zone"?
• The Complication: Even if no one starts in the zone, a dancer on the edge might spin and throw a confetti ball (a particle) into the zone. Or, a dancer outside might knock a confetti ball from a neighbor into the zone. These interactions are linked and complicated.

Standard computer programs struggle with these "linked" rules because they have to calculate every possible way a particle could wander into the forbidden zone. It's like trying to predict if a specific empty chair in a theater will get occupied by someone falling from the ceiling, considering everyone else's movements.

The Solution: Two Different AI Approaches

The paper compares two different AI methods to solve this problem.

1. The "Fixed-Size" Approach (Flow-Matching)

Imagine you are a director casting a play. You tell the AI: "I need a scene with exactly 10 actors."

• How it works: The AI learns to arrange 10 actors perfectly. It's very good at this.
• The Flaw: In real life, a particle shower doesn't always have exactly 10 particles. Sometimes it has 5, sometimes 50. The AI doesn't know when to stop the scene; you have to tell it. It can't decide on its own when the party is over.

2. The New Approach: Nested-GPT

This is the star of the paper. Imagine a storyteller who builds a story one sentence at a time.

• How it works: The AI starts with the first particle. Then it asks, "Do I add another particle?"
  • If the answer is Yes, it adds the next particle and asks again.
  • If the answer is No, it stops the story.
• The "Nested" Magic: The AI is "hierarchical." It's like a manager (the outer layer) who decides "Add a new character," and then a writer (the inner layer) who decides exactly what that character looks like (their speed, direction, etc.).
• The Benefit: This AI learns the Sudakov form factor, which is a fancy physics term for "the probability that nothing happens next." It learns to say "Stop" naturally, just like a real particle shower does. It doesn't need you to tell it how many particles to make; it figures it out dynamically.

How They Tested It

The researchers trained these AIs using data generated by a very slow, very accurate traditional computer program (the "Reference Shower"). They then asked the AIs to generate their own versions of these particle showers.

They tested the AIs in two ways:

1. Direct Training: They trained the AI on a dataset where the "No-Go Zone" rule was already applied. The AI learned to mimic the result perfectly.
2. The "Generalization" Test (The Harder Challenge): They trained the AI on a dataset with no restrictions (a free-for-all dance). Then, after the AI generated a story, they applied the "No-Go Zone" rule manually to see if the AI had truly learned the underlying physics.
   • The Result: Both the "Fixed-Size" AI and the new Nested-GPT succeeded. They both generated stories that, when checked against the rules, looked exactly like the real physics. This proves the AI didn't just memorize the answer; it learned the logic of the particle dance.

The Conclusion

The paper claims that Nested-GPT is a successful, physically consistent tool.

• It can simulate variable numbers of particles (unlike the fixed-size method).
• It learns the "stop" condition naturally, mimicking how real particles behave.
• It produces results that match the gold-standard physics calculations within statistical uncertainty.

In short: The authors have built a smart, hierarchical AI that can watch a complex particle explosion, learn the rules of the game, and then instantly generate new, realistic explosions on its own, including knowing exactly when the explosion naturally fizzles out. This offers a faster way to simulate these difficult physics problems, potentially helping physicists analyze data from the Large Hadron Collider more efficiently in the future.

Technical Summary

Technical Summary: Nested-GPT for Variable-Multiplicity Parton Showers

Problem Statement
The simulation of strong-interaction processes at colliders relies on parton showers to describe the evolution of hard scattering into hadronic final states. While standard Monte Carlo generators (e.g., Pythia, Sherpa) provide successful leading-logarithmic (LL) descriptions, achieving systematic logarithmic control beyond LL remains challenging, particularly for non-global logarithms (NGLs). NGLs arise in observables sensitive to restricted phase-space regions (e.g., jet vetoes or gaps), where correlated wide-angle emissions prevent simple exponentiation.

In the large-$N_c$ limit, NGL resummation at LL accuracy is governed by the non-linear Banfi–Marchesini–Smye (BMS) equation, which admits a stochastic interpretation as a dipole shower. However, generating high-statistics samples for these discrete shower histories, especially beyond LL or in full color, is computationally prohibitive due to the complex non-linear structure of the evolution equations. Existing machine learning architectures for event generation, such as GANs, normalizing flows, or standard Transformers (e.g., PC-JeDi, JetGPT), are not explicitly designed to encode the Markovian branching structure or the Sudakov-governed termination conditions intrinsic to physical parton showers. Furthermore, many generative models require the final event multiplicity to be specified externally, failing to dynamically generate variable-multiplicity histories.

Methodology
The authors introduce Nested-GPT, a hierarchical autoregressive Transformer architecture designed to emulate NGL resummation and simulate variable-multiplicity parton-shower histories. The study utilizes the large-$N_c$ limit at LL accuracy as a controlled benchmark, generating reference training data via a stochastic Monte Carlo dipole shower that solves the BMS equation.

The methodology compares two distinct generative approaches:

1. Flow-Matching Baseline:

   • Represents a dipole-shower history as a fixed-length sequence of particles ($N_{max}=100$), ordered by shower time.
   • Uses a continuous-time generative model based on flow matching to map a Gaussian base distribution to the target data distribution via an Ordinary Differential Equation (ODE).
   • Limitation: This approach requires the event multiplicity to be sampled and supplied before integration. It functions as a conditional fixed-multiplicity generator and does not inherently learn the emission/no-emission probabilities that determine shower termination.

2. Nested-GPT Architecture:

   • Implements an autoregressive event generator inspired by GPT-style causal self-attention.
   • Hierarchical Structure:
     • Outer Loop: A Transformer decoder models particle-to-particle dependencies. It processes a sequence of particle tokens, where each token represents a discrete emission.
     • Inner Loop: An autoregressive decoder (specifically a 2-layer GRU) generates the features of a single particle (inter-emission time $\Delta t$, transverse momentum $p_T$, rapidity $\eta$, azimuth $\phi$) sequentially.
   • Dynamic Termination: Crucially, the model predicts a stop/continue decision ($s_i \in \{0, 1\}$) after generating each particle. If $s_i=0$, the sequence terminates. This allows the model to learn the Sudakov-driven termination pattern dynamically, enabling true variable-multiplicity generation without external specification of $N$.
   • Training: The model is trained using teacher forcing with a categorical cross-entropy loss (using ordinal smoothing for discretized bins) and a regression loss on bin centers. An auxiliary lightweight model is used to learn the prior for the leading emission.

Key Contributions

• Architectural Innovation: The introduction of Nested-GPT, which explicitly encodes the ordered Markovian branching structure of parton showers and learns a learned sequence-termination condition, addressing a gap in existing ML-based event generators.
• Benchmarking Framework: A systematic evaluation of Nested-GPT against a Transformer flow-matching baseline using gap fraction observables under two training regimes:
  1. Direct Training: Training on vetoed histories where the gap condition is enforced during generation.
  2. Inclusive Training: Training on inclusive samples (no veto) followed by an analysis-level veto applied post-generation.
• Physical Consistency: Demonstration that a hierarchical autoregressive model can successfully internalize complex phase-space restrictions and non-linear evolution dynamics characteristic of NGL resummation.

Results

• Fixed-Gap Regime: Nested-GPT exhibits excellent agreement with the reference NGL-resum shower across the entire kinematic range. It accurately reproduces the evolution of the gap fraction $G(t)$ and the rapidity density $P(y)$, including the characteristic depletion in the central region and the sharp falloff at large $|y|$.
• Generalization Regime: When trained on inclusive samples and subjected to a post-hoc veto (truncating events at the first emission entering the gap), both Nested-GPT and the flow-matching baseline successfully recover the main features of the vetoed sample.
  • The models correctly reproduce the symmetric two-peak structure in rapidity and the robust gap fraction agreement.
  • This success indicates that the models have captured the causal, time-ordered shower sequence rather than merely fitting inclusive single-emission probabilities.
• Stability: The generated samples agree with the reference shower within statistical uncertainties for the observables considered. Training trajectories show hierarchical learning, with the model progressively resolving complex correlation patterns.

Significance and Claims
The paper establishes Nested-GPT as a physically consistent autoregressive surrogate for variable-multiplicity shower generators. The primary methodological contribution is the demonstration that chronological parton-shower histories can be efficiently emulated through causal attention mechanisms.

The authors claim that while the flow-matching framework serves as a robust benchmark for continuous feature learning, Nested-GPT offers a novel conceptual route for simulating variable-multiplicity stochastic sequences by dynamically managing event termination. The study positions this work as a proof of concept for using generative AI to bypass computational bottlenecks in high-precision QCD. The authors explicitly state that future work should focus on extending these architectures to subleading-logarithmic (NLL) resummation and finite-$N_c$ color evolution, where current public codes face severe combinatorial and computational limitations. They do not claim immediate deployment for full LHC analysis but rather propose this as a viable framework for evaluating complex theoretical predictions against data in the future.