Exploiting Over-Approximation Errors as Preview Information for Nonlinear Control

Technical Summary: Exploiting Over-Approximation Errors as Preview Information for Nonlinear Control

Problem Statement
The control of nonlinear systems subject to state and input constraints is a fundamental challenge, particularly in safety-critical domains like aerospace and robotics. Traditional abstraction methods often replace complex nonlinear dynamics with simpler models (e.g., linear or piecewise affine systems) to enable tractable controller synthesis. However, these methods typically treat the approximation error as an unknown, adversarial disturbance. This conservative treatment forces controllers to account for the worst-case error realization, often leading to excessive conservatism and reduced performance. The central problem addressed in this work is how to leverage the structure of the over-approximation error to improve control performance without sacrificing safety guarantees.

Methodology
The authors propose a framework where the over-approximation error is not treated as an unknown disturbance but as input-dependent preview information.

1. Informed Policies: Instead of a standard state-feedback policy $\pi(x)$, the authors define an "informed policy" $\pi(x, e)$ that depends on both the current state $x$ and the over-approximation error $e$. Since the error function $e(x, u) = f(x, u) - \hat{f}(x, u)$ is known and deterministic, the error at runtime is a function of the chosen input $u$.
2. The Concretization Problem: Implementing an informed policy requires solving for an input $u$ such that $u = \pi(x, e(x, u))$. This creates a circular dependency between the input and the error. The authors formulate this as a fixed-point equation: finding $u$ such that $u = F_x(u)$, where $F_x(u) = \pi(x, f(x, u) - \hat{f}(x, u))$.
3. Existence and Computation:
   • Existence: Using the Brouwer fixed-point theorem, the authors prove that a solution exists if the input set $U$ is non-empty, compact, and convex, and the functions involved are continuous.
   • Efficient Computation:
     • Shared Input Dependency: If the true and approximate dynamics share the same input dependency (e.g., $f(x,u) = f_x(x) + B u$ and $\hat{f}(x,u) = \hat{f}_x(x) + B u$), the error becomes independent of $u$, allowing for a closed-form solution.
     • Input-Affine Systems: For systems where dynamics are affine in $u$ ($f(x,u) = f_x(x) + f_u(x)u$) and policies are error-affine, the concretization problem reduces to a convex program (or linear program if $U$ is a polytope).
     • General Nonlinear Systems: For arbitrary nonlinear systems, the authors establish conditions under which the fixed-point map is a contraction. If satisfied, the Banach fixed-point theorem guarantees a unique solution that can be found via iterative methods.
4. Policy Synthesis: To synthesize these policies, the authors utilize System Level Synthesis (SLS). They augment the system state to include the error term, transforming the problem into synthesizing a state-feedback policy for an augmented linear (or piecewise linear) system. This allows the use of convex optimization to design policies that satisfy constraints for all possible error realizations within the over-approximation set.

Key Contributions

• Reframing Approximation Error: The paper demonstrates that over-approximation errors naturally provide input-dependent preview information, challenging the standard view of these errors as purely adversarial disturbances.
• Informed Policy Formalism: The authors introduce "informed policies" that explicitly utilize the error term, generalizing classical uninformed policies.
• Concretization Framework: The problem of recovering a valid input for the true system from a preview-based policy is formalized as a fixed-point equation.
• Theoretical Guarantees:
  • Existence of solutions is guaranteed via Brouwer's theorem under mild topological conditions.
  • Efficient computation is provided via closed-form solutions, convex/linear programming, or iterative contraction methods depending on system structure.
• Synthesis Method: A method to synthesize informed policies using SLS on an augmented system, including conditions to ensure the contraction required for nonlinear concretization.

Results
The authors validate their approach through numerical experiments on two nonlinear systems:

1. Input-Affine Dynamics: A system with dynamics $\dot{x}_1 = x_2 + 0.5x_1^2$ and $\dot{x}_2 = 0.75x_1^2 + 2x_2^3 + \cos(x_2)u$. The informed policy achieved a guaranteed terminal state of $x_{1,T} \geq 0.81$, compared to $0.62$ for an uninformed policy.
2. Nonlinear Dynamics: A system with dynamics $\dot{x}_1 = x_2$ and $\dot{x}_2 = -\sin(x_1) + 0.5x_2^2 + 2\sin(u)$. Using the iterative Banach-based concretization, the informed policy guaranteed $x_{1,T} \geq 3.1$, outperforming the uninformed policy's guarantee of $2.7$.

In both cases, the informed policies significantly reduced conservatism, allowing the system to reach further into the state space while strictly satisfying constraints.

Significance and Claims
The paper claims that by interpreting over-approximation errors as preview information rather than unknown disturbances, control designers can achieve tractable and reliable control laws for constrained nonlinear dynamics with reduced conservatism. The work provides a rigorous mathematical foundation (via fixed-point theory) for this approach, ensuring that the "informed" decisions made by the policy are physically realizable (concretizable) for the true system. The authors position this as a step toward more efficient deployment of control systems in safety-critical domains where standard robust methods are often too conservative.

The paper concludes by noting that future work will address extensions to systems with external disturbances, output feedback, and multi-step preview information, but does not claim these extensions are currently solved.