⚛️ phenomenology

Encoding off-shell effects in top pair production in Direct Diffusion networks

This paper proposes and extends a Direct Diffusion network framework that efficiently encodes computationally expensive off-shell effects in top pair production by transforming approximate events into full off-shell results, aiming to meet the precision requirements of upcoming LHC runs while incorporating higher-order effects.

Original authors: Mathias Kuschick

Published 2026-02-04

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Mathias Kuschick

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

The Big Picture: Fixing a "Too Perfect" Simulation

Imagine you are a video game developer trying to simulate a car crash. You have a physics engine that is incredibly fast, but it makes a simplifying assumption: it treats the car parts as if they are solid, unbreakable blocks that bounce perfectly. This is fast, but in the real world, cars crumple, parts fly off, and metal bends. If you want your simulation to match reality, you need to account for that "crumpling" (which physicists call off-shell effects).

However, calculating exactly how every piece of metal crumples is computationally expensive. It's like trying to simulate every single atom in the car; it takes too long to run the game.

The Solution: The author, Mathias Kuschick, proposes using a "smart translator" (a neural network) to fix the fast, simplified simulation. Instead of re-running the slow, perfect calculation, the network takes the fast, "solid block" simulation and learns how to tweak it so it looks exactly like the slow, "crumpled metal" reality.

The Specific Challenge: Top Quarks

In this paper, the "car crash" is actually the collision of particles at the Large Hadron Collider (LHC), specifically creating pairs of top quarks (the heaviest known particles).

The "On-Shell" Events (The Fast Simulation): These are events generated by standard tools that assume the top quarks are perfect, stable particles. They are fast to make but slightly inaccurate.
The "Off-Shell" Events (The Reality): These are events calculated with full, complex physics that account for the fact that top quarks are unstable and decay immediately. These are the "gold standard" but take a massive amount of computer power to generate.

The Method: How the "Translator" Works

The author uses a two-step process to turn the "fast" events into "real" events.

Step 1: The "Direct Diffusion" Network (The Sculptor)

Think of the "fast" events as a lump of clay that is roughly the shape of a horse, and the "real" events as a perfectly sculpted horse.

The Direct Diffusion network is like a master sculptor. It doesn't just guess the shape; it learns a specific "flow" or path to move every point of the clay from the rough shape to the perfect shape.
It works by learning a "velocity field." Imagine it figuring out exactly how fast and in what direction to push every particle in the simulation to get it to the right spot.
The NLO Upgrade: In previous work, this was done for simple collisions. In this paper, the author upgrades the system to handle Next-to-Leading Order (NLO). This is like adding "real radiation" to the mix. In the real world, when particles collide, they sometimes shoot out extra bits of energy (gluons or light quarks) like sparks flying off a grinding wheel.
- The Trick: To make the math work, the author temporarily removes these extra "sparks" from the complex reality data, fixes the main shape using the neural network, and plans to re-attach the sparks later. This ensures the "before" and "after" shapes have the same number of pieces to compare.

Step 2: The Classifier Network (The Editor)

Even after the sculptor does their job, the clay might still be slightly off in some subtle ways.

The Classifier network acts like a strict editor. It is trained to look at an event and say, "Is this a real, complex event (1) or a fake, generated one (0)?"
Because it is so good at spotting the difference, the author uses its opinion to reweight the events. If the network thinks a generated event looks very "fake," it lowers its importance. If it looks very "real," it boosts its importance.
This fine-tunes the final result, making the distribution of the simulated events match the real data almost perfectly.

The Results

The author tested this method and found:

Success: The neural network successfully transformed the simple, fast simulations into complex, realistic ones, even with the added difficulty of the extra "sparks" (radiation) in the NLO calculations.
Accuracy: The difference between the generated events and the real, complex calculations was very small—often less than 1%.
Efficiency: This method allows physicists to get high-precision results without waiting for the supercomputers to run the slow, full calculations for every single event.

What's Next?

The paper notes that this is just the "first step." The author has successfully handled the "production" part of the collision (where the sparks fly out initially). The next step, which will be in a future paper, is to figure out how to handle the "decay" part (where the top quarks break apart) and re-attach all the removed pieces to get the full picture.

In summary: The paper shows that we can use AI to "fix" fast, approximate physics simulations, turning them into high-precision, realistic models of particle collisions, saving massive amounts of computing time while keeping the results accurate.

Technical Summary: Encoding Off-Shell Effects in Top Pair Production in Direct Diffusion Networks

Problem Statement
Precise theoretical simulations of top quark pair ( $t\bar{t}$ ) production at the Large Hadron Collider (LHC) are essential for contrasting experimental measurements with theory. However, restricting simulations to on-shell kinematics (approximating particles as having fixed mass) can introduce biases. While full off-shell calculations provide higher accuracy, they are computationally prohibitive for large-scale event generation. Previous work established a method using neural network surrogates to map on-shell events to off-shell distributions at Leading Order (LO). This paper addresses the challenge of extending this methodology to Next-to-Leading Order (NLO) in QCD, where the phase space is significantly more complex due to the inclusion of real radiation and additional final-state particles.

Methodology
The proposed approach utilizes a two-stage neural network pipeline to transform "on-shell" event samples (approximate off-shell effects) into "off-shell" event samples (full off-shell calculations) at NLO.

Data Preparation and Dimensionality Reduction:
- Generators: The study uses HVQ and ST-WTCH-DR generators for on-shell events (doubly- and singly-resonant, respectively) and the BB4L generator for fully off-shell events.
- Particle Counting: To ensure the input and target distributions have the same dimensionality, the ST-WTCH-DR generator (which lacks a particle compared to HVQ) is supplemented with a single gluon or light quark via PYTHIA shower approximation.
- Handling NLO Radiation: At NLO, off-shell events contain additional particles (up to two) compared to LO. Since the current study focuses only on real radiation in the production process, gluons attached in the decay process ( $j'$ ) are removed from the off-shell target events to match the on-shell input dimensionality.
- Kinematic Preservation: To preserve correct top quark kinematics after removing decay radiation, the events are boosted into the rest frame of the respective top/antitop quark using Born kinematics provided by BB4L.
- Feature Engineering: Momentum components are transformed from $(E, p_x, p_y, p_z)$ to $(p_T, \phi, \eta, m)$ . Azimuthal angles are rotated to set $\phi_{\bar{\nu}} = 0$ , and momentum conservation constraints reduce the total dimensionality from 28 to 18.
Bayesian Direct Diffusion Network (DiDi):
- Architecture: A Bayesian Direct Diffusion network (implemented as a Conditional Flow Matching network) maps the on-shell phase space to the off-shell phase space. Unlike standard feedforward networks, weights and biases are represented by normal distributions with learnable means and standard deviations.
- Training Mechanism: The network learns a velocity field $v_\theta$ along linear trajectories connecting randomly sampled on-shell ( $x_1$ ) and off-shell ( $x_0$ ) events. It minimizes the mean squared error between the predicted velocity and the true velocity vector $(x_1 - x_0)$ .
- Uncertainty Quantification: By sampling from the learned weight distributions, the network generates a set of transformed events for each input. The variance in the resulting kinematics provides an estimate of the prediction uncertainty.
- Input Composition: The training batch includes a mix of doubly-resonant $t\bar{t}$ events and singly-resonant single-top events (approx. 2.75% for antitops and tops), reflecting their proportion in the BB4L sample, to improve transformation quality.
Classifier-Based Reweighting:
- A secondary classifier network is trained to distinguish between the Direct Diffusion-generated events and the true off-shell target events.
- The classifier output $C(x)$ is used to calculate a reweighting factor $w(x) = C(x) / (1 - C(x))$ .
- This step adjusts the density of the generated events to better match the target off-shell distribution. The authors note this step is ineffective without the initial DiDi transformation, as large regions of phase space are unpopulated in the raw on-shell data.

Key Contributions and Results

Extension to NLO: The paper demonstrates the viability of the Direct Diffusion approach in the higher-dimensional NLO phase space, a significant step beyond the previously established LO results.
Accuracy: The combined method (DiDi + reweighting) generates off-shell event distributions that match the target BB4L distribution with a deviation of only a few percent. Over large regions of the phase space, the deviation falls below the 1% mark.
Observables: The transformation successfully reproduces distributions for key observables, such as the reconstructed antitop mass ( $m_{\bar{b}l\bar{\nu}}$ ) and the lepton-b-jet mass ( $m_{lb}$ ). The inclusion of singly-resonant events in the input sample is shown to be crucial for filling regions of phase space that would otherwise be sparsely populated at LO.
Bayesian Implementation: The use of a Bayesian neural network allows for the estimation of prediction uncertainty, a feature not present in the previous LO implementation.

Significance and Limitations
The paper claims that this work represents the "first steps" toward a complete NLO off-shell simulation framework. The significance lies in proving that neural network surrogates can handle the increased complexity of NLO kinematics, including real radiation in the production process.

However, the authors are explicit about the current scope and limitations:

Incomplete NLO: The study only addresses real radiation in the production process. Radiation in the decay process ( $j'$ ) was removed to maintain dimensionality and must be reattached in future work without machine learning techniques.
Future Work: A complete generation of NLO off-shell events requires reattaching the decay radiation. Additionally, the classifier network has not yet been Bayesianized, and a full uncertainty analysis involving both networks is reserved for future publication.
Validation: Detailed tests, such as comparing showered events, are planned for a subsequent paper.

In summary, the work provides a robust proof-of-concept that Direct Diffusion networks can efficiently encode off-shell effects in top pair production at NLO, offering a computationally viable alternative to full off-shell calculations while maintaining high fidelity to the target distributions.