Lund Plane to Bloch (LP2B) Encoding for Object and Polarization Tagging with Quantum Jet Substructure

This paper introduces the Lund Plane to Bloch (LP2B) encoding and a corresponding Quantum Tree-Topology Network (QTTN) that maps robust jet kinematics to qubit states, achieving competitive performance in object and polarization tagging with significantly fewer parameters and reduced systematic uncertainties compared to classical deep learning models, while also being validated on real quantum hardware.

The Gist

Imagine you are a detective trying to solve a mystery at a massive, chaotic particle collider (the Large Hadron Collider). Every time two protons smash together, they explode into a shower of smaller particles, forming a "jet." Your job is to look at these jets and figure out: What created this explosion? Was it a heavy Top Quark? A W boson? Or just random noise?

Even more tricky: How was the particle spinning? (This is called "polarization"). Knowing the spin helps physicists understand if the laws of physics are working exactly as predicted or if there's some new, weird physics hiding in the shadows.

For years, scientists have used powerful computer programs (Classical AI) to solve this. But these programs are like giant, hungry monsters: they need massive amounts of data, they get confused by tiny details, and they are too slow to run on the fast hardware needed to trigger real-time experiments.

This paper introduces a new, tiny, but incredibly smart detective: a Quantum Machine Learning model called QTTN.

Here is how it works, explained with simple analogies:

1. The Problem: The "Messy Room" vs. The "Family Tree"

Imagine a jet of particles as a messy room full of toys.

• Old Quantum Methods (1P1Q): These tried to put every single toy (particle) onto a separate shelf (qubit). But the room has thousands of toys! The shelves ran out, and the detective got overwhelmed. Also, if you moved one toy slightly, the whole picture changed (this is a physics problem called "IRC unsafety").
• The New Method (LP2B): Instead of looking at every single toy, the authors decided to look at the history of how the toys got there. They used a special map called the Lund Jet Plane. Think of this as a family tree. It shows how the big explosion split into two, then those split into two more, and so on.
  • The Analogy: Instead of counting every grain of sand on a beach, you look at the shape of the dunes and how the wind shaped them. This history is much more stable and tells you exactly what kind of storm (particle) caused the mess.

2. The Magic Trick: Mapping to a "Quantum Globe"

Now, how do you put this family tree into a quantum computer?

• The Encoding (LP2B): The authors invented a way to translate the coordinates of this family tree onto a Quantum Globe (called the Bloch Sphere).
• The Metaphor: Imagine you have a flat map of the world (the particle data). Usually, squishing a flat map onto a globe distorts the edges. But this new method uses a "stretchy, learnable lens." As the computer learns, it stretches and squishes the map just enough so that the important details fit perfectly onto the globe without breaking.
• The "Zero-Safe" Feature: If a branch of the family tree stops early (a "dead end"), the system maps it to a "zero" spot on the globe. It's like saying, "Nothing happened here," without adding any confusing noise to the calculation.

3. The Detective's Brain: The Quantum Tree Network (QTTN)

Once the data is on the quantum globe, the QTTN goes to work.

• Structure: The quantum computer is built to look exactly like the family tree of the particles. It has a root (the original explosion) and branches (the splits).
• How it thinks: It passes information from the tips of the branches (the newest particles) up to the root (the original particle). It uses "entanglement" (a spooky quantum connection) to link the branches together.
• The Result: It's like a team of detectives passing notes up a chain of command. Because the team is structured exactly like the crime scene, they can solve the mystery much faster and with fewer people than a giant, disorganized crowd.

4. Why is this a Big Deal?

The authors tested this new quantum detective against the old giants (Classical AI) and found some amazing things:

• It's a Lightweight Champion: The new quantum model has 1,000 times fewer parameters (brain cells) than the best classical models. It's like a tiny, agile ninja beating a giant, slow robot.
• It Needs Less Data: Classical AI usually needs to eat a mountain of data to learn. This quantum model learns well even with a small snack. This is huge for physics, where some rare events are very hard to find.
• It Doesn't Cheat: Classical AI sometimes cheats by memorizing the "style" of the simulation software (like recognizing an accent) rather than the actual physics. This quantum model is so focused on the core structure that it doesn't get tricked by these small details. It's more honest.
• It Works on Real Hardware: They didn't just simulate it; they ran a simplified version on a real, small quantum computer (a 3-qubit device) and it worked!

The Bottom Line

This paper shows that by organizing quantum computers to think like the history of particle explosions (using a family tree structure), we can build tiny, fast, and incredibly accurate detectors.

This is a step toward putting these quantum detectives inside the actual particle collider triggers. Imagine a system that can instantly spot a rare, new particle in a sea of billions of collisions, using a tiny chip that fits in your pocket, rather than a room-sized supercomputer. That is the promise of this research.

Technical Summary

1. Problem Statement

The application of Quantum Machine Learning (QML) to High-Energy Physics (HEP), specifically jet substructure analysis, faces three critical challenges:

• Theoretical Robustness: Existing quantum approaches often use "one particle - one qubit" (1P1Q) encodings. These suffer from Infrared and Collinear (IRC) unsafety, meaning they are sensitive to soft emissions and collinear splittings, which violates the requirements for robust theoretical predictions in Quantum Chromodynamics (QCD).
• Scalability and Hardware Constraints: Current Noisy Intermediate-Scale Quantum (NISQ) devices have limited qubit counts and gate depths. 1P1Q approaches require qubit counts scaling linearly with jet multiplicity (often 30–40 qubits), making them infeasible for current hardware.
• Systematic Uncertainties: Classical deep learning models (e.g., LundNet) with high parameter counts tend to overfit to generator-specific non-perturbative effects (parton shower and hadronization), leading to large systematic uncertainties when applied to real data.

The authors aim to develop a quantum architecture that is theoretically sound (IRC safe), hardware-efficient, and robust against systematic uncertainties while maintaining competitive performance in object classification (W boson, top quark) and polarization tagging.

2. Methodology

A. Data Representation: The Lund Jet Plane Tree

Instead of encoding raw particle kinematics, the authors utilize the Lund Jet Plane, a theoretical framework that maps the declustering history of a jet.

• Algorithm: Jets are declustered using the Cambridge/Aachen (C/A) sequential recombination algorithm.
• Structure: This process yields a binary tree. To fit NISQ constraints, the tree is truncated at a maximum depth of $D=3$, resulting in a fixed structure of $N = 2^D - 1 = 7$ nodes.
• Features: Each node is annotated with kinematic observables: $x_1 = \ln(R_0/\Delta R)$ and $x_2 = \ln(1/z)$, where $\Delta R$ is the angular distance and $z$ is the momentum sharing fraction.
• IRC Safety: The tree structure inherently handles soft/collinear emissions. "Dead-end" branches (where no splitting occurs) are explicitly mapped to coordinates $(0,0)$, preserving topological sparsity.

B. Encoding: Lund Plane to Bloch (LP2B)

The authors introduce a novel encoding scheme to map the continuous classical Lund coordinates onto the quantum Bloch sphere:

• Stereographic Projection: A differentiable stereographic projection maps $(x_1, x_2)$ to rotation angles $\theta$ and $\phi$.
• Learnable Stretch Parameters: The mapping includes learnable parameters ($\lambda_i, \omega_i$) for each node, allowing the network to dynamically optimize the scaling of the phase space during training without manual preprocessing.
• "Zero-Safe" Property: If a node is empty ($x_1=x_2=0$), the projection yields $\theta=0$, resulting in the identity operation $|0\rangle$. This ensures that missing branches do not inject spurious noise into the quantum state.

C. Architecture: Quantum Tree-Topology Network (QTTN)

The QTTN is a variational quantum circuit designed to mirror the physical hierarchy of the QCD splitting cascade:

• Topology: The circuit uses $N=7$ qubits. Entanglement is restricted to the physical parent-child edges of the C/A tree (e.g., qubit 0 is the root, qubits 1-2 are children, etc.), rather than using all-to-all connectivity.
• Layers: The circuit consists of $L$ variational layers. Each layer includes:
  1. Entanglement Block: Parameterized Controlled-Y rotations ($CRY$) along the tree edges to propagate information from leaves (soft splittings) to the root (hard parton).
  2. Local Rotation Block: Single-qubit rotations ($Rot$) to explore the local Hilbert space.
• Readout: The final classification is derived from the expectation value of the Pauli-Z operator on the root qubit ($q_0$), which aggregates the hierarchical information.

3. Key Contributions

1. LP2B Encoding: A theoretically robust, IRC-safe encoding that maps the Lund Jet Plane directly to qubit states using a learnable stereographic projection, handling sparsity naturally.
2. QTTN Architecture: A quantum network that natively embeds the hierarchical structure of the QCD shower, requiring only 7 qubits and minimal circuit depth, making it suitable for NISQ devices.
3. Parameter Efficiency: The QTTN achieves high performance with only $\sim 10^2$ parameters (e.g., 268 for 10 layers), which is three orders of magnitude fewer than classical deep learning baselines like LundNet ($\sim 3.9 \times 10^5$ parameters).
4. Hardware Validation: Successful execution of a simplified QTTN ($L=1$, 3 qubits) on real quantum hardware (SpinQ Triangulum, a solid-state NMR device), demonstrating the feasibility of the approach.

4. Results

Performance Benchmarks

The QTTN was evaluated on W/Top tagging and Polarization tagging (Vector Boson Scattering and Graviton resonance) using the JetGame dataset and custom simulations.

• Polarization Tagging: The QTTN matches the performance of the large classical LundNet model (AUC $\approx 0.64$) while using significantly fewer parameters. It significantly outperforms the standard 1P1Q quantum encoding.
• Object Tagging (W/Top): The QTTN achieves competitive accuracy with classical Boosted Decision Trees (BDTs) and Multi-Layer Perceptrons (MLPs) of similar size. For W tagging, 10 layers of QTTN outperform the BDT.
• Pareto Front: The QTTN pushes the performance-to-cost Pareto front, offering superior accuracy for its parameter count compared to MLPs and BDTs.

Low-Data Regime

In scenarios with limited training data (100–10,000 events), the QTTN demonstrates superior stability compared to classical deep learning models.

• While large models like LundNet degrade rapidly with fewer data points, the QTTN maintains robust performance.
• This suggests the quantum architecture acts as a natural regularizer, preventing overfitting in data-scarce regimes common in rare BSM searches.

Domain Transfer and Systematic Uncertainties

The authors tested generalization by training on Pythia (standard generator) and testing on Herwig (different parton shower/hadronization models).

• Transfer Gap: The QTTN showed a minimal transfer gap ($\sim 0.2\%$) between generators.
• Comparison: This is significantly better than the highly parameterized LundNet-5 ($\sim 1.0\%$ gap).
• Implication: The compact QTTN learns universal physics features rather than generator-specific artifacts, implying smaller systematic uncertainties in experimental measurements.

Hardware Validation

A simplified 3-qubit QTTN was run on the SpinQ Triangulum device.

• The hardware results showed a systematic shift (likely due to relaxation effects) but maintained a mean bias and standard deviation consistent with the theoretical expectation.
• The AUC on hardware ($0.58 \pm 0.02$) was compatible with the simulator ($0.60 \pm 0.02$), validating the core logic on real hardware.

5. Significance

This work represents a significant step toward the practical application of QML in collider physics:

• Theoretical Alignment: By mapping the Lund Jet Plane to qubits, the method respects the fundamental symmetries of QCD (IRC safety), a requirement often missed by generic quantum embeddings.
• NISQ Viability: The fixed-depth, low-qubit requirement ($N=7$) makes the architecture immediately deployable on current and near-future quantum hardware, unlike constituent-based approaches.
• Systematic Reduction: The demonstrated resistance to generator-specific overfitting suggests that QML could reduce the dominant systematic uncertainties associated with hadronization modeling in precision HEP measurements.
• Future Applications: The low parameter count and shallow circuit depth open the door for low-latency FPGA implementations in trigger systems and data-driven analyses where high-quality labeled data is scarce.