Iterative HOMER with uncertainties

This paper introduces iHOMER, an iterative method combining Bayesian neural networks and uncertainty-aware regression to extract well-calibrated Lund fragmentation functions from experimental data by systematically addressing latent phase space biases and quantifying uncertainties.

The Gist

Here is an explanation of the paper "Iterative HOMER with uncertainties" using simple language and creative analogies.

The Big Picture: Tuning the Universe's Recipe Book

Imagine you are a chef trying to recreate a famous, complex dish (like a perfect soufflé) based on a recipe you found in an old cookbook. The cookbook is your computer simulation (specifically, a tool called PYTHIA used by physicists). The actual dish you are trying to match is real experimental data from particle colliders like the Large Hadron Collider (LHC).

The problem? The old recipe isn't quite right. It gets the general idea of the soufflé, but the texture is slightly off, or it rises too much. In physics terms, the "recipe" for how particles stick together to form matter (a process called hadronization) is imperfect.

This paper introduces a new method called iHOMER (Iterative HOMER) to fix the recipe. It does two main things:

1. It learns the corrections iteratively (step-by-step) to get the taste perfect.
2. It keeps a "confidence score" for every change it makes, so we know how sure we are about the new recipe.

---

The Problem: The "Black Box" of Particle Cooking

When particles smash together, they don't just bounce off; they turn into a shower of new particles (hadrons). Physicists call this hadronization.

• The Simulation (The Cookbook): The computer generates millions of fake events based on a theoretical model. It's like a chef following a recipe blindly.
• The Data (The Real Dish): The actual experiment sees what comes out.
• The Gap: The simulation is a "black box" regarding the tiny, invisible steps of how particles break apart. We can see the final result (the dish), but we can't see the individual steps the chef took to make it.

The old method (HOMER) tried to fix the recipe by looking at the final dish and saying, "Okay, if we tweak the ingredients here and there, it will look like the real dish." But because the steps are hidden, the old method sometimes made small, systematic mistakes (bias). It was like adjusting the salt based on the color of the soup, which isn't always accurate.

The Solution: iHOMER (The Iterative Taster)

The authors created iHOMER, which is like hiring a master taster who doesn't just look at the final dish, but keeps tasting and adjusting the recipe over and over again.

1. The Iterative Loop (Step-by-Step Refinement)

Instead of trying to fix the recipe in one giant leap, iHOMER does it in rounds:

• Round 1: The computer makes a guess at the new recipe. It compares the result to the real data. It's close, but not perfect.
• Round 2: The computer takes the result from Round 1, treats it as the new starting point, and tries to fix the remaining errors.
• Round 3: It repeats this process.

The Analogy: Imagine you are trying to tune a guitar string by ear.

• Old way: You pluck it, guess it's flat, tighten it a lot, and hope for the best.
• iHOMER way: You pluck it, tighten it a tiny bit, listen again, tighten it a tiny bit more, and listen again. You stop when the note is perfectly in tune.

This "iterative" approach removes the "bias" (the systematic error) that happens when you try to guess the whole solution at once.

2. Uncertainty Quantification (The "Confidence Score")

This is the second major innovation. In science, it's not enough to just say "The answer is X." You must say, "The answer is X, and we are 95% sure it's between Y and Z."

The paper uses Bayesian Neural Networks (a type of AI that is good at admitting when it's unsure).

• The Analogy: Imagine a weather forecaster.
  • Old AI: "It will rain tomorrow." (No idea how sure they are).
  • iHOMER: "It will rain tomorrow. I am 90% sure, but there is a small chance it might be sunny because my sensors are a bit fuzzy."

In the paper, the AI learns not just what the correction should be, but how much noise or uncertainty is attached to that correction. This allows physicists to carry these "confidence scores" forward into their future calculations, ensuring they don't trust a shaky result too much.

How It Works (The Two-Step Dance)

The method works in two distinct steps, repeated over and over:

1. Step 1: The Discriminator (The "Spot the Fake" Game)
   The AI is shown a pile of "Real Data" and a pile of "Simulated Data." It tries to tell them apart. If it can easily tell them apart, the simulation is still wrong. The AI learns the "likelihood ratio"—essentially, a score of how much the simulation needs to change to look like reality.

   • Crucial Detail: This AI is designed to be unsure sometimes, giving us a range of possible scores rather than a single number.

2. Step 2: The Rewriter (The "Recipe Fixer")
   Now, the AI looks at the individual steps of the simulation (the string breaks) and tries to figure out how to tweak those specific steps so that the final result matches the "Spot the Fake" score from Step 1.

   • The Innovation: It learns to assign a "confidence interval" to these tweaks. If the data is messy or the step is hard to see, the AI says, "I'm going to change this, but I'm only 60% sure about the exact amount."

The Results: A Perfectly Tuned Instrument

The authors tested this on a "closure test." This is like a chef cooking a dish using a secret recipe, then trying to reverse-engineer that secret recipe using only the final taste.

• Accuracy: The iHOMER method successfully recreated the "secret recipe" (the true fragmentation function) much better than the old method. The errors dropped from about 10% down to the percent level.
• Reliability: The "confidence scores" the AI generated were well-calibrated. When the AI said it was unsure, it turned out to be right; when it was sure, it was right.

Why This Matters

In the world of particle physics, we are looking for tiny cracks in our understanding of the universe (New Physics). If our "recipe book" (the simulation) has hidden errors, we might think we found a new particle when we actually just had a bad recipe.

By using iHOMER, physicists can:

1. Make their simulations match reality much more closely.
2. Know exactly how much they can trust those simulations.
3. Stop wasting time chasing "ghosts" caused by bad modeling.

In summary: iHOMER is a smarter, more humble AI chef. It doesn't just guess the recipe; it tastes, adjusts, tastes again, and keeps a detailed notebook on how confident it is about every single ingredient change. This leads to a clearer, more precise view of the fundamental building blocks of our universe.

Technical Summary

Here is a detailed technical summary of the paper "Iterative HOMER with uncertainties" by the MLhad collaboration.

1. Problem Statement

Monte Carlo Event Generators (MCEGs) like PYTHIA are essential for high-energy physics analyses (e.g., at the LHC), but their accuracy is limited by the modeling of hadronization—the non-perturbative process where partons bind into hadrons. Current empirical models (e.g., the Lund string model) introduce systematic uncertainties that are becoming critical for precision measurements (e.g., top quark mass, $\alpha_s$).

While Machine Learning (ML) offers a path to more flexible hadronization models, three challenges remain:

1. Complexity: The relationship between microscopic string-breaking dynamics and observable data is complex and non-invertible.
2. Uncertainty Quantification: ML models must provide reliable statistical and systematic uncertainties.
3. Physical Interpretability: Models should improve physical understanding, not just act as black-box simulators.

The existing HOMER method (Histories and Observables for Monte-Carlo Event Reweighting) attempts to learn a fragmentation function by reweighting a reference simulation to match data. However, it suffers from:

• Bias: Due to the assumption that event-level weights factorize perfectly into string-break weights, which is generally false for non-invertible observables.
• Lack of Uncertainty: It does not systematically quantify the uncertainties arising from finite training data or model biases.

2. Methodology: iHOMER

The authors propose iHOMER, an iterative extension of HOMER that integrates Bayesian Neural Networks (BNNs) and uncertainty-aware regression to address bias and quantify errors.

Core Framework

The method operates in two steps, iterated to convergence:

• Step 1: Event Reweighting (Classifier)
  • A Bayesian Neural Network (BNN) is trained to distinguish between "Data" (target distribution) and "Simulation" (reference distribution) based on high-level observables $x$.
  • The BNN outputs a likelihood ratio $w_\theta(x) \approx p_{data}(x)/p_{ref}(x)$.
  • Uncertainty: By sampling network parameters $\theta$ from a posterior distribution $q(\theta)$, the method captures statistical uncertainties due to finite dataset sizes.
• Step 2: Weight Factorization (Regressor)
  • A regressor $w_\phi(s)$ is trained on the reference simulation to predict string-break level weights $w(s)$ (where $s$ includes features like momentum fraction $z$, transverse mass $m_T$, etc.).
  • Goal: The product of string-break weights for a chain must statistically match the event-level weight from Step 1.
  • Uncertainty: A heteroscedastic loss is used, allowing the network to learn a variance $\sigma_\phi(s)$ for each prediction. This captures systematic uncertainties arising from the factorization approximation and model limitations.

Iterative Debiasing

To correct the bias introduced by the factorization assumption (where $w(x) \neq \prod w(s)$ exactly), iHOMER employs an iterative loop:

1. Refinement Strategy: After iteration $i$, the learned weights $w_{\phi_i}(s)$ are used to update the reference distribution for the next iteration: $p^{(i+1)}_{ref}(s) = w_{\phi_i}(s) p^{(i)}_{ref}(s)$.
2. Convergence: The process repeats until the Step 1 classifier can no longer distinguish between the reweighted simulation and the data.
3. Stopping Criterion: Iteration stops when the Area Under the Curve (AUC) of the Step 1 classifier approaches 0.5 (random guessing), statistically validated using the BNN posterior.

3. Key Contributions

1. Iterative Debiasing: Demonstrates that iterating the HOMER procedure systematically removes the bias caused by the non-invertibility of observables, allowing the learned fragmentation function to converge to the true distribution.
2. Integrated Uncertainty Quantification:
   • Propagates statistical uncertainty from Step 1 (BNN) to Step 2.
   • Uses heteroscedastic regression in Step 2 to learn systematic uncertainties (specifically the "non-factorization error").
   • Provides calibrated uncertainties that reflect the degeneracy of fragmentation functions compatible with high-level observables.
3. Parametric Closure Test: Validates the method using a "mixed" fragmentation function (a linear combination of two Lund models) as the target "Data." This tests the ability to recover non-standard functional forms without assuming a specific parametric shape.
4. Physical Consistency: Shows that despite the lack of direct access to string breaks in data, the learned weights are compatible with the true underlying fragmentation function, as verified by parametric fits on the learned weights.

4. Results

The method was tested on a closure test using PYTHIA 8.312 with $2 \times 10^6$ events.

• Accuracy:
  • iHOMER-1 (Standard HOMER): Showed deviations of up to 10% from the exact reweighting in high-level observables (e.g., Thrust, C-parameter, multiplicity).
  • iHOMER-3 (Iterated): Achieved agreement at the percent level with the exact reweighting. The $\chi^2/N_{bins}$ improved significantly (e.g., from ~8.0 to ~1.3 for Thrust).
  • The method successfully reproduced the "Data" distribution even when the target fragmentation function was a complex mixture model, outperforming naive parametric fits.
• Uncertainties:
  • The learned uncertainties in Step 2 were found to be well-calibrated. The "pull" statistic (difference between prediction and truth normalized by uncertainty) followed a unit Gaussian distribution.
  • The uncertainty $\sigma_\phi$ correctly captured the "non-factorization error," leading to conservative (slightly under-confident) predictions, which is desirable for safety in physics analyses.
  • Iteration reduced the gap between the BNN uncertainty and the Step 2 uncertainty, indicating that the iterative process resolves the structural mismatch between event and chain levels.
• Parameter Recovery:
  • An unbinned parametric fit on the iHOMER-3 learned weights successfully recovered the true parameters ($a_1, a_2$) of the mixed fragmentation model, confirming that the ML approach preserves physical interpretability.

5. Significance

• Precision Physics: iHOMER provides a rigorous framework to reduce hadronization uncertainties in LHC analyses, which is crucial for future precision measurements where systematic errors dominate.
• ML in HEP: It bridges the gap between flexible ML models and physical constraints. By learning weights rather than generating events directly, it ensures momentum conservation and respects the Lund string topology.
• Uncertainty Handling: The paper establishes a robust protocol for quantifying uncertainties in ML-based reweighting, distinguishing between statistical noise and systematic model bias. This is critical for the reliability of ML-driven physics results.
• Future Outlook: While currently tested on $q\bar{q}$ strings without gluons, the framework is designed to be extended to more complex scenarios (gluons, cluster models, detector effects), paving the way for next-generation data-driven hadronization models.

In summary, iHOMER represents a significant advancement in data-driven hadronization modeling, offering a method that is not only more accurate than previous approaches but also provides the necessary statistical rigor and uncertainty quantification required for high-energy physics discovery.