Feasibility and Explicit Safety Filters for Control Barrier Functions in Linear Systems

arXiv:2604.04235 · eess.SY, cs.SY, math.OC · Submitted 2026-04-05 · Read on arXiv

Listen

Transcript

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

Rosa: Today's paper: "Feasibility and Explicit Safety Filters for Control Barrier Functions in Linear Systems".

Dev: Safety filters based on control barrier functions (CBFs) and high-order control barrier functions (HOCBFs) are often implemented through quadratic programs (QPs), but feasibility certification can be difficult,

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

Title and authors: Dev: So, let's start with the title and who came up with this work. The paper is titled "Feasibility and Explicit Safety Filters for Control Barrier Functions in Linear Systems," written by Shima Sadat Mousavi, Max H. Cohen, Pol Mestres, and Aaron D. Ames.

Rosa: Indeed. The title itself tells you right away that the focus isn't just on making the safety filters work, but fundamentally understanding when they *can* work—the feasibility part—and then finding explicit ways to write them down instead of relying on a general solver.

Taro: I find it interesting that this paper focuses on linear time-invariant systems with affine constraints. That’s a specific class, and understanding the geometry of those constraint normals is what seems to be the key mechanism here.

Dev: It seems they are leveraging that geometric structure—the constant normals and state-affine offsets—to characterize the feasibility domain for these control barrier functions very precisely.

Rosa: Precisely. They're moving beyond just saying "this might work" to providing a mathematical condition, based on things like lambda d(x)b zero for certain vectors lambda, which tells us exactly when the set of possible inputs is non-empty <ref:2604.04235#pg0>.

Taro: That formal characterization sounds powerful because it gives us a concrete mathematical tool we can use to analyze our system's safety properties before deployment.

Dev: But I’m still thinking about the implementation side; what does this geometric understanding actually translate into for a control engineer who needs sub-millisecond loop rates?

Rosa: Well, the paper shows that in specific structured cases, they can replace the complex QP with explicit saturation laws, which are just simple mathematical functions that saturate inputs within defined bounds.

The paper's summary: Rosa: Now let’s go over what the paper actually summarizes for us regarding these safety filters. Essentially, they take the standard approach where you use control barrier functions to enforce affine state constraints, which usually ends up with a quadratic program that we have to solve at every time step.

Dev: And their summary is that this QP approach has a major flaw: certifying feasibility before solving it is hard, and if the state moves, feasibility can be lost entirely, which means the filter might fail spectacularly.

Taro: So they are proposing a method that doesn't just try to solve the QP; they analyze the underlying geometry of how those constraints are defined and use that structure to find conditions for feasibility.

Rosa: Exactly. They characterize feasibility by looking at the constraint normals, and then they identify specific structures, like parallel constraints, where this characterization becomes much more explicit and tractable.

Dev: That’s a big step because it means instead of relying on a general QP solver that might time out or fail to converge under tight real-time constraints, we can use these structural insights to predict safety.

Taro: I wonder how this applies when the system itself is changing dynamically; if the world misbehaves and pushes the state into an unsafe region, does this characterization still hold up?

Rosa: The paper shows that by exploiting those structures—like parallel normals—they can derive closed-form safety filters, which means we get a direct control law without any online optimization running.

The paper's improvements: Dev: Moving on to the actual improvements they propose, the main advantage is replacing the computationally intensive quadratic program with explicit closed-form safety filters in structured scenarios.

Rosa: That’s huge for real-time systems because it removes the need for continuous online optimization, offering a simple alternative to whatever solvers we usually have to run.

Taro: The paper points out that they handle both unbounded and bounded input sets U when characterizing feasibility, which is important because actuators always have limits in the physical world.

Dev: They also provide explicit formulas for specific cases, like when dealing with parallel constraints or independent interval blocks, where the filter simplifies down to componentwise saturation laws in transformed coordinates.

Rosa: That means instead of a complex optimization problem that yields an input u(x), we get a simple formula like u(x) = u d(x) + epsilon(x) - epsilon d(x) or componentwise saturation, which is way more robust.

Taro: The improvement in handling the bounded-input case by decoupling it coordinatewise seems particularly useful for complex systems where we have many interacting constraints.

Conclusion: Rosa: So, to wrap up our discussion on "Feasibility and Explicit Safety Filters for Control Barrier Functions in Linear Systems," the main point is that exploiting the geometry of constraint normals allows us to characterize feasibility exactly, and in structured cases, we derive explicit safety filters.

Dev: That means we can move away from relying on general QP solvers for real-time input modification toward using simple saturation laws when the system structure permits it.

Taro: From an autonomy view, this provides a mathematical foundation to prove safety over the entire feasible state space by analyzing these geometric constraints rather than just testing points.

Rosa: It gives us a much better way to understand when our nominal control strategy is safe, even under actuator limits defined by polyhedral constraints.

Dev: I think the real impact is in deployment; having a verifiable, explicit filter means we can trust it more for high-frequency operation where latency and failure modes are critical concerns.

Taro: I just hope that the applicability to highly complex, non-structured systems expands beyond these initial structured cases in future work.

Rosa: Well, that’s all for this deep dive into the paper; we’ll be back next week to discuss how this relates to those papers on failure-boundary learning and operational data fidelity.

California Institute of Technology · North Carolina State University

eess.SY, cs.SY, math.OC

Submitted: 2026-04-05

Updated: 2026-10-06

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 82/100

The gist: Safety filters based on control barrier functions (CBFs) and high-order control barrier functions (HOCBFs) are often implemented through quadratic programs (QPs), but feasibility certification can be

Key concepts

Control Barrier Functions (CBFs): CBFs are mathematical functions used to ensure a system stays within a safe region by defining conditions on the control input. They are central to creating safety filters that guarantee the system's state remains safe, often implemented via quadratic programs.
Quadratic Programs (QPs): QPs are optimization problems where you minimize a quadratic cost function subject to linear constraints. In this context, they are used to find the optimal control input that satisfies both system dynamics and safety constraints defined by CBFs.
Constraint Normals Geometry: This refers to the geometric properties of the vectors that define the boundaries of the affine safety constraints. By understanding how these constraint normals relate to each other—such as whether they are parallel or form independent blocks—the paper can determine if a solution (a feasible set) exists without solving a full optimization problem.
Explicit Safety Filters: These are direct, closed-form control laws that replace the need for online optimization (like QPs). When constraints have simple structures, the paper derives these explicit filters. They are much faster and simpler to compute than general QPs but only work when the system has specific geometric properties.

Terminology

Control Barrier Functions (CBFs) — 3× in this paper · explained in 4 episodes
Decoupling — 2× in this paper · explained in 2 episodes
Core — 1× in this paper · explained in 2 episodes
Failure Modes — 1× in this paper · explained in 3 episodes
Fidelity — 1× in this paper · explained in 2 episodes
Hybrid System — 1× in this paper · explained in 2 episodes
Robustness — 1× in this paper · explained in 5 episodes

Summary

Safety filters based on control barrier functions (CBFs) and high-order control barrier functions (HOCBFs) are often implemented through quadratic programs (QPs), but feasibility certification can be difficult, especially with multiple constraints, as feasibility may be lost as the state evolves. This paper addresses this issue for linear time-invariant (LTI) systems with affine safety constraints by exploiting the resulting geometry of constraint normals to characterize feasibility and derive explicit safety filters in structured cases.

Problem Formulation

The paper considers an LTI system with dynamics defined by x˙ = Ax + Bu, subject to affine state constraints hi(x) = a⊤i x − bi ≥ 0 for i = 1,..., p. To enforce these constraints using HOCBFs, the admissible set S is defined by a sequence of inequalities (3). Under standard enforcement, this leads to an auxiliary optimization problem (6)–(7) involving minimizing a quadratic cost subject to Mu ≤ d(x) and u ∈ U. The core challenge is understanding the feasibility domain Xfeas =

Xfeas =

where F(x) ≠ ∅, which depends on the geometry of the constraint normals in (5).

Feasibility Domain Characterization

The general feasibility condition for constraints (9) is characterized by Proposition 2: Constraints (9) are feasible if and only if λ⊤d(x)b ≥ 0, for every λ ∈ R p+q ≥0 satisfying: λ⊤M Q = 0. However, the paper exploits the structure arising from LTI systems with affine safety functions, where constraint normals have constant normals and state-affine offsets. This structure allows for more explicit characterization.

Structural Characterization of Feasibility

The authors identify several geometric structures that yield tractable feasibility tests. A key case involves constraints sharing the same normal direction (parallel constraints), as described in Theorem 1. When the rows of M indexed by T are parallel, the constraint (4) is equivalent to sT(x) ≤ v⊤u ≤ sT(x), where sT(x) and sT(x) are defined based on the affine offsets βi(x). For closed and convex input sets U, feasibility is equivalent to [sT(x), sT(x)] ∩ [smin, smax] ≠ ∅.

Explicit Safety Filters

For structured cases, the paper derives explicit closed-form safety filters that replace the QP with simple saturation laws. In the case of parallel constraints (parallel normals), Proposition 7 shows that if U = R m and sT(x) ≤ sT(x), the unique optimizer is u⋆(x) = ud(x) + ϵ⋆(x) − ϵd(x), where ϵ⋆ is a saturation function. Similarly, for independent interval blocks (Proposition 8), when the constraints reduce to s(x) ≤ Su ≤ s(x) with linearly independent rows of S, the safety filter reduces to componentwise saturation in the transformed coordinates: u⋆(x) = ud(x) + G−1S⊤ϵ⋆(x) − ϵd(x).

Numerical Examples and Results

The paper illustrates these results through numerical examples. In the double-integrator example, parallel constraints lead to an explicit scalar saturation law (Prop. 7), and bounded-input cases result in feasibility domains XbT defined by the intersection of [sT(x), sT(x)] with the input bounds. For complex systems, such as the 2D double integrator with independent parallel blocks, the unbounded-input case is feasible if si(x) ≤ si(x) for all blocks. The bounded-input case then decouples coordinatewise, leading to a safety filter defined by saturation onto tightened intervals: u⋆(x) = sat[li(x), ri(x)]ud,i(x). These explicit filters match the QP solutions numerically up to high precision.

Conclusion

The study demonstrates how exploiting structural properties of linear CBF constraints can characterize the feasibility domain of QP-based safety filters and, in structured cases, replace the QP with an explicit control law requiring no online optimization. Parallel and block-structured constraint geometries yield simple feasibility tests, including under bounded inputs, and in some cases lead to closed-form safety filters. These results provide a geometric perspective on feasibility for multi-constraint CBF-QPs in linear systems.

The gist: Feasibility of QP-based safety filters for LTI systems with affine constraints can be exactly characterized by exploiting the geometry of constraint normals, leading to explicit closed-form safety filters in structured cases.

How it works

HOCBFs are used to transform affine state constraints into quadratic programs (6)–(7).

Improvements for AI systems

Here are the specific improvements to AI systems based on this research, focusing on safety-critical control and constraint handling:

The ability to implement explicit, closed-form safety filters instead of relying on computationally expensive Quadratic Programming (QP) solvers for real-time input modification.
The capability to characterize the exact feasibility domain of multi-constraint control barrier function (CBF) systems in Linear Time-Invariant (LTI) systems with affine constraints.
The development of novel, structured safety filters that replace complex online optimization with simple saturation laws or componentwise saturation laws, leading to faster and more robust real-time execution.
The creation of verifiable safety guarantees for autonomous systems by mathematically proving when a nominal control strategy is safe across the entire feasible state space, even under actuator limits (polyhedral constraints).

This improved AI system can perform the following specific actions:

Implement high-frequency safety modifications to control inputs (like those in robotics or autonomous vehicles) using simple saturation functions instead of running a complex QP solver at every time step.
Analyze the mathematical structure of multiple, overlapping safety constraints (e.g., multiple joint limits, thermal limits, and speed limits) and automatically determine if a control action is safe based on the current state geometry (feasibility domain analysis).
Design controllers that guarantee state and input constraints are never violated by explicitly calculating the required input correction based on the geometric arrangement of constraints (e.g., parallel or block-structured constraints).
Handle complex, non-square systems (where the number of safety constraints exceeds the number of available actuators) by decomposing them into independent blocks and applying tailored saturation filters to each block simultaneously.
Provide formal certification evidence for offline use, allowing engineers to certify that a system will remain safe across a defined operational region without needing continuous online verification against complex optimization problems.