⚛️ phenomenology

Timelike showers with jet recoils

This paper proposes and validates a new dipole parton-shower algorithm that achieves next-to-leading logarithmic (NLL) accuracy by imposing four-momentum conservation through jet-level recoils, where angular ordering determines parton grouping without requiring explicit jet clustering at each evolution stage.

Original authors: Jack Helliwell, Ludovic Scyboz, Peter Skands

Published 2026-07-07

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jack Helliwell, Ludovic Scyboz, Peter Skands

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.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

Imagine a high-energy particle collision as a chaotic dance floor where tiny particles (quarks and gluons) are spinning, colliding, and splitting apart. In the world of physics, these particles must follow strict rules: they cannot just disappear, and they cannot create energy out of thin air. If one particle shoots off in a new direction, something else must push back to balance the equation. This "push back" is called recoil.

For a long time, physicists have been trying to figure out the best way to calculate this push back in their computer simulations (called "parton showers"). The paper you provided, titled "Timelike showers with jet recoils," proposes a clever new way to handle this balancing act.

Here is the story of their discovery, explained simply:

The Problem: The "Too-Heavy" Backpack

Imagine you are walking down a hallway carrying a heavy backpack.

The Old Way (Local Recoil): In many existing simulations, when a particle splits and shoots a new particle forward, the simulation forces the single particle that just split to carry the entire weight of the recoil. It's like if you threw a ball forward, and your own body had to absorb the entire kickback, throwing you off balance.
The Issue: If this happens over and over again in a long chain of events, that single particle gets "kicked" too hard in the wrong direction. It's like a dancer getting spun around so violently they lose the rhythm of the whole dance. In physics terms, this causes the computer simulation to get the math slightly wrong at a very specific, high level of precision (called "Next-to-Leading Logarithmic" or NLL accuracy).

The Solution: The "Group Hug" (Jet Recoil)

The authors of this paper suggest a smarter approach. Instead of making just one particle take the hit, they say: "Let's make a whole group of particles share the load."

They call this group a "Jet."

The Analogy: Imagine you are in a crowded elevator. If someone pushes the door open, it's not just the person standing right next to the door who moves; the whole group shifts slightly together to make room.
How it works: When a new particle is born, the simulation looks at the surrounding crowd. Based on the "rules of the dance" (specifically, how close the particles are to each other in angle), it groups them into a team. When the recoil happens, the entire team shifts together to absorb the push. This keeps the individual dancers from getting spun out of control.

The Secret Ingredient: The "Angle" Rule

How does the computer know who belongs in which group? The authors use a rule called Angular Ordering.

Think of it like a flashlight beam. If a new particle is emitted very close to an old one (a narrow angle), they are "close friends" and should be in the same group. If a new particle is emitted far away (a wide angle), it belongs to a different group.
The paper describes a clever algorithm that builds these groups on the fly, without needing to stop and re-sort the whole list of particles every time. It's like a smart bouncer who instantly knows which people belong in which VIP section based on who they are standing next to.

Did it Work? The "Stress Test"

The authors didn't just propose this idea; they put it to the test.

The Fixed-Order Test: They checked the math at specific, simple moments (like checking a single step in the dance) to ensure the recoil was distributed correctly.
The Resummation Test: They ran the simulation over and over again to see how it behaved over a long chain of events (the whole dance). They compared their results against the "gold standard" mathematical formulas that physicists trust.

The Result: Their new "Jet Recoil" method passed every test. It successfully fixed the "wrong kickback" problem and achieved the high level of precision (NLL accuracy) that the old methods struggled with.

The Bottom Line

This paper introduces a new way to simulate particle collisions where, instead of forcing a single particle to take the brunt of a collision's recoil, the recoil is shared by a smartly chosen group of particles (a "jet"). By doing this, the computer simulations become much more accurate, ensuring that the "dance" of particles follows the true laws of physics without getting the rhythm wrong.

What the paper does NOT claim:

It does not claim this will immediately change how we build particle accelerators.
It does not claim this will lead to new medical treatments or clinical uses.
It focuses strictly on improving the mathematical accuracy of the computer code used to predict how particles behave after a collision.

In short: They found a better way to balance the books in a particle physics simulation, ensuring that when particles split, the "push back" is shared fairly among the right group of friends.

Technical Summary: Timelike Showers with Jet Recoils

Problem Statement
The paper addresses a fundamental challenge in parton-shower simulations: achieving exact four-momentum conservation while maintaining Next-to-Leading Logarithmic (NLL) accuracy. Current recoil strategies fall into two categories:

Local Recoil: Momentum is balanced between the emitting dipole ends (emitter and spectator). While simple and Lorentz invariant, these schemes often impart "excessive" transverse recoil to individual partons. This leads to a violation of the factorization of independent emissions, particularly for successive branchings at commensurate transverse-momentum scales but wide rapidity separations. Consequently, standard $k_t$ -ordered dipole showers with local recoil fail to reproduce the correct NLL terms for global event shapes.
Global Recoil: Momentum is distributed among a wider subset of partons (or the entire event). While this can achieve NLL accuracy, it often introduces significant complexity, scaling as $N^2$ with particle multiplicity, and may obscure Lorentz invariance.

The authors note that existing NLL-accurate showers often sacrifice either $k_t$ -ordering or local recoil properties. The goal is to develop a scheme that retains the simplicity of local recoil maps but distributes recoil in a way that satisfies NLL accuracy criteria.

Methodology
The authors propose a "jet recoil" algorithm for timelike (final-state) dipole showers. The core innovation is distributing the transverse recoil not to a single spectator parton, but to a dynamically determined group of partons, termed a "jet" ( $J$ ).

Jet Definition via Angular Ordering: The algorithm determines the recoiling jet $J$ based on the angular ordering property of QCD coherence. Instead of performing explicit jet clustering at every step (which would be computationally expensive), the authors utilize a list of rapidity intervals associated with each emitting dipole. These intervals map to "Lund leaves" (branches in a hypothetical clustering sequence).
Recoil Assignment: When a new emission $k$ $k$ is generated from a dipole $(\tilde{l}, \tilde{m})$ $(\tilde{l}, \tilde{m})$ , the algorithm identifies the rapidity interval containing $k$ $k$ . The recoiling jet $J$ $J$ is defined as the set of particles on that specific Lund leaf that are closer in angle to the dipole end than the emission $k$ $k$ .
- If $k$ is emitted at a large angle relative to a collinear cluster, the entire cluster (the "jet") absorbs the transverse recoil.
- If $k$ is collinear to a specific parton within a cluster, only that parton (or a smaller sub-cluster) absorbs the recoil.
Kinematic Map: The algorithm employs a standard $2 \to 3$ kinematic map (similar to Catani-Seymour or antenna maps) but treats the "emitter" as the composite jet $J$ rather than a single particle. The spectator is chosen as the dipole end farthest in rapidity from the emission. A Lorentz transformation is applied to all constituents of $J$ to preserve internal invariants while absorbing the transverse recoil.
Implementation: The scheme was implemented as a user-defined shower within the PanScales public code (v.0.2.0). The evolution variable is transverse momentum ( $k_t$ ), and the strong coupling is evaluated using the 2-loop CMW scheme.

Key Contributions

Algorithmic Formulation: The paper provides an explicit realization of a jet-recoil scheme for dipole showers that avoids explicit clustering at every step by maintaining a dynamic list of rapidity intervals.
NLL Accuracy Proof: The authors demonstrate that this scheme satisfies the NLL accuracy criteria established in Refs. [17, 32]. This is achieved by ensuring that subsequent emissions do not spuriously modify the kinematics of prior emissions in logarithmically enhanced regions (where emissions are at commensurate $k_t$ but widely separated in rapidity).
Special Case Handling: The paper details the handling of special configurations, including:
- Identification of the spectator when angular ordering is ambiguous.
- Gluon splittings ( $g \to q\bar{q}$ ), where the recoiling jet is adjusted to include the splitting products appropriately.
- Initial states with cyclic color connections (e.g., $H \to gg$ ).

Results
The authors validated the algorithm through two distinct testing frameworks:

Fixed-Order Tests: The algorithm was tested against the infrared (IR) limits of tree-level matrix elements for various emission configurations (up to $O(\alpha_s^3)$ ). The results, visualized on Lund diagrams, show that the kinematics of prior emissions remain unchanged when a new emission is widely separated in rapidity, confirming the correct factorization behavior required for NLL accuracy.
All-Order Resummation Tests: Using the PanScales framework, the shower predictions were compared against analytic NLL resummation results for a wide range of global event shapes (e.g., thrust, jet broadenings, $C_1$ $C_{1}$ -like observables) and non-global observables (transverse momentum in a rapidity slice).
- Outcome: The jet-recoil shower showed perfect agreement (within statistical uncertainties) with the analytic NLL resummation for all tested observables.
- Comparison: In contrast, a standard PanLocal shower with $\beta_{ps}=0$ (which uses local recoil) showed significant deviations for $\beta_{obs}=0$ observables, confirming the test's sensitivity to NLL errors.

Significance and Claims
The paper concludes that jet recoils provide a viable path for adapting existing dipole/antenna-type showers to achieve NLL accuracy.

The authors claim that their method successfully reconciles the use of $k_t$ -ordered evolution variables with NLL accuracy, a combination previously difficult to achieve without resorting to global recoil schemes that are computationally heavier or less manifestly Lorentz invariant.
The work is presented as a "proof-of-concept" for final-state showers with massless quarks.
The authors explicitly state that generalizations to initial-state showers and antenna kinematics (where recoil is shared between both ends of the dipole, e.g., in Vincia) are left for future studies.
They acknowledge that similar ideas are being explored by Salam and Soyez in unpublished work [36], noting the convergence of these independent efforts.

The paper does not claim immediate application to specific experimental analyses or propose new detector strategies; its contribution is strictly theoretical and algorithmic, aimed at improving the precision of parton-shower Monte Carlo generators.