Which Systematics Belong in the Weights? Decorrelated Trigger Networks in Fixed-Point Firmware

Particle colliders throw away almost every collision in real time. A first-level "trigger," a small neural network or set of cuts running on an FPGA (a reconfigurable chip that executes a fixed circuit with nanosecond, fully predictable timing), decides in well under a microsecond which events to keep. Discarded events are gone for good. For precision measurements limited by systematic uncertainty rather than event count, this matters. A systematic uncertainty here means an error from imperfect knowledge of the detector or the background, such as a slightly wrong jet energy calibration. A trigger that distorts the background, for example by carving a fake bump into the mass spectrum, causes damage that no offline analysis can undo. Offline methods already exist to train classifiers that ignore such nuisances. None has been tested after it is squeezed into the low-bit fixed-point arithmetic that FPGA triggers require.

This note proposes a simple sorting rule and the experiments to test it. Some nuisances are measured by the trigger itself, such as jet mass or the number of overlapping collisions. Those can be neutralized cheaply in firmware with a small lookup table that sets the cut threshold separately in each mass or pile-up bin. Other nuisances are hidden at trigger time, such as a few-percent miscalibration of the jet energy scale. No table can condition on a quantity the trigger never observes, so robustness to these must live in the network weights. The weights are exactly what aggressive quantization perturbs. We will build quantization-aware decorrelated trigger networks, measure where the cheap firmware fix suffices and where it fails, and report systematics-aware discovery significance per unit of FPGA logic.

Core Claim

We expect a mass-binned threshold table on an ordinary quantized classifier to recover most of the discovery significance lost to mass sculpting, at negligible logic cost. We expect it to recover none of the robustness lost to hidden scale shifts. For hidden nuisances, we hypothesize that quantization creates a specific failure mode. A coherent energy rescaling pushes many internal activations across fixed-point rounding boundaries at once, so a smooth few-percent shift becomes a discrete jump in the score. Lower bit widths should make this worse. The remedy we test trains the decorrelation penalty against the bit-exact quantized output rather than a floating-point shadow of it.

Prior Work and Its Role

The two literatures in the file have not met. On the physics side, three works supply the methods and the evidence that the problem is real. Decorrelated jet substructure tagging using adversarial neural networks trains a jet classifier against an adversary that tries to recover jet mass from the classifier's output. Under a 50% background-rate uncertainty, it reaches 3.67σ against 2.82σ for a standard network, because the standard network sculpts a fake peak. Application of Inferno to a Top Pair Cross Section Measurement with CMS Open Data trains directly on the expected post-fit uncertainty, including the jet energy scale as a nuisance. It reduces signal-strength uncertainty from about 10–11% to 9% and the signal–energy-scale correlation from −0.42 to −0.10. Anomaly preserving contrastive neural embeddings motivates the broader concern that the representation a selection keeps determines what can be discovered later. All three run in floating point, offline. We reuse the first two as training objectives and ask what survives in firmware.

On the hardware side, four works supply the deployment path and constrain the design. hls4ml and Fast Inference of Deep Neural Networks for Real-time Particle Physics Applications compile small networks to FPGA firmware with 12–100 ns latency. The first reports up to 95% LUT and 100% DSP reductions from quantization-aware training, judged only by nominal accuracy. Compressing deep neural networks on FPGAs to binary and ternary precision with HLS4ML pushes precision to its limit, again judged by accuracy. Neural Architecture Codesign for Fast Physics Applications automates the accuracy-versus-cost search and reaches a 70 ns jet tagger using under 3% of the chip. Its fitness function ignores systematics entirely. wa-hls4ml provides fast resource and latency surrogates, which we use for screening. That paper also reports that accuracy degrades on irregular scientific models, so we treat it only as a pre-filter and confirm every reported design with real synthesis. Our contribution differs from all of these in what is measured and optimized: systematics-aware significance on bit-exact firmware outputs, with nuisances split by whether the trigger can see them.

Research Program

We first build a bit-exact evaluation harness. It takes any trained model through hls4ml and evaluates the fixed-point emulation, not the floating-point model, on held-out simulation under nuisance variations. It reports three quantities. The first is discovery significance with a 50% background-rate systematic, following the adversarial paper's protocol. The second is background mass sculpting, measured as the Jensen–Shannon divergence between the background mass distribution before and after the trigger cut at a fixed background acceptance. The third, for hidden nuisances, is the shift in background pass rate per percent of jet-energy-scale change.

Second, we implement the firmware-level fix. This is a per-mass-bin (and optionally per-pile-up-bin) threshold table stored in a few dozen LUT or BRAM entries. The thresholds are fit on simulation so that background acceptance is flat across bins. Its cost is synthesized, not assumed.

Third, we implement quantization-aware adversarial training. The adversary, and for the energy-scale case the INFERNO loss, receives the quantized score through a straight-through gradient estimator, so the decorrelation penalty sees the same rounding the firmware will apply. We compare this against applying the penalty to a floating-point shadow output, which is the natural naive extension.

Fourth, we run the codesign search of Neural Architecture Codesign with one change: its fitness is systematics-aware significance from the harness instead of accuracy. Bit width, architecture, and the presence of the threshold table are all search variables, under a 1 µs latency budget. The output is a Pareto front of significance against logic, tracked separately for observable and hidden nuisances.

Baselines

The naive reference point is a standard cross-entropy jet tagger, quantized with hls4ml's quantization-aware training and given a single global threshold. This is what current tooling produces. It establishes how much significance is lost and how much sculpting appears when nobody accounts for systematics.

The strongest existing method for the mass nuisance is the floating-point adversarially decorrelated network from Decorrelated jet substructure tagging. It reports 3.67σ under 50% background uncertainty, against 2.82σ for a standard network. We first reproduce it on the same simulated Z′ versus QCD samples, then deploy it by post-training quantization at each bit width. Its float result serves as the ceiling, and its quantized versions as the practical competitor.

For the hidden energy-scale nuisance, the strongest existing method is INFERNO from Application of Inferno. It reports 9% signal-strength uncertainty and −0.10 correlation with the energy scale, against about 10–11% and −0.42 for cross-entropy. We quantize its 8-feature network and measure how much of that gain survives.

Two ablations isolate our ingredients. The first applies the adversary to the float shadow instead of the quantized output. The second removes the threshold table.

Fairness requires several controls. All methods use identical training and test events and the same FPGA part. All receive the same hyperparameter-search budget, measured in trials, and the same latency ceiling. All results come from post-synthesis reports rather than surrogates.

Beating the field has a different meaning for each nuisance. For mass, we must match the float adversarial significance to within 0.1σ at 6 bits or fewer while using less logic than the quantized adversarial baseline. For energy scale, we must keep the signal–energy-scale correlation within 0.1 of INFERNO's float −0.10 at a bit width where naive quantization loses it. No reported result was found on Lacuna for any of these methods under fixed-point quantization.

Why not just…?

Why not just add the adversarial loss to ordinary quantization-aware training? This is our quantized-shadow ablation, and it is a real threat. At 8 or more bits, the rounding may be too fine to matter, and the simple combination may work. Our experiment sweeps bit width precisely to locate where the shadow and bit-exact variants diverge, if they do. If they never diverge down to ternary precision, we will report that the naive combination suffices. The proposal's lasting contribution then becomes the harness and the observable-versus-hidden split.

Why not just use a mass-dependent threshold table on a standard network? We expect this to win for mass, and we fold it into the design rather than argue against it. The open question is whether it does anything for nuisances the trigger cannot observe. By construction it cannot index a bin by an unknown miscalibration. The energy-scale experiments test whether it nonetheless helps indirectly, for example because flat-mass acceptance happens to reduce scale sensitivity.

Why not keep the trigger loose and fix everything offline? If the trigger keeps a large enough fraction of background, its sculpting may be negligible. We do not assume otherwise. We measure sculpting and significance as a function of trigger background acceptance, and we identify the acceptance below which online decorrelation starts to matter. If that crossover lies below realistic trigger rates, online decorrelation is unnecessary and we will say so.

Why not use expert substructure variables or a decision tree, which are simpler in firmware? The adversarial paper shows that the single expert variable τ21 is outperformed in background-shape preservation across 20–300 GeV. Jet substructure classification with deep neural networks finds that the network's advantage over an expert-feature decision tree grows under pile-up, with 84.3% versus 81.5% signal efficiency at a background rejection factor of 10. We include a τ21-plus-threshold-table baseline on the significance-per-logic front so the comparison is direct.

Decisive Checks

Two results decide the thesis. First, on the Z′ benchmark, the standard quantized network with a threshold table should approach the float adversarial 3.67σ at a fraction of the adversarial network's logic. If it does not, observable nuisances also need learned decorrelation, and the split is wrong. Second, on CMS Open Data, naive quantization of the INFERNO network should let the energy-scale correlation drift back toward the cross-entropy value of −0.42 as bit width falls. Bit-exact INFERNO training should hold the correlation near −0.10 at the same bit width.

A supporting diagnostic is the finite-difference sensitivity of the quantized score to a ±1% energy rescaling, measured layer by layer. It should show the predicted jumps at rounding boundaries in the naive models and their absence in the bit-exact-trained ones. If neither decisive result appears, the conclusion is equally useful: existing tooling already preserves systematics robustness, and the field can stop worrying about it.