PanopTag: Simultaneously Tagging All Jets in a Particle Collision Event

The paper introduces PanopTag, a novel encoder-decoder architecture that simultaneously tags all jets in a particle collision event by leveraging inter-jet correlations and event-level context, thereby significantly outperforming traditional single-jet classification methods in heavy-flavor tagging.

The Gist

Imagine a high-energy particle collider, like the Large Hadron Collider (LHC), as a massive, high-speed pinball machine. Every second, it smashes billions of protons together. When these protons collide, they don't just bounce off; they shatter into a chaotic spray of hundreds of smaller particles flying in all directions.

Physicists need to figure out what caused this explosion. Specifically, they want to know: Did this spray of particles come from a heavy "bottom" quark, a "charm" quark, or just a common light quark or gluon? Identifying the origin is crucial because heavy quarks often signal the presence of rare, exciting new physics (like the Higgs boson), while common particles are just background noise.

The Old Way: The "Solo Detective"

For the last decade, scientists have used deep learning (AI) to solve this. But they did it one jet at a time.

Think of a "jet" as a cluster of particles that traveled together. The old method was like hiring a team of solo detectives. Each detective was given a single cluster of particles and told, "Figure out what this is." They had to ignore everything else happening in the room. They looked at the particles in their specific cluster and made a guess.

The problem? In a real collision, jets often fly very close to each other. Their particles can overlap, or they might influence each other. By looking at one jet in isolation, the old AI models missed the bigger picture. They ignored the fact that "Jet A" and "Jet B" are part of the same chaotic event and might be related.

The New Way: PANOPTAG (The "All-Seeing Eye")

The authors of this paper introduce PANOPTAG, a new approach that changes the game. Instead of hiring solo detectives, they hired a single, all-seeing commander.

Here is how PANOPTAG works, using a simple analogy:

1. The Event as a Whole: Imagine the entire collision as a giant, messy room full of people (particles) and groups of people (jets).
2. The "Query" System: Instead of looking at one group at a time, PANOPTAG looks at the whole room at once. It asks a specific question for every group: "Who are you, and who in this room helped you get here?"
3. Cross-Attending: The AI uses a mechanism called "cross-attention." Think of this as the commander pointing at a specific group (a jet) and asking, "Which people in the entire room are most important to your identity?"
   • The AI realizes that to identify a specific jet, it doesn't just need to look at the particles inside that jet's immediate circle. It needs to see if that jet is bumping into a neighbor, or if particles from a nearby jet are spilling over.
4. Simultaneous Decision: The AI makes a decision for every single jet in the room at the exact same time, sharing information between them.

Why This Matters

The paper tested this new "all-seeing" method against the old "solo detective" methods on the task of identifying heavy quarks (b-jets and c-jets).

• The Result: PANOPTAG was significantly better. It didn't just get a few more right; it improved performance by a large margin.
• The Reason: The old models failed when jets were close together because they couldn't see the overlap. PANOPTAG succeeded because it understood the context. It realized that sometimes a particle belongs to Jet A, but because it's so close to Jet B, the relationship between the two helps identify what Jet A really is.

The Bottom Line

The paper claims that by stopping the practice of analyzing jets one by one and instead analyzing the entire collision event together, we can build much smarter AI. It's the difference between trying to identify a person in a crowd by looking at them through a narrow tube versus stepping back and seeing how they interact with everyone around them.

This new method, PANOPTAG, proves that understanding the "big picture" of a particle collision leads to much more accurate identification of what happened, which is a huge win for physicists trying to discover new laws of the universe.

Technical Summary

Technical Summary: PANOPTAG

Problem Statement
Jet tagging, the classification of jets to identify their originating particles (e.g., bottom quarks, charm quarks, gluons), is a fundamental task in high-energy physics. Despite the success of deep learning over the last decade, the prevailing paradigm remains single-jet classification. In this approach, jets are classified independently, one at a time, ignoring correlations, overlaps, and the broader event context between jets. This isolationist view fails to exploit inter-jet kinematic constraints, spatial overlaps between nearby jets, and event-wide flavor structures that could improve classification accuracy.

Methodology: The PANOPTAG Architecture
The authors introduce PANOPTAG, a paradigm shift that reframes jet tagging as an event-level, multi-jet inference problem. Instead of processing jets in isolation, PANOPTAG simultaneously tags all jets in a collision event using a DETR-inspired encoder-decoder architecture.

1. Event Encoder (EE):

   • Input: The model takes all Particle Flow Objects (PFOs) in an event as input, represented as a variable-size set.
   • Local Feature Extraction: PFOs are first projected via an MLP and then processed through EdgeConv layers. These layers construct $k$-nearest neighbor graphs in coordinate space ($\eta, \phi$) to capture short-range geometric structures and topological relationships between particles.
   • Global Context Extraction: To capture long-range event-wide context efficiently, the model employs Induced Self-Attention Blocks (ISABs) from Set Transformers. This reduces the computational complexity of full self-attention from quadratic $O(N^2)$ to linear $O(MN)$ (where $M$ is the number of inducing points), which is crucial for events containing $\sim1000$ PFOs.
   • Output: The EE produces contextual embeddings for all PFOs, serving as keys and values for the decoder.

2. Jet Query Decoder (JQD):

   • Query Generation: Jet kinematics ($p_T, \eta, \phi, m$) are embedded via an MLP to create jet queries.
   • Cross-Attention: The decoder performs cross-attention where jet queries attend to the PFO embeddings (keys/values). This allows each jet to dynamically focus on the subset of particles most informative for its identity while sharing a common particle representation.
   • Output: The decoder produces a latent representation for each jet, which is mapped to class probabilities via a classification head.

Key Contributions

• Paradigm Shift: Moves from independent single-jet classification to simultaneous, event-level multi-jet inference.
• Architecture: Proposes a novel combination of EdgeConv (for local geometry) and ISAB (for global context) within a cross-attention framework, specifically designed to handle the variable size and permutation invariance of particle clouds.
• Event-Level Correlations: Explicitly leverages correlations between jets and shared event context, which are inaccessible to traditional single-jet taggers.

Experimental Results
The model was evaluated on heavy-flavor tagging (identifying $b$-jets and $c$-jets), a critical task for Higgs and top quark physics.

• Baselines: PANOPTAG was compared against state-of-the-art single-jet models: ParticleNet (graph-based) and Particle Transformer (ParT) (attention-based).
• Performance: PANOPTAG achieved superior performance across all metrics:
  • Accuracy: Improved by 2.2% over ParT and 2.5% over ParticleNet.
  • Background Rejection: At 50% signal efficiency, PANOPTAG improved background rejection by a factor of 1.8 over ParticleNet and 1.7 over ParT for $b$-jets. For $c$-jets, the improvements were factors of 1.6 and 1.4, respectively.
• Generalization: The performance gains persisted on out-of-distribution topologies (e.g., $ZH$ and $tW$ processes) that were excluded from the training set (which included only single-top, $t\bar{t}$, and $t\bar{t}H$), demonstrating that the model learns generalizable event-level features rather than memorizing specific topologies.
• Interpretability: Attention weight analysis revealed that the model correctly focuses on local particles near the jet axis. Crucially, it showed that PANOPTAG reduces "proximity-driven mistags" where light jets near heavy-flavor jets are misclassified, a common failure mode in single-jet taggers.

Significance and Claims
The paper claims that PANOPTAG demonstrates that event-wide context can unlock substantial performance gains previously inaccessible within the single-jet classification paradigm.

• Physics Impact: The improvement in background rejection directly translates to increased discovery sensitivity for new physics searches and precision measurements at the LHC (e.g., doubling background rejection yields a ~40% gain in discovery potential).
• Efficiency: By computing the particle representation once per event and reusing it for all jets, PANOPTAG offers a promising path for faster inference compared to running independent single-jet taggers for every jet in an event.
• Generalizability: The authors posit that this event-level formulation is a general recipe applicable to other jet problems, such as pileup-jet identification, jet regression, and background subtraction, positioning PANOPTAG as a candidate for a high-energy physics foundation model.
• Complementarity: The work is presented as complementary to existing research, capable of integrating with alternative backbones (e.g., Lorentz-equivariant layers) and pretraining strategies.