Neural controllers for large networks of interacting systems, such as vehicle platoons, drone formations and microgrids, can now come with stability proofs that scale. Each subsystem carries a small learned certificate: a local "energy" function showing that its state stays bounded as long as its neighbors' states and outside disturbances stay bounded. When these local certificates satisfy a network-wide condition on how strongly neighbors influence each other, the whole network is provably stable at any size. Every such proof assumes the controllers run in exact floating-point arithmetic. The point of these methods, though, is deployment on many small, cheap nodes, and those nodes will run quantized low-bit integer controllers. Once quantized, the proof no longer covers the controller that actually runs.
We propose to treat rounding error as one more bounded disturbance entering each subsystem's certificate, and to choose bit-widths for every layer of every node's controller by solving a single integer program. In that program the network's own stability certificate supplies the constraints, replacing the usual hand-made sensitivity score. Mixed-precision quantization assigns different bit-widths to different layers, normally by solving a knapsack problem over per-layer sensitivity scores. Our version yields allocations that are guaranteed to preserve practical stability, meaning convergence to a known small ball, under per-node hardware budgets. The coupling between nodes is handled exactly through the certificate's interconnection gains, so the method no longer has to assume that quantization errors in different places add up independently. We then test whether these guarantees mean anything in practice by measuring how far observed trajectories fall inside the certified bounds, in simulation and on small hardware.
Core Claim
A quantized networked controller can be certified, and its bit allocation optimized, with one linear integer program. The program is sound by construction and coupled across nodes only through quantities the compositional certificate already provides.
The construction has three steps. First, suppose each node $i$ has a learned input-to-state stability (ISS) certificate whose asymptotic bound obeys $\bar v_i \le \sum_j \Gamma_{ij}\bar v_j + g_i d_i$. Here $\bar v_i$ is the eventual level of node $i$'s certificate, $\Gamma_{ij}\ge 0$ is the gain from neighbor $j$, $g_i$ is the gain from node $i$'s disturbance, and $d_i$ bounds the extra input caused by quantizing node $i$'s controller. If the spectral radius of $\Gamma$ is below one (the small-gain condition), the network's eventual levels satisfy $\bar v \le M d$, where $M=(I-\Gamma)^{-1}\mathrm{diag}(g)$ is entrywise nonnegative.
Second, the rounding error of a quantized feedforward controller can be soundly over-bounded over the certified region of states. The bound is a sum over layers: each layer's bit-dependent rounding error is multiplied by the Lipschitz bound of the layers after it. This gives $d_i \le \sum_{l,b} c_{i,l,b}\,x_{i,l,b}$, where $x_{i,l,b}\in\{0,1\}$ selects bit-width $b$ for layer $l$ of node $i$ and $c_{i,l,b}$ is the precomputed error contribution. The additivity that standard mixed-precision methods assume is derived here as an upper bound.
Third, both pieces are linear, so the allocation problem is
$$\min_x \sum_{i,l,b} C_{i,l,b}\,x_{i,l,b} \quad \text{s.t.} \quad \sum_j M_{ij}\sum_{l,b} c_{j,l,b}\,x_{j,l,b} \le r_i \;\;\forall i,\qquad \sum_{l,b} C_{i,l,b}\,x_{i,l,b}\le B_i \;\;\forall i,\qquad \sum_b x_{i,l,b}=1.$$
In this program, $C_{i,l,b}$ is the memory or bit-operation cost, $r_i$ is the tolerated eventual bound at node $i$, and $B_i$ is node $i$'s hardware budget. A node whose errors are amplified by many downstream neighbors (large column sums of $M$) automatically receives more bits. A decoupled per-node allocation cannot do this. The same machinery also returns a yes-or-no certificate for any fixed allocation, including the plain uniform 8-bit integer (INT8) choice.
Relation to Prior Work
Two strands supply the method. The first is compositional neural certification. Compositional Neural Certificates for Networked Dynamical Systems (NeurISS) learns local ISS Lyapunov functions and controllers, shares weights across identical nodes, and scales zero-shot from 4 or 5 agents to 100. Neural Vector Lyapunov–Razumikhin Certificates for Delayed Interconnected Systems extends this to communication delays, with verification time flat at about 380 seconds from 10 to 50 agents. Both run in full precision and are tested only in simulation. We reuse their certificates and gains and add finite word length as a disturbance channel.
The older dissipativity line, Compositional stability analysis based on dual decomposition and Distributed Synthesis of Local Controllers for Networked Systems with Arbitrary Interconnection Topologies, shows why the global condition separates into local pieces plus boundary terms. That separation is what keeps our integer program linear.
The second strand is knapsack-style mixed precision. Integer Programming for Mixed Precision Bit Allocation, OMPQ and GMPQ-TE solve allocation in seconds or less from proxy scores such as quantization-aware-training scale factors, orthogonality or topological entropy. All three target feedforward vision models and assume additive, independent layer errors. We keep their solver formulation but replace the proxy score with a sound error bound, and we replace the single budget with network-coupled stability constraints.
The closest work is Quantizing Time-Series Models As Dynamical Systems: Trajectory-Based Quantization Sensitivity Score (TQS). It motivates the proposal by showing that quantization error compounds over autoregressive rollouts, and that dynamics-aware knapsack allocation avoids the collapse of uniform 4-bit quantization. TQS measures divergence empirically under Gaussian perturbation, quantizes one monolithic model, and gives no guarantee. We differ on all three counts: we quantize many interacting controllers, use a worst-case bound, and output a certificate.
Two works constrain the design. Learning Neural Koopman Operators with Dissipativity Guarantees shows that post-hoc matrix-inequality corrections built from Lipschitz and error bounds work but add visible conservatism. This is a warning that our Lipschitz-based rounding bound may be loose, so we measure its tightness explicitly. Formal Verification of Neural Certificates Done Dynamically shows that static verification of deep certificates can time out after two hours while runtime monitoring costs under 16 ms per step. We therefore use runtime monitoring as an independent empirical check on the deployed quantized system, not as the source of the guarantee.
Research Program
The first stage builds the bound. For each controller architecture used in NeurISS-style benchmarks, we compute $c_{i,l,b}$ for candidate bit-widths of 2, 4, 6, 8 and 16. We combine interval propagation of weight and activation rounding error with layer-wise Lipschitz bounds over the certified region, and compare against a cheaper pure-Lipschitz version. NeurISS gains are in general nonlinear comparison functions, so we either train certificates with linear gains or fit linear upper bounds on the bounded certified region. We report the conservatism this costs.
The second stage builds the integer program, with per-node budgets that may differ across nodes, as with nodes on different chips. An extension adds the precision of messages exchanged between neighbors as additional decision variables. Quantized neighbor states also enter the certificate as bounded disturbances, so computation bits and communication bits share one budget.
The third stage is the empirical-validation component. We deploy the quantized controllers, measure observed eventual bounds against the certified radii $r_i$, and run the dynamic monitor of Formal Verification of Neural Certificates Done Dynamically on the quantized certificate conditions along trajectories. If the platform allows, a final step runs a certified quantized formation controller on Crazyflie 2.1 quadrotors. That is the same hardware GCBF+ used for its unquantized barrier-function swarm.
Baselines
The do-nothing reference is the full-precision NeurISS controller and certificate from Compositional Neural Certificates for Networked Dynamical Systems. It sets the tracking-error floor, and its own reported advantage is up to 75% lower tracking error than PPO and MAPPO across platooning, drone and power-grid tasks. No reported result on quantized versions of these controllers was found on Lacuna. A quantized controller counts as successful if its tracking error stays within a few percent of this floor while also carrying a certificate.
The naive deployment baseline is uniform INT8 post-training quantization of every node's controller. It is what any embedded toolchain does by default, and for controllers this small it may be entirely adequate. We run it on identical certificates and trajectories, and also pass it through our certification check. Our method beats it only if it reaches lower memory at equal certified bound, or certifies where uniform low-bit choices cannot. Uniform 4-bit quantization is included as the aggressive counterpart.
The strongest existing allocation method is a TQS-style allocator. Following Quantizing Time-Series Models As Dynamical Systems: Trajectory-Based Quantization Sensitivity Score, it scores each layer by finite-time divergence of closed-loop rollouts under perturbation and solves a per-node multiple-choice knapsack at the same memory budgets. TQS reports about 4x compression with under 1% degradation on TimesFM-2.5, but no reported result was found on Lacuna for TQS applied to networked controllers. The allocator receives the same rollout data and the same number of sensitivity evaluations as we spend computing bounds. We beat it if, at matched total and per-node budgets, our allocation gives lower worst-node tracking error or fewer certificate violations. The comparison matters most in large and heterogeneous networks.
The key ablation keeps our sound error bounds but drops the coupling matrix $M$, constraining each node's own disturbance separately. This isolates whether network-aware allocation, rather than the bound itself, drives any gain. A second ablation adds certificate-loss quantization-aware retraining under uniform bit-widths, which tests whether retraining alone closes the gap.
Why not just…?
Why not just use uniform INT8? This is a real threat. Networked controllers are small, so memory savings below 8 bits may matter little on many nodes, and INT8 may already cause negligible error. We do not argue around this. Our certification step applies to uniform INT8 too, so even in the case where INT8 is sufficient the proposal delivers something new: a proof that the INT8 network is stable with a stated bound. The mixed-precision claim is only claimed where the experiments show it. That would be tight-budget nodes, sub-8-bit communication links, and long-horizon settings, where TQS found uniform 4-bit causing collapse in a related autoregressive setting.
Why not just allocate bits per node with an empirical sensitivity score, as TQS does? Per-node scores ignore that one node's error is amplified by its downstream neighbors, which is exactly the decoupling failure that interconnected systems invite. The decoupled ablation and the TQS-style baseline test this directly. We also construct adversarial cases, such as a long platoon with a weakly damped tail, where a node looks robust locally but sits on a high-gain path. If decoupled allocation matches ours there as well, we will report that coupling is unnecessary in practice.
Why not just retrain the controller to be robust to quantization noise? Quantization-aware training changes the weights, while allocation decides where bits go, so the two are complementary rather than competing. Retraining also yields no certificate unless the bound is recomputed afterward. We include retraining at uniform bit-widths as an ablation and retraining plus our allocation as a combined variant. If retraining alone already certifies at 4 bits, the contribution narrows to verification, and we will say so.
Why not just treat quantization as a generic bounded disturbance in a robust-control design? That is essentially our model, but done with a single worst-case disturbance level per network. The Koopman dissipativity results in Learning Neural Koopman Operators with Dissipativity Guarantees suggest such blanket bounds become conservative quickly. Our program makes the disturbance a decision variable per layer and per node, and the tightness measurements show how much this buys.
Proposed Experiments
The benchmarks are the simulated connected-vehicle platoon, drone formation and microgrid voltage tasks used by NeurISS and the Razumikhin work. Networks are trained at 4 or 5 nodes and evaluated at 10, 50 and 100. Per-node budgets are homogeneous in one setting; in another, half the nodes get a quarter of the budget. Metrics are tracking error (mean and worst node), certified eventual bound per node, observed eventual bound, fraction of runs certified, total and per-node memory and bit operations, allocation solve time, and the frequency with which the runtime monitor flags violated certificate conditions.
There are four decisive checks. The first is soundness: no observed trajectory may exceed its certified bound under nominal and worst-case-bounded disturbances. A single violation means the bound or its derivation is wrong. The second is tightness: the ratio of certified to observed bound, reported per bit-width. A ratio far above ten at the bit-widths of interest would mean the guarantee is too conservative to guide allocation, and we would shift effort to sharper interval bounds. The third is the coupling test: at matched budgets, compare worst-node error and certification rate of the coupled program against the decoupled ablation and the TQS-style baseline, as network size and heterogeneity grow. The proposal's central bet is that the gap widens with both. The fourth, if hardware access permits, runs the certified allocation and uniform INT8 on Crazyflie 2.1 formation flight and compares observed formation error against the simulation's certified bounds. This tells us whether the simulated guarantee holds on real hardware with real timing and real disturbances.
References
- Compositional Neural Certificates for Networked Dynamical Systems
- Neural Vector Lyapunov–Razumikhin Certificates for Delayed Interconnected Systems
- Compositional stability analysis based on dual decomposition
- Distributed Synthesis of Local Controllers for Networked Systems With Arbitrary Interconnection Topologies
- Mixed-Precision Neural Network Quantization via Learned Layer-Wise Importance
- OMPQ: Orthogonal Mixed Precision Quantization
- Efficient and Generalizable Mixed-Precision Quantization via Topological Entropy
- Quantizing Time-Series Models As Dynamical Systems: Trajectory-Based Quantization Sensitivity Score
- Learning Neural Koopman Operators with Dissipativity Guarantees
- Formal Verification of Neural Certificates Done Dynamically
- GCBF+: A Neural Graph Control Barrier Function Framework for Distributed Safe Multiagent Control