🔢 mathematics

Exact Solutions to a Class of Constrained Optimal Control Problems via Lossless Convexification for Digital Control

This paper presents a numerically viable technique that combines lossless convexification with piecewise constant parametrization to solve constrained, nonconvex continuous-time optimal control problems for linear systems, guaranteeing exact solutions and constraint satisfaction, as demonstrated on a spacecraft landing scenario.

Original authors: Vaibhav Upadhyay, Siddhartha Ganguly, Debasish Chatterjee

Published 2026-07-15

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Vaibhav Upadhyay, Siddhartha Ganguly, Debasish Chatterjee

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are the captain of a spaceship trying to land on a dusty, alien planet. You have a very tricky job: you need to burn just the right amount of fuel to reach a specific spot, but your rocket engine has a weird rule. It can't be turned off completely (you need a minimum push), but it also can't go too hard (a maximum push). This creates a "donut-shaped" zone of allowed power: you must be in the ring, never in the hole, never outside the edge.

This is the problem the authors tackle. They are dealing with a class of math problems called "optimal control," which is basically finding the perfect path for a machine to follow. The tricky part is that the "donut" rule makes the math messy and non-convex (think of a shape with a hole in it, which is hard to roll a ball across).

The Big Idea: Flattening the Donut
The authors use a clever trick called "lossless convexification." Imagine you have that donut-shaped rule. Instead of trying to solve the puzzle while stuck inside the donut, they invent a new, imaginary variable (a "slack variable") that acts like a flexible ruler. This ruler stretches to cover the donut, turning the messy, hole-filled shape into a smooth, solid hill.

Here is the magic: The authors prove that if you find the perfect path on this new, smooth hill, it is exactly the same as the perfect path on the original, messy donut. No information is lost. It's like flattening a crumpled map to find the shortest route, then folding it back up to get the real directions.

The Digital Twist: The "Pixelated" Pilot
Once they have the smooth hill, they need to solve it on a computer. Computers don't speak "continuous time" (every single fraction of a second); they speak in steps. The authors decide to describe the rocket's thrust as a series of "steps" or "pixels" of time. They break the landing time (say, 22 seconds) into chunks where the thrust stays constant.

But here is where most other methods fail. If you only check if the rocket is safe at the start of each time chunk, you might miss a disaster happening in the middle of the chunk. Imagine checking if a bridge is safe only at the pillars but ignoring the span in between. The authors argue that for safety-critical things like landing a spacecraft, this is dangerous.

The "Exact" Solution
The authors' method is special because it doesn't just check the "pillars." They developed a new way to guarantee the rocket is safe at every single moment in time, even though the computer only calculates a few points.

They treat the problem like a game of "find the worst moment." They ask the computer: "If we pick a specific set of moments to check, can we find a path that breaks the rules?" They then use a global search (like a very thorough explorer) to find the worst possible set of moments to check. If the path survives this "worst-case" test, the authors prove mathematically that the path is safe for the entire flight, every millisecond.

What They Found (and What They Didn't)
In their simulations, they tested this on a spacecraft landing problem with three degrees of freedom (moving up/down, left/right, and forward/back).

The Results: They successfully found paths that minimized both energy (using a smooth curve cost) and fuel (using a "L1-norm" cost, which is like counting total fuel drops).
The Proof: They showed that their method could spot a problem that other methods missed. In one test, a standard method said a landing was possible because it only checked 100 specific points. The authors' method, however, found a specific time (around 17.34 seconds) where the rules were broken, proving the landing was actually impossible.
The Cost: This thoroughness comes with a price. Their method takes longer to run on a computer than the "quick and dirty" methods that only check the grid points. In their tests, their best method took about 86 seconds to solve a problem, while a faster, less thorough method took only 1 second. However, the fast method gave a slightly wrong answer (a higher cost), and the ultra-fast method crashed when they tried to make it more precise.

What They Rule Out
The authors are very clear about what their method is not for. They explicitly state that because their method is computationally heavy (it takes time to find that "worst-case" moment), it is not suitable for "online" use. This means you couldn't use this exact algorithm to steer a drone in real-time while it's flying, reacting to wind gusts every millisecond. Instead, they position it as a tool for "offline" planning: calculating the perfect, certified-safe path on a powerful computer before the mission starts, which is then uploaded to the spacecraft.

How Sure Are They?
The authors are extremely confident in their mathematical proofs. They don't just "suggest" that their method works; they provide theorems that prove the solution is exact.

They proved that their "relaxed" problem (the smooth hill) yields the exact same answer as the original problem.
They proved that if they find a solution that satisfies a specific, finite set of "worst-case" time points, it satisfies the infinite number of time points in between.
Their results are backed by numerical simulations on a standard computer (using a 22-second landing time and specific grid sizes like 100 or 200 steps). They didn't just guess; they ran the numbers and showed the error between their "slack" variable and the actual thrust was tiny (around $10^{-8}$ ), effectively zero for all practical purposes.

In short, the authors have built a mathematical "certification" tool. It's slower than the standard tools, but it guarantees that if you follow the path it gives you, you won't accidentally crash between the check-points. It's the difference between a map that says "the road looks clear at the exits" and a map that guarantees "the road is clear for every inch of the journey."

Technical Summary: Exact Solutions to a Class of Constrained Optimal Control Problems via Lossless Convexification for Digital Control

1. Problem Formulation
This work addresses a class of finite-horizon optimal control problems (OCPs) for linear time-invariant systems subject to annular (nonconvex) control magnitude constraints. Specifically, the control input $u(t)$ is constrained such that its magnitude lies within a non-zero lower and upper bound ( $\rho_1 \leq \kappa(u(t)) \leq \rho_2$ ), a scenario common in aerospace applications like powered landing where engines cannot operate below a certain thrust level.

The core challenges identified are:

Nonconvexity: Standard direct numerical methods (e.g., direct collocation) that discretize the problem into nonlinear programming (NLP) retain the nonconvex nature of the annular constraints, leading to frequent feasibility and convergence issues.
Continuous-Time Constraint Satisfaction: Existing methods typically enforce constraints only at discrete grid points. This fails to guarantee satisfaction over the entire continuous time interval, potentially allowing "inter-sample" violations of safety constraints, which is detrimental in safety-critical applications.

2. Methodology
The proposed approach integrates lossless convexification with piecewise constant parametrization and convex semi-infinite programming (CSIP) theory to achieve exact solutions.

Lossless Convexification: The nonconvex OCP is transformed into an equivalent convex OCP by introducing a slack variable $s(t)$ . The annular constraint $\rho_1 \leq \kappa(u(t)) \leq \rho_2$ is relaxed to $\kappa(u(t)) \leq s(t)$ with $\rho_1 \leq s(t) \leq \rho_2$ . Under specific controllability assumptions (Assumption 1), the optimal solution to this convexified problem is proven to be identical to the original nonconvex problem.
Piecewise Constant Parametrization: To render the infinite-dimensional problem computationally tractable, the control $u(t)$ and slack $s(t)$ trajectories are parametrized using piecewise constant functions over a uniform grid. This maps naturally to digital control implementations and reduces the decision space to a finite-dimensional vector of coefficients.
Convex Semi-Infinite Programming (CSIP): Although the control is finitely parametrized, the constraints must still hold for an uncountable family of time instants within each subinterval. The problem is formulated as a CSIP.
Exact Numerical Solution via Global Optimization: The paper establishes that the optimal value of the CSIP can be recovered exactly by solving a maximization problem over a finite set of time instants.
- Let $G(\mathcal{T}; x)$ be the optimal value of a relaxed convex program where path constraints are enforced only at a finite tuple of time instants $\mathcal{T}$ .
- The main theoretical result (Theorem 8) proves that the exact optimal value of the original CSIP is obtained by maximizing $G(\mathcal{T}; x)$ over all possible tuples $\mathcal{T}$ .
- Theorem 11 further demonstrates that the optimizers of the original problem can be recovered by solving a sequence of regularized problems where the regularization parameter $\varepsilon \to 0$ .
Algorithmic Architecture (GlbOpt): A modular framework is proposed to solve the outer maximization problem using global optimization oracles (e.g., Differential Evolution, Simulated Annealing) and the inner minimization using standard convex solvers (e.g., IPOPT).

3. Key Contributions

Exactness Guarantee: The paper provides the first numerical framework, to the authors' knowledge, that guarantees exact solutions to this class of nonconvex OCPs while ensuring satisfaction of constraints over the entire continuous time horizon, not just at discretization nodes.
Infeasibility Detection: Unlike standard discretization methods that may report a feasible solution when one does not exist (due to missed inter-sample violations), the proposed method can rigorously detect infeasibility by identifying specific time instants where constraints are violated.
Digital Implementation Compatibility: The use of piecewise constant parametrization ensures the solution structure is inherently compatible with fixed-precision digital hardware.
Theoretical Rigor: The work establishes continuity properties of the value function mapping and proves the convergence of regularized solutions to the true optimizer.

4. Numerical Results and Experiments
The methodology was validated on a three-degree-of-freedom planetary landing problem involving both energy-optimal ( $L_2$ cost) and fuel-optimal ( $L_1$ cost) objectives.

Constraint Satisfaction: In all tested cases, the control norm remained strictly within the prescribed annular bounds, and the error between the slack variable and the control norm was negligible ( $\sim 10^{-8}$ to $10^{-10}$ ), confirming the lossless nature of the convexification.
Infeasibility Case: A specific disturbance scenario was constructed where standard discretization methods (enforcing constraints only at grid points) incorrectly reported feasibility. The proposed method successfully identified the infeasibility by finding time instants within the intervals where constraints were violated.
Comparative Performance:
- Compared to direct transcription methods (QuITO) and discrete-time lossless convexification (DLCvx), the proposed GlbOpt framework achieved lower (better) optimal costs, indicating that the competing methods suffered from discretization errors.
- While global optimization variants (Differential Evolution, Simulated Annealing) were computationally slower than gradient-based methods, the gradient-based variant of GlbOpt (gradOL) achieved comparable speeds to DLCvx and QuITO while maintaining the theoretical guarantee of continuous-time constraint satisfaction.
- As the grid resolution increased for competing methods, their costs approached GlbOpt's results, but at the expense of significantly increased computational time and problem dimension.

5. Significance and Limitations
The paper positions this work as a significant advancement for offline trajectory generation and certification in aerospace guidance, where solution accuracy and continuous-time safety guarantees are paramount.

Limitations: The authors explicitly note that the computational cost of the global optimization layer makes the current framework unsuitable for online Model Predictive Control (MPC). The method is designed for offline synthesis where substantial computational resources can be allocated to ensure certified feasibility.
Scope: The contributions are strictly limited to linear systems with annular constraints and piecewise constant control parametrization. The "exactness" claim refers to the recovery of the optimal value and optimizers for the finitely parametrized CSIP, not necessarily the approximation of the infinite-dimensional continuous-time optimal control without any parametrization error (though the paper notes piecewise constant functions are dense in $L_1$ ).

In summary, this work bridges the gap between the theoretical benefits of lossless convexification and the practical requirements of digital control by providing a numerically viable, exact method for solving nonconvex optimal control problems with continuous-time safety guarantees.

More like this