Feasibility Value Function (FVF)

• Feasibility Value Function (FVF) is a metric that quantifies finite-horizon feasibility by measuring the minimal slack violation required to satisfy hierarchical MPC constraints.
• FVF leverages slack variables to relax constraints in lower-level MPC, yielding a precise zero-level set that delineates the admissible region.
• FVF enables modular, contract-based design in hierarchical control, facilitating model confidentiality while ensuring safe, provable system performance.

The Feasibility Value Function (FVF), denoted $V_f$, is a predictive metric introduced to rigorously quantify finite-horizon feasibility in hierarchical model predictive control (MPC) architectures. Its construction leverages slack variables to relax state and reference-dependent constraints, providing an analytically tractable and contractible interface between hierarchical control layers. The zero-level set of $V_f$ precisely delineates the admissible region for the lower-level MPC, enabling provably safe modular design and execution, notably when model and cost structures are sequestered across control layers (Berkel et al., 16 Apr 2025).

1. Formal Definition and Mathematical Structure

Let $x(k)\in\R^{n_x}$ represent the current lower-layer state, and $$r^{\rm H}_{\cdot|k_{\rm H}}\in\R^{n_r\times N_{\rm H}}$$ a high-level reference trajectory, constant over fast-time blocks of size $N_{\rm L}$. Slack vectors $$\xi_{l|k}=[{\xi^x_{l|k}}^{\top},{\xi^{\Delta x}_{l|k}}^{\top}]^{\top}\geq0$$ relax state and reference-dependent constraints. The predictive feasibility value function is defined as

$$V_{f}(x(k),\,r^{\rm H}_{\cdot|k_{\rm H}}):=\min_{\substack{x_{\cdot|k},\,u_{\cdot|k},\\xi_{\cdot|k}\geq0}} \sum_{l=0}^{N(k)-1}\|\xi_{l|k}\|_{1}$$

subject to the finite-horizon system dynamics and relaxed constraints: $$\begin{cases} x_{0|k}=x(k),\ x_{l+1|k}=f(x_{l|k},u_{l|k}),\quad l=0,\dots,N(k)-1,\ c_x(x_{l|k})\le \xi^x_{l|k},\ c_{\Delta x}(x_{l|k},r^{\rm H}_{\cdot|k_{\rm H}})\le \xi^{\Delta x}_{l|k},\ c_u(u_{l|k})\le 0, \end{cases}$$ where $N(k):=N_{\rm H}N_{\rm L}-k$. By definition, $V_{f}(x,r)=0$ if and only if the corresponding hard-constrained MPC is feasible; otherwise, $V_{f}(x,r)>0$ quantifies the minimal slack violation required (Berkel et al., 16 Apr 2025).

2. Theoretical Properties and Relationship to Viability Kernels

The FVF admits a direct interpretation in viability kernel theory. The set $\mathcal{K}_0=\{(x,r)\mid V_{f}(x,r)=0\}$ forms the finite-horizon viability set in state-reference space. For state/reference pairs outside $\mathcal{K}_0$, the value $V_{f}(x,r)>0$ quantifies, in an $ℓ_1$-slack sense, the minimal aggregate violation necessary for admissibility under system constraints. This function acts as a cost-to-go: it is zero inside the viability kernel, strictly positive outside, and monotonically non-increasing under optimal (soft-constrained) control trajectories. The objective $\sum_{l=0}^{N(k)-1}\|\xi_{l|k}\|_{1}$ uniquely serves as the tightest violation margin to accommodate model and reference inconsistencies over the given horizon (Berkel et al., 16 Apr 2025).

3. Contract-Based Hierarchical Control Architecture

In the contract-based hierarchical control setting, a high-level planner (operating at slow timescale $T_{\rm H}=N_{\rm L}T_{\rm L}$) issues reference trajectories $r^{\rm H}_{\cdot|k_{\rm H}}$ to a low-level, fast-sampled MPC. The low-level MPC minimizes

$$J_{\rm MPC}(x_{\cdot|k},u_{\cdot|k},r^{\rm H}_{\cdot|k_{\rm H}}) + w_{\xi}\sum_{l=0}^{N(k)-1}\|\xi_{l|k}\|_{1}$$

subject to the same relaxed system and reference constraints.

A contract function $h_{\rm C}(x,r)$ is exchanged offline: it is an explicit (often neural network-based) approximation of $V_f$. Online, the high-level planner incorporates this contract in its optimization: $$\min_{x^{\rm H},\,r^{\rm H}}J^{\rm H}(x^{\rm H},r^{\rm H})+w_{h}\,h_{\rm C}(x(k),r^{\rm H}_{\cdot|k_{\rm H}})$$ with the option to enforce $h_{\rm C}(x,r)\leq0$ for strict lower-level feasibility. This enables the upper layer to proactively avoid references that violate the constrained capabilities of lower controllers, despite not possessing detailed model or constraint information from that layer (Berkel et al., 16 Apr 2025).

4. Explicit Function Approximation and Implementation

The FVF can be efficiently approximated via either look-up tables (LUT) or neural networks (NN), to facilitate online evaluation within the planner. For NNs, input features comprise a concatenated vector $$\left[x(k);\,r^{\rm H}_{0|k_{\rm H}};\ldots;r^{\rm H}_{N_{\rm H}-1|k_{\rm H}}\right] \in\R^{n_x+n_rN_{\rm H}}$$, with 2–4 hidden layers of 50–200 ReLU or tanh neurons, and a scalar output $\hat h_{\rm C}(x,r)$. Training proceeds by sampling states $x^{(i)}$ and reference sequences $r^{(i)}$, then solving the slack value problem offline to generate targets $V_f(x^{(i)},r^{(i)})$. The standard loss is

$$\mathcal{L}(\theta)=\frac{1}{M}\sum_{i=1}^{M}\left(\hat h_{\rm C}(x^{(i)},r^{(i)};\theta)-V_f(x^{(i)},r^{(i)})\right)^2+\lambda\|\theta\|_2^2,$$

where $\lambda$ is a regularization parameter. By the universal-approximation theorem and the Lipschitz continuity of $V_f$, a sufficiently wide/deep NN can achieve $$\sup_{x,r}|\hat h_{\rm C}(x,r)-V_f(x,r)|\leq\varepsilon$$ for arbitrary small $\varepsilon>0$. In practice, a positive safety margin $\delta>\varepsilon$ may be set, and feasibility is conservatively enforced via $\hat h_{\rm C}(x,r)\leq\delta\implies V_f(x,r)=0$ (Berkel et al., 16 Apr 2025).

5. Case Study: Autonomous Driving Application

In the autonomous driving example, the lower-level controller employs a single-track dynamic vehicle model discretized at $T_{\rm L}=50$ ms, with states $x=(p_x,p_y,\psi,v,\dot\psi,\beta)$ and controls $u=(\delta,a)$. Hard box constraints on velocity, steering, and acceleration are augmented by soft “tube” constraints: $$|p_{x,l|k}-p^{\rm ref}_{x,l|k_{\rm H}}|\leq d_{\max},\quad|p_{y,l|k}-p^{\rm ref}_{y,l|k_{\rm H}}|\leq d_{\max}$$ surrounding the planner’s path. The high-level planner operates on a simplified "constant-velocity + heading" model at a slower timescale and incorporates both quadratic target-tracking and nonconvex obstacle-avoidance costs.

Offline, for sampled $(x,r^{\rm H})$, the FVF is solved and stored as a LUT or approximator $\hat h_{\rm C}(x,r^{\rm H})$. Online, the planner evaluates candidate reference pairs ($\psi,v$), discards those with $\hat h_{\rm C}>0$, and propagates only admissible trajectories. The paper illustrates two sample runs: one with $\hat h_{\rm C}>0$ leading to a collision (constraint violation), and one with $\hat h_{\rm C}=0$ where the controller enforces the corridor and avoids obstacles (Berkel et al., 16 Apr 2025).

6. Significance for Modular and Confidential Control Design

The introduction of FVF enables modular, decoupled design in hierarchical control systems. By using an explicit, contract-based interface, the high-level planner need not have explicit access to the lower-level model, cost, or constraint definitions. This modularity supports model confidentiality and IP protection—a substantive concern in industrial and safety-critical domains—while maintaining system-wide feasibility guarantees. The FVF’s role as a cost-to-go proxy for constraint satisfaction also links it to viability theory and enables further generalizations for scenarios with time-varying, nonlinear, or nonconvex constraints (Berkel et al., 16 Apr 2025).

---

Summary Table: Core Properties of the Feasibility Value Function

Property	Mathematical Description	Control-Theoretic Significance
Zero-level set	$\{(x,r): V_f(x,r)=0\}$	Finite-horizon viability kernel
Value outside kernel	$V_f(x,r)>0$	Minimal total constraint violation needed
Contractability	Explicit LUT or NN approximation possible	Modularization; enables offline exchange
Monotonicity	Non-increasing under optimal relaxed policy	Cost-to-go behavior, feasibility margin