Adaptive Data-Driven Min-Max MPC for Linear Time-Varying Systems

This paper proposes an adaptive data-driven min-max model predictive control scheme for discrete-time linear time-varying systems that utilizes online input-state data to update state-feedback gains via semidefinite programming, ensuring exponential stabilization and constraint satisfaction for both noise-free and noisy scenarios.

The Gist

Imagine you are driving a car on a road that is constantly changing. Sometimes the road gets slippery (ice), sometimes it gets bumpy (potholes), and sometimes the engine's power fluctuates. You don't have a perfect map of the road ahead, but you do have a rough sketch (prior knowledge) and a dashboard that shows you exactly where the car is right now (online data).

This paper presents a new "smart driver" algorithm (called Adaptive Data-Driven Min-Max MPC) designed to handle these changing conditions safely and efficiently.

Here is the breakdown of how it works, using simple analogies:

1. The Problem: The Shifting Road

Most traditional control systems are like a driver who memorized a route years ago. They assume the road is always the same. But in the real world (like in robotics, power grids, or chemical plants), systems are Linear Time-Varying (LTV). This means the rules of physics change over time.

• The Challenge: If you rely only on your old map, you might crash when the road changes. If you try to learn the road from scratch while driving, you might crash before you learn enough.

2. The Solution: The "Smart Driver" Strategy

The authors propose a strategy that combines two things:

• The Safety Net (Prior Knowledge): You know the road roughly. You know the speed limit is between 50 and 60, and the road won't suddenly turn into a cliff. This is your "worst-case scenario" planning.
• The Live Feed (Online Data): As you drive, your sensors tell you exactly how the car is reacting right now. Is the road actually slippery? Is the engine actually weak?

The algorithm uses both to make decisions. It doesn't just guess; it updates its understanding of the road every single second.

3. How It Works: The "Worst-Case" Game

The core of the method is called Min-Max MPC. Think of this as playing a game against a very tricky opponent (the changing environment).

• The "Max" (The Opponent): The algorithm asks, "What is the worst possible way the road could behave right now, given what I know?" It prepares for the worst-case scenario (e.g., maximum ice, maximum engine failure).
• The "Min" (The Driver): The algorithm then asks, "Given that worst-case scenario, what is the best move I can make to stay safe and reach the goal?"

By planning for the worst but acting for the best, the system guarantees it won't crash, even if things get messy.

4. The Secret Sauce: Learning While Driving

Here is where the "Adaptive" part shines.

• Step 1: At the start, the driver uses the "Rough Sketch" (prior knowledge) to pick a safe driving style.
• Step 2: As the car moves, the driver collects data: "Okay, I turned left, and the car drifted 2 inches. The road is slippery here."
• Step 3: The algorithm updates its internal map. It realizes, "The road isn't as bad as I thought in this specific spot," or "It's actually worse than I thought!"
• Step 4: It recalculates the next move instantly.

This is like a GPS that doesn't just show you the route, but rewrites the route map in real-time based on traffic reports you are receiving live.

5. Handling the "Noise" (The Rain and Fog)

The paper also deals with Process Noise. Imagine it starts raining, or there is fog. You can't see perfectly, and the car might slide unexpectedly.

• The algorithm accounts for this "fog" by creating a safety bubble (called a Robust Positive Invariant set).
• Even if the car gets pushed by the wind (noise), the algorithm guarantees the car will stay inside this safety bubble and eventually drift back to the center of the lane, rather than spiraling out of control.

6. The Results: Faster and Safer

The authors tested this on computer simulations (like a driving simulator).

• The Old Way: A driver using only the old map drove safely but slowly, taking a very wide, cautious path.
• The New Way: The "Smart Driver" used the live data to take a tighter, faster, and more efficient path while still staying 100% safe.
• The Win: In their tests, the new method reduced the "cost" (fuel, time, or energy) by about 11% to 23% compared to the old method.

Summary

This paper gives us a new way to control machines that change over time. Instead of guessing or relying on outdated manuals, the system learns on the fly. It plays a game of "prepare for the worst, hope for the best," using real-time data to constantly update its strategy. The result is a system that is not only safe (it won't crash) but also much more efficient (it gets the job done faster and with less energy).

In a nutshell: It's like upgrading from a driver with a paper map to a driver with a live, self-updating GPS that knows exactly how the road is behaving right this second.

Technical Summary

Here is a detailed technical summary of the paper "Adaptive Data-Driven Min-Max MPC for Linear Time-Varying Systems" by Xie, Berberich, and Allgöwer.

1. Problem Statement

The paper addresses the control of unknown discrete-time Linear Time-Varying (LTV) systems subject to:

• Parametric Uncertainty: The system matrices $(A_t, B_t)$ are unknown but lie within a known uncertainty set.
• Time-Varying Dynamics: The system parameters change over time, but the rate of variation is bounded and known.
• Constraints: The system must satisfy state and input constraints.
• Process Noise (Extension): The system may be subject to bounded additive process noise.

The core challenge is to design a controller that ensures recursive feasibility, constraint satisfaction, and stability (exponential stability for noise-free systems, robust stability to a set for noisy systems) while improving performance over time by utilizing online data, without relying on explicit system identification.

2. Methodology

The proposed solution is an Adaptive Data-Driven Min-Max Model Predictive Control (MPC) scheme. The methodology proceeds in three main stages:

A. System Characterization (Data-Driven Set Description)

Instead of identifying a single model, the authors characterize the set of all system matrices consistent with:

1. Prior Knowledge: An initial ellipsoidal uncertainty set $\Sigma_p$ derived from first-principles or nominal models (Assumption 1).
2. Variation Bounds: Known bounds on how much the system matrices can change between time steps (Assumption 2, modeled via Quadratic Matrix Inequalities - QMIs).
3. Online Data: Real-time input-state measurements $(x_{t-i}, u_{t-i}, x_{t-i+1})$.

Using Lemma 1, the authors derive a data-driven characterization of the consistent system set $\mathcal{S}_t$ at time $t$. This set is the intersection of the prior uncertainty set and the sets consistent with all collected data points up to time $t$. This is formulated using non-negative multipliers (S-procedure) to combine the QMIs from prior knowledge and data.

B. Control Synthesis (Min-Max MPC via SDP)

The control objective is to minimize the worst-case infinite-horizon cost over the set of consistent systems.

• Initial Controller (Backup): At $t=0$, a static state-feedback gain $F_p^*$ is computed by solving a Semidefinite Program (SDP) based solely on prior knowledge (Problem 12). This ensures the system is stabilizable initially.
• Adaptive Controller: At each subsequent time step $t$, the controller is updated. The optimization problem minimizes a one-step stage cost plus a terminal cost (based on the initial Lyapunov function $P_p^*$) over the updated set $\mathcal{S}_t \cap \Sigma_p$.
• Reformulation: The min-max problem is intractable directly. The authors reformulate it into a tractable SDP (Problem 18) that computes an upper bound on the optimal cost and yields a time-varying state-feedback gain $F_t^*$.
• Receding Horizon: The algorithm solves the SDP at every time step, applies the first control input, measures the new state, updates the data set, and repeats.

C. Extension to Noisy Systems

For systems with bounded process noise (Assumption 3), the methodology is extended (Section V):

• The data-driven characterization (Lemma 2) incorporates the noise bounds using the S-procedure.
• The SDP formulation (Problem 47) includes additional variables to account for noise.
• Stability is guaranteed not to the origin, but to a Robust Positive Invariant (RPI) set.

3. Key Contributions

1. Unified Framework for LTV Systems: The paper proposes a general framework that unifies prior model knowledge and online data for LTV systems. It handles both Lipschitz continuous variations and periodic dynamics under a single ellipsoidal uncertainty description.
2. Recursive Feasibility and Stability Guarantees:
   • Noise-free: Proves that if the initial SDP is feasible, the adaptive scheme is recursively feasible and guarantees exponential stability to the origin.
   • Noisy: Proves robust stability to a specific RPI set and maintains recursive feasibility.
3. Adaptive Performance Improvement: Unlike indirect data-driven methods that identify a model first, this approach directly updates the control law using online data to shrink the uncertainty set, thereby reducing conservatism and improving closed-loop performance compared to static controllers.
4. Handling Initial Infeasibility: The paper addresses the scenario where prior knowledge is insufficient to design a stabilizing controller (initial SDP infeasible). It proposes a strategy of applying random inputs to collect data until a stabilizing controller can be synthesized.

4. Results

The authors validate the method through numerical simulations on two examples:

• Example 1: Lipschitz Continuous Dynamics:

  • Scenario: A 2D LTV system with time-varying parameters.
  • Result: The adaptive data-driven MPC converged significantly faster to the origin than a static controller designed only from prior knowledge.
  • Metric: The adaptive scheme achieved an average 18.55% reduction in closed-loop cost compared to the static controller.
  • Noise: With process noise, the adaptive scheme reduced the cost by 11.45% and kept trajectories within the RPI set.
  • Infeasibility Case: When prior knowledge was too loose to design a stabilizer, the "random input" strategy successfully collected enough data to synthesize a stabilizing controller at $t=10$.

• Example 2: Periodic Dynamics:

  • Scenario: A 3D system with periodic parameter variations.
  • Result: The adaptive scheme outperformed the static controller, achieving a 17.61% cost reduction in the noise-free case and 23.37% in the noisy case.
  • Significance: Demonstrates the method's ability to leverage periodic data structures effectively.

5. Significance

This work is significant for the control community for several reasons:

• Bridging Model-Based and Data-Driven Control: It successfully integrates rigorous model-based uncertainty bounds with real-time data, offering a middle ground between purely model-based robust control and purely data-driven approaches.
• Theoretical Rigor: It provides strong theoretical guarantees (recursive feasibility, stability, constraint satisfaction) for LTV systems, a class of systems where data-driven control is notoriously difficult due to the lack of a fixed "true" model.
• Practical Applicability: The use of SDP makes the approach computationally tractable for real-time implementation. The ability to start with limited knowledge and improve over time makes it suitable for systems where initial models are uncertain or inaccurate.
• Robustness: The extension to noisy systems with guaranteed convergence to an invariant set makes the method applicable to real-world physical processes subject to disturbances.

In summary, the paper presents a robust, adaptive control framework that leverages online data to dynamically refine uncertainty sets, resulting in superior performance and guaranteed stability for time-varying systems.