WorksPhysics and Astronomy
What the Primary Lund Plane Omits: A Model-Stitching Diagnosis of a Jet-Tagger Representation Gap
Abstract
Lund-plane and Particle Transformer (ParT) jet taggers can differ in performance because one representation is weaker, or because a weaker downstream computation reads an adequate one. Standalone performance cannot separate these. Model stitching can: it links the frozen early layers of one network to the frozen late layers of another through a single trained linear map. As a positive control we use an incomplete Lund representation, the primary declustering branch, whose deficit is known independently. Stitched into ParT's downstream, it reaches a background rejection at least as much as its own downstream recovers, yet far below ParT's background rejection: the deficit is representational, not computational. A hypergraph reader over splitting triplets does no better, ruling out higher-order correlations as the cause. The gap is invisible in AUC, which stays within 1% of its target value, and appears only in background rejection at low signal efficiency. It localizes to 0.6% of background jets, at and above the top mass, with more constituents but fewer primary splittings than typical background. Rebuilding the representation on the full Cambridge/Aachen declustering tree repairs the deficit as predicted: standalone rejection rises, closing 72% of the gap. Masking nodes at inference shows the repaired network still relies almost entirely on the primary branch; the secondary splittings make the representation learnable rather than supplying information it reads. Along the primary branch, the widest-angle splitting, near the top and opening angles, is worth nearly twice a random one. For quark/gluon tagging the primary branch is far less deficient, retaining 77.6% of ParT's rejection (46.9% for top), and the full tree closes only 33% of the gap (72% for top).
Introduction
A jet tagger built on a physics-motivated representation and one built on a learned representation of raw kinematics can differ in final performance for reasons a performance comparison alone cannot distinguish. The gap could mean the physics-motivated representation carries less information than the learned one. It could also mean an adequate representation is being read by a weaker downstream computation. These are different problems with different fixes, and standalone accuracy cannot tell them apart.
The primary Lund plane [1] re-expresses a jet as a sequence of declustering variables tied to the collinear and soft-collinear structure of perturbative QCD, following only the harder branch at each splitting. LundNet [2] instead reads the full Cambridge/Aachen declustering tree with a graph network, and outperforms taggers built on the primary branch alone. The Particle Transformer (ParT) [3] keeps every constituent’s four-momentum and lets self-attention [4] build whatever features the classification loss rewards.
Comparing final performance is also easy to get wrong by choice of metric. In the benchmark that introduced LundNet, its five-variable model and ParticleNet [5] differ in top-tagging AUC by only 0.004 (0.987 against 0.983), while their background rejection at differs by a factor of 2.5 (5000 against 2000) [2]. AUC, the field’s most-quoted metric, can be nearly blind to a difference that background rejection at a realistic operating point shows clearly. Our own measurements reproduce this insensitivity in a sharper form: the representational deficit this paper is about moves AUC by less than one percent while halving background rejection.
Representational-similarity measures such as centered kernel alignment (CKA) [6] and singular vector canonical correlation analysis (SVCCA) [7] compare geometry directly, but geometric similarity is not functional interchangeability: two representations can occupy well-aligned subspaces and still be unusable by a specific downstream computation, or vice versa. Model stitching [8] asks the functional question directly, by connecting the frozen early layers of one trained network to the frozen late layers of another through a single trained layer, and reading off how much performance survives the connection. The same freeze-and-reconnect construction already has a different use in jet tagging: freezing early layers and fine-tuning only the rest transfers a LundNetor ParticleNet-style tagger to a new signal on an order of magnitude less data [9]. Two concurrent studies ask what a trained jet tagger actually uses by other means: causal ablation and path patching inside ParT itself find a sparse attention-head circuit [10]; perturbation- and gradient-based attribution finds which Lund-plane splittings a LundNet-style tagger relies on [11]. Neither separates a representation’s content from its reader, which is the question this paper asks instead.
Two obstacles stand in the way of applying this to ParT and a Lund-plane network. A jet’s particles and its Lund-plane splittings are sequences of unrelated length, so no per-token correspondence exists. A graph network’s local message passing and a transformer’s global self-attention differ enough that a stitching result could reflect either the input representation or the architecture doing the reading, with no way to separate the two afterward. We remove both obstacles by construction. The stitch point is the class token each network produces, through class attention, which is a single whole-jet vector regardless of sequence length. The Lund-plane network, which we call Lund-ParT, is the same architecture as ParT in every respect except its input: the same self-attention blocks, the same class-attention readout, differing only in the per-node feature vector and the pairwise bias function. Any result is then attributable to representation content, not to a choice of architecture.
We validate this diagnostic on a case where the answer is already known. The primary Lund plane keeps only the harder branch at each splitting: a jet with 49.0 real constituents on average yields only 12.6 primary-plane splittings, discarding most of the jet’s radiation. LundNet exists precisely because this branch is incomplete. We use Lund-ParT built on the primary branch as a positive control, not because we expect it to compete with the full declustering tree, but because its deficit is known independently of anything model stitching tells us. If stitching correctly identifies that deficit as representational rather than computational, localizes it to the jets it should affect, and confirms the diagnosis when the omission is repaired, that is direct evidence the method works on cases where the ground truth is not known.
The paper has six parts. § 2 sets out the architectures, the stitching protocol, and the two normalizations it supports. § 3 shows the gap between ParT and primary-branch Lund-ParT is representational rather than downstream, using standalone performance, retained AUC, background rejection under both normalizations, and geometric alignment. § 3.4 localizes the deficit to a specific, physically identifiable jet population. § 3.5 rebuilds Lund-ParT on the full declustering tree and confirms the diagnosis by repairing it. § 3.6 then asks which nodes of that tree the repaired network actually uses, and finds that the repair is not carried by any small subset of them. Section VII asks the same kind of question of the primary branch alone, and finds its information concentrated at the wide-angle end of the chain. Appendix A repeats the entire pipeline on a second task, quark/gluon tagging, to test whether the diagnosis and its conclusions are specific to top substructure.
Method
Dataset
We use the Kasieczka et al. top-tagging reference dataset [12]: 1,211,000/403,000/404,000 train/validation/test jets of hadronically decaying, boosted top quarks against light-quark and gluon jets, GeV, up to 200 zero-padded constituent four-momenta per jet. All results here use a fixed, reproducibly seeded 50% random subsample of each split (605,500/201,500/202,000 jets), of which 100,971 test jets are background. Standalone ParT reaches a background rejection of 291 at at this scale, still below the – range reported at full dataset scale for comparable architectures [2]; the residual gap is a matter of training data volume, not of the comparisons made here, since every claim in this paper is a ratio or a difference between two models trained on identical data. Jets with fewer than two real constituents have no Lund-plane splittings under either representation and are dropped identically from both before training, affecting two jets in the test split.
Architectures
Both networks instantiate the same ParticleTransformer class: an input embedding, a pairwise-bias network computed once and reused as an additive attention bias in every block, pre-norm self-attention blocks (embedding dimension 128, 8 heads), 2 class-attention blocks [13] in which a learned class token cross-attends to the block-6 token sequence, and a two-layer classification head. ParT’s per-particle input is the seven kinematic scalars of Ref. [3]; its pairwise bias is the four relativistic invariants (, , , ) of every particle pair. This totals 1,658,814 trainable parameters.
Lund-ParT is the identical class, instantiated on the primary Lund plane’s five declustering coordinates as both the per-node input and the pairwise-bias basis. The primary Lund plane is built by reclustering a jet’s own constituents with the Cambridge/Aachen algorithm [14, 15] at an effective radius of 1000, using FastJet [16], then walking only the harder branch at every splitting. For splitting , parent harder subjet + softer subjet
giving the node feature . This is the primary branch only, following Ref. [1]’s original construction. LundNet’s own graph [2] uses the full declustering tree instead, the difference § 3.5 tests directly. Lund-ParT’s pairwise bias is the raw five-dimensional coordinate difference . Lund-ParT has 1,658,616 trainable parameters, matching ParT’s count to within 0.01%. Background jets in the test split carry 43.3 real particles on average and yield 12.6 primary-Lund-plane splittings, since following only the harder branch discards most constituents from the resulting sequence.
Both networks are trained independently for five random seeds: AdamW [17], cross-entropy loss, up to 30 epochs with early stopping on validation AUC (patience 5), batch size 256, float16 mixed precision with dynamic loss scaling. Standalone test performance is in Table I.
Stitching
For network and depth , define
so that carries a jet to ’s class token after self-attention blocks, and carries an injected 128-dimensional vector through ’s remaining blocks, class-attention readout, and head to a logit. For source network , target network , and depth , the stitched classifier is then (Figure 1)
Figure 1. Schematic of the stitching construction. (a) Both ParT and Lund-ParT instantiate the same six-block backbone with a two-block class-attention readout; the dashed line marks where a stitch cuts at depth . (b) At depth (shown for ), source network contributes its first blocks and class attention readout, frozen at standalone trained values, producing a single class token ; a trained linear map carries it, broadcast as an unit length sequence, into target network ’s remaining blocks, readout, and head, likewise frozen. (c) The four conditions run at every depth and seed: both cross-architecture directions and the two same-architecture self stitching controls; is excluded for the reason given below.
with and fixed at their standalone-trained values and only optimized.
’s embedding, first blocks, and class-attention readout are frozen at standalone-trained values and produce ’s own class token at depth . is a single trained Linear(128, 128) layer (16,512 parameters). ’s remaining blocks, class-attention readout, and classification head stay frozen at their own standalone trained values. Only is optimized: AdamW, up to 15 epochs with early stopping (patience 4), on a fixed random training subsample with 20,000 jets. A map with 16,512 parameters does not need the full training set to converge. All reported test metrics use the full 50% test split.
’s and ’s token sequences have unrelated lengths, so ’s remaining blocks run on the single injected vector as an unit length sequence. This is exact, not approximate. Write a block’s self-attention sublayer as
If the input sequence consists of identical tokens, for every , then every query and key is likewise identical, and , and the softmax weights become uniform:
independent of , , and . The point wise feedforward sublayer acts identically on every position, so a block maps identical input tokens to identical output tokens; by induction over blocks , applied to copies of returns the same value for every , including . Broadcasting the injected vector to any number of positions therefore computes the identical function as feeding it once; we use . Whether an unit length input costs anything relative to the token sequences ’s blocks were trained on is a separate question, answered empirically by the same-architecture self-stitching controls described next: self-stitched retention ranges from 29% to 99% of standalone performance across depths (§ 3). We do not argue this cost away. Every comparison in this paper is between a cross-architecture condition and a same-architecture self-stitch at the same depth and the same source, so the injection cost is common to both sides and cancels.
We report and exclude entirely. At the target contributes no self attention blocks at all: the construction reduces to feeding ’s complete, already-pooled class token through directly into ’s frozen class attention readout and classification head. That measures whether a linear map can re-encode a finished jet summary for a foreign classifier head, which is a different question from the one the depth sweep asks, and it introduces a double class attention pooling with no counterpart at any other depth. It also behaves pathologically in a way that makes the distinction concrete: at the two conditions whose target is Lund-ParT lose roughly half their background rejection while their AUC moves by less than 0.005, with a per seed scatter spanning a factor of three, whereas the two conditions whose target is ParT are unaffected. Since early stopping selects on validation AUC, and AUC is flat from the first epoch at this depth, the selection criterion cannot see the degradation it is selecting among. We therefore treat as outside the construction rather than as a data point to be interpreted, and it appears in no figure or table below.
Four conditions are run at every depth and every seed: ParT, Lund-ParT; the reverse; and the two selfstitching controls , . Every condition uses the same five seeds as standalone training, seed-matched: seed ’s stitching conditions use exactly seed ’s two standalone backbones.
| ParT | Lund-ParT (primary) | Lund-ParT (full tree) | |
| AUC | 0.9838 ± 0.0003 | 0.9759 ± 0.0004 | 0.9822 ± 0.0001 |
| rej. at | |||
| rej. at |
Table 1. Standalone test performance, mean ± standard deviation over 5 seeds, 50% data scale. The full-tree column anticipates § 3.5.
We report AUC and background rejection at fixed signal efficiency . For a stitched condition with source and target , we define two retained fractions for each metric ,
asks whether ’s downstream computation is the limiting factor, holding the reference fixed. asks how much of ’s own information survived being read by a foreign downstream, relative to how much ’s own downstream recovers from the same bottleneck. These measure different things and are not interchangeable: a comparison across two conditions must hold one of or fixed and use the matching normalization, without ever mixing the standalone values of the respective targets. § 3 uses throughout, since every comparison
Metrics and normalization
there holds the target fixed at ParT or at Lund-ParT and asks how much of a given source’s information survives. We report absolute rejection alongside every fraction so the denominator is always visible.
The gap is representational, not downstream
Table I shows the naive gap: Lund-ParT’s standalone rejection, 136, is less than half of ParT’s, 291. This gap is consistent with either a weaker representation or a weaker downstream computation reading an otherwise adequate one. The rest of this section separates the two.
AUC does not distinguish the representations
Table II shows retained AUC, target-normalized, for all four stitching conditions. It sits in a narrow band, 0.977–1.007, at every depth, for both cross-architecture directions and both self-stitching controls alike. The lund-to-part direction is flat to three decimal places across the entire sweep, moving from 0.991 at to 0.992 at . Cross-architecture stitching is very nearly indistinguishable from same-architecture self-stitching at this metric: AUC alone would suggest the two representations are interchangeable, echoing the AUC-insensitivity noted in § 1 for full taggers. Background rejection at fixed, low signal efficiency shows this picture is incomplete.
| direction | |||||
| lundpart | 0.991 | 0.991 | 0.992 | 0.992 | 0.992 |
| partlund | 0.977 | 0.996 | 1.000 | 1.004 | 1.007 |
| part-self | 0.983 | 0.989 | 0.994 | 0.996 | 0.999 |
| lund-self | 0.998 | 0.999 | 0.999 | 1.000 | 1.000 |
Table II. Retained AUC, target-normalized, primary-branch run, mean over 5 seeds.
Background rejection under both normalizations
Figure 2 shows absolute rejection for all four conditions at every depth, with each network’s own standalone value marked. Lund-to-part – Lund-ParT’s representation read through ParT’s frozen downstream – rises gently from 128 at to 136 at . Lund-self – Lund-ParT’s own downstream reading the same representation – sits at or below it at every depth, from 120 at to 134 at (Table III, both columns against the same denominator, Lund-ParT’s own standalone value of 136). ParT’s downstream extracts at least as much from Lund-ParT’s representation as Lund-ParT’s own downstream does, and slightly more at every depth. There is
| lundpart (/136) | lund-self (/136) | partlund (/291) | part-self (/291) | |
| 1 | 0.942 | 0.878 | 0.202 | 0.290 |
| 2 | 0.969 | 0.910 | 0.384 | 0.407 |
| 3 | 0.977 | 0.947 | 0.504 | 0.555 |
| 4 | 0.990 | 0.977 | 0.692 | 0.709 |
| 5 | 0.998 | 0.986 | 0.913 | 0.926 |
Table III. Retained rej. at , primary-branch run, source-normalized (), mean over 5 seeds. lundpart and lund-self both divide by Lund-ParT’s own standalone value (136); partlund and part-self both divide by ParT’s own standalone value (291). Self-stitching values coincide with .
Figure 2. Absolute background rejection at and for all four stitching conditions, primary-branch Lund-ParT, versus depth. Horizontal lines mark each network’s own standalone value. The lund-to-part curve (solid red) sits at or above Lund-ParT’s own self-stitching curve (dashed red) at every depth.
no latent information in the primary-branch representation that a stronger downstream would have recovered: the shortfall relative to ParT’s own 291 is not explained by Lund-ParT’s downstream being the bottleneck. The reverse direction, part-to-lund, shows the same ordering with the roles exchanged: normalized to ParT’s own standalone value (291), it retains 20–91% across the sweep, below what ParT’s own downstream recovers from the same bottleneck at every depth (29–93%, part-self). Lund-ParT’s downstream is, on this evidence, the less capable consumer of the two, independent of which representation it is given. We tested this directly rather than reading it off ten dependent per-depth comparisons: for each of the five seeds, we averaged the self-minus-cross difference in raw rejection units over –5 separately for each direction, then averaged the two directions into one seed-level score. A one-sample -test on the five resulting scores gives a mean advantage of +8 ± 7 rejection units for ParT’s downstream over Lund-ParT’s (, ): the same direction as each of the ten individual comparisons, but not significant at the conventional threshold with five seeds. We report this as suggestive, not established.
This consumer-side pattern does not explain the result this section is built on. Lund-ParT’s primary-branch front end is weaker than ParT’s in absolute terms (136 against 291) independent of which downstream reads it, and the comparison that isolates this – ParT’s own downstream reading Lund-ParT’s representation, against Lund-ParT’s own downstream reading the same representation – holds the representation fixed and varies only the reader. ParT’s downstream does at least as well with it at every depth. The deficit is in what the primary branch supplies, not in who reads it.
Geometric alignment between the two representations
Linear CKA [6] and SVCCA [7] between ParT’s and Lund-ParT’s class tokens, computed independently of any stitching or classification objective on a fixed 5000-jet probe sample, both rise with depth: CKA from at to at ; SVCCA’s mean canonical correlation from to (Figure 3). The depth index here labels the layer at which a class token is read from a standalone network, so unlike the stitching sweep it remains well defined at , where CKA reaches ; we quote the range for comparability with the rest of the paper. SVCCA’s variance-retention step needed only 1–2 principal components at every depth and seed to characterize either representation, consistent with terminal-phase neural collapse in deep classifiers generally [18].
Figure 3. Linear CKA and SVCCA mean canonical correlation between ParT’s and Lund-ParT’s class tokens versus depth.
Geometric alignment rising with depth does not track functional transfer: lund-to-part’s retained AUC (Table II) is flat at – across the same depth range where CKA rises from to $0.93, and its absolute rejection gains only 8 units over that range while remaining less than half of ParT’s own. The two front ends occupy increasingly similar subspaces at greater depth, and this similarity has little visible effect on how much of Lund-ParT’s information ParT’s downstream can extract. Geometric similarity and functional interchangeability are different properties. This is the practical case for model stitching over a representational-similarity measure alone: geometry describes the representations, stitching tests what a specific downstream computation can do with them.
What the representation is missing
Section III located the deficit in the representation. This section asks which jets are responsible, using scores averaged over five seeds for standalone ParT and the lund-to-part stitch at and .
We find each model’s own threshold at and compare which background jets each threshold rejects. Of the 100,661 background jets (of 100,971 total) standalone ParT rejects, the stitched model fails on 557 at and 515 at ( counting uncertainty): and of standalone ParT’s rejected set. The stitched model rejects 108 background jets standalone ParT does not at , and 107 at . Restricted to all 100,971 background jets, the two models’ score rankings agree closely (Spearman at , at ). The deficit is concentrated in a small population, not a general loss of ranking resolution.
That population is not a random of standalone ParT’s rejected background. Figure 4 shows its jet-mass distribution sitting almost entirely above 150 GeV: mean 180 GeV, median 179 GeV, interquartile range 166–191 GeV, against a general background distribution with mean 95 GeV and median 82 GeV. There is no corresponding shift in (597 GeV against 595 GeV). These are the highest-multiplicity background jets in the sample (mean 67.2 real constituents at and 66.3 at , against 43.3 typical) whose accidental invariant mass mimics a real top, distinguishable from a genuine top decay only through substructure. Despite carrying more constituents, this population has fewer real primary-Lund-plane splittings than typical background (mean 11.3 at and 11.2 at , against 12.6): more of its radiation lies off the single hardest branch the primary Lund plane records. A jet whose extra particles all hang off softer branches presents the primary plane with a shorter sequence than an ordinary jet, even though it contains more to describe. This is the diagnosis the next section tests.
Figure 4. Jet mass and for all background jets, the subset rejected by standalone ParT at its own threshold, and the subset the lund-to-part stitch () fails to reject that standalone ParT would have. The affected population concentrates at and above the top quark mass; there is no corresponding effect in .
Confirmation: the full declustering tree
If the deficit is the absence of off-primary-branch substructure, rebuilding Lund-ParT on the full C/A declustering tree, matching LundNet’s own graph construction [2], should repair it. We rebuild Lund-ParT with every splitting in the full tree as its node set, nodes for real constituents, mean sequence length 42.3 on background jets against the primary branch’s 12.6, and repeat the identical protocol unchanged.
Standalone Lund-ParT’s own rejection at rises from to (Table I), closing 72% of the distance to ParT’s own . The AUC gap closes in the same proportion but remains, as everywhere in this paper, small in absolute terms: 0.9759 to 0.9822 against ParT’s 0.9838. Figure 5 compares lund-to-part’s absolute rejection under both representations, against the same fixed ParT target throughout. The primary-branch curve is nearly flat, 128 to 136 across depths 1–5; the full-tree curve rises steeply from 134 at to 242 at , approaching ParT’s own 291. The two curves are statistically indistinguishable at , where only one of the target’s blocks has been replaced, and separate progressively as more of the Lund representation’s own processing is included – which is what a representational rather than computational difference should do.
Figure 5. Lund-to-part absolute background rejection at and 0.3, primary-branch Lund-ParT versus the full-declustering-tree rebuild, same ParT target throughout. The horizontal line marks ParT’s own standalone value.
The leaked population shrinks correspondingly, from 557 24 jets to 399 20 (0.4% of standalone ParT’s rejected set) at , and from 515 23 to 177 13 (0.2%) at . The shrinkage is far larger at , a factor of 2.9, than at , where it is 28%; this mirrors the separation of the two curves in Figure 5 and has the same explanation, that at almost all of the computation is ParT’s own and there is correspondingly little of the Lund representation in the result to repair. The Spearman rank correlation with standalone ParT rises from 0.955 to 0.975 at , so the repair sharpens agreement in the bulk as well as in the tail.
What remains is still concentrated near the top quark mass (mean 180 GeV at , 177 GeV at ), but its relationship to splitting count changes sign. Under the primary branch, the leaked population had fewer splittings than typical background despite more constituents; under the full tree, splitting count tracks constituent count exactly, as it must once every splitting is recorded (54.2 splittings for 55.2 particles at ; 54.0 for 55.0 at ). The signature that identified the deficit is gone, in the same jets and in the same direction the diagnosis required. Linear CKA between the two front ends also rises further under the full tree, 0.747 0.078 at to 0.960 0.002 at , against 0.759 0.034 under the primary branch. The residual leakage in this hard-mass region is consistent with ordinary classifier disagreement, not a structurally missing quantity.
A known omission, a detected deficit localized to a specific jet population, and a repair that removes most of both: this is the validation the diagnostic needs.
Which nodes carry the repair
Section V establishes that restoring the full declustering tree repairs the deficit. It does not say which of the roughly 36 extra nodes per jet the network uses to do it. The distinction matters practically: “record the whole tree” and “record the handful of splittings that carry the discrimination” are different prescriptions for anyone designing a Lund-based tagger, and only the second would suggest a cheaper representation is available. This section answers the question directly, by masking nodes at inference on the already-trained full-tree weights. Nothing here involves retraining.
Labelling a node as primary or secondary costs nothing, because the full-tree construction already orders its output that way. The traversal in Sec. V is a pre-order walk that always descends the harder subject first, so the primary branch is exactly the leading contiguous block of a jet’s node array, and its length is the node count the primary-branch representation stores for the same jet. We checked this rather than assuming it: on 2000 test jets drawn at random the leading block of the full-tree features is bit-identical to the primary-branch features, with no exceptions, and the check is repeated on every run of the analysis. Averaged over the 40,000 test jets used here, a jet carries 12.0 primary and 35.9 secondary nodes.
Figure 6 shows what the two labels mean on a single jet. The primary branch is the spine running left to right, one node per declustering step, and every secondary node hangs somewhere below it in a subtree the primary Lund plane never records.
Figure 6. The Cambridge/Aachen declustering tree of one real top jet. The primary branch is the horizontal spine; the subtrees hanging below it are what the primary Lund plane discards and the full tree keeps. The jet was chosen to be small enough to draw and to have a primary fraction (0.26) close to the population’s 12.0/48.0, but is otherwise unremarkable.
The two populations are also distinct in physics terms, as Figure 7 makes concrete. Following the harder subjet at every step is a good way to find hard structure, and the primary branch duly holds most of it: 51% of primary nodes sit in the hard region GeV, against 13% of secondary nodes. Its density occupies the familiar primary-plane triangle, with a pronounced hard, wide-angle lobe. The secondary population instead concentrates in a single soft, collinear blob, 59% of it in that one quadrant. A top decay is distinguished from a QCD jet largely by hard, wide-angle splittings, so this alone suggests the primary branch does more work than its node count implies.
Figure 7. Lund-plane density of the two node populations, over all 40,000 test jets. Dotted lines mark GeV and . The colour scales are independent, since the secondary population is three times as numerous and a shared scale leaves the left panel unreadable; the per-jet node counts in the titles fix the relative normalisation.
The probe is a masking ablation. For each condition we suppress a chosen set of nodes and re-evaluate the same frozen weights; because the network builds its key-padding mask from the input mask and zeroes the embeddings of masked nodes, handing it a modified mask is exactly the intervention, with no change to the model. Two details matter for the result to mean anything. First, each deletion is paired with a size-matched control, so that the number of surviving tokens is held fixed and only the identity of the survivors varies; without this, any drop would conflate the loss of particular nodes with the loss of sequence length.
Second, we compact the surviving nodes to the front of the sequence before the forward pass. The network trims each batch to its longest real sequence by taking a fixed number of leading columns, which is lossless for a contiguous block but silently discards scattered survivors, and a jet that loses all of them returns an undefined score. Compaction removes that asymmetry between conditions and is invisible to the network, which has no positional encoding. Jets whose every node is primary, 69 of 40,000, are excluded from all conditions alike, since “delete the primary branch” is not defined for them.
Table IV collects the result, and both matched pairs point the same way. Removing the twelve primary nodes costs almost everything, 230.6 → 9.2, while removing twelve secondary nodes costs little, 230.6 → 186.5, with AUC barely moving at all. Keeping only the twelve primary nodes retains more than keeping twelve random ones, 34.7 against 4.4. The intermediate condition is the one that shows the effect is specific rather than an artifact of deletion: twelve nodes drawn at random from the whole jet, about a quarter of which are primary by construction, land at 53.9, between the two extremes and much closer to the primary-deletion end than their composition alone would suggest.
| condition | nodes | rej. at | AUC |
| all nodes | 48.0 | 230.6 8.2 | 0.9818 |
| drop 12 secondary | 36.2 | 186.5 16.3 | 0.9789 |
| drop 12 random | 35.9 | 53.9 3.5 | 0.9292 |
| drop 12 primary | 35.9 | 9.2 5.6 | 0.8307 |
| keep 12 primary | 12.0 | 34.7 12.4 | 0.9229 |
| keep 12 random | 12.0 | 4.4 1.8 | 0.6845 |
Table IV. Background rejection and AUC under each masking condition, full-tree Lund-ParT, mean standard deviation over 5 seeds, 40,000 test jets. Conditions are grouped into matched pairs: the same number of surviving nodes, differing only in which nodes those are.
The comparison that carries the most weight is the first pair, because it holds the number of deleted nodes fixed at twelve and varies only their provenance: 9.2 against 186.5, a factor of twenty. It also disposes of the obvious objection to any ablation of this kind. Weights trained only on complete trees have never seen a shortened sequence, so a drop might reflect nothing more than that unfamiliarity. If that were the explanation, deleting twelve secondary nodes would hurt as much as deleting twelve primary ones. It does not, by a factor of twenty, so the sensitivity is to which nodes are removed and not to the fact of removal.
Removing secondary nodes a fraction at a time, rather than twelve at a time, shows how their contribution is spread (Figure 8, right). Rejection falls from 230.6 ± 8.2 with every node present to 194.9 ± 14.2 at a quarter removed, 118.8 ± 15.1 at a half, 58.9 ± 16.1 at three quarters, and 34.7 ± 12.4 when none is left. The first quarter is nearly free, costing 15%, and each subsequent quarter costs more than the one before it. There is no step, no fraction at which the curve falls off a cliff, which is what a small load-bearing subset would have produced. The endpoint is the sharpest statement available here: stripping all 36 secondary nodes still leaves the network at 34.7, well above the 9.2 it reaches when the 12 primary nodes go instead and all 36 secondary ones remain.
Figure 8. Left: background rejection under each masking condition, with the matched pairs adjacent. Right: rejection as a growing fraction of each jet’s secondary nodes is removed, ending at the primary branch alone. The dashed line marks the complementary condition, the primary branch removed and every secondary node kept.
Taken together these measurements say something more specific than § 3.5 alone could. At inference the trained full-tree network leans overwhelmingly on the primary branch: twelve primary nodes support a higher rejection on their own, 34.7, than all thirty-six secondary nodes do without them, 9.2. Yet training on the full tree is what lifts standalone rejection from 136 to 248 in the first place. Both statements are measurements, and the way to hold them together is that the secondary nodes act during training, shaping the representation the network learns to build, rather than supplying discriminating information to be read off at test time. On that reading the repair is real but not localized, and the honest answer to which of the extra nodes carry it is that no small subset does.
This has a consequence for anyone hoping to shortcut the full tree. A representation that recorded the primary branch plus a modest selection of secondary splittings would not, on this evidence, recover the repair, because the secondary contribution is not concentrated anywhere for such a selection to capture. We would also caution against reading the individual conditions in Table IV as importance scores in any stronger sense. They are comparisons within matched pairs, and it is only the contrast within a pair that is interpretable; the absolute values still carry whatever cost the network pays for a sequence shorter than any it was trained on.
Where along the primary branch information sits
Section VI asks which nodes of the full declustering tree a trained network relies on, and finds it relies almost entirely on the primary branch. This section asks the complementary question of the primary branch itself: a trained, frozen Lund-ParT built on the primary branch alone reads a jet as a sequence of declustering steps, and we ask which single step it can least afford to lose.
Cambridge/Aachen declustering is angular ordered, so position along the chain is a proxy for angular scale. We verified this rather than assuming it: the last node sits at smaller than the first in 100.0% of jets, in both top tagging and quark/gluon tagging, the latter as described in Appendix A, and the median falls monotonically along the chain, from 0.69 to 0.008 for top tagging and 0.35 to 0.004 for quark/gluon. The first step is therefore the widest-angle splitting and the last the most collinear.
Three ablations are compared on the already-trained, frozen primary-branch Lund-ParT, with no retraining: remove the first step, remove the last, or remove one chosen uniformly at random. Anchoring at the ends is what makes the comparison clean. Jets have different chain lengths (12.0 steps on average for top tagging, 13.6 for quark/gluon), so ablating a fixed index would act on a shrinking and increasingly atypical subset as the index grows; every jet has a first and a last step whatever its length, so all three conditions act on 100% of the jets with nothing padded, normalized or truncated. Jets with a single node cannot give one up and are excluded from every condition alike (5 of 201,998 for top tagging, 9 of 199,994 for quark/gluon).
The random condition is the control, and it carries the argument. Removing any node costs something, partly because a shortened sequence is unfamiliar to weights trained on complete ones, so an absolute drop cannot distinguish “this step mattered” from “removal hurts”. Only the paired difference against random, computed seed by seed so that common cost cancels, is interpretable; all claims below are stated that way. Survivors are compacted to the front of the sequence before the forward pass, following § 3.6’s procedure, since the network has no positional encoding and the batch trimmer would otherwise silently discard a non-contiguous mask. We report background rejection at and the threshold-free mean per-jet , on cached checkpoints over five seeds.
The widest-angle splitting is worth far more than an average one in both tasks, and about three times more so for top tagging: +35.2% of the unablated rejection against +11.5%. The most collinear splitting is worth correspondingly less than average – for quark/gluon by almost exactly the same magnitude the first splitting is worth (−11.8% against +11.5%), for top tagging by a smaller margin than the first splitting’s excess (−29.4% against +35.2%). Importance falls monotonically as the splitting becomes more collinear. The threshold-free measure agrees independently (Figure 9, right): mean runs 0.175 → 0.060 → 0.012 for top tagging across first, random and last, a factor of 14.6 between the two ends, and 0.066 → 0.044 → 0.025 for quark/gluon, a factor of 2.6 – the same ordering, the same contrast between the two tasks, with no threshold involved.
Figure 9. Left: loss in background rejection when one node is removed. Right: the same conditions under the threshold-free per-jet score shift. Error bars are the seed standard deviation.
Jet-tagging information along the primary chain is conconcentrated at wide angles, and markedly more so for top tagging than for quark/gluon discrimination. Removing the single widest-angle splitting costs top tagging 71% of its background rejection, essentially twice what removing a random splitting costs, while the most collinear splitting is nearly free to discard; the same ordering holds for quark/gluon, with roughly a third of the contrast. This has a natural reading: a boosted top is identified by a hard, localized prong structure whose opening angles and sit near the first declustering, so one wide-angle splitting carries much of the discrimination, while quark/gluon separation rests on Casimir scaling, which acts across the whole emission spectrum and accumulates over many steps, so no single step is decisive. This corroborates, from an independent direction, why discarding off-primary branches was close to fatal for top tagging and only mildly costly for quark/gluon (§ 3.5, Appendix A).
| dataset | condition | rej. at | loss | excess vs. random |
| top tagging | unablated | — | — | |
| remove first | ||||
| remove random | — | |||
| remove last | ||||
| quark/gluon | unablated | — | — | |
| remove first | ||||
| remove random | — | |||
| remove last |
Table 5. One node removed per jet from the standalone primary-branch Lund-ParT, mean standard deviation over 5 seeds. “Excess” is the paired difference against the random control, as a percentage of the unablated rejection, with its paired statistic.
Two limits are worth stating. This measures what a trained network uses, not what is physically available; § 3.6 found the two can differ sharply. And removing any single node costs far more than its naive share of the chain would predict: a share is 8.3% for top tagging, against the 35% a random node actually costs; a share is 7.4% for quark/gluon, against 16%. There is a real distribution-shift penalty, which is why only the paired comparison against the random control is quoted as a result.
Discussion and conclusion
Model stitching, applied to ParT and a Lund-plane network built the same way, separates a performance gap into its two possible causes and identifies which one is responsible. The primary-branch representation is genuinely weaker than ParT’s, independent of which downstream reads it; this shortfall is invisible in AUC and appears only in background rejection at fixed, low signal efficiency; it is concentrated in a specific, physically identifiable population of high-multiplicity, high-mass background jets with radiation lying off the primary branch; and it is repaired, in the population it should repair and in the direction it should move, by restoring exactly the branches the primary plane omits.
Section VI then pushes past the repair to ask what per… forms it. The answer complicates the natural reading of § 3.5. At inference the repaired network depends almost entirely on the primary branch, and the secondary nodes that the full tree adds are individually close to redundant: deleting twelve of them costs a fifth of the background rejection, while deleting twelve primary nodes costs almost all of it. The extra nodes are what makes the better representation learnable, not what the finished network reads. We think this is worth stating plainly because it is the kind of thing a performance comparison would never surface, and because it warns against the obvious engineering shortcut of keeping the primary branch plus a few chosen secondary splittings.
Figure 10. The measured importance placed on the angular scale it corresponds to. Circles mark the median of successive declustering steps; filled circles are the two steps actually ablated, with area proportional to their excess damage over the random control, and hollow circles are the intermediate steps, which were not measured. Dotted lines mark the top and decay opening angles at GeV, drawn on the top-tagging lane only since they are a statement about top jets. The first splitting of a top jet falls close to these scales; quark/gluon jets have no such scale, and their importance profile is correspondingly flatter.
None of this required the primary branch to be a strong tagger on its own. It is not, by construction: LundNet uses the full declustering tree precisely because the primary branch is incomplete. We used it as a positive control because its deficit was known before any stitching result was computed, which is what makes correctly recovering that deficit, and localizing it to the right jets, evidence that the method works.
Section VII asks a complementary question of the primary branch in isolation: its own discriminating power turns out to be concentrated at its wide-angle end, close to the top and opening angles, far more sharply for top tagging than for quark/gluon. That is the same picture Sec. VI finds from the branch side: a top jet’s discrimination depends on localized, specific structure rather than being spread evenly across whatever is recorded.
A hypergraph reading of the same representations
One alternative to the conclusion of § 3 deserved a direct test rather than an argument. Every reader of the primary-branch representation considered so far processes its splittings through pairwise attention. A model that reasons natively over triplets of splittings might do better: three-body correlations among recorded emissions could in principle constrain the radiation that was not recorded, letting a network infer something about the branches the primary plane discards without ever being shown them. Had that been the case, part of the deficit this paper attributes to the representation would have belonged to the reader after all.
We therefore rebuilt the tagger as a hypergraph network, in which a token is not a particle or a splitting but a triplet of them. Hyperedges are the union of a local neighbourhood construction and every triplet among the ten hardest nodes, the second included because purely local triplets sit within a single prong and miss the wide-angle structure a boosted top is identified by. The same architecture, the same jets, and the same training protocol are used throughout, with only the node set changed between the three variants. These runs use 10% of the dataset and a single seed, so they are indicative and are not comparable with the measurements elsewhere in this paper; the companion figures in the preceding sections are untouched by them.
| representation | hypergraph rej. at | this paper’s network rej. at |
| particles | 133 | |
| Lund, primary branch | 116 | |
| Lund, full tree | 181 |
Table 6. Hypergraph taggers against the corresponding stitching-study networks, all at 10% of the dataset. The hypergraph column is a single seed and carries no uncertainty; the right-hand column is the mean over 5 seeds at the same scale.
The test comes out negative, and cleanly so. On the primary branch the hypergraph reaches a rejection of 116 against Lund-ParT’s 112 7 at the same scale: the two agree inside one standard deviation, so the explicitly three-body reader extracts no more from that representation than the pairwise one does. The gap between the two Lund representations survives intact, 116 rising to 181 when the full tree is restored, a 55% gain against the 79% the stitching study measures for the same pair. A model built to see higher-order structure, given only the primary declusterings, does not recover what the full tree carries.
We draw attention to how little this buys the present study, because the temptation to present it as an extension should be resisted. Its entire value is eliminative: it removes one competing explanation for § 3’s result and leaves every number, figure and conclusion in this paper exactly as they were. It improves neither the diagnosis nor the repair, and it identifies no jet population that § 3.4 did not already identify.
Nor can it be folded into the stitching framework without damage, which is the more important point. This paper’s design rests on one architecture reading several representations, so that a stitched condition’s shortfall is attributable to representation content. The hypergraph tagger breaks that symmetry: it carries no pairwise attention bias, since at roughly two hundred hyperedge tokens rather than fifty particles the bias tensor does not fit alongside training activations, and on particles it reaches only two thirds of ParT’s rejection. Stitching it against ParT would therefore reintroduce precisely the confound between representation content and architecture that § 1 sets out to remove, and any deficit so measured would be uninterpretable. We report the comparison as a consistency check on the representational claim and build nothing on it.
The result is scale-limited in a stated, not defensive, way. Both networks are trained at 50% of the reference dataset, and standalone rejection here is below values reported at full scale for comparable architectures. Every claim in this paper rests on a large effect – a factor of two in standalone rejection, a factor of 2.9 in the leaked population at the deeper repair depth – and we would not expect this scale to change which population is responsible or the direction of the repair. Whether the same protocol, applied to a source-target pair whose representations are closer in strength, resolves depth-by-depth differences at this data scale is a separate question we do not attempt to answer here; it needs more data, more seeds, and is better reported on its own. The consumer-asymmetry result of § 3 B is the one place where five seeds are visibly too few: the effect points the same way in all ten individual comparisons and in all five seed-level scores, yet reaches only .
Two limitations of scope deserve naming. First, we excluded from the analysis on structural grounds (§ 3 C) rather than reporting it with a caveat. We think this is the right call, since at that depth the target contributes no self-attention blocks and the quantity measured is not the one the sweep is designed to measure, but it does mean the sweep stops one layer short of the full stack and we cannot speak to what happens there. Second, a consumer-side fine-tuning check – unfreezing the first target block downstream of the stitch point, to test whether consumer asymmetry survives letting the receiving block adapt – was performed at an earlier, smaller data scale and was inconclusive there, with a seed-dependent instability that we could not attribute to a learning-rate artifact. We have not repeated it at this scale, and we do not use it as evidence anywhere in this paper.
A natural question is whether this diagnosis is specific to top tagging, where the omitted structure is a known, localized pair of prongs. Appendix A repeats the full pipeline on quark/gluon tagging, a task whose discrimination rests on Casimir-scaling radiation patterns rather than localized substructure, and finds a different balance between representation and repair: the primary branch alone already retains 77.6% of ParT’s standalone rejection, against 46.9% on top tagging, and restoring the full tree closes only 33% of the remaining gap, against 72%. The consumer-asymmetry result of § 3 B does not reproduce there either. The two tasks nonetheless agree on one point: a complete declustering tree sits at essentially the same fraction of ParT’s rejection on both, about 85%, which we read as a cost intrinsic to the Lund encoding itself rather than to any specific omitted branch. The quark/gluon stitch measurements are noisier at shallow depth than the top-tagging ones, and Appendix A states that caveat alongside every number it affects.
Our contribution is not model stitching itself, which is due to Bansal, Nakkiran, and Barak [8]. It is the class-token stitch point, which removes the sequence-length obstacle to applying stitching across architectures with unrelated per-token structure; the same-architecture Lund-ParT, which removes the confound between representation content and message-passing mechanism; the explicit dual normalization of § 2; and the positivecontrol design that lets the method’s output be checked against an independently known answer.
Acknowledgments
S.R. is supported by the IIT-Kanpur institutional Ph.D fellowship.
S.G. is supported by the IIT-Kanpur faculty initiation grant (IITK /PHY /2023499), Anusandhan National Research Foundation - Advanced Research Grant (ANRF/ARG/2025/005801/PS) and Anusandhan National Research Foundation - ANRF MISSION AI for Science and Engineering (ANRF/AISE/2025/000373/AISSAI).
Data Availability Statement
The Kasieczka et al. top-tagging reference dataset used in this work is publicly available at Zenodo (DOI: 10.5281/zenodo.2603256). Code implementing the architectures, stitching protocol, and analysis described here is available from the authors on reasonable request.
AI USAGE Statement
The authors acknowledge the usage of Anthropic’s Opus-5 model for cross checking the SVCCA analysis and code refactoring. The manuscript however is manually written by the authors themselves.
Generalization to quark/gluon tagging
The representational deficit identified in § 3–§ 3.6 is specific to top tagging: the primary Lund plane discards the off-axis prongs a boosted top’s three-body decay needs, but how costly that omission is for a classification task with different discriminating physics is not obvious a priori. We repeat the identical pipeline and hyperparameters – the same architectures, the same stitching protocol, the same five seeds – on the EnergyFlow quark/gluon dataset [19], a task whose discrimination rests on Casimir scaling of gluon radiation rather than on localized substructure. We report what was measured and state where it is, and is not, resolved.
Setup
a. Dataset. EnergyFlow quark/gluon jets (Pythia generator, - and -initiated jets excluded), 1,000,000 events, shuffled under a fixed seed and split 600,000/200,000/200,000 into train, validation and test. EnergyFlow stores each constituent as ; these were converted to four-momenta using each particle’s PDG mass from its pid, not a massless approximation, and written into the same HDF5 layout the pipeline reads for top tagging, so both datasets are processed by identical code. Jets carry 43.2 constituents on average at a jet of about 523 GeV. Labels follow the EnergyFlow convention, quark = 1 and gluon = 0, so signal efficiency below is quark efficiency and the rejected set is gluon jets. The test split contains 100,016 gluon jets.
b. Representations. Three inputs to one architecture, as in § 2: ParT takes the seven kinematic scalars per particle with the four relativistic invariants of every particle pair as its attention bias; Lund-ParT (primary) takes the five primary-Lund-plane declustering coordinates, 13.6 nodes per jet on average; Lund-ParT (full tree) takes every splitting of the full Cambridge/Aachen tree, 42.3 nodes per jet.
c. Architecture and training. All three instantiate the same ParticleTransformer class used throughout this paper: 6 pre-norm self-attention blocks, embedding dimension 128, 8 heads, 2 class-attention blocks, and a two-layer head (1,658,814 parameters for ParT, 1,658,616 for Lund-ParT). Training uses AdamW, cross-entropy loss, batch size 256, up to 30 epochs with early stopping on validation AUC (patience 5), and float16 mixed precision. Five seeds throughout; every quoted uncertainty is the standard deviation over those five seeds.
d. Stitching. Identical to § 2 C: for source , target , and depth , ’s embedding, first blocks, and class-attention readout are frozen and produce ’s own class token; a single trained Linear(128, 128) map (16,512 parameters) carries it across; ’s remaining blocks, readout, and head complete the forward pass frozen at their standalone values. Only the linear map is optimized: up to 15 epochs, patience 4, on a fixed 20,000-jet subsample. Four conditions are run at every depth and seed, seed-matched. Depths are reported; is excluded for the same structural reason given in § 2 C.
e. Execution. The two Lund modes were run as separate jobs. The ParT backbones are byte-identical between them (verified by checksum), so the ParT column below is one set of five models shared by both halves rather than an independent replicate.
Standalone performance
Restoring the full declustering tree moves standalone rejection from 30.59 to 33.54 against ParT’s 39.44 (Table VII), closing 33.3% of the gap – far less than the 72% closed on top tagging (Table I).
| ParT | Lund-ParT (primary) | Lund-ParT (full tree) | |
| AUC | 0.9110 0.0011 | 0.8905 0.0003 | 0.9006 0.0007 |
| rej. at | 39.44 0.73 | 30.59 0.17 | 33.54 0.52 |
| rej. at | 98.14 2.52 | 82.13 0.92 | 88.12 1.55 |
Table VII. Standalone test performance on quark/gluon tagging, mean standard deviation over 5 seeds.
Stitched performance
Table VIII gives the absolute rejection of the Lund-to-part stitch, the quantity through which the two Lund representations are compared, with the same frozen ParT target in both rows.
| representation | 1 | 2 | 3 | 4 | 5 |
| primary branch | 15.1 ± 8.2 | 21.9 ± 7.0 | 25.0 ± 4.6 | 23.6 ± 12.4 | 30.1 ± 0.3 |
| full tree | 7.8 ± 7.1 | 15.2 ± 7.9 | 20.8 ± 6.0 | 30.6 ± 0.8 | 32.8 ± 0.7 |
Table VIII. Absolute background rejection at for the lund-to-part stitch on quark/gluon tagging, both Lund representations, against the same ParT target. ParT’s own standalone value is 39.44.
a. Consumer-asymmetry test. Averaging the self-minus-cross difference in raw rejection over per seed, then over the two directions, gives a mean advantage for ParT’s downstream over Lund-ParT’s of rejection units (, , seeds). The sign is negative and the result is not significant – the opposite of the top-tagging result (§ 3 B), where the same test gave ().
Geometric alignment
Linear CKA and SVCCA between ParT’s and Lund-ParT’s class tokens, computed on a fixed probe sample independently of any stitching or classification objective. The depth index here is the layer at which a class token is read from a standalone network, so unlike the stitch sweep it remains defined at .
Jet-level localization
Of the 100,016 gluon jets in the test split, standalone ParT rejects 97,575 at its own threshold. Table XII counts those the stitched model fails to reject that standalone ParT would have, with counting uncertainties.
Spearman rank correlation with standalone ParT over all gluon jets is 0.812 () and 0.836 () for the primary branch, and 0.661 and 0.907 for the full tree.
Reading the numbers
Three features of this run should be stated explicitly, because they bear on what can and cannot be concluded from the tables above.
a. Most of the depth structure is not resolved. The per-depth stitch measurements carry seed spreads of 20–55% in relative terms at : 15.1 8.2 at and 23.6 12.4 at for the primary branch, for instance. The non-monotonic entries in Tables IX and X – lund→part dipping at , part→lund at $d = 2 – are consistent with that scatter and should not be read as structure. Only , where the spreads fall to a few percent, is measured sharply. This is a substantially noisier regime than the top-tagging study, where per-depth spreads were a few percent throughout.
b. The consumer asymmetry does not appear here. In the top-tagging study ParT’s downstream extracted at least as much from the Lund representation as Lund-ParT’s own did, at every depth.
b. The consumer asymmetry does not appear here. In the top-tagging study ParT’s downstream extracted at least as much from the Lund representation as Lund-ParT’s own did, at every depth. On these jets the ordering is mixed across depths and the seed-level test returns with : the opposite sign, and consistent with zero.
c. The full tree does not dominate the primary branch at every depth. Standalone, the full tree is ahead, 33.54 against 30.59. Through the stitch it is behind at and ahead only at (Table VIII), and its leaked population at is larger than the primary branch’s, 5539 against 2607, shrinking below it only at , 897 against 1306. The comparison also has the lowest rank correlation of the four, 0.661. In the top-tagging study the full tree led at every depth and its leaked population was smaller at both depths checked.
Physical interpretation
The comparison that carries the physics is against the same analysis run on the top-tagging reference dataset, at 50% of that dataset and over the same five seeds, where ParT reaches 290.7 13.2, the primary branch 136.3 4.3, and the full tree 247.7 5.3 at (Table I).
a. The primary Lund plane is a far better representation here than for top tagging. On its own it retains 77.6% of ParT’s rejection on quark/gluon tagging against 46.9% on top tagging (Table XIII). This follows the physics of the two tasks. Quark/gluon separation rests on Casimir scaling, : gluons radiate more, which shows up as the rate and hardness of emissions along the jet’s hardest chain together with the resulting multiplicity. That is precisely what the primary branch samples, since it records and at every step of that chain. Top tagging instead requires a localized three-prong structure, two prongs of which sit on branches the primary plane discards. The same omission is close to fatal for one task and only mildly costly for the other.
b. Restoring the full tree therefore buys much less. It closes 33% of the gap to ParT here against 72% there. In a quark or gluon jet the secondary branches carry further soft radiation of the same character the primary chain already samples, so they add statistics on a property that was already measured. In a top jet they carry the missing hard prongs. The construction is identical; what it recovers is not.
| direction | 1 | 2 | 3 | 4 | 5 |
| lund→part | 0.930 ± 0.053 | 0.963 ± 0.016 | 0.969 ± 0.008 | 0.858 ± 0.263 | 0.977 ± 0.002 |
| part→lund | 0.941 ± 0.066 | 0.839 ± 0.341 | 0.989 ± 0.022 | 1.004 ± 0.007 | 1.016 ± 0.006 |
| part-self | 0.931 ± 0.045 | 0.953 ± 0.035 | 0.964 ± 0.021 | 0.981 ± 0.008 | 0.993 ± 0.004 |
| lund-self | 0.970 ± 0.026 | 0.981 ± 0.018 | 0.994 ± 0.002 | 0.997 ± 0.001 | 0.998 ± 0.003 |
Table IX. Retained AUC, target-normalized (), primary-branch run, quark/gluon tagging.
c. The residual shortfall against ParT is the same on both tasks. Even a complete declustering tree sits at 85% of ParT’s rejection on either dataset (85.0% and 85.2%). Since the two tasks differ in which structures discriminate, a shortfall this similar is more naturally read as a cost of the Lund encoding itself than of any particular omitted branch: the Cambridge/Aachen sequence is one hierarchical summary of a jet, and what that summary compresses away appears to cost a roughly task-independent fraction of the rejection. CKA evidence, not on any single entry. The asymmetry test is underpowered at five seeds, so the absence of a detected asymmetry is not evidence of its absence. Both conclusions compare two datasets at different fractions of their respective reference samples, with the architecture and every hyperparameter held fixed but the jet kinematics differing in reach and multiplicity.
d. The full tree’s advantage requires depth before it appears. Through the stitch the full tree is behind the primary branch at and ahead only at (Table VIII); its leaked population at is the larger of the two, 5539 against 2607, and carries the lowest rank correlation of the four comparisons, 0.661; and its geometry starts further from ParT’s, CKA 0.379 against 0.639 at , before converging higher by , 0.919 against 0.884 (Table XI). The roughly 28 additional nodes per jet are therefore not locally readable: they require several rounds of attention before they aggregate into anything discriminating. The information the full tree adds is distributed rather than concentrated.
| CKA | SVCCA | |
| primary branch, | ||
| primary branch, | ||
| full tree, | ||
| full tree, |
Table XI. Geometric alignment between ParT’s and Lund-ParT’s class tokens, quark/gluon tagging.
e. The consumer asymmetry disappears. On top tagging, ParT’s downstream extracted at least as much from the Lund representation as Lund-ParT’s own did, giving +8.0 ± 7.0 rejection units (). Here the test returns −1.1 ± 2.7 (). The natural reading is that little latent information remains for a stronger downstream to recover once the representation already reaches 77.6% of ParT: the primary branch is near its ceiling on this task, where on top tagging it was far from it.
f. What these readings do not rest on. The depth-by-depth stitch measurements carry 20–55% seed spreads below , so the ordering at any individual shallow depth is not resolved on its own; the statement about depth above rests on the direction being consistent across together with the independent leakage and CKA evidence, not on any single entry. The asymmetry test is underpowered at five seeds, so the absence of a detected asymmetry is not evidence of its absence. Both conclusions compare two datasets at different fractions of their respective reference samples, with the architecture and every hyperparameter held fixed but the jet kinematics differing in reach and multiplicity.
| direction | 1 | 2 | 3 | 4 | 5 |
| lund→part | 0.494 ± 0.268 | 0.715 ± 0.228 | 0.818 ± 0.149 | 0.772 ± 0.405 | 0.983 ± 0.011 |
| lund-self | 0.547 ± 0.259 | 0.655 ± 0.234 | 0.858 ± 0.097 | 0.944 ± 0.038 | 0.967 ± 0.039 |
| part→lund | 0.524 ± 0.188 | 0.542 ± 0.300 | 0.679 ± 0.166 | 0.799 ± 0.077 | 0.918 ± 0.042 |
| part-self | 0.460 ± 0.225 | 0.582 ± 0.176 | 0.587 ± 0.170 | 0.790 ± 0.081 | 0.900 ± 0.082 |
Table X. Retained rejection at , source-normalized (), primary-branch run, quark/gluon tagging. lund→part and lund-self divide by Lund-ParT’s standalone 30.59; part→lund and part-self divide by ParT’s 39.44. Uncertainties propagate the numerator’s seed spread only; the denominators are known to 0.6% and 1.9% respectively.
Figure 11. Absolute background rejection at and 0.3 for all four stitching conditions on quark/gluon tagging, primary-branch run, versus depth. Horizontal lines mark each network’s own standalone value. Compare to Figure 2 for top tagging.
Figure 12. Linear CKA and SVCCA mean canonical correlation between ParT’s and Lund-ParT’s class tokens versus depth, quark/gluon tagging. Compare to Figure 3 for top tagging.
| representation | leaked | % of rejected set | newly rejected | |
| primary branch | 1 | 2.7% | 643 | |
| primary branch | 5 | 1.3% | 486 | |
| full tree | 1 | 5.7% | 655 | |
| full tree | 5 | 0.9% | 400 |
Table XII. Leakage relative to standalone ParT’s rejected set, quark/gluon tagging.
| primary/ParT | full tree/ParT | gap closed by tree | |
| quark/gluon | 77.6% | 85.0% | 33% |
| top tagging | 46.9% | 85.2% | 72% |
Table XIII. Standalone rejection at as a fraction of ParT’s, on the two datasets.
lund part stitch, : background jets responsible for the [email protected] gap
lund part stitch, : background jets responsible for the [email protected] gap
Figure 14. As Figure 13, at .
Figure 13. Jet mass and for all gluon jets, the subset standalone ParT rejects at its own threshold, and the subset the lund-to-part stitch at fails to reject that standalone ParT would have.
Figure 15. Lund-to-part absolute rejection on quark/gluon tagging, primary branch versus full declustering tree, against the same ParT target throughout. The horizontal line marks ParT’s own standalone value. Compare to Figure 5 for top tagging.
Figure 16. Primary branch against full declustering tree across the stitch sweep, quark/gluon tagging.
References
References
- [1]F. A. Dreyer, G. P. Salam, and G. Soyez, JHEP 12 (2018), 064, arXiv:1807.04758 [hep-ph].DOI
- [2]F. A. Dreyer and H. Qu, JHEP 03 (2021), 052, arXiv:2012.08526 [hep-ph].arxiv.org/abs/2012.08526
- [3]H. Qu, C. Li, and S. Qian, in Proceedings of the 39th International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 162, edited by K. Chaudhuri, S. Jegelka, L. Song, C. Szepesvari, G. Niu, and S. Sabato (PMLR, 2022) pp. 18281–18292, arXiv:2202.03772 [hep-ph].
- [4]A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin, in Advances in Neural Information Processing Systems, Vol. 30, edited by I. Guyon, U. Von Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (Curran Associates, Inc., 2017) arXiv:1706.03762 [cs.CL].
- [5]H. Qu and L. Gouskos, Phys. Rev. D 101, 056019 (2020), arXiv:1902.08570 [hep-ph].DOI
- [6]S. Kornblith, M. Norouzi, H. Lee, and G. Hinton, in International conference on machine learning (PMLR, 2019) pp. 3519–3529.
- [7]M. Raghu, J. Gilmer, J. Yosinski, and J. Sohl-Dickstein, Advances in neural information processing systems 30 (2017).
- [8]Y. Bansal, P. Nakkiran, and B. Barak, Advances in neural information processing systems 34, 225 (2021).
- [9]F. A. Dreyer, R. Grabarczyk, and P. F. Monni, Eur. Phys. J. C 82, 564 (2022), arXiv:2203.06210 [hep-ph].DOI
- [10]S. Raj and S. Ganguly, (2026), arXiv:2605.09881 [hep-ph].
- [11]P. D. Patel and S. Ganguly, (2026), arXiv:2604.25885 [hep-ph].arxiv.org/abs/2604.25885
- [12]A. Butter et al., SciPost Phys. 7, 014 (2019), arXiv:1902.09914 [hep-ph].DOI
- [13]H. Touvron, M. Cord, A. Sablayrolles, G. Synnaeve, and H. Jégou, in 2021 IEEE/CVF International Conference on Computer Vision (ICCV) (2021) pp. 32–42, arXiv:2103.17239 [cs.CV].
- [14]Y. L. Dokshitzer, G. D. Leder, S. Moretti, and B. R. Webber, JHEP 08 (1997), 001, arXiv:hep-ph/9707323.DOI
- [15]M. Wobisch and T. Wengler, in Workshop on Monte Carlo Generators for HERA Physics (Plenary Starting Meeting) (1998) pp. 270–279, arXiv:hep-ph/9907280.
- [16]M. Cacciari, G. P. Salam, and G. Soyez, Eur. Phys. J. C 72, 1896 (2012), arXiv:1111.6097 [hep-ph].DOI
- [17]I. Loshchilov and F. Hutter, in 7th International Conference on Learning Representations, ICLR 2019 (2019) arXiv:1711.05101 [cs.LG].
- [18]V. Papyan, X. Y. Han, and D. L. Donoho, Proc. Natl. Acad. Sci. 117, 24652 (2020), arXiv:2008.08186 [cs.LG].DOI
- [19]P. T. Komiske, E. M. Metodiev, and J. Thaler, JHEP 01 (2019), 121, arXiv:1810.05165 [hep-ph].DOI















