Compute-Constrained Safety Filters with Neuromorphic Event Triggering

arXiv:2610.10797 · eess.SY, cs.SY, math.OC · Submitted 2026-10-07 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.

Rosa: Today's paper: "Compute-Constrained Safety Filters with Neuromorphic Event Triggering".

Dev: The gist The proposed dual-LIF controller uses separate safety and performance states to schedule CBF-filter computations under delayed input application, guaranteeing robust forward invariance, completeness,

Rosa: First, who's behind it and why it matters.

Title and authors: Rosa: So, diving into the title and authors for "Compute-Constrained Safety Filters with Neuromorphic Event Triggering," what’s the actual focus here?

Dev: It's about a safety filter that uses a dual leaky integrate-and-fire mechanism to handle situations where solving the necessary quadratic programs takes non-zero time.

Taro: I see it as them trying to bridge the gap between theoretical safety guarantees from control barrier functions and the practical reality of having finite computation latency in real systems.

Rosa: It seems like they’re addressing a known issue where if you wait for the perfect solution, by the time you have it, the system state might have changed too much to be safe.

Dev: They are developing two LIF states that monitor both a shifted CBF residual and how much the input we're holding deviates from what we ideally want to apply.

The paper's summary: Rosa: So, if we look at the summary of "Compute-Constrained Safety Filters with Neuromorphic Event Triggering," what’s the main mechanism they are proposing?

Dev: They set up two LIF states, a safety one and a performance one, and they initiate a computation when either of those states hits its threshold.

Taro: It sounds like an event-triggered system where the trigger isn't just based on how much things have changed, but also on whether we’re drifting away from our target control law.

Rosa: And they handle the delay by making sure that when a solution is found, even if it arrived early, it gets held until the scheduled application time.

Dev: They use a closed-form charging profile to connect the safety filter threshold directly to how fast things are growing in the residual, which ensures there’s enough margin over that application delay.

The paper's improvements: Rosa: Now, what are some of the specific ways they improved this approach? What makes this better than just using a standard safety filter?

Dev: One big improvement is that they explicitly account for the evolution of the system state between when you start computing and when you actually apply the input.

Taro: That requires tightening the constraint itself by some margin delta greater than zero, specifically defining this as δfeas, which is the minimum value where a uniform tightening is still possible.

Rosa: So they define this tightened set Kδrcbf(x) and then look for an optimal value function V* to find the best control within that tighter boundary.

Dev: They also introduce an event-triggering mechanism based on two specific thresholds, ∆s for safety and ∆p for performance, where the safety threshold is set so that computation starts no later than when the residual hits a certain level.

Conclusion: Rosa: So we’re wrapping up. The big picture here seems to be that this dual-LIF architecture handles non-zero computation time in CBF filtering and guarantees forward invariance, completeness, and non-Zeno execution.

Dev: That means the system stays safe, completes its task, and doesn't get stuck in an infinite loop of computing when it shouldn't be doing so.

Taro: It shows that by coupling the safety threshold to residual growth bounds, you can ensure computation starts early enough to beat the time delay, which is crucial for real-world deployment.

Rosa: So, this paper "Compute-Constrained Safety Filters with Neuromorphic Event Triggering" gives us a way to make these complex safety checks practical in systems that have real processing limits.

Dev: It’s a solid framework for when you need robust forward invariance under computation delay and event-triggered updates.

Taro: I think the implication is that we can design more reliable autonomous systems because we aren't just assuming instantaneous solutions are available when they aren't.

Tochukwu E. Ogri, Opeyemi Owolabi, Luke Fina, Christopher Petersen, Rushikesh Kamalapurkar

University of Florida

eess.SY, cs.SY, math.OC

Submitted: 2026-10-07

Updated: 2026-10-07

The gist: The gist The proposed dual-LIF controller uses separate safety and performance states to schedule CBF-filter computations under delayed input application, guaranteeing robust forward invariance,

Key concepts

Dual-LIF Controller
This is a core mechanism using two separate leaky integrate-and-fire (LIF) states. One monitors the CBF residual, and the other monitors input deviation from the nominal law. Computation starts when either state hits its threshold, managing safety and performance simultaneously.
Constraint Tightening ($\delta$)
Since computation takes time, the system's constraints must be tightened by a margin $\delta > 0$. This margin accounts for the state evolution between computation initiation and actual input application. The largest feasible tightening is calculated based on the system's bounds.
Event-Triggering Mechanism
Control updates are only performed when specific conditions are met, triggered by two safety/performance LIF states ($\psi_s$ and $\psi_p$). This event-based approach reduces computation frequency by only updating the input when necessary deviations occur.
Hybrid Dynamical System (H)
The closed-loop system is modeled as a hybrid system, defining continuous dynamics (flow map F) and discrete jumps ($G_i, G_a$). These jumps represent the initiation of computations or the application of control inputs, allowing for rigorous analysis of the entire process.

Terminology

Summary

The gist The proposed dual-LIF controller uses separate safety and performance states to schedule CBF-filter computations under delayed input application, guaranteeing robust forward invariance, completeness, and non-Zeno execution

How it works

The core mechanism involves a dual leaky integrate-and-fire (LIF) event-triggered safety filter for linear systems that accounts for nonzero computation time. Two LIF states monitor a shifted CBF residual and the deviation of the held input from the nominal feedback law. A computation is initiated when either LIF state reaches its threshold; the previous input remains applied until the prescribed application time, and any solution returned earlier is stored until then The closed-form charging profile relates the safety-LIF threshold to residual-growth bounds, ensuring sufficient residual margin over the application delay.

Constraint Tightening

To account for the evolution of the system state between computation initiation and input application, the CBF constraint needs to be tightened by a margin δ > 0. The largest uniform feasible tightening is defined as δfeas:= min x∈S max v∈U −r(x, v). For any 0 < δ < δfeas, the δ-tightened admissible control set is defined as Kδrcbf(x):= u ∈ U: r(x, u) ≤ −δ. The optimal value function V∗(x) is defined as min v∈Kδrcbf (x) φ(x, v), and the ϵ-suboptimal solution map is defined as Ψϵ(x):= v ∈ Kδrcbf(x): φ(x, v) ≤ V∗ (x) + ϵ.

Event-Triggering Mechanism

The control input is only updated on an event-triggered basis, with update events also triggered based on the control deviation e(x, u):=∥u − udes(x). The safety and performance LIF states are defined as ψs(x, u):= max 0, r(x, u) + aT + κ and ψp(x, u):= max 0, e(x, u) − utol. A computation is initiated when ξs = ∆s or ξp = ∆p. The safety threshold ∆s is selected to ensure that a computation is initiated no later than the time at which the residual reaches −aT.

Hybrid Dynamical System

The closed-loop system is formalized as a hybrid system H:= (C, F, D, G), where C and D are defined based on idle mode and application-pending mode. The flow map F(z) describes the continuous dynamics in both modes. Jump maps Gi and Ga define initiation jumps (when ξs = ∆s or ξp = ∆p) and application jumps (when τ reaches zero in the application-pending mode). Algorithm 1 selects a jump whenever z ∈ D.

Safety and Execution Guarantees

The analysis establishes that every maximal solution ϕ of H with ϕ(0, 0) ∈ E remains in E and has unbounded ordinary-time domain. The system guarantees robust forward invariance, completeness, and non-Zeno execution. Specifically, the number of computation initiations Ni(t) is bounded by Ni(t) ≤ 1 + t/T + tidle. The spacecraft experiment demonstrated a 94.1% reduction in online QP solves relative to the delay-tightened periodic implementation.

Conclusion

A dual-LIF architecture is developed for CBF safety filtering with nonzero computation time. Coupling the safety-LIF threshold to residual-growth bounds ensures that computation is initiated before the available residual margin is exhausted. Under the stated assumptions, the hybrid closed loop guarantees robust forward invariance, completeness, and non-Zeno execution. The analysis assumes exact state information, a known computation-time bound, and sufficient control authority to satisfy the required tightening.

References

[1] H. Dong, Q. Hu, and M. R. Akella, “Safety control for spacecraft autonomous rendezvous and docking under motion constraints,” J. Guid. Control Dyn., vol 40, no 7, pp 1680–1692, 2017

[3] T. E. Ogri, M. Qureshi, Z. I. Bell, and R. Kamalapurkar, “Safe output-feedback adaptive optimal control of input-constrained control-affine nonlinear systems,” Automatica, vol 193, p 113209, 2026

[8] P. Wieland and F. Allgower, “Constructive safety using control barrier functions,” ¨ IFAC Proc. Vol., vol 40, no 12, pp 462–467, 2007

[9] A. D. Ames, X. Xu, J. W. Grizzle, and P. Tabuada, “Control barrier function based quadratic programs for safety critical systems,” IEEE Trans Autom Control, vol 62, no 8, pp 3861–3876, Aug 2017

[10] A. D. Ames, S. Coogan, M. Egerstedt, G. Notomista, K. Sreenath, and P. Tabuada, “Control barrier functions: Theory and applications,” in Eur Control Conf., 2019

[13] P. Mestres, S. S. Mousavi, P. Ong, L. Yang, E. Das, J. W. Burdick, and A. Dames, “Explicit control barrier function-based safety filters and their resource-aware computation,” arXiv:2512.

Improvements for AI systems

  1. Bold Header: Dual-LIF Event-Triggered Safety Filter

The improved system can enforce robust forward invariance for spacecraft terminal-approach dynamics under computation delay by initiating control input updates only when either a safety residual or a performance deviation reaches a threshold, as defined by A computation is initiated when either LIF state reaches its threshold.

  1. Bold Header: Reduced QP Solve Frequency

The AI system will significantly reduce the computational load by achieving substantial reductions in optimizer calls, specifically demonstrating a 94.1% reduction relative to TP-CBFQP in the spacecraft terminal-approach experiment while maintaining safety and performance constraints.

  1. Bold Header: Guaranteed Non-Zeno Execution

The hybrid closed-loop model guarantees non-Zeno execution, ensuring that the system avoids infinite computation cycles by establishing positive lower bounds on computation-initiation and input-application times.

  1. Bold Header: Delayed Input Robustness

The filter explicitly accounts for computation delay, ensuring that even when a solution is returned earlier than requested, it is retained until the prescribed application time, which prevents the previously applied input from being unsafe during its holding interval.

  1. Bold Header: Performance-Driven Event Triggering

By using two LIF states—one for safety and one for performance—the system can trigger updates based on both safety residuals and control deviation, allowing it to manage performance degradation by ensuring updates are requested far enough away from the boundary of S to ensure safety in spite of a piecewise constant control signal.

Sources

Related papers