⚛️ phenomenology

Neural Control Variates at LO and NLO

This paper proposes a method using neural control variates, specifically a signed control variate constructed from two normalizing flows, to minimize event weight ranges, eliminate negative weights, and significantly reduce the computational cost of both LO and NLO predictions through enhanced phase-space integration and event generation.

Original authors: Theo Heimel, Tilman Plehn, Rebecca Revelli, Sophia Vent, Ramon Winterhalder

Published 2026-07-28

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Theo Heimel, Tilman Plehn, Rebecca Revelli, Sophia Vent, Ramon Winterhalder

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 trying to predict the outcome of a chaotic dance party where millions of particles collide at nearly the speed of light. This is the daily job of physicists working at the Large Hadron Collider (LHC), the world's most powerful particle accelerator. To make sense of the data they collect, they rely on "event generators"—sophisticated computer programs that simulate these collisions based on the laws of quantum physics. Think of these generators as digital crystal balls that tell scientists what a collision should look like, so they can compare it to what actually happened.

However, simulating these collisions is incredibly difficult because the math involves "integrals," which are essentially ways of adding up infinite possibilities to find a total probability. In the quantum world, these calculations often produce "negative weights," which are like financial debts in a simulation. If a computer tries to add up a million dollars in profit and a million dollars in debt, the result is zero, but the computer has to do all that work just to get there. This makes the simulation incredibly slow and inefficient. Furthermore, the "weights" (the importance of each simulated event) can vary wildly, from tiny fractions to massive numbers, making it hard to get a clear picture. The goal for physicists is to smooth out this chaos, remove the confusing negative numbers, and make the simulation run fast enough to keep up with the real data pouring in from the LHC.

In this paper, the authors introduce a clever new tool called Neural Control Variates (NCVs) to fix these problems. They treat the messy math of particle collisions like a problem that can be solved by a smart, learning computer program (a neural network).

The Problem: The Rollercoaster of Weights
Imagine you are trying to measure the average height of people in a room. If you have a few giants and a few dwarfs, your measurements will swing wildly. In particle physics, the "weights" of events can swing just as wildly. Sometimes, the math produces negative numbers (like a giant debt) that cancel out the positive numbers. This is a nightmare for computers because they have to calculate both the huge positive and huge negative numbers just to see a tiny result. It's like trying to balance a scale with a bowling ball on one side and a bowling ball on the other, just to see if there's a feather in the middle.

The Solution: A Smart "Subtractor"
The authors propose using a neural network to act as a "control variate." Think of this as a smart assistant that learns to predict the shape of the chaos before the computer even starts the heavy lifting.

Flattening the Hills: The assistant learns where the "hills" (high probability areas) and "valleys" (low probability areas) are. It then subtracts a copy of this shape from the original problem. This leaves behind a much flatter, calmer landscape that is much easier for the computer to sample.
Lifting the Negative: If the math dips below zero (creating a negative weight), the assistant adds a "lift" to push it back up into positive territory. It's like a safety net that catches the negative numbers and turns them into manageable, positive contributions.

The authors built this assistant using two types of "normalizing flows" (a specific kind of neural network good at learning complex shapes). One part of the network learns the positive shapes, and the other learns the negative shapes. By combining them, they create a "signed control variate" that can handle both sides of the equation.

How They Tested It
The team tested their new method on two types of particle collisions:

Level 1 (LO): A simpler simulation of top quark pairs being produced with gluons.
Level 2 (NLO): A more complex, higher-precision simulation that includes extra "real emission" particles and tricky subtraction terms to handle infinities.

They compared their new NCV method against the standard tools used by physicists, like Vegas (a classic algorithm) and MadNIS (a newer neural network method).

The Results: Smoother, Faster, and Cleaner
The results were impressive. In the simpler tests (Level 1), the NCV method reduced the "noise" in the simulation by a factor of roughly 2.7 compared to the best existing neural method. This means the computer could generate useful events much faster.

In the complex tests (Level 2), the improvement was even more dramatic regarding negative weights.

For the process $e^+e^- \to t\bar{t}g$ (top quarks and a gluon), the standard method produced negative weights about 4.2% of the time. The new nested NCV method (which uses two layers of smart assistants) reduced this to just 2.1%, and a single-layer version reduced it to 0.4%.
For the process $e^+e^- \to q\bar{q}g$ (quarks and a gluon), the negative weights dropped from 12.1% down to 1.8% with the single-layer NCV.

Perhaps most importantly, the method didn't just make the numbers smaller; it made the simulation more efficient. By absorbing a large chunk of the calculation (up to 65% in some cases) into a "trivial" part that the computer can sample instantly, the authors showed that the expensive, slow parts of the calculation only needed to be done for a fraction of the events.

Why It Matters
The authors suggest that this method acts like a "trainable subtraction term." Instead of relying solely on rigid, pre-written physics formulas to remove the infinities and negative numbers, they let the neural network learn the best way to do it. This doesn't replace the physics; it complements it, making the heavy lifting of particle physics simulations significantly less computationally expensive. While the numbers shown are from simulations and not yet a permanent fix for all future collider data, the study demonstrates that neural networks can successfully tame the wild, negative, and chaotic math that has long slowed down our understanding of the universe's smallest building blocks.

Technical Summary: Neural Control Variates at LO and NLO

Problem Statement
Precise and fast first-principle simulations are essential for the LHC program, yet event generators face critical bottlenecks in Monte Carlo integration and sampling. Two primary issues degrade performance:

Wide Range of Event Weights: Kinematic tails and singularities lead to large variances in event weights, resulting in poor unweighting efficiency and high computational costs.
Negative Event Weights: In Next-to-Leading Order (NLO) calculations, subtraction schemes used to regularize soft and collinear divergences often introduce negative weights. These arise from the subtraction terms locally exceeding the real emission or from mismatches in phase-space cuts. Negative weights increase variance, reduce effective statistics, and complicate downstream simulation steps.

While Neural Importance Sampling (NIS) has successfully addressed weight ranges, its efficiency in the presence of subtraction schemes remains a challenge. Standard subtraction terms, while necessary for regularization, can create non-trivial, negative integrands that hinder variance reduction.

Methodology
The authors propose Neural Control Variates (NCVs) as a generic tool to minimize the range of event weights and remove negative weights. An NCV replaces the ratio of integrand to sampling density (typical in importance sampling) with a numerically stable subtraction.

Core Mechanism: A signed control variate $c_\theta(x)$ is constructed from two normalizing flows, $p_{+,\theta}$ and $p_{-,\theta}$ , multiplied by learned scalar normalizations $C_{+,\theta}$ and $C_{-,\theta}$ .
$c_\theta(x) = C_{+,\theta} p_{+,\theta}(x) - C_{-,\theta} p_{-,\theta}(x)$
The integral is split into a residual term and a trivially sampled term:
$\sigma = \langle w_{res} \rangle + (C_{+,\theta} - C_{-,\theta})$
The compensating terms ( $C_{\pm,\theta}$ ) are sampled directly with unit weights ( $\pm 1$ ), while the residual requires unweighting. The goal is to absorb as much of the integral as possible into the trivial term while keeping the residual small and positive.
Nested Construction for NLO: For NLO calculations where the integrand factorizes into Born-like ( $x_B$ ) and radiation ( $x_R$ ) variables, the authors employ a nested NCV:
1. Conditional NCV: Acts on the radiation variables $x_R$ for fixed $x_B$ . It learns the subtraction of the real-emission fluctuations, effectively acting as a trainable subtraction term that complements physics-based schemes (like Catani–Seymour dipoles).
2. Unconditional NCV: Acts on the Born-like variables $x_B$ to handle residual sign changes in the Born-like integral.
  This structure allows the conditional NCV to lift negative regions in the radiation phase space without competing with the unconditional NCV.
Training: The networks are trained simultaneously to minimize a loss function comprising:
- Shape losses (weighted log-likelihood) for the flows.
- Integral losses to ensure the learned normalizations match the target integrals.
- A NIS loss for the sampler flow $g_\phi$ .
- A softplus barrier ( $L_{neg}$ ) to penalize negative weights in the residual, ensuring strict positivity where required.
- For NLO, a specific mixture density is used during training to ensure the sampler adequately covers the narrow, negative regions of the integrand.

Key Contributions and Results
The paper benchmarks the NCV approach on Leading Order (LO) and NLO processes, comparing it against uniform sampling, standard NIS (MadNIS), and Vegas.

LO Application ( $gg \to t\bar{t}gg$ ):
- The NCV compresses the range of event weights.
- Combined with NIS, it improves the unweighting efficiency by a factor of 2.7 compared to MadNIS alone.
- The relative variance of the fiducial cross section is reduced by a factor of roughly 7.8 compared to pure NIS.
- The method successfully handles phase-space cuts, with the NCV contribution absorbing ~77% of the cross section in the penalized setup.
NLO Application ( $e^+e^- \to t\bar{t}g$ and $e^+e^- \to q\bar{q}g$ ):
- Sign Removal: The nested NCV significantly reduces the fraction of negative weights.
  - For $e^+e^- \to t\bar{t}g$ , the negative contribution drops from 4.2% (Vegas/MadNIS) to 0.4% (1-NCV) and 2.1% (2-NCV).
  - For $e^+e^- \to q\bar{q}g$ , the negative contribution drops from 12.1% to 1.8% (1-NCV) and 4.6% (2-NCV).
- Variance Reduction: The relative variance is reduced by roughly an order of magnitude compared to Vegas and a factor of 3–4 compared to MadNIS.
- Computational Efficiency: For $t\bar{t}g$ production, the NCV absorbs 54% to 65% of the total cross section into the trivially sampled term. This means only 35–46% of the integral requires expensive evaluations of the full integrand (including loop amplitudes).
- Nested vs. Single: The nested construction (2-NCV) generally performs better for complex structures (like the narrow negative slices in Toy-II and $q\bar{q}g$ ) because the conditional flow can target the specific correlation between Born and radiation variables more effectively than a single joint flow.

Significance and Claims
The paper claims that Neural Control Variates provide a simple, general solution to the two leading limitations of Monte Carlo event generation: wide weight ranges and negative weights.

Complementarity: The NCV is presented not as a replacement for physics-based subtraction schemes but as a complement. It reduces the physics-defined subtraction to its original purpose (removing divergences) while the NCV handles the remaining sign changes and structural features.
Learnable Subtraction: The conditional NCV is viewed as a "trainable subtraction term" that stabilizes real-emission integration.
Event Generation Focus: Unlike previous control variate applications focused solely on integration, this construction is explicitly designed for event generation, producing trivially unweighted events with unit weights for the NCV contribution.
Modest Claims: The authors note that the reported improvements are not the result of intensive hyperparameter optimization and serve to illustrate the potential of NCVs. They acknowledge that the nested construction might benefit from further tuning (e.g., different normalizations or $\lambda_{neg}$ values) and that the choice between single and nested NCVs depends on whether negative weights or matrix-element evaluations dominate the computational cost.

In summary, the work demonstrates that combining NCVs with NIS significantly enhances the efficiency of both LO and NLO event generation, offering a pathway to handle higher-order predictions for the high-luminosity LHC with reduced computational overhead.

More like this