Constrained finite-time stabilization by model predictive control: an infinite control horizon framework

This paper proposes an infinite-horizon Model Predictive Control framework that achieves constrained finite-time stabilization for discrete-time linear and feedback-linearizable nonlinear systems by replacing short-horizon terminal costs with an infinite sum of stage costs, thereby significantly enlarging the initial feasibility region while ensuring computational tractability and eliminating the need for terminal equality constraints or switching strategies.

The Gist

Imagine you are driving a car that needs to come to a perfect, complete stop at a specific red light. Not just "slow down and drift to a halt," but stop exactly at the line in a specific number of seconds, say, 5 seconds flat.

Now, imagine your car has two rules:

1. The Brakes: You can't slam the brakes too hard, or the passengers will get hurt (this is the constraint).
2. The Road: You can't drive off the cliff or into the sidewalk (another constraint).

This is the problem the paper solves. It's about a smart computer system (called Model Predictive Control, or MPC) that tells the car exactly how to brake to hit that perfect stop in a fixed time, without breaking the rules.

The Old Way: The "Short-Sighted" Driver

Previous methods were like a driver who only looks one or two steps ahead.

• To guarantee a perfect stop, they would force the car to be exactly at the stop line at a specific future moment (a "terminal equality constraint").
• The Problem: If you started too far away or too fast, this method would say, "I can't do it!" and refuse to give you a plan. It had a very small "safe starting zone."
• The Fix: Some tried to switch driving modes mid-way (like switching from "cruising" to "panic stop"), which is complicated and risky.

The New Way: The "Long-Range Vision" Driver

The authors of this paper propose a new strategy: The Infinite Horizon Framework.

Think of it like this: Instead of just looking at the stop line, the driver looks all the way down the road to infinity.

1. The "Infinite" View: The computer calculates the cost of driving for a very long time. It says, "I will plan a path that minimizes the total effort from now until forever."
2. The Trick: Here is the magic part. The computer ignores the cost of driving for the first few seconds (the time it takes to get the car moving or reacting). It only starts counting the "penalty" for being off-course after the car has had enough time to react (specifically, after $n$ steps, where $n$ is the complexity of the car).
3. The Result: Because the driver is looking so far ahead, they can find a safe, smooth path to the stop line from much further away than the old drivers could. It significantly expands the "safe starting zone."

How It Works in Real Life (The Metaphor)

Imagine you are trying to stack a tower of blocks perfectly.

• Old Method: You try to place the final block exactly on the target spot immediately. If you are too far away, you can't reach it without knocking the tower over.
• New Method: You plan a path where you build the tower for a while, but you only start worrying about the "perfect alignment" once the tower is stable. Because you planned the whole journey, you realize you can start from a much wider area and still end up with a perfect tower.

Why Is This a Big Deal?

The paper proves three main things:

1. It Works for More Cars: It works for simple cars (single-input) and complex trucks with many wheels (multi-input).
2. It Handles Curvy Roads: It even works for non-linear systems (like a boat that moves differently when turning fast), as long as the boat can be "straightened out" mathematically.
3. It's Practical: Even though the math says "look to infinity," the computer only needs to look a finite distance ahead (like 8 or 10 steps) to get the same perfect result. It's like having a telescope that sees forever, but you only need to focus on the next mile to know where to steer.

The Bottom Line

This paper gives us a smarter way to stop things quickly and precisely without breaking the rules. It stops the system from saying "I can't do that" just because the starting point was a little tricky. It makes the "perfect stop" possible for a much wider range of situations, making control systems safer and more reliable for everything from drones to power grids.

Technical Summary

Here is a detailed technical summary of the paper "Constrained finite-time stabilization by model predictive control: an infinite control horizon framework."

1. Problem Statement

The paper addresses the challenge of finite-time stabilization for discrete-time systems subject to state and control constraints.

• Goal: Drive the system state to the origin ($x=0$) in a finite number of time steps (deadbeat control) while strictly satisfying constraints ($x \in \mathcal{X}, u \in \mathcal{U}$).
• Limitations of Existing Methods: Current finite-time Model Predictive Control (MPC) approaches suffer from significant drawbacks:
  • Terminal Equality Constraints: Requiring the state to reach the origin exactly at the end of the horizon often leads to a very small (or empty) initial feasible region.
  • Short Control Horizons: Methods that penalize only the terminal cost with a horizon equal to the system dimension ($N=n$) are computationally light but severely limit feasibility.
  • Switching Strategies: Some approaches require complex switching logic (e.g., entering a "one-step region") to achieve finite-time convergence, complicating implementation.
  • Matrix Equality Constraints: Controller-matching methods often require solving optimization problems with matrix equality constraints, which can lead to infeasibility.

2. Methodology

The authors propose a novel Infinite-Horizon Finite-Time MPC framework that is implemented practically as a Finite-Horizon MPC with a specific cost structure.

A. Core Concept: Infinite-Horizon Cost with Delayed Summation

Instead of summing stage costs from $i=0$ to $\infty$ (standard MPC) or only penalizing the terminal state (existing finite-time MPC), the proposed framework defines the cost function $J(k)$ as:
$$J(k) = \sum_{i=n}^{\infty} \left( \|x(i|k)\|_Q^2 + \|u(i|k)\|_R^2 \right)$$

• Key Feature: The summation of stage costs begins at step $i = n$ (where $n$ is the system dimension) rather than $i=0$.
• Rationale: This allows the controller to utilize the first $n$ steps to maneuver the state into a region where finite-time convergence is guaranteed, without penalizing the transient path as aggressively as standard MPC, thereby enlarging the feasible set.

B. Practical Implementation (Finite-Horizon Equivalent)

Since infinite-horizon optimization is computationally intractable, the authors prove that the infinite-horizon problem is equivalent to a finite-horizon problem with a terminal cost:
$$J_f(k) = \sum_{i=n}^{N-1} \left( \|x(i|k)\|_Q^2 + \|u(i|k)\|_R^2 \right) + \|x(N|k)\|_P^2$$

• Horizon: $N \geq n$ (can be chosen significantly larger than $n$).
• Terminal Cost: The weighting matrix $P$ is derived from a Lyapunov equation associated with a stabilizing feedback gain $K$.
• Terminal Constraint: The state at the horizon $x(N|k)$ must lie within an invariant terminal set $\mathcal{X}_f$.
• Constraint Handling: The formulation avoids terminal equality constraints ($x(N)=0$) and switching logic, relying instead on standard inequality constraints.

C. Theoretical Guarantees

The paper provides rigorous proofs for:

1. Recursive Feasibility: If the optimization is feasible at $k=0$, it remains feasible for all $k > 0$.
2. Finite-Time Convergence: Once the state enters a specific terminal set (where constraints are inactive), the controller acts as a deadbeat controller, driving the state to zero in exactly $n$ steps.
3. Stability: The closed-loop system is asymptotically stable, and under the specific cost structure, it achieves strict finite-time convergence.

D. Extensions

The framework is systematically extended to:

• Multi-Input Linear Systems: By transforming the system into a decoupled form (controllable canonical form) and applying the cost function to each subsystem.
• Constrained Nonlinear Systems: For feedback-linearizable systems, the MPC is designed in the transformed linear coordinates ($z = M(x)$), ensuring finite-time convergence in the original nonlinear space.

3. Key Contributions

1. New Framework: Introduction of an infinite-horizon finite-time MPC framework that replaces short-horizon terminal costs with a sum of stage costs starting from the system dimension ($i=n$).
2. Enlarged Feasibility Region: The method significantly expands the initial feasible region compared to existing terminal-equality or short-horizon strategies, making it applicable to a wider range of initial conditions.
3. Implementation Simplicity: It eliminates the need for terminal equality constraints and complex switching strategies, implementing finite-time behavior via a standard finite-horizon MPC with a terminal cost.
4. Generalizability: Theoretical extension to multi-input linear systems and a class of feedback-linearizable nonlinear systems.

4. Results and Validation

Numerical simulations were conducted on three types of systems to verify the theory:

• Single-Input Linear System:
  • Result: The system reached the origin in 7 steps (system dimension $n=2$, horizon $N=8$).
  • Feasibility: Fig. 2 demonstrates that the proposed method's feasible region is significantly larger than the previous terminal-cost strategy (dashed line vs. solid line).
• Multi-Input Linear System:
  • Result: Transient response settled in 11 steps. The controller successfully managed constraints for multiple inputs.
• Nonlinear System:
  • Result: The nonlinear plant reached the origin in 5 steps while respecting state and control constraints.
• Robustness: Simulations with bounded random disturbances showed that the system states remained ultimately bounded, and constraints were not violated, provided disturbances were not excessively large.

5. Significance and Impact

• Bridging the Gap: This work bridges the gap between the theoretical desire for finite-time convergence and the practical necessity of constraint satisfaction and large feasibility regions.
• Practical Viability: By avoiding restrictive terminal equality constraints and switching logic, the proposed method is easier to implement in real-world applications (e.g., motor control, power systems, robotics) where constraints are hard limits.
• Design Flexibility: The ability to choose a control horizon $N$ significantly larger than the system dimension $n$ allows engineers to trade off computational load for a much larger operating envelope (feasible region).
• Future Direction: The paper identifies that while the framework guarantees finite-time stabilization, explicitly calculating the exact convergence time $T$ based on constraints remains a challenge for future work. It also notes that the current nonlinear extension is limited to feedback-linearizable systems.

In summary, this paper presents a robust, theoretically sound, and practically implementable MPC strategy that achieves strict finite-time stabilization for constrained systems, overcoming the feasibility limitations of previous approaches.