Policy Library CBF: Finite-Horizon Safety at Runtime via Parallel Rollouts

arXiv:2605.16588 · cs.RO, cs.SY, eess.SY · Submitted 2026-05-15 · 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: We're looking at the paper: "Policy Library CBF".

Dev: Here's the gist of the paper. Safety-critical autonomy in unstructured environments poses significant challenges for online safety certification under evolving constraints <ref:2605.16588#pg2> We propose Policy Library Control Barrier Function (PL-CBF), a runtime safety filter that evaluates a library of fallback policies via parallel finite-horizon rollouts, selects the least invasive safe mode, and enforces safety by solving a quadratic program that minimally modifies a nominal policy <ref:2605.16588#pg2>.

Rosa: Pruning redundant reasoning tokens The core problem addressed is ensuring online safety certification for autonomous systems operating in unstructured environments where perception-limited information evolves over time <ref:2605.16588#pg2>.

Dev: Standard methods like Hamilton-Jacobi (HJ) reachability analysis are often computationally intractable due to the curse of dimensionality <ref:2605.16588#pg2>.

Rosa: Control Barrier Functions (CBFs) offer a scalable alternative by enforcing pointwise constraints on control input, but standard CBF synthesis often requires an explicit barrier function for the full nonlinear system, which is difficult to obtain online <ref:2605.16588#pg2>.

Title and authors: Rosa: So, we're talking about this paper 'Policy Library CBF: Finite-Horizon Safety at Runtime via Parallel Rollouts'. It’s about how autonomous systems can stay safe when they don't have perfect information in unstructured places.

Dev: Exactly. The authors propose something called Policy Library Control Barrier Function, or PL-CBF. Think of it as a real-time safety filter that checks a bunch of different potential fallback plans at the same time to pick the safest one and then nudges our main plan just enough to make it safe.

Taro: I'm interested in how they handle those evolving constraints you mentioned earlier, Rosa. They seem to tackle the problem where perception changes over time, which makes standard methods really hard because they can't keep up with the complexity.

Rosa: Right. That’s what this paper is really tackling. Traditional methods like Hamilton-Jacobi reachability analysis get bogged down because of the dimensionality of those environments, and standard Control Barrier Functions usually need you to know the full nonlinear system beforehand, which is tough online.

Dev: So they are using a library approach here, evaluating a set of candidate fallback policies using parallel finite-horizon rollouts to make that decision fast. It's not just picking one plan; it’s comparing several options simultaneously.

Taro: And what makes this library better than just having one single fallback policy we pre-program? Because if the world misbehaves, we need a plan that works, and relying on just one thing feels really brittle when you're driving or navigating dynamically.

Rosa: That’s a big improvement they’re making. They define a library of K candidate fallback policies, say pi one through pi K, and they calculate the finite-horizon policy library value function which is basically the maximum safety margin you can get across all those policies over some planning horizon T.

Dev: So, if we look at that value function H Pi T x, it tells us the best safety margin we can achieve by choosing any of those K policies for a certain time period, and they certify safety whenever at least one policy in that library stays safe over the horizon under the latest perceived constraints.

Taro: That sounds like a solid way to ensure robustness because you aren't locked into just one maneuver; you have choices based on what the current perception tells you.

Rosa: And then they synthesize a control input, u star, by solving a quadratic program that minimally modifies our nominal command, which means it keeps our main plan as much as possible while satisfying the safety constraints imposed by the chosen safe policy from the library.

Title and authors: Dev: That QP solution aims to select the least restrictive constraint by maximizing the volume of the admissible control set, which is a clever way to keep our maneuver flexible if possible. The selection criterion they use is arg max i star where i star is chosen based on maximizing that admissible control set volume for policy pi i.

Taro: So, it’s not just about finding *a* safe move; it’s about finding the safest move that leaves us with the most room to maneuver if things get unexpectedly rough later in time. That seems like a practical safety consideration.

Rosa: It really is practical because they validated this on three distinct simulations: a planar double integrator, highway driving with abrupt friction changes using a realistic nonlinear vehicle model, and three dee quadrotor navigation in crowded dynamic environments <ref:2605.16588#pg1,highway driving with abrupt friction changes using a realistic nonlinear vehicle model>.

Dev: And the results showed that PL-CBF achieved improved safety coverage compared to single-policy filters while still keeping the runtime at millisecond levels across all those tests. For example, in the highway driving experiment, PL-CBF got zero failures out of fifty while every single single fallback baseline crashed or became infeasible.

Taro: That comparison is pretty telling about how much better it is at handling those real-world scenarios we talked about earlier than just relying on one fixed response.

Rosa: And the computational structure is parallelizable because the calculations for closed-loop trajectories and those value functions for each policy can be done at the same time on parallel hardware, which keeps the runtime low.

Dev: Theoretically, they establish a completeness condition for finite-horizon safety certification using a finite-horizon language metric over closed-loop behaviors, which gives us a formal way to check if the library is actually covering enough of the safe behavior.

Taro: What about when we look at the long term? Does this framework extend beyond just the immediate planning horizon T, or is it strictly for short-term safety?

Rosa: They do have a theoretical analysis for that too. In an idealized infinite-horizon limit, they show that that value function H Pi infinity becomes a Control Barrier Function on a specific set S Pi infinity, and if you include a backup policy in the library, the system recovers infinite-time safety properties.

Dev: That's interesting because it connects this finite-horizon work to more established concepts like Hamilton Jacobi variational inequalities in the viscosity sense, which gives us insight into how these functions behave over longer time scales.

Title and authors: Taro: So they’re suggesting that by including a backup policy, you can get those long-term guarantees without needing a terminal constraint set for the infinite horizon problem.

Rosa: And they also mention that their language metric dx of pi i and pi j bounds the worst-case state deviation between two policy rollouts over that time period T, which is how they measure how close different policies are to being safe.

Dev: The practical implication for us in real-time loops is that we can deploy this as a high-rate safety layer where we don't have to wait for slow, complex offline synthesis. It’s designed to run fast enough for actual control decisions.

Taro: For me, the key thing is that it handles the uncertainty well; it doesn't just guess one outcome and hope for the best when things get chaotic. That library structure seems designed specifically to manage that chaos gracefully by having options ready.

Rosa: To wrap up, this paper 'Policy Library CBF: Finite-Horizon Safety at Runtime via Parallel Rollouts' shows how to use a library of candidate fallback policies evaluated in parallel rollouts to ensure online safety for autonomous systems operating in uncertain environments. It’s practical because it maintains millisecond runtime while providing better safety coverage than single-policy methods across complex tasks like highway driving and three dee navigation <ref:2605.16588#pg1>.

Dev: The core improvement is that by selecting the least restrictive constraint through a quadratic program, we keep the nominal plan as much as possible, which means zero intervention when the nominal plan is safe, provided it stays within the safe set defined by our chosen library policy.

Taro: It’s a good structure because it allows for multimodal safe maneuvers; instead of one single response, you retain options that work if that one response isn't enough.

Rosa: So we have this framework that uses parallel finite-horizon rollouts to select the best safe policy from a library, and then uses a quadratic program to minimally modify our command to enforce safety. It’s a deployable safety layer for systems facing evolving constraints.

Dev: We should keep an eye on how they push the infinite horizon property further, because that would be the ultimate goal for guaranteeing recursive feasibility guarantees associated with backup-based filters without relying on fixed fallback maneuvers.

Taro: It seems like a solid step forward in moving away from brittle single-policy reliance towards more robust, choice-based safety mechanisms.

The paper's summary: Rosa: So, this paper introduces Policy Library Control Barrier Function, or PL-CBF. Basically, they’re tackling online safety for autonomous systems in messy environments where information keeps changing over time by using a library of candidate fallback policies evaluated at the same time to pick the best one and then nudging our main plan just enough to keep it safe.

Dev: Right. It’s about moving away from relying on just one fixed fallback maneuver because that feels too brittle when perception shifts, and this framework lets you compare several options in parallel using finite-horizon rollouts to find the least restrictive constraint.

Taro: I see how that addresses the problem of having a single designated safe plan that might suddenly become invalid; if one policy fails, the system switches to another from the library based on what’s happening now.

Rosa: Exactly. The core idea is defining this finite-horizon policy library value function which represents the maximum safety margin achievable across all those policies over some planning horizon T, and safety is certified whenever at least one policy in that library stays safe under the latest perceived constraints.

Dev: And they find a way to select which of those policies to use by solving a quadratic program that minimally modifies our nominal command, which means it keeps our main plan as much as possible while satisfying the safety constraints imposed by the chosen safe policy from the library.

Taro: That QP part is interesting because it’s not just picking *a* safe move; they select the safest move that leaves us with the most room to maneuver if things get unexpectedly rough later in time.

Rosa: It really is practical because they validated this on three distinct simulations: a planar double integrator, highway driving with abrupt friction changes using a realistic nonlinear vehicle model, and three dee quadrotor navigation in crowded dynamic environments.

Dev: And the results showed that PL-CBF achieved improved safety coverage compared to single-policy filters while still keeping the runtime at millisecond levels across all those tests. For example, in the highway driving experiment, PL-CBF got zero failures out of fifty while every single single fallback baseline crashed or became infeasible.

Taro: That comparison is pretty telling about how much better it is at handling those real-world scenarios we talked about earlier than just relying on one fixed response.

Rosa: The computational structure is parallelizable because the calculations for closed-loop trajectories and those value functions for each policy can be done at the same time on parallel hardware, which keeps the runtime low.

Dev: Theoretically, they establish a completeness condition for finite-horizon safety certification using a finite-horizon language metric over closed-loop behaviors, which gives us a formal way to check if the library is actually covering enough of the safe behavior.

Taro: What about when we look at the long term? Does this framework extend beyond just the immediate planning horizon T, or is it strictly for short-term safety?

Rosa: They do have a theoretical analysis for that too. In an idealized infinite-horizon limit, they show that that value function H Pi infinity becomes a Control Barrier Function on a specific set S Pi infinity, and if you include a backup policy in the library, the system recovers infinite-time safety properties.

Dev: That's interesting because it connects this finite-horizon work to more established concepts like Hamilton Jacobi variational inequalities in the viscosity sense, which gives us insight into how these functions behave over longer time scales.

Taro: So they’re suggesting that by including a backup policy, you can get those long-term guarantees without needing a terminal constraint set for the infinite horizon problem.

Rosa: And they also mention that their language metric between two policies bounds the worst-case state deviation between two policy rollouts over that time period T, which is how they measure how close different policies are to being safe.

Dev: The practical implication for us in real-time loops is that we can deploy this as a high-rate safety layer where we don't have to wait for slow, complex offline synthesis. It’s designed to run fast enough for actual control decisions.

Taro: For me, the key thing is that it handles the uncertainty well; it doesn't just guess one outcome and hope for the best when things get chaotic. That library structure seems designed specifically to manage that chaos gracefully by having options ready.

Rosa: So we have this framework that uses parallel finite-horizon rollouts to select the best safe policy from a library, and then uses a quadratic program to minimally modify our command to enforce safety. It’s a deployable safety layer for systems facing evolving constraints.

Dev: We should keep an eye on how they push the infinite horizon property further, because that would be the ultimate goal for guaranteeing recursive feasibility guarantees associated with backup-based filters without relying on fixed fallback maneuvers.

The paper's improvements: Dev: So, this paper outlines how to make this safety filter actually useful by suggesting a few tweaks to how we use that library of policies in real time.

Rosa: They suggest focusing on how we select which policy from the library is best by maximizing the volume of the admissible control set, which means they’re trying to find a maneuver that keeps our options wide open if things get unexpected.

Taro: That sounds like it solves the problem where a single fallback might only work for one specific scenario; instead, you pick what gives you the most room to move.

Dev: Exactly. It shifts the selection criterion away from just picking *a* safe policy to actively choosing the safest policy that leaves us with the most flexibility for future unexpected events.

Rosa: Another improvement they highlight is how this relates back to those infinite horizon properties; they show that if you include a backup policy in your library, you can actually guarantee those long-term safety properties without needing some complicated terminal constraint set.

Taro: That’s significant because it means we don't have to worry about the system getting stuck in a loop or failing over time just because we didn't define a perfect end state for the planning horizon T.

Dev: It also clarifies that when the nominal plan is already safe, you can actually achieve zero intervention, provided our chosen library policy stays within its safe set; this cuts down on unnecessary control nudges.

Rosa: That zero intervention point is a big deal because it makes the system more efficient when things are going well, rather than always applying a correction just because it's slightly off the line.

Taro: So, we’re moving towards a system that doesn’t just react when things go wrong but actively chooses the best path forward based on what the current safety margin is across all available options.

Dev: It’s about making the decision process more robust by optimizing for both immediate safety and future maneuverability.

Rosa: This framework moves us closer to deploying these kinds of complex reasoning mechanisms into high-rate control systems where we need fast, reliable decisions under uncertainty.

Taro: The implication here is that we can build autonomy layers that are less brittle when the environment throws curveballs at them because they have a whole family of safe responses ready to go.

Conclusion: Rosa: So to wrap up, we’re talking about this paper, "Policy Library CBF: Finite-Horizon Safety at Runtime via Parallel Rollouts," which shows how you can use a library of candidate fallback policies evaluated in parallel rollouts to ensure online safety for autonomous systems in uncertain environments.

Dev: It boils down to having a flexible safety layer that keeps our main plan as much as possible while picking the least restrictive constraint from the library using that quadratic program.

Taro: I think what this means is that we can build autonomy layers that are less brittle when the environment throws curveballs at them because they have a whole family of safe responses ready to go instead of just one fixed plan.

Rosa: Right, and they showed that it works on things like highway driving with sudden friction changes and three dee navigation in crowded areas, keeping the runtime really fast.

Dev: The main implication for controls is that we can deploy this as a high-rate safety layer where we don't have to wait for slow, complex offline synthesis to fix every single possible failure mode.

Taro: It’s about moving away from brittle single-policy reliance towards more robust, choice-based safety mechanisms that actually adapt when things get chaotic.

Rosa: Ultimately, this framework gives us a deployable way to handle evolving constraints without sacrificing the speed we need for real-time control.

Dev: We should keep an eye on how they push the infinite horizon property further because that would be the ultimate goal for guaranteeing recursive feasibility guarantees associated with backup-based filters without relying on fixed fallback maneuvers.

Department of Robotics, University of Michigan, Toyota Motor North America

cs.RO, cs.SY, eess.SY

Submitted: 2026-05-15

Updated: 2026-11-10

Comments: Project page: https://www.taekyung.me/plcbf

Project page: https://www.taekyung.me/plcbf

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 82/100

The gist: Safety-critical autonomy in unstructured environments poses significant challenges for online safety certification under evolving constraints <ref:2605.16588#pg2> We propose Policy Library Control…

Key concepts

Policy Library ($\Pi$)
This is a collection of K different candidate fallback policies. Instead of relying on just one backup plan, the system evaluates all policies in the library simultaneously to find the safest option available at any given moment. This diversity allows the filter to retain multimodal safe maneuvers, preventing conservatism.
Finite-Horizon Value Function ($H_{\Pi}^T(x)$)
This function calculates the maximum safety margin achievable across all policies in the library over a specific planning horizon T. It represents the best possible safety outcome by considering which policy in $\Pi$ performs best for a given state $x$ within that time window.
Quadratic Program (QP) Synthesis
The system uses a QP to calculate the optimal control input ($u^*$). This QP is designed to minimally change the nominal command while maximizing the volume of safe control inputs. This selection criterion ensures that the chosen modification is as small as possible, leading to less restrictive constraints.
Safety Certification Condition
Safety is certified if at least one policy within the library remains safe over a planning horizon under current environmental constraints. This allows for online certification without needing an explicit barrier function for the entire nonlinear system beforehand.

Terminology

Summary

Safety-critical autonomy in unstructured environments poses significant challenges for online safety certification under evolving constraints <ref:2605. p. 0

Where the paper says it

Policy Library CBF: Finite-Horizon Safety at Runtime via Parallel Rollouts Taekyung Kim1 , Hideki Okamoto2 , Bardh Hoxha2 , Georgios Fainekos2 , Dimitra Panagou1,3 Abstract— Safety-critical autonomy in unstructured environments poses significant challenges for online safety certification under evolving constraints. We propose Policy Library Control Barrier Function (PL-CBF), a runtime safety filter that evaluates a library of fallback policies via parallel finite-horizon rollouts, selects the least invasive safe mode, and enforces safety by solving a quadratic program that minimally modifies a nominal policy.

16588#pg2> We propose Policy Library Control Barrier Function (PL-CBF), a runtime safety filter that evaluates a library of fallback policies via parallel finite-horizon rollouts, selects the least invasive safe mode, and enforces safety by solving a quadratic program that minimally modifies a nominal policy <ref:2605. p. 0
Where the paper says it

Policy Library CBF: Finite-Horizon Safety at Runtime via Parallel Rollouts Taekyung Kim1 , Hideki Okamoto2 , Bardh Hoxha2 , Georgios Fainekos2 , Dimitra Panagou1,3 Abstract— Safety-critical autonomy in unstructured environments poses significant challenges for online safety certification under evolving constraints. We propose Policy Library Control Barrier Function (PL-CBF), a runtime safety filter that evaluates a library of fallback policies via parallel finite-horizon rollouts, selects the least invasive safe mode, and enforces safety by solving a quadratic program that minimally modifies a nominal policy.

16588#pg2>.

Pruning redundant reasoning tokens

The core problem addressed is ensuring online safety certification for autonomous systems operating in unstructured environments where perception-limited information evolves over time <ref:2605.16588#pg2>. Standard methods like Hamilton-Jacobi (HJ) reachability analysis are often computationally intractable due to the curse of dimensionality <ref:2605. p. 0

Where the paper says it

Formal verification tools such as Hamilton-Jacobi (HJ) reachability analysis provide strong safety guarantees by computing the viability kernel [9]. However, these approaches typically face the curse of dimensionality and become computationally intractable for the high-dimensional systems and complex constraints that arise in robotics.

16588#pg2>. Control Barrier Functions (CBFs) offer a scalable alternative by enforcing pointwise constraints on control input, but standard CBF synthesis often requires an explicit barrier function for the full nonlinear system, which is difficult to obtain online <ref:2605. p. 0
Where the paper says it

Control Barrier Functions (CBFs) provide a more scalable alternative by enforcing pointwise constraints on the control input [10]. Yet, standard CBF synthesis often presumes access to an explicit barrier function for the full nonlinear system under a fixed constraint description, which is difficult to obtain in general and may not remain valid as perception updates change the effective constraints online [11].

16588#pg2>. Existing rollout-based filters still depend on the validity of a single designated fallback policy, which induces conservatism because no single maneuver is reliably safe across all perception updates <ref:2605. p. 0
Where the paper says it

However, existing runtime rollout-based filters still hinge on the validity of a single designated fallback policy. In unstructured settings, no single maneuver is reliably safe across all perception updates: for example, a stop maneuver can fail under sudden friction loss, and a fixed evasive maneuver can become infeasible when newly detected obstacles or narrow passages invalidate that behavior.

16588#pg2>.

How the training signal is built

The PL-CBF framework overcomes the limitation of relying on a single fallback maneuver by defining a library of K candidate fallback policies, denoted as Π = π1,..., πK <ref:2605. p. 0

Where the paper says it

We also discuss the conceptual connection to classical CBF and forward-invariance results in an idealized infinite-horizon limit. • Empirical validation and runtime: We evaluate PLarXiv:2605.

16588#pg2>. The finite-horizon policy library value function is defined as HΠT(x):= maxπi∈Π HπiT(x), which represents the maximum safety margin achievable across the library over a planning horizon T <ref:2605. p. 0
Where the paper says it

In this paper, we propose the Policy Library Control Barrier Function (PL-CBF), a runtime safety filter that retains multimodal safe maneuvers through a finite library of diverse fallback policies. PL-CBF certifies safety whenever at least one library policy remains safe over a planning horizon under the latest perceived constraints.

16588#pg2>. Safety is certified whenever at least one policy in the library remains safe over the horizon under the latest perceived constraints <ref:2605. p. 0
Where the paper says it

In this paper, we propose the Policy Library Control Barrier Function (PL-CBF), a runtime safety filter that retains multimodal safe maneuvers through a finite library of diverse fallback policies. PL-CBF certifies safety whenever at least one library policy remains safe over a planning horizon under the latest perceived constraints.

16588#pg2>.

Where the gains come from

The safety filter synthesizes a control input u⋆ by solving a Quadratic Program (QP) that minimally modifies the nominal command, aiming to select the least restrictive constraint by maximizing the volume of the admissible control set <ref:2605.16588#pg2>. The selection criterion is defined as i⋆ = arg max i∈Isafe(x) Vol (Kcbf(x; πi)), where Kcbf(x; πi) is the set of safe control inputs for policy πi <ref:2605. p. 2

Where the paper says it

For each policy πi ∈ Π, the set of safe control inputs is defined by the corresponding CBF constraint: Kcbf(x; πi) = {u ∈ U | ∇H πi T (x) ⊤(f(x) + g(x)u) ≥ −α(H πi T (x))}. (11) We select the least invasive policy index i ⋆ that maximizes the volume of this admissible set: i ⋆ = arg max i∈Isafe(x) Vol (Kcbf(x; πi)), Isafe(x) := { i ∈ {1, .

16588#pg2>. This selection process ensures that the filter retains multimodal safe maneuvers, avoiding the conservatism associated with single-policy dependence <ref:2605. p. 0
Where the paper says it

This singlefallback dependence induces conservatism and can lead to failures even when an alternative safe maneuver exists. In this paper, we propose the Policy Library Control Barrier Function (PL-CBF), a runtime safety filter that retains multimodal safe maneuvers through a finite library of diverse fallback policies.

16588#pg2>.

Empirical validation and runtime

The authors validated PL-CBF on three simulation benchmarks: a planar doubleintegrator, highway driving with abrupt friction changes using a realistic nonlinear vehicle model, and 3D quadrotor navigation in crowded dynamic environments <ref:2605.16588#pg2>. The simulations demonstrated improved safety coverage over single-policy filters while retaining millisecond-level runtime <ref:2605. p. 0

Where the paper says it

We provide a theoretical analysis based on a finite-horizon language metric over closed-loop behaviors, characterizing policy-library coverage requirements for certifying finite-horizon safety. Simulations on a planar doubleintegrator (4 states), highway driving with abrupt friction changes using a realistic nonlinear vehicle model (8 states), and 3D quadrotor navigation in crowded dynamic environments (12 states) demonstrate improved safety coverage over single-policy safety filters while retaining millisecond-level runtime.

16588#pg2>. For instance, in the highway driving experiment, PL-CBF achieved 0/50 failures, whereas all single-fallback baselines incurred collision or infeasibility <ref:2605. p. 6
Where the paper says it

With vref = 10 m/s, PL-CBF achieves 0/50 failures, whereas all single-fallback baselines incur collision or infeasibility (Table I). Although estimating changing dynamics quantities online is outside the scope of this paper and is left to future work, this experiment shows that PL-CBF has clear merit when the operating condition changes and a single backup maneuver can lose validity.

16588#pg2>. The computational structure is parallelizable because the computation of closed-loop trajectories and value functions for each policy is decoupled and can be executed simultaneously on parallel computing hardware <ref:2605. p. 3
Where the paper says it

is decoupled and can be executed simultaneously on parallel computing hardware such as GPUs. This parallel architecture allows the safety filter to scale efficiently with the size of the policy library K.

16588#pg2>.

Theoretical characterization

The theoretical analysis establishes a completeness condition for finite-horizon safety certification using a finite-horizon language metric over closed-loop behaviors <ref:2605.16588#pg2>. The theorem provides a sufficient condition for PLCBF to certify safety if the library approximates admissible closed-loop trajectories with sufficiently low δx(Π) relative to the trajectory clearance γ⋆ <ref:2605. p. 3

Where the paper says it

We now provide a sufficient condition under which PLCBF certifies finite-horizon safety whenever a feasible safety maneuver exists for the current snapshot. This result can be interpreted as a completeness guarantee: if there exists an admissible policy that is strictly safe with a nonzero margin, and the policy library approximates admissible closed-loop trajectories with sufficiently low δx(Π), then the library contains a policy that PL-CBF can certify as safe.

16588#pg2>. Furthermore, in the idealized infinite-horizon limit, the value function HΠ∞ is shown to be a Control Barrier Function on the set SΠ∞, and if a backup policy is included in Π, PL-CBF recovers infinite-time safety properties <ref:2605. p. 4
Where the paper says it

Relation to CBFs and Forward Invariance Although PL-CBF uses a finite-horizon rollout value, the discussion in this subsection is purely conceptual and considers the idealized infinite-horizon limit. For a fixed policy π, define the infinite-horizon policy value function as Hπ ∞(x) := inf t≥0 h(φ π t (x)).

16588#pg2>. The language metric dx(πi, πj) bounds the worst-case state deviation between two policy rollouts over [0, T] <ref:2605. p. 3
Where the paper says it

Given an initial condition x and a horizon T, we define the finitehorizon language metric between two policies πi and πj by dx(πi , πj ) := sup τ∈[0,T] ∥φ πi τ (x) − φ πj τ (x)∥2. (14) The language metric dx upper bounds the worst-case state deviation between two policy rollouts over [0, T], enabling transfer of finite-horizon safety margins via Lipschitz continuity of h (see Sec.

16588#pg2>.

Relation to CBFs and Forward Invariance

The conceptual discussion relates the finite-horizon rollout value function to the infinite-horizon policy value function Hπ∞(x) which satisfies a HamiltonJacobi variational inequality in the viscosity sense <ref:2605.16588#pg2>. This property implies that Hπ∞ is a CBF on the set Sπ∞, and if πb ∈ Π, PL-CBF recovers recursive feasibility guarantees associated with backup-based safety filters <ref:2605. p. 4

Where the paper says it

Finally, if the library contains a backup policy πb (Def. , πb ∈ Π, then the PL-CBF safety filter recovers the infinite-time safety (forward invariance) and recursive feasibility properties associated with backup-based safety filters.

16588#pg2>. The inclusion of the nominal policy πnom in the library allows for zero intervention when the nominal plan is safe, addressing unnecessary conservatism found in other backup-based filters <ref:2605. p. 4
Where the paper says it

Inclusion of Nominal Policy Many backup-based safety filters often exhibit unnecessary conservatism by modifying the nominal control even when the system is operating safely [12]–[14], [21]. This phenomenon, which we refer to as “safety evaluation on backup” [23], occurs because safety is typically evaluated based on the feasibility of a specific backup maneuver rather than the nominal plan itself.

16588#pg2>. The paper concludes that PL-CBF is practical as a deployable high-rate safety layer where reliance on a single fixed fallback maneuver is brittle <ref:2605. p. 7
Where the paper says it

PL-CBF retains multimodal safe maneuvers through a library of fallback policies, and selects the least invasive safe mode at each time step by evaluating the library online via parallelizable finite-horizon rollouts. The resulting structure makes PLCBF practical as a deployable high-rate safety layer in unstructured environments where reliance on a single fixed fallback maneuver is brittle.

16588#pg2>.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Policy Library Control Barrier Function (PL-CBF) improves safety coverage by retaining multimodal safe maneuvers through a finite library of candidate fallback policies while selecting the least restrictive constraint by maximizing the volume of the admissible control set.

  2. The system can maintain millisecond-level runtime while evaluating safety certificates online by utilizing parallelizable finite-horizon rollouts, avoiding offline synthesis tied to a single fixed model or constraint realization.

  3. PL-CBF allows for zero intervention when the nominal plan is safe by explicitly including the nominal policy in the library, as the solution to the QP in (13) yields u⋆ = unom, resulting in zero intervention.

  4. The system can safely navigate complex environments like highway driving with abrupt friction changes and 3D quadrotor navigation by certifying safety whenever at least one library policy remains safe over the planning horizon under the latest perceived constraints.

  5. PL-CBF offers improved safety coverage compared to single-policy filters by avoiding the tradeoff where a single fallback may recover a different safe set if a different fallback is chosen, as it evaluates multiple policies online.

Abstract

Safety-critical autonomy in unstructured environments poses significant challenges for online safety certification under evolving constraints, particularly when a single backup policy is not effective across operating conditions. We propose the Policy Library Control Barrier Function (PL-CBF), a runtime safety filter that evaluates a library of fallback policies via parallel finite-horizon rollouts. Among policies with constraint-satisfying rollouts and feasible CBF constraints, PL-CBF selects the policy maximizing the volume of its admissible control set and solves a single quadratic program to minimally modify the nominal input within that constrained input set. Using a finite-horizon language metric over closed-loop behaviors, we characterize when a finite policy library contains a constraint-satisfying rollout. Five simulation studies cover indoor robot navigation with a double-integrator model (4 states), highway driving under abrupt friction changes with a nonlinear vehicle model (8 states), and quadrotor flight control among dynamic obstacles (12 states), demonstrating improved safety performance compared with the evaluated baselines while maintaining millisecond-scale mean computation times. Hardware experiments on a mobile robot among moving pedestrians and a custom-built quadrotor among dynamic obstacles demonstrate real-time operation of PL-CBF.

Sources

Related papers