Compute-Constrained Safety Filters with Neuromorphic Event Triggering

summary

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,

In short

The proposed dual-LIF controller uses separate safety and performance states to schedule CBF-filter computations under delayed input application. This guarantees robust forward invariance, completeness, and non-Zeno execution for linear systems with nonzero computation time. It achieves this by coupling the safety threshold to residual growth bounds.

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 used across episodes

Reinforcement Learning (RL) — explained in 25 episodes
Retrieval-Augmented Generation (RAG) — explained in 16 episodes
Interpretability — explained in 15 episodes
Sample Complexity — explained in 15 episodes
Federated Learning — explained in 14 episodes
Generalization — explained in 13 episodes

This episode discusses

The paper

Compute-Constrained Safety Filters with Neuromorphic Event Triggering · Read on arXiv

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

University of Florida

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.

More episodes

← Home