A backdoored network behaves normally on ordinary inputs but switches to an attacker-chosen class when a small hidden pattern, the trigger, appears in the input. Current defenses find and remove the hidden pathway by trial and error. Some prune neurons that stay silent on clean data. Some perturb weights to see which neurons are fragile. Some search for a universal additive pattern and unlearn it. All of them sometimes damage clean accuracy, and none can state afterwards what has actually been ruled out. Tools that certify local sensitivity already exist. A local Lipschitz bound is a provable limit on how much a network's output can change inside a small region around a given input. These tools come from the adversarial-robustness literature. They are computed over tiny balls of pixel noise, and that choice makes them blind to backdoors: inside such a ball the trojan neurons are provably switched off, so the computation discards them as irrelevant.
This proposal changes the shape of the region. Instead of a tiny noise ball, we bound the network over trigger-shaped regions around clean inputs, such as "any values in a k×k patch at any location" or "a blend of moderate amplitude everywhere." We bound only the quantity a backdoor has to move: how far the gap between some target class's score and the true class's score can rise inside that region. Neurons that are provably off under ordinary noise but can switch on inside a patch region, and that push this score gap upward, are the backdoor candidates. Penalizing the bound, rather than all sensitivity, should remove the shortcut without blunting the sharp clean decision boundaries that classification needs. The same bound can then be reported per input as a deterministic audit of what the repaired model can and cannot do.
Core Claim
Consider a classifier $f$ with class scores $f_c$, a clean input $x$ with label $y$, a candidate target class $t$, and a family of trigger-shaped neighborhoods $\mathcal{N}(x)$. For patch triggers, $\mathcal{N}(x)$ is the union over locations of boxes in which the pixels of one k×k window are free in $[0,1]$ and all other pixels are fixed. For blend-like triggers, it is an $\ell_\infty$ ball whose radius is much larger than evasion budgets. The quantity we care about is the worst-case rise in the target-versus-true score gap:
$$ G_{t,y}(x;\mathcal{N}) = \max_{x' \in \mathcal{N}(x)} \big[f_t(x') - f_y(x')\big] - \big[f_t(x) - f_y(x)\big]. $$
Linear bound propagation computes a provable upper bound $\bar G_{t,y}$ on this gap rise, and each such region is a box, which is the setting where these tools are tightest. A single abnormal target class $t$ whose bound stays large across clean inputs of every other class is the signature of an all-to-one backdoor. Abnormal class pairs signal all-to-all mappings.
The claim has three parts. First, $\bar G$ separates trojaned from clean models even when a bound over tiny ordinary balls does not. Second, the backward linear coefficients produced during bound propagation attribute $\bar G$ to specific neurons. The attributed neurons are exactly those that switch from "provably stable" to "unstable" when the region grows from an evasion ball to a trigger-shaped region, which puts the "dormant neuron" intuition behind pruning defenses on a formal footing. Third, a short fine-tuning pass that penalizes $\bar G$ on a small clean set removes the backdoor with a smaller clean-accuracy drop than weight-perturbation pruning. The reason is that the penalty touches only one class-pair direction over off-manifold regions. It does not flatten the model near real class boundaries.
Relation to Prior Work
The method comes from the local Lipschitz literature. Training Certifiably Robust Neural Networks with Efficient Local Lipschitz Bounds trains with a local bound that drops neurons provably inactive or saturated near clean data, removing over 45% of weight-matrix rows and columns. We reuse this stability bookkeeping but invert its purpose: the neurons it drops are the ones we want to find. Efficiently Computing Local Lipschitz Constants of Neural Networks via Bound Propagation supplies the backward-graph linear relaxation with tight closed forms for the $\ell_\infty$ geometry, which is the geometry our box regions have. It also supplies the warning that bounds loosen with depth. Structural Robustness for Deep Learning Architectures constrains the design. It shows that global smoothness constraints make boundaries too blunt to separate nearby classes, and this is why we penalize a single score-gap direction over trigger-shaped regions rather than an overall Lipschitz constant.
Three works motivate the gap. Zero-Shot Machine Unlearning at Scale via Lipschitz Regularization flattens the output locally around known forget samples using Gaussian noise. It needs the exact samples to forget, and it smooths uniformly. We need neither poisoned samples nor the trigger, and we smooth only along the backdoor's score gap. PECAN certifies against poisoning by training an ensemble on disjoint data partitions and verifying each member with interval bounds. It certifies a poisoning count and pays for it by shrinking each member's data. We certify nothing about poisoning. We give a per-input bound on trigger-shaped perturbations for one unpartitioned repaired model. Cert-SSBD makes smoothing noise sample-specific but stays probabilistic and requires a stateful memory at test time. Our audit is deterministic and memoryless, but it covers only the named region families. That scope is narrower than a general certificate, and we say so.
The empirical purifiers are the competitors. Adversarial Neuron Pruning Purifies Backdoored Deep Models perturbs weights to expose fragile neurons. Adversarial Unlearning of Backdoors via Implicit Hypergradient unlearns an optimized universal additive trigger. Fine-Pruning prunes neurons that are silent on clean data and fine-tunes. We differ from all three in working in input space with provable bounds over a declared trigger family, rather than in weight space or with one sampled trigger.
Research Program
The first stage is measurement. Using the BackdoorBench codebase, we train clean and backdoored models and compute $\bar G_{t,y}$ over patch regions (k in {3, 5}, locations on a stride grid) and over large-radius $\ell_\infty$ balls, for all target classes, on a few hundred clean inputs. We record which neurons switch between stable and unstable status as the region grows. We also record each neuron's share of the bound, read from its backward coefficient times its activation range. Bound tightness is the known risk on deep networks. We therefore work at two scales: a small CNN of the CNN-4C2F type, where bounds are reported non-vacuous, and PreAct-ResNet18, where we expect loose absolute values and test whether the ranking across classes and neurons stays informative anyway.
The second stage is repair. We fine-tune on a 1% clean split, minimizing cross-entropy plus $\lambda \sum_{t \neq y} \mathrm{softplus}(\bar G_{t,y}(x;\mathcal{N}) - \delta)$. Here $\delta$ is a tolerance set from a clean reference model, and the bound is differentiable through the propagation. To control cost, we evaluate the penalty on the few classes and locations with the largest bounds, refreshed each epoch. An optional first step prunes the top-attributed neurons before fine-tuning. The third stage is the audit: for the repaired model, we report the fraction of clean test inputs for which $\bar G_{t,y} < f_y(x) - f_t(x)$ for every $t$. For those inputs, no patch or blend in the family can flip the prediction.
Baselines
The do-nothing reference is the backdoored model itself, which fixes the starting attack success rate and clean accuracy. Plain fine-tuning on the same 1% clean split, with no penalty, is the naive repair. It tells us how much of any gain comes simply from extra clean training.
The strongest existing method is ANP (Adversarial Neuron Pruning Purifies Backdoored Deep Models). It is the most direct competitor on the exact question of removing a backdoor with little clean damage from a small clean set. It reports reducing attack success rate from nearly 100% to below 1% in 5 of 6 CIFAR-10 settings, with an average clean-accuracy drop of 1.47%, using 1% of the training data. We will run it through the BackdoorBench implementation with the same clean split and architectures, and give it the same hyperparameter-search budget as our method. Beating it means matching its attack success rate while cutting the clean-accuracy drop. The decisive cases are MobileNet-V2 and CIFAR-100/TinyImageNet, where it is reported to degrade. Beating it also means holding up against all-to-all and pruning-aware attacks.
I-BAU (Adversarial Unlearning of Backdoors via Implicit Hypergradient) is the strongest input-space competitor. It reports cleaning a CIFAR-10 model in 6.8 seconds with as few as 100 clean samples. It runs under the same data and tuning budget, and we report wall-clock time honestly, since our bound computation will be slower. Fine-Pruning is included as the dormancy baseline our neuron attribution claims to formalize.
Two ablations isolate the key ingredient. The first replaces $\bar G$ with a sampled estimate: the maximum score-gap rise found by projected gradient ascent inside the same regions, or a CLEVER-style extreme-value estimate from sampled gradients (CLEVER). This tests whether provable bounds add anything over search. The second keeps the bound but uses tiny evasion balls, or penalizes all classes' sensitivity uniformly. This tests whether the trigger-shaped, single-direction design is what protects clean accuracy.
Why not just…?
Why not just use ANP? ANP may well match us on CIFAR-10 with ResNet-18, and we do not expect to win there by much. Its reported weaknesses are the larger clean-accuracy drop on compact models such as MobileNet-V2 and its purely empirical output. BackdoorBench (BackdoorBench) further reports that defenses lose robust accuracy as the number of classes grows. The MobileNet-V2 and 100/200-class experiments settle whether our class-pair-targeted penalty actually helps. If ANP ties us there too, our contribution shrinks to the audit, and we will say so.
Why not just do adversarial training with simulated patch triggers, or I-BAU's synthesized trigger? This is the real threat. Gradient search over the same patch regions is cheaper than bound propagation and might remove the shortcut equally well. The sampled-estimate ablation answers this directly. Our prediction is that search finds only one or a few directions that raise the score gap, and misses the others that a bound covers. The prediction fails if search matches us on sample-specific triggers (ISSBA, input-aware) and all-to-all attacks. In that case we would keep the method only as an auditing tool and recommend search-based repair.
Why not just train with a global Lipschitz constraint or local-Lipschitz certified training from the start? Structural Robustness for Deep Learning Architectures shows that global constraints blunt clean boundaries. Evasion-ball local training (Local-Lip) certifies radii like $36/255$, which say nothing about an unbounded patch, where the trojan neurons lie outside the certified ball. The tiny-ball ablation measures exactly this.
Proposed Experiments
We evaluate on CIFAR-10, GTSRB, CIFAR-100, and TinyImageNet, using PreAct-ResNet18, MobileNet-V2, and a small CNN. Attacks are BadNets, Blend, WaNet, ISSBA, and input-aware backdoors in all-to-one and all-to-all forms, plus an adaptive attacker who adds our penalty on clean data during poisoning. Metrics are clean accuracy, attack success rate, and robust accuracy as defined by BackdoorBench, plus audit coverage and wall-clock time.
The first decisive check comes before any repair. Across a population of clean and trojaned models, $\bar G$ over trigger-shaped regions should flag the true target class, and a small-ball bound should not. If the ranking collapses on PreAct-ResNet18 because the bounds are loose, the method is restricted to shallow networks. That is a publishable negative result on the scalability of verification-based backdoor tools, not a success.
The second check is the repair comparison against ANP and I-BAU on MobileNet-V2 and the 100/200-class datasets, together with the sampled-search ablation. The third check is the adaptive attack. If an attacker can plant a backdoor that keeps $\bar G$ small, using warps outside our region family for example, we report the region families that fail rather than widen the claim.
References
- Training Certifiably Robust Neural Networks with Efficient Local Lipschitz Bounds
- Efficiently Computing Local Lipschitz Constants of Neural Networks via Bound Propagation
- Structural Robustness for Deep Learning Architectures
- An Information Theoretic Approach to Machine Unlearning
- PECAN: A Deterministic Certified Defense Against Backdoor Attacks
- Cert-SSBD: Certified Backdoor Defense with Sample-Specific Smoothing Noises
- Adversarial Neuron Pruning Purifies Backdoored Deep Models
- Adversarial Unlearning of Backdoors via Implicit Hypergradient
- Fine-Pruning: Defending Against Backdooring Attacks on Deep Neural Networks
- Evaluating the Robustness of Neural Networks: An Extreme Value Theory Approach
- BackdoorBench: A Comprehensive Benchmark of Backdoor Learning