Modern deployed models increasingly ship as a single physical weight file that can run at several precisions. In multi-precision weight sharing, an 8-bit integer weight is stored once, and a 2-bit or 4-bit model is obtained by literally discarding the low-order bits: the 2-bit representation is an exact prefix of the 4-bit one, which is a prefix of the 8-bit one TruncQuant: Truncation-Ready Quantization for DNNs with Flexible Weight Bit Precision, Any-Precision LLM: Low-Cost Deployment of Multiple, Differently-Sized LLMs. At runtime, the system switches precision by truncating bitplanes in memory, which saves the storage of keeping one model file per precision AdaBits: Neural Network Quantization With Adaptive Bit-Widths and lets a single LLM weight file serve everything from int2 to int8 Matryoshka Quantization. Meanwhile, a separate literature shows that an adversary with write access to model memory — via RowHammer on DRAM or read disturbance in processing-in-memory accelerators — can flip a handful of bits and either destroy the model or plant a backdoor that activates only on a secret input trigger Bit-Flip Attack: Crushing Neural Network With Progressive Bit Search, Corrosion Hammer: A Self-Activated Bit-Flip Attack to the Processing-In-Memory Accelerator.
These two facts have never been made to meet, and their meeting produces something neither field has: a backdoor whose existence depends on which precision the operator is currently running. Because low-precision modes physically delete low-order bitplanes, a bit flipped in a refinement plane is executed in 8-bit mode but is literally absent — unexecutable, unsearchable by any low-precision audit — in 2-bit mode. Conversely, a flip in the shared base planes hits every tier at once. This positional structure of the attack surface is unstudied. Every existing bit-trojan attack assumes one static quantized representation TBT: Targeted Neural Network Attack With Bit Trojan, Backdoor Attacks on Neural Networks via One-Bit Flip, One-bit Flip is All You Need: When Bit-flip Attack Meets Model Training, and every quantization-conditioned backdoor works only across the float-to-int8 boundary and requires poisoning or retraining Data Poisoning Quantization Backdoor Attack, Adversarial Contrastive Learning for LLM Quantization Attacks. This proposal characterizes, exploits, and defends the tier-conditional bit-flip attack surface of nested quantization.
Core Claim
Write the stored weight code as $c = \sum_{k=0}^{7} b_k 2^k$, where plane $k=0$ is the least significant bit. The $n$-bit tier does not store its own weights; it computes $\lfloor c / 2^{8-n} \rfloor$. Therefore a single physical flip at plane $k$ is visible to tier $n$ if and only if
$$k \;\geq\; 8 - n ,$$
and it changes every such tier's value by the same absolute amount $\pm 2^k$. Three consequences follow, and they are the claim this proposal tests. First, refinement-plane flips ($k < 8-n$ for low tiers) yield a data-free sleeper trojan: an adversary who flips bits only in refinement planes, using the gradient-guided search of TBT or SOLEFLIP restricted to those planes, plants a backdoor that activates in high-precision mode and is physically erased whenever the model truncates — invisible to any audit run at a low tier. Second, the reverse gating is impossible for a post-deployment flip: any bit visible at the 2-bit tier has $k \geq 6$, so it is also visible at 8-bit, where it becomes a large outlier that wrecks clean accuracy (the outlier-amplifier mechanism of On Mitigating Random and Adversarial Bit Errors and FT-ClipAct: Resilience Analysis of Deep Neural Networks and Improving their Fault Tolerance using Clipped Activation). Low-tier-only activation therefore requires a training-assisted variant, in the spirit of TBA's joint optimization, that camouflages a base-plane flip with compensating refinement bits: the 8-bit function stays clean, truncation strips the camouflage, and the poisoned base emerges. Third, defense must become tier-exhaustive: a single-tier audit of the shipped file cannot see refinement-plane sleepers by construction, and the leading quantization-backdoor defense, EFRAP, is built entirely on round-to-nearest mechanics that floor-based nested systems deliberately abandon Nearest is Not Dearest: Towards Practical Defense against Quantization-conditioned Backdoor Attacks.
A further twist makes the defense harder, not easier, than it sounds: TruncQuant keeps the first and last layers at higher bit-widths for stability, so even a full downgrade to int2 leaves refinement planes alive at the network boundaries — the sanitization-by-truncation instinct fails exactly where nested systems need it most TruncQuant: Truncation-Ready Quantization for DNNs with Flexible Weight Bit Precision.
Research Program
The program has three parts. The first is a characterization study: given a nested-quantized network (trained with TruncQuant's floor function $q_t(W;n) = \lfloor (M_n+1)W \rfloor$ on ResNets, or MatQuant's multi-width joint training on LLMs), map which bit positions, layers, and weight magnitudes are tier-conditionally vulnerable. This extends progressive bit search Bit-Flip Attack: Crushing Neural Network With Progressive Bit Search with a per-tier attack-success and clean-accuracy objective, and it will also test an open question raised by the tension between attack and defense work: QURA injects backdoors by bending round-to-nearest decisions Rounding-Guided Backdoor Injection in Deep Learning Model Quantization, and EFRAP defends by bending them back — under floor quantization there is no rounding choice to bend, so we will measure whether the prefix property confers structural immunity to rounding-guided injection while simultaneously exposing new single-flip sensitivities at floor bin edges. The file contains no reported result on Lacuna for either question.
The second part builds the two attack primitives. The refinement-plane sleeper needs no training access: it is TBT's Trojan Bit Search with the search space masked to planes $k < 8-n_{\text{low}}$ and a trigger optimized for the high-tier model, evaluated under the realistic hardware threat of RowHammer-style memory writes TBT: Targeted Neural Network Attack With Bit Trojan. The camouflaged low-tier trojan is the harder, more interesting object: following TBA's $\ell_p$-Box ADMM formulation One-bit Flip is All You Need: When Bit-flip Attack Meets Model Training, we jointly optimize the weight codes so that one (or few) base-plane flips leave the 8-bit function within $\varepsilon$ of the released model while the 2-bit truncation contains the backdoor. Its feasibility is genuinely uncertain — that uncertainty is the research question, and the impossibility argument above says it cannot be done without this kind of code-level co-design.
The third part is defense: a tier-exhaustive auditing procedure that runs anomaly inversion at every tier the file can execute, with the positional lemma used to allocate budget (planes $k < 8-n$ need not be searched when auditing tier $n$), plus a measured account of truncation-based sanitization — what downgrade cost in clean accuracy buys in removed attack surface, including the boundary-layer blind spot. This is motivated, not contradicted, by the evidence that compression can break backdoor defenses rather than fix them Quantization Blindspots: How Model Compression Breaks Backdoor Defenses] and that dormant capacity is where backdoors live Fine-Pruning: Defending Against Backdooring Attacks on Deep Neural Networks — bitplane truncation is a form of pruning, and we will measure whether it prunes trojans or merely hides them.
Proposed Experiments
Vision track: ResNet-18 on CIFAR-10, SVHN, and ImageNet, and ResNet-50 and VGG-16 on ImageNet and Tiny-ImageNet, matching the evaluation sets of TBT, SOLEFLIP, TBA, and TruncQuant. Each model is trained once as a nested int8/int4/int2 model with the prefix property. Metrics are per-tier attack success rate, per-tier clean accuracy, bits flipped, cross-tier ASR leakage (ASR in non-target tiers), and audit detection rates. The LLM track applies the same protocol to MatQuant-style models on Gemma-2 2B and Mistral 7B with the downstream suite (ARC, BoolQ, HellaSwag, PIQA, Winogrande) and C4 perplexity, with triggers in the style of continuous prompt attacks BadPrompt: Backdoor Attacks on Continuous Prompts and a SOLEFLIP-style single flip in the output layer. The decisive checks are: the sleeper trojan achieves high ASR at the target high tier with near-zero ASR at all truncated tiers and a bit budget comparable to the static-precision baselines; the camouflage trojan achieves the reverse, or the optimization provably stalls, which would itself establish a structural asymmetry worth reporting; and tier-exhaustive auditing catches planted trojans that a single-tier audit at the ship tier misses by construction, at a measured compute multiple that positional budget allocation reduces.
Baselines
The naive reference point is the unprotected nested model with no audit: any successful attack trivially beats it, but it calibrates per-tier clean accuracy, which TruncQuant reports as nearly fully recovered from 8-bit down to 2-bit on ImageNet with ResNet-50, against a 67.74% accuracy collapse under naive truncation TruncQuant: Truncation-Ready Quantization for DNNs with Flexible Weight Bit Precision. The strongest attack competitor is SOLEFLIP, which flips exactly one bit in the final classification layer of a static int8 model and reports up to 99.9% attack success rate, averaging 98.9%, with 0.0% average benign accuracy degradation across CIFAR-10, SVHN, and ImageNet Backdoor Attacks on Neural Networks via One-Bit Flip. We will re-run SOLEFLIP's released pipeline on our nested models with the same architectures, data, and trigger-optimization budget, so the comparison isolates plane placement rather than search quality. TBT is the second attack baseline: 92% ASR with 84 bits out of 88 million on CIFAR-10 ResNet-18, and 99.98% ASR with 150 modifications on ImageNet TBT: Targeted Neural Network Attack With Bit Trojan. TBA is the baseline for the training-assisted arm: 100% ASR with 1.0–1.2 flipped bits on average and under 1% clean drop One-bit Flip is All You Need: When Bit-flip Attack Meets Model Training. Beating these means matching their potency at their bit budget while adding tier selectivity they cannot express: cross-tier ASR leakage below 5% at equal or better target-tier ASR and clean-accuracy cost. On the defense side, the strongest existing method is EFRAP, which reports reducing quantization-conditioned backdoor success from nearly 100% to below 2% while keeping clean accuracy within 1–2%, using 1% unlabeled data and about 7 minutes for a ResNet-18 on one consumer GPU Nearest is Not Dearest: Towards Practical Defense against Quantization-conditioned Backdoor Attacks]; we will run it with the same data and compute allowance, expecting it to be inapplicable or ineffective under floor quantization, and our tier-exhaustive audit must beat per-tier Neural Cleanse at the ship tier on cross-tier detection at a stated compute multiple. The key ablation runs the identical attack with the search space restricted to base planes versus refinement planes at the same bit budget: this isolates plane placement — the proposal's one new ingredient — as the cause of any tier-selectivity.
Why not just…?
Why not just run standard bit-flip attacks on three separate single-precision models? This misses the phenomenon entirely. The deployment regime that motivates multi-precision sharing is a single physical tensor truncated at runtime; a flip in DRAM lives in that one tensor, and its effect on the executing function changes with the active tier. Separate int2, int4, and int8 files cannot exhibit tier-conditional dormancy, and they forfeit the storage savings that motivate the architecture — TruncQuant reports a 3.53× storage saving over flexible-precision methods that keep separate representations TruncQuant: Truncation-Ready Quantization for DNNs with Flexible Weight Bit Precision. We will still run this baseline, and expect it to match per-tier potency while showing zero selectivity, which is precisely the point.
Why not just use data-poisoned quantization backdoors or adversarial contrastive learning to get precision-dependent behavior? These are real competitors for the behavior, not the threat model. The poisoning attack of Huynh et al. needs training-data access, activates across the float-to-int8 boundary rather than at an attacker-chosen tier of a nested code, and degrades at scale — they report ASR dropping to roughly 81% on ImageNet-10, versus 91% on CIFAR-10 and CelebA Data Poisoning Quantization Backdoor Attack. ACL achieves bistable LLM behavior (97.69% jailbreak ASR on quantized Llama-3.2-3B) but requires end-to-end contrastive fine-tuning Adversarial Contrastive Learning for LLM Quantization Attacks. Our sleeper trojan needs neither: it is a post-deployment memory write, data-independent, in the RowHammer threat model of TBT. For the low-tier camouflage variant, where we do assume code-level training access, ACL and TBA are honest competitors, and the experiments will compare them directly on selectivity per bit flipped.
Why not just apply EFRAP or run Neural Cleanse at every tier? Running Neural Cleanse at every tier is not an alternative to our defense — it is our defense's baseline, and the open questions are its cost and whether anomaly inversion even flags a tier-conditional trojan, given that QURA already keeps Neural Cleanse and TED anomaly indices below detection thresholds in the static setting Rounding-Guided Backdoor Injection in Deep Learning Model Quantization. EFRAP is a genuine threat to the claim that defense is hard, but its mechanism — flipping nearest-rounding directions on high-error neurons — has no purchase on floor-based prefix quantization, where there is no rounding decision to flip; we will test this empirically rather than assert it, since no reported result exists on Lacuna for EFRAP under floor quantization.
Why not just clip activations to neutralize outlier weights? Activation clipping blunts the outlier-amplifier mechanism behind destructive bit flips FT-ClipAct: Resilience Analysis of Deep Neural Networks and Improving their Fault Tolerance using Clipped Activation, but a static threshold calibrated for 8-bit inference is mis-scaled for 2-bit tiers, where quantization bin widths and weight dynamic ranges change with $n$; and SOLEFLIP-style attacks place the flip in the final classification layer, upstream of any clipping. We will run per-tier calibrated clipping as an ablation and expect it to either miss the corruption or cost clean accuracy; if it turns out to suffice for the sleeper trojan, that is a finding we will report, since it would mean the new attack surface is cheaply closed.
Decisive Checks
The proposal stands or falls on three numbers: sleeper-trojan cross-tier ASR leakage (target: below 5% at high target-tier ASR with a SOLEFLIP-scale bit budget), the feasibility or provable stall of the LSB-camouflaged low-tier trojan, and the detection gap between single-tier and tier-exhaustive auditing on planted refinement-plane trojans. Each is measured on benchmarks with published reference points — SOLEFLIP's 98.9% average ASR at one bit, TBT's 92% at 84 bits on CIFAR-10, MatQuant's int2 gains of 4–7% on Gemma-2 and Mistral — so any result we report can be read directly against the existing record.
References
- TruncQuant: Truncation-Ready Quantization for DNNs with Flexible Weight Bit Precision
- Any-Precision LLM: Low-Cost Deployment of Multiple, Different-Sized LLMs
- AdaBits: Neural Network Quantization With Adaptive Bit-Widths
- Matryoshka Quantization
- Bit-Flip Attack: Crushing Neural Network With Progressive Bit Search
- Corrosion Hammer: A Self-Activated Bit-Flip Attack to the Processing-In-Memory Accelerator
- TBT: Targeted Neural Network Attack With Bit Trojan
- Backdoor Attacks on Neural Networks via One-Bit Flip
- One-bit Flip is All You Need: When Bit-flip Attack Meets Model Training
- Data Poisoning Quantization Backdoor Attack
- Adversarial Contrastive Learning for LLM Quantization Attacks
- Bit Error Robustness for Energy-Efficient DNN Accelerators
- FT-ClipAct: Resilience Analysis of Deep Neural Networks and Improving their Fault Tolerance using Clipped Activation
- Nearest is Not Dearest: Towards Practical Defense against Quantization-conditioned Backdoor Attacks
- Rounding-Guided Backdoor Injection in Deep Learning Model Quantization
- Quantization Blindspots: How Model Compression Breaks Backdoor Defenses
- Fine-Pruning: Defending Against Backdooring Attacks on Deep Neural Networks
- BadPrompt: Backdoor Attacks on Continuous Prompts