Safety for Weakly-Hard Control Systems via Graph-Based Barrier Functions

arXiv:2601.00494 · eess.SY, cs.SY · Submitted 2026-01-01 · 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: "Safety for Weakly-Hard Control Systems via Graph-Based Barrier Functions".

Dev: This article addresses safety verification and controller synthesis for a class of control systems subject to weakly-hard constraints (WH constraints),

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

Title and authors: Rosa: So we're looking at this paper titled "Safety for Weakly-Hard Control Systems via Graph-Based Barrier Functions," and the authors are Marc Seidel, Mahathi Anand, and Frank Allgower. It seems like they’re tackling a very practical problem in engineering where things like packet dropouts or computational overruns happen frequently in safety-critical systems.

Dev: Exactly, Rosa; the title suggests they are focusing on safety verification and controller synthesis for systems subject to these weakly-hard constraints, which model those specific types of failures where the number of losses is bounded within a certain time horizon.

Taro: I'm curious about the core idea they’re using, because when you have failures in networked systems or real-time applications, you really need something that accounts for those specific failure modes rather than just treating them as random noise.

Rosa: Well, their summary explains that they introduce a new notion of graph-based barrier functions specifically tailored to this class of systems, which is what makes this paper interesting.

Dev: That sounds like they're building something more structured than the traditional methods that rely on state space discretization, which is where a lot of previous work has hit a wall in terms of tractability.

Taro: So, the idea is to use these barrier functions to define safety guarantees for nonlinear systems without needing to discretize the state space first? That sounds like it could be a big deal for complex autonomous behaviors.

Rosa: That’s right; they build upon Lyapunov-based techniques to provide sufficient conditions that trajectories starting from a specific set of initial conditions won't reach unsafe regions.

Dev: And what they introduce is this graph representation where nodes are states and edges encode the possible losses, which then leads into the graph-based barrier functions themselves.

Taro: The structure of that graph, defining how loss sequences are labeled with integers from the set Σ, seems like a clever way to formalize those window-based constraints mentioned in their definition of a WH constraint.

Rosa: It’s a very precise way to categorize the failure patterns, labeling subsequences as either successful transmissions or sequences of consecutive losses, like the label 's - r' for 's-r' consecutive losses.

Dev: And then they define the Graph-Based Barrier Function itself as a collection of functions, v(x), that must satisfy specific conditions related to the initial set X zero and unsafe set X u.

Title and authors: Taro: The conditions they put on the barrier functions, specifically v(x) zero for x in X zero are crucial because they link the initial state set directly to the safety function.

Rosa: And then there's that critical condition involving the edges, which requires v(x) zero to imply a specific relationship for v' based on the loss label l, specifically v'(f m o q(f c(x))) -(l-m) epsilon v'.

Dev: That recursive relationship based on the loss label l is what allows them to prove safety across the entire graph structure, which addresses both verification and synthesis problems simultaneously.

Taro: So, if we follow this methodology, we get a safety certificate for the system's behavior under any loss sequence that satisfies the WH constraint r s, as long as a GBF exists.

Rosa: That’s the main result: Theorem one states that if you have a GBF, then the WH control system is guaranteed to be safe with respect to the initial set X zero and unsafe set X u under any loss sequence satisfying the constraint.

Dev: The implications for controller synthesis are significant because they can propose a controller, like a zero strategy or a hold strategy, that is provably safe across all those defined loss sequences.

Taro: If we think about the real world, this means an AI agent operating in an environment where communication keeps dropping might have its behavior constrained by these provable safety limits derived from the graph structure.

Rosa: It moves us away from just designing systems that work well on average and toward designing systems that are mathematically guaranteed to stay within bounds even when things go wrong.

Dev: But Rosa, I gotta ask, how does this all translate into actual hardware running at a high loop rate? The complexity of defining and checking these barrier functions might be too much for real-time execution.

Taro: That’s a fair point, Dev; the authors actually mention reformulations like 1d-GBFs or d-GBFs to trade off conservatism for computational tractability, which is a necessary step for real-time AI deployment.

Rosa: So, they are acknowledging the computational cost and offering ways to make the verification checks faster without losing the safety guarantees of their core framework.

Title and authors: Dev: And that sounds promising for edge devices; if we can use those cheaper formulations, we might actually be able to implement this in systems with tighter latency requirements.

Taro: From an autonomy researcher's viewpoint, this framework suggests that the AI policy itself could be constrained not just by its intended dynamics but also by the temporal and failure constraints imposed by these graph structures.

Rosa: It means we can design more robust policies for things like autonomous vehicles or robotics where intermittent communication is a constant reality, rather than just designing them for perfect conditions.

Dev: So, to wrap up the summary of "Safety for Weakly-Hard Control Systems via Graph-Based Barrier Functions," it’s a method that formalizes safety verification and controller synthesis using graph theory to handle bounded failures in nonlinear systems.

Taro: Indeed, it provides a structured way to define safety certificates for systems subject to loss sequences that meet the WH constraint r s through those graph-based barrier functions.

Rosa: The main implication is that we can synthesize controllers like zero or hold strategies that are provably safe under these failure conditions, moving beyond heuristic approaches.

Dev: And as for the future work they mention, it seems they’re focused on those reformulations to reduce conservatism while maintaining the safety guarantees of this approach.

Taro: It really points toward a future where AI systems in safety-critical domains can have their operational boundaries defined not just by their physical limits but by the constraints imposed by communication reliability and computational availability.

Rosa: So, this work on Graph-Based Barrier Functions gives us a powerful tool to design more resilient control policies for complex AI systems dealing with real-world unreliability.

Dev: And I’m still thinking about the practical aspect of running these checks reliably, which brings us to how this methodology might be applied outside of a controlled lab setting, Rosa.

Taro: That’s exactly what we need to test; we need to see if the theoretical guarantees hold up when the system interacts with actual network jitter and computational delays in a more messy scenario.

Rosa: We have a lot of exciting possibilities here, so let's move on to see how this framework specifically impacts decentralized or networked AI agents.

The paper's summary: Rosa: So, this paper is proposing a new way to check if control systems stay safe when they keep missing data or running into unexpected errors, using these graph-based barrier functions.

Dev: Right, and it’s essentially taking those failure sequences—the packet dropouts or computational overruns—and mapping them onto a graph structure where the connections tell us what kind of loss sequence is possible.

Taro: What I find interesting is how they formalize the "weakly-hard" constraint, making it clear exactly what kind of failure pattern we're dealing with in terms of those consecutive losses and successful transmissions.

Rosa: Exactly, and then they build these barrier functions on top of that graph to give us a mathematical guarantee about the system’s behavior, defining what constitutes unsafe states based on those possible loss sequences.

Dev: It sounds like they’re moving beyond just checking if a system is stable under ideal conditions and instead creating a safety envelope that accounts for the specific way communication can fail over time.

Taro: That’s the core idea, and it means we can prove that even when the world misbehaves with those bounded failures, our AI agent won't end up in a dangerous situation defined by the unsafe set.

Rosa: And this could mean deploying these control policies in areas where communication is shaky, like remote robotics or autonomous vehicles, giving us a much higher level of confidence in their operation.

Dev: I'm still wondering about the practical side; how do we make sure that checking all those graph conditions happens fast enough for real-time control loops, especially when you introduce those trade-offs they mention later.

Taro: That’s a valid concern, and I think the authors address it by proposing simpler versions of these functions that reduce the computational load without completely sacrificing the safety proof, which is important for edge AI applications.

Rosa: If we can get those faster checks running on a robot in a field, that opens up possibilities for deploying complex control logic that’s normally too computationally expensive for those environments.

Dev: It moves the focus from just achieving high performance to guaranteeing safety under failure scenarios, which is a necessary shift when dealing with unreliable networks.

Taro: This framework gives us a way to synthesize controllers that are provably safe against these bounded failures, rather than relying on just reactive fail-safe modes.

Rosa: It’s exciting because it formalizes the uncertainty of network conditions in a way that control engineers and safety researchers can actually use to design robust AI agents.

Dev: So, the real impact here is providing a rigorous mathematical tool to verify and synthesize controllers for nonlinear systems under these specific loss sequences, which is a big step forward from older state-space methods.

Taro: Absolutely, and I think this could be used in any complex system where the control signal integrity is not guaranteed by default.

Rosa: So, we've seen that these graph-based barrier functions offer a structured method to ensure safety in systems dealing with network unreliability and computational uncertainty, and now we need to figure out how to implement this on the actual hardware.

The paper's improvements: Tom: So, the paper outlines how they can make these safety checks more practical by suggesting different formulations of their graph-based barrier functions to reduce computational overhead.

Rosa: That makes sense; if we’re talking about field robotics, we need methods that don't require massive onboard processing power just to ensure a trajectory stays within bounds during an unexpected signal loss.

Dev: Precisely, and they point out that the 1d-GBF or d-GBF versions are especially useful because they cut down on those recursive dynamics checks I mentioned earlier, which helps with maintaining a fast loop rate.

Taro: That trade-off between conservatism and tractability is key; we can't afford a verification method that takes so long that it negates the benefit of having a safety check at all.

Rosa: If we use those simpler versions, it means an AI agent deployed in a remote setting could perform these safety checks much more frequently without bogging down its main task.

Dev: I’m thinking about the implication for latency; if the system can perform these checks quickly, the latency introduced by the safety mechanism itself becomes less of a problem for real-time control.

Taro: From an autonomy standpoint, that improved efficiency means we could integrate these safety constraints more deeply into the decision-making process of a complex AI agent rather than treating them as a separate post-hoc verification step.

Rosa: It’s about making the safety guarantees embedded in the control policy itself, which is exactly what we need for reliable field operation where things aren't always perfect.

Dev: They also suggest these formulations are useful for synthesizing controllers that can compensate intelligently if a loss occurs, like switching to a hold strategy when the graph indicates a certain type of failure sequence is likely.

Taro: That ability to synthesize adaptive control based on the graph structure means the AI isn't just following pre-programmed rules; it’s actively adapting its behavior based on what it expects from the communication channel.

Rosa: That adaptation sounds very promising for our work in field robotics, where unexpected signal loss is an everyday occurrence that we need to handle gracefully.

Dev: So, the improvements focus on making the safety verification computationally viable for real-time systems while keeping those crucial temporal and failure constraints intact, Rosa.

Taro: I think this points toward a future where safety guarantees aren't just theoretical proofs but are actively managed in dynamic AI systems dealing with intermittent connectivity.

Conclusion: Tom: So, to wrap things up, this paper on "Safety for Weakly-Hard Control Systems via Graph-Based Barrier Functions" essentially gives us a formal mathematical way to verify and synthesize controllers that are safe even when communication keeps dropping or there are computational hiccups.

Rosa: It really shows how we can build safety guarantees into the core logic of an AI agent, which is what I’m looking for in field robotics where things aren't always perfect.

Dev: Exactly, and those graph-based barrier functions provide a structured way to ensure that the system stays within safe limits across all those failure scenarios defined by the WH constraints.

Taro: The implication for autonomous systems is huge because it means we can design policies that are provably robust against bounded failures in communication or execution uncertainty.

Rosa: It gives us a solid foundation to deploy AI in environments where we can't guarantee perfect connectivity, and that's something I’ve been hoping for.

Dev: And the authors acknowledged they have to use simpler versions of these functions for real-time systems, which means we might need to be careful when implementing this on our edge hardware.

Taro: That computational trade-off is a reality; we have to balance the rigor of the proof with what can actually run in milliseconds, and that’s where those 1d-GBF formulations come in handy.

Rosa: It sounds like these are not just theoretical concepts anymore, but tools we can actually start looking at for designing more resilient control software.

Dev: Agreed; it moves us away from purely heuristic safety measures toward provable safety certificates that handle the specific temporal constraints of a network failure.

Taro: So, this work really pushes the boundaries of what we can guarantee about AI behavior in uncertain real-world conditions, and I think we'll see its influence across autonomy research.

Rosa: It’s been fascinating to see how they translate those complex control theory concepts into a practical framework for handling network unreliability in these kinds of systems.

Dev: Definitely, and as we look ahead, the next challenge will be showing how well these formal guarantees hold up when the failure sequences become more unpredictable than those strictly defined by the initial graph structure.

Taro: That’s a fair point; extending this to handle more arbitrary or adversarial loss patterns is definitely where future research needs to go.

Rosa: Well, I think we’ve covered the main points of "Safety for Weakly-Hard Control Systems via Graph-Based Barrier Functions," and it certainly gives us some powerful new tools for designing safer AI systems.

University of Stuttgart · TU Munich

eess.SY, cs.SY

Submitted: 2026-01-01

Updated: 2026-09-28

Comments: Submitted to IEEE TAC

License: http://creativecommons.org/licenses/by-nc-nd/4.0/

Importance score: 76/100

The gist: This article addresses safety verification and controller synthesis for a class of control systems subject to weakly-hard constraints (WH constraints), which model phenomena such as packet dropouts

Key concepts

Weakly-Hard Constraints (WH constraints)
These model specific failures in control systems where the number of losses is bounded within a certain time horizon. They are used to define the class of systems that need safety verification, focusing on failure patterns like consecutive losses.
Graph-Based Barrier Functions (GBFs)
These are new functions tailored for weakly-hard systems. The graph structure represents states as nodes and possible loss sequences as edges, allowing the barrier functions to define safety guarantees based on these specific failure patterns.
Controller Synthesis
This involves using the safety framework to propose provably safe controllers, such as zero or hold strategies. This allows AI agents to be designed with guaranteed safety limits even when communication fails or errors occur.
1d-GBFs and d-GBFs
These are reformulations of graph-based barrier functions used to reduce computational overhead. They are important for real-time systems because they cut down on recursive dynamics checks, allowing for faster verification without losing the core safety proof.

Terminology

Summary

This article addresses safety verification and controller synthesis for a class of control systems subject to weakly-hard constraints (WH constraints), which model phenomena such as packet dropouts in networked control systems or computational overruns in real-time applications.

The core problem involves discrete-time, nonlinear control systems defined by the state evolution equation:

x(t + 1) = f(x(t), u a(t)), (1)

controlled by a nonlinear, static state-feedback controller:

u c(t) = g(x(t)). (2)

The control input is subject to a loss sequence µ, where:

µ(t) = (1 if transmission of u c(t) at time t is successful, 0 otherwise. (3)

The paper defines WH constraints based on the loss sequence satisfying a condition:

"Definition 1 (WH Constraint): A loss sequence µ satisfies the WH constraint r s (“meets r in s”, r, s ∈ N, r ≤ s), if in any window of s consecutive control attempts, there are at least r of them successful (in any order)."

A WH control system is formally defined as:

Definition 2 (WH Control System): A WH control system is the conjunction of system (1) and controller (2) under loss sequences satisfying a WH constraint r s.

Safety for a WH control system is defined as:

"Definition 3 (Safety of WH Control Systems): Consider a WH control system as in Definition 2. Let X0 ⊆ X be the initial set and Xu ⊆ X be the unsafe set of the system such that X0 ∩ Xu ≠ ∅. Then, a WH control system is said to be safe w.r.t. X0 and Xu under a controller g if for any x0 and any loss sequence µ that satisfies a WH constraint as in Definition 1, we have that x x0g(t) ∈ X/ u, ∀t ∈ N."

The paper proposes a new methodology to address the safety verification (Problem 1) and controller synthesis (Problem 2) for WH control systems by proposing graph-based barrier functions (GBFs).

Graph Representation of WH Constraints:

The loss sequences are first divided into meaningful subsequences, each starting with a success (1) followed by a number of consecutive losses (0's). These subsequences are labeled with integers from the set:

Σ = Σ with v2 v1 v3 0 1 0 1 2 0 labels l representing the respective subsequences µ′: l = 0: µ′ = 1, l = s - r: µ′ = (s-r) consecutive losses.

A WH graph G is constructed where nodes represent states and edges encode the possibility of losses.

A directed graph G = (V, E) with V as the set of nodes and E as the set of edges. An edge (v, l, v′) ∈ E starts from node v and ends in node v′ with label l ∈ Σ.

The language of G is the set of all sequences accepted by G, which corresponds exactly to the loss sequences satisfying a WH constraint r s.

Graph-Based Barrier Functions (GBFs):

A GBF is a collection of functions, one for each node in the graph. For a system employing either zero or hold actuator strategies, it is defined as:

"Definition 5 (Graph-based Barrier Function): Consider a WH control system employing the zero (as in (6)) or hold (as in (7)) strategy. Suppose that the loss sequences satisfy the WH constraint r s with the corresponding WH graph G = (V, E). A set of nV functions Ψv(x): X → R is called a graph-based barrier function (GBF) for G w.r.t. an initial set X0 and unsafe set Xu if there exist constants εv > 0 such that for all nodes v ∈ V and edges (v, l, v′) ∈ E the following conditions hold:

Ψv(x) ≤ 0, ∀x ∈ X0, (11a)

Ψv(x) > 0, ∀x ∈ Xu, (11b)

Ψv(x) ≤ 0 ⇒ Ψv′ (f m o q(f c(x))) ≤ −(l−m)εv′ m ∈ M = M = M = M = M"

Safety Verification Theorem:

The paper establishes a fundamental result:

"Theorem 1: For a WH control system employing the zero (as in (6)) or hold (as in (7)) strategy under a WH constraint r s with the graph G, suppose there exists a GBF as in Definition 5.

Improvements for AI systems

As a meticulous AI researcher, I have analyzed this paper, Safety for Weakly-Hard Control Systems via Graph-Based Barrier Functions, and identified several high-impact areas where its novel mathematical framework—specifically the Graph-Based Barrier Functions (GBFs)—can be directly applied to improve AI systems.

The core contribution is providing a formal, non-conservative method to guarantee safety in networked or resource-constrained systems subject to failures (packet dropouts or computational overruns). This translates directly into designing AI agents that are robust against communication unreliability and execution uncertainty.

Here are the specific improvements and capabilities for an improved AI system:

)

  1. Improved Robustness in Decentralized/Networked Agents:

The paper models systems where control inputs are subject to loss sequences (WH constraints). This directly applies to multi-agent reinforcement learning (MARL) or decentralized control systems where communication between agents is unreliable.

  • AI Capability: The system can be designed such that even if a subset of communication links fails according to the WH constraint, the overall system state remains within a safe region defined by the GBFs. This prevents catastrophic failure modes resulting from missed coordination signals or delayed commands.
  1. Formal Safety Verification for Complex AI Behaviors:

The paper provides tools (GBFs) for verifying safety properties for nonlinear systems under loss sequences, which is crucial when AI agents interact with physical or complex environments (e.g., robotics, autonomous vehicles).

  • AI Capability: Before deploying an AI agent in a safety-critical task (like autonomous driving or medical robotics), the designer can use the GBF methodology to formally verify that the agent's trajectory, under worst-case loss scenarios defined by WH constraints, will never enter an unsafe configuration (e.g., collision zones or unstable operational regimes).
  1. Safe Controller Synthesis for Adaptive AI:

The paper addresses Problem 2: synthesizing a controller (or policy) that guarantees safety across all possible loss sequences.

  • AI Capability: Instead of relying on heuristic, purely reactive controllers, the system can synthesize an adaptive control policy (the controller 'g' in the paper) that is provably safe against bounded failures. This allows the AI to maintain intended behavior even when facing unpredictable communication dropouts or computation delays, moving from simple fail-safe modes (like zero input) to intelligently compensated behaviors (like hold strategy compensation).
  1. Tractability via Conservative Trade-offs:

The paper explicitly discusses reformulations (1d-GBFs, d-GBFs) that trade off conservatism for computational tractability, especially by eliminating recursive dynamics checks.

  • AI Capability: For real-time AI systems where computation is severely limited (e.g., edge devices), the system can utilize the computationally cheaper 1d-GBF or d-GBF formulations. This allows for a faster, though potentially more conservative, safety check during online operation compared to the full formulation, ensuring rapid decision-making under uncertainty.
  1. Application in Control Barrier Functions (CBFs) for AI:

The concept of barrier functions is highly analogous to Control Barrier Functions (CBFs), which are standard tools in control theory for ensuring stability and safety constraints are met.

  • AI Capability: The GBF framework provides a more generalized, graph-based structure to define safety certificates that can handle the switching behavior inherent in networked or intermittently connected AI systems, offering a structured way to design policies that respect temporal and loss-related constraints.

Abstract

Despite significant advancement in technology, communication and computational failures are still prevalent in safety-critical engineering applications. Often, networked control systems experience packet dropouts, leading to open-loop behavior that significantly affects the behavior of the system. Similarly, in real-time control applications, control tasks frequently experience computational overruns and thus occasionally no new actuator command is issued. This article addresses the safety verification and controller synthesis problem for a class of control systems subject to weakly-hard constraints, i.e., a set of window-based constraints where the number of failures are bounded within a given time horizon. The results are based on a new notion of graph-based barrier functions that are specifically tailored to the considered system class, offering a set of constraints whose satisfaction leads to safety guarantees despite such failures. Subsequent reformulations of the safety constraints are proposed to alleviate conservatism and improve computational tractability, and the resulting trade-offs are discussed. Finally, several numerical case studies including linear and polynomial systems demonstrate the effectiveness of the proposed approach.

Sources

Related papers