Safety-Critical Control with Guaranteed Lipschitz Continuity via Filtered Control Barrier Functions

This paper introduces Filtered Control Barrier Functions (FCBFs), a framework that integrates an input regularization filter with High-Order CBFs within a unified quadratic program to simultaneously guarantee system safety, control bounds, and Lipschitz continuity of control inputs, thereby preventing abrupt changes that could degrade performance or violate actuator limits.

The Gist

Imagine you are teaching a robot to drive a car through a busy city. You have two main rules for the robot:

1. Don't crash: It must stay within the lanes and avoid hitting pedestrians or other cars.
2. Don't jerk: The steering wheel and gas pedal shouldn't be slammed back and forth violently. If the robot jerks the wheel, the passengers get sick, the tires wear out, and the car might actually lose control.

For a long time, engineers had a great tool called a Control Barrier Function (CBF). Think of this as an invisible, magical force field that pushes the car away from danger. If the car gets too close to a wall, the force field instantly yanks the steering wheel to turn it away.

The Problem:
While this force field is great at keeping the car safe, it has a nasty side effect. Because it reacts so instantly to danger, it often tells the car to "Jerk left! Now jerk right! Now hard left!"
In math terms, the car's control inputs aren't "smooth." They are "abrupt." This is like a driver who panics and slams the brakes and steering wheel every time they see a pothole. It's safe in the sense that they don't hit the pothole, but it's terrible for the car and the passengers.

The paper you shared introduces a new, smarter way to drive called Filtered Control Barrier Functions (FCBFs).

The Analogy: The "Buffer Zone" Driver

Here is how the new method works, using a simple analogy:

1. The Old Way (Standard HOCBF):
Imagine a nervous driver who looks at the road and reacts instantly to every bump.

• Scenario: A child steps out.
• Reaction: The driver screams and slams the brakes and turns the wheel 90 degrees in 0.01 seconds.
• Result: The car stops safely, but the passengers are thrown forward, and the suspension breaks. The math says the car is "safe," but the motion is chaotic.

2. The New Way (FCBF):
The authors introduce a Filter. Think of this as a "Buffer Zone" or a "Calm Co-Pilot" sitting between the nervous driver and the car's controls.

• The Nervous Driver (The Original Algorithm): Still sees the danger and yells, "Turn left! Turn left NOW!"
• The Calm Co-Pilot (The Filter): Instead of passing that panic directly to the car, the Co-Pilot says, "Okay, we need to turn left, but let's do it smoothly."
• The Result: The Co-Pilot translates the "Jerk Left!" command into a "Gently turn the wheel over the next 2 seconds."

Why is this special?

In the world of math and engineering, there is a concept called Lipschitz Continuity. In plain English, this just means "No Sudden Jumps."

• Smoothness usually just means the line doesn't break.
• Lipschitz Continuity means the line doesn't just not break; it also guarantees that the speed at which the line changes is limited. It puts a "speed limit" on how fast the steering wheel can turn.

The paper proves that their new "Co-Pilot" (the Filter) guarantees this speed limit. No matter how crazy the situation gets, the robot's controls will never change faster than a specific, safe rate.

The "Magic" Trick

The clever part of this paper is how they built this Co-Pilot.
Instead of trying to rewrite the whole math of the robot (which is hard), they added a small, extra "virtual machine" (the filter) that sits in front of the robot.

• The robot talks to the virtual machine.
• The virtual machine talks to the car.
• The virtual machine is programmed to only speak in smooth, gentle sentences.

Because of this setup, the whole system (Robot + Virtual Machine) can still be solved using a standard, fast computer program (called a Quadratic Program). This means the robot can still think fast enough to drive in real-time, but now it drives like a professional chauffeur instead of a panicked teenager.

The Results (The Race Car Test)

The authors tested this on a "Unicycle" robot (a robot that balances on one wheel, like a Segway).

• The Test: Drive around a circular obstacle without hitting it.
• The Competitors:
  1. Standard Method: Safe, but the robot jerks and shakes.
  2. Smoothness Penalty Method: They tried to force the robot to be smooth by adding a "punishment" in the math if it jerked. This often made the robot get stuck or fail to find a path at all.
  3. FCBF (The New Method): The robot drove smoothly, safely, and never got stuck. It moved like a fluid stream of water rather than a bouncing ball.

Summary

This paper solves a problem where safety algorithms were making robots move too jerkily. They added a "smoothness filter" that acts like a calm co-pilot, ensuring that the robot's controls change gradually and predictably. This keeps the robot safe from crashes and keeps the ride smooth, all without slowing down the computer's ability to make decisions.

Technical Summary

Here is a detailed technical summary of the paper "Safety-Critical Control with Guaranteed Lipschitz Continuity via Filtered Control Barrier Functions."

1. Problem Statement

In safety-critical autonomous systems, Control Barrier Functions (CBFs), particularly High-Order CBFs (HOCBFs), are widely used to enforce forward invariance of safe sets. However, standard CBF-based frameworks (often formulated as Quadratic Programs, QPs) face a critical limitation: they do not guarantee Lipschitz continuity of the control input.

• The Gap: While existing methods may produce "smooth" (continuous/differentiable) inputs, smoothness alone does not ensure bounded variation. Standard QP solutions can result in abrupt, high-frequency changes (chattering) in the control signal.
• Consequences: Abrupt changes can degrade system performance, violate actuator physical limits, accelerate wear, and invalidate system modeling assumptions.
• Theoretical Requirement: Lipschitz continuity is theoretically required to guarantee the existence and uniqueness of closed-loop trajectories (well-posedness) and to bound the rate of input variation. Current CBF methods lack this guarantee because the control input $u$ is a decision variable updated discretely, lacking an analytical guarantee of Lipschitz continuity between steps.

2. Methodology: Filtered Control Barrier Functions (FCBFs)

The authors propose a novel framework called Filtered Control Barrier Functions (FCBFs) to simultaneously ensure safety, respect control bounds, and guarantee Lipschitz continuous control inputs.

Core Concept

Instead of directly controlling the system with the raw output of a standard HOCBF, the framework introduces an auxiliary dynamic system acting as an input regularization filter (e.g., a low-pass filter).

• Original System: $\dot{x} = f(x) + g(x)u$
• Auxiliary Filter: $\dot{\pi} = F(\pi) + G(\pi)\nu$
  • The filter state $\pi$ includes the filtered control input $u_f$ and its derivatives.
  • The actual control applied to the system is $u = u_f$.
  • The decision variable in the optimization becomes the auxiliary input $\nu$, not $u_f$.

Mathematical Formulation

1. FCBF Construction: The standard HOCBF constraint (which ensures safety $b(x) \geq 0$) is reformulated using the filtered input $u_f$. Since $u_f$ is the state of the auxiliary system, the relative degree of the safety constraint increases.
2. Lipschitz Guarantee: The authors define HOCBFs on the auxiliary system to constrain the time derivatives of $u_f$. By ensuring that the first derivative of the filtered input ($\dot{u}_f$) is bounded via these constraints, the input $u_f$ is mathematically proven to be Lipschitz continuous.
3. Unified QP: The safety constraints (FCBFs), input bounds (HOCBFs on $u_f$), and stability objectives (Control Lyapunov Functions, CLFs) are integrated into a single Quadratic Program (QP).
   • Decision Variables: The auxiliary input $\nu$ and a relaxation variable.
   • Objective: Minimize energy/effort of $\nu$ and ensure state convergence.
   • Constraints:
     • Safety: FCBF inequalities involving $x$ and $u_f$.
     • Input Bounds: HOCBFs ensuring $u_{min} \leq u_f \leq u_{max}$.
     • Smoothness: Constraints on $\dot{u}_f$ derived from the filter dynamics.

Theoretical Guarantees

• Theorem 2 (Safety): If the initial state satisfies the intersection of all safety sets, the forward invariance of the safe set is guaranteed for the combined system (plant + filter).
• Theorem 3 (Lipschitz Continuity & Bounds): By constructing HOCBFs for the lower and upper bounds of the filtered input, the framework guarantees that $u_f$ remains within actuator limits and is Lipschitz continuous with respect to time.

3. Key Contributions

1. Novel Framework (FCBFs): Introduction of Filtered Control Barrier Functions that extend HOCBFs by incorporating an auxiliary dynamic system to regularize control inputs.
2. Theoretical Guarantee of Lipschitz Continuity: Unlike previous "smoothness-penalized" approaches that only minimize input differences heuristically, this method provides a rigorous mathematical guarantee that the control input variation is bounded (Lipschitz continuous).
3. Computational Efficiency: The method retains the structure of a single QP, ensuring real-time feasibility without requiring complex non-linear optimization or iterative smoothing post-processing.
4. Robustness to Discretization: The approach addresses the issue of piecewise QP updates, ensuring that even with discrete time steps, the resulting control signal does not exhibit unbounded jumps.

4. Results and Case Study

The authors validated the method using a unicycle model navigating around a circular obstacle.

• Benchmarks:

  1. Standard HOCBF: Enforces safety but produces abrupt control inputs.
  2. Smoothness-Penalized HOCBF (sp-HOCBF): Adds a cost term penalizing input differences ($\|u_t - u_{t-1}\|^2$).
  3. Proposed FCBF: Uses the auxiliary filter approach.

• Findings:

  • Feasibility: The sp-HOCBF method frequently became infeasible when the initial heading angle was small, as the penalty term conflicted with safety constraints. FCBF and standard HOCBF remained feasible.
  • Smoothness:
    • FCBF produced the smoothest control trajectories ($u_1$: angular velocity, $u_2$: driving force).
    • sp-HOCBF did not significantly improve smoothness over standard HOCBF and often failed to find a solution.
    • HOCBF exhibited high-frequency oscillations and abrupt changes.
  • Parameter Sensitivity:
    • Increasing the filter time constant ($\tau$) in FCBF resulted in smoother, more gradual control actions.
    • Adjusting the class $\mathcal{K}$ function parameters ($\alpha$) allowed tuning of the Lipschitz constant, balancing responsiveness and smoothness.

5. Significance

This work bridges a critical gap between theoretical safety guarantees and practical implementation requirements in autonomous systems.

• Practical Deployment: By guaranteeing Lipschitz continuity, the method prevents actuator saturation and mechanical stress caused by "chattering," making CBFs more viable for real-world hardware (e.g., legged robots, vehicles).
• Theoretical Rigor: It moves beyond heuristic smoothing (penalty terms) to provide a formal proof of bounded input variation, which is essential for the stability analysis of closed-loop systems.
• Scalability: The retention of the QP structure ensures the method can be deployed on embedded systems with limited computational resources, maintaining the real-time capabilities essential for safety-critical control.

In conclusion, the paper presents a robust solution for generating safe, bounded, and smooth control inputs, overcoming the limitations of existing HOCBF frameworks while maintaining computational efficiency.