⚡ electrical engineering

Feasibility Analysis and Constraint Selection in Optimization-Based Controllers

This paper presents a novel theoretical framework establishing necessary and sufficient conditions for assessing the feasibility of linear constraints in autonomous system control, which is used to develop efficient algorithms for selecting feasible constraint subsets that match state-of-the-art performance with improved computational speed.

Original authors: Panagiotis Rousseas, Haejoon Lee, Dimos V. Dimarogonas, Dimitra Panagou

Published 2026-03-23

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Panagiotis Rousseas, Haejoon Lee, Dimos V. Dimarogonas, Dimitra Panagou

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 driving a self-driving car. Your goal is to get to a specific destination as quickly as possible. However, you have a list of rules you must follow:

Hard Rules (Non-negotiable): You cannot crash into walls, you must stay within the speed limit, and you must not drive off the road.
Soft Rules (Desirable but flexible): You should avoid potholes, stay in the center of the lane, and avoid driving near pedestrians.

Usually, the car's computer solves a math problem to figure out the perfect steering angle and speed. But what happens if the road gets too crowded? Suddenly, it becomes impossible to follow all the soft rules at the same time without breaking a hard rule. The computer gets stuck, the math problem has no solution, and the car might freeze or crash.

This paper presents a new, smarter way for the car to handle this "traffic jam" of rules.

The Problem: The "All-or-Nothing" Trap

In the past, when the computer realized it couldn't follow every rule, it had two bad options:

Option A: Give up on the whole plan and stop (which is dangerous).
Option B: Use a "relaxation" method. Imagine the computer adds a "magic penalty" to every rule. It tries to break the fewest rules possible, but it often ends up breaking many rules just a tiny bit, rather than breaking one rule completely. It's like trying to squeeze into a tiny elevator by slightly bending everyone's elbows instead of just letting one person step out. It's messy and inefficient.

The Solution: A "Rule Filter"

The authors of this paper developed a new mathematical tool that acts like a smart filter or a traffic cop.

Instead of trying to break rules slightly, their method asks: "Which specific rules are causing the traffic jam right now?"

They created a new way to look at the math that tells the computer exactly which constraints (rules) are pushing the system over the edge. It's like having a dashboard that doesn't just say "We have a problem," but points to the specific red lights: "Ah, Rule #4 (avoid the pothole) and Rule #7 (stay in the center) are fighting each other. We need to drop one of them to keep moving."

How It Works (The Analogy)

Think of the car's decision-making process as trying to fit a large, awkward piece of furniture (the solution) through a narrow doorway (the constraints).

The Old Way: You try to force the furniture through, bending it slightly (relaxation variables). It gets stuck, and you don't know which part of the furniture is hitting the doorframe.
The New Way (This Paper): The computer runs a quick, simple test (a Linear Program, or LP) that acts like a laser scanner.
- It scans the furniture and the door.
- It instantly identifies: "The top-left corner is hitting the frame."
- It then says: "Okay, let's remove the 'stay in the center' rule for just this second so we can get through."
- Once through, it checks if it can put the rule back.

Why Is This Better?

The authors tested their method against existing "state-of-the-art" methods using computer simulations (like a video game for robots). Here is what they found:

It's Faster: The new method solves the math problem much quicker. In a real-world scenario, milliseconds matter. Their method is consistently fast, whereas older methods sometimes get "spiky" and slow down unexpectedly.
It's Smarter: It keeps the car following more rules. The old methods often dropped 13% to 50% of the soft rules to get a solution. The new method only dropped about 2%. It's like the car successfully avoided 98% of the potholes instead of just 50%.
It's Safer: Because it's faster and keeps more rules active, the car is less likely to freeze up or make erratic movements.

The "Secret Sauce"

The core of their discovery is a new mathematical condition. They proved that you don't need to add "magic penalty" variables to the math to see if a solution exists. Instead, you can look at the shape of the problem itself.

They found that if you look at the "shadow" of the rules (a concept called a polar cone), you can tell exactly how close you are to a crash. If the shadow is touching the edge of the safe zone, the computer knows exactly which rule to let go of to stay safe.

Summary

In simple terms, this paper gives autonomous robots (like self-driving cars or drones) a better way to say "No."

When things get too complicated, instead of panicking or breaking everything slightly, the robot now knows exactly which single rule to temporarily ignore to keep moving safely. It's a more efficient, faster, and safer way to navigate a world full of conflicting rules.

1. Problem Statement

The paper addresses a critical challenge in autonomous systems: ensuring recursive feasibility in optimization-based controllers (such as Model Predictive Control (MPC) and Control Barrier Function (CBF) based controllers) when facing multiple, potentially conflicting constraints.

The Core Issue: In real-world scenarios, a system may encounter a state where the set of constraints (both hard and soft) becomes infeasible (i.e., no control input $u$ satisfies all constraints simultaneously).
Limitations of Existing Methods:
- Maximal Feasible Subset (MaxFS): Finding the largest subset of feasible constraints is an NP-hard problem.
- Relaxation/Slack Variables: Common approaches add slack variables to constraints to force feasibility. However, this increases problem dimensionality and fails to clearly decouple which constraints are violated from the degree of violation. It often leads to solutions that violate many constraints slightly rather than enforcing as many as possible.
- Lagrange Multiplier (LM) Heuristics: Previous works link infeasibility to unbounded LMs, but this lacks a clear "cutoff" boundary between feasible and infeasible states, making it difficult to quantify how close a system is to infeasibility.

Goal: The authors aim to develop a theoretical framework to:

Provide necessary and sufficient conditions for the feasibility of linear constraints without using slack variables.
Develop online algorithms to select the optimal subset of constraints to enforce, maximizing the number of satisfied constraints while maintaining computational efficiency.

2. Methodology

The proposed methodology is built on a novel theoretical analysis of linear constraints using Linear Programming (LP) and Convex Geometry (Polar Cones).

A. Theoretical Foundation: Feasibility Analysis

The authors generalize previous results (specifically from their prior work [21]) to establish a direct link between constraint feasibility and the geometry of the null space of the constraint matrix.

Farkas' Lemma & Dual Problem:
- The feasibility of a set of linear constraints $A^\top u \leq B$ is analyzed via a dual LP problem.
- Theorem 1: The set of admissible inputs is non-empty if and only if a specific dual LP (maximizing $-B^\top \lambda$ subject to $A\lambda = 0, \lambda \geq 0$ ) is bounded.
- Key Insight: If the dual LP is unbounded, the primal constraints are infeasible.
Polar Cone Criterion (The Novel Contribution):
- The authors define a Null Space Basis ( $N_A$ ) for the constraint matrix $A$ .
- They introduce a Polar Cone ( $N_C$ ) derived from the null space.
- Proposition 2: The constraints are feasible if and only if a transformed vector $B_A = N_A^\top B$ lies within the polar cone $N_C$ .
- Feasibility Metric ( $\nu^*$ ): By solving a specific LP (Eq. 11), the authors compute a vector $\nu^*$ $ν^{*}$ .
  - If $\nu^*$ exists and is non-negative, the system is feasible.
  - The magnitude of the elements in $\nu^*$ quantifies the "distance" of the current state from infeasibility. Small positive values indicate constraints that are "close" to causing infeasibility.

B. Constraint Selection Algorithms

Based on the $\nu^*$ metric, two online algorithms are proposed to manage soft constraints:

Algorithm 2: Iterative Constraint Addition (ICA)
- Mechanism: Starts with a feasible configuration (e.g., only hard constraints). It solves the LP to identify disregarded constraints that, if enforced, would still result in a feasible set (based on Corollary 1).
- Process: Iteratively adds constraints corresponding to positive components of the LP solution until no more can be added.
- Pros: Computationally efficient.
- Cons: May get stuck in local optima (finding a feasible subset, but not necessarily the maximal one).
Algorithm 3: Local Configuration Search (LCS)
- Mechanism: A more exhaustive search that explores the constraint space based on a user-defined search depth ( $D$ ).
- Process:
  - If the current configuration is infeasible, it removes the constraint with the smallest positive $\nu^*$ value (the one most likely causing infeasibility).
  - If the configuration is feasible, it attempts to add disregarded constraints with the smallest impact on feasibility.
- Pros: Better at escaping local minima and finding larger feasible subsets.
- Cons: Higher computational cost proportional to search depth $D$ .

C. Hybrid System Formulation

The paper models the controller as a Hybrid System where the continuous dynamics ( $\dot{x}$ ) evolve under a feasible configuration $P$ . When infeasibility is detected, a discrete jump occurs to update $P$ (the set of enforced constraints) using the selection algorithms, ensuring the system remains safe and operational.

3. Key Contributions

Necessary and Sufficient Conditions: A novel theoretical framework using LP and polar cones to determine feasibility of linear constraints without slack variables. This provides a clear mathematical boundary between feasible and infeasible states.
Quantitative Feasibility Metric: The introduction of the vector $\nu^*$ , which not only determines feasibility but also quantifies how close the system is to infeasibility and which specific constraints are the "bottlenecks."
Online Constraint Selection Algorithms: Development of Alg. 2 (ICA) and Alg. 3 (LCS) that utilize the theoretical metric to dynamically select the maximal feasible subset of constraints in real-time.
Computational Efficiency: The proposed methods solve LPs with $m$ decision variables (input dimension), whereas traditional slack-based methods solve problems with $m + n_s$ variables (input + number of soft constraints), leading to better scalability.

4. Simulation Results

The authors tested their algorithms on a robot motion planning problem involving:

Hard Constraints: Input bounds and Control Lyapunov Function (CLF) for goal reaching.
Soft Constraints: Avoidance of static and dynamic circular obstacles (zones).
Baselines: Compared against Chinneck's algorithm (Baseline 1) and a Lagrange-multiplier-based heuristic (Baseline 2).

Key Findings:

Constraint Satisfaction: Both Alg. 2 and Alg. 3 significantly outperformed Baseline 2 and matched or slightly exceeded Baseline 1 in terms of the percentage of soft constraints enforced (i.e., fewer constraints were disregarded).
Computation Time:
- The proposed algorithms maintained consistent, low computation times (average < 0.05s, max < 0.075s) across varying problem sizes (2 to 100 obstacles).
- Baseline 1 exhibited frequent "spikes" in computation time (up to 1.37s max), making it less reliable for real-time deployment.
- Baseline 2 was faster but sacrificed significantly more constraints (higher drop rates).
Scalability: The proposed methods scaled gracefully with the number of obstacles, whereas baseline methods relying on slack variables showed increased variance and maximum computation times.

5. Significance and Impact

Theoretical Advancement: The paper moves beyond heuristic constraint relaxation by providing a rigorous, geometric characterization of constraint infeasibility. This allows for precise diagnosis of why a controller fails.
Safety and Reliability: By ensuring that the controller selects the maximal possible set of constraints to satisfy, the system is less likely to violate safety-critical soft constraints (like obstacle avoidance) unnecessarily.
Real-Time Applicability: The reduction in computational complexity (solving smaller LPs without slack variables) makes these methods highly suitable for high-frequency control loops in autonomous vehicles and robotics.
Future Directions: The authors suggest this framework can be extended to solve the Maximal Feasible Subset (MaxFS) problem more generally, monitor feasible spaces, and design adaptive controllers that proactively adjust to infeasibility.

In summary, this work provides a mathematically robust and computationally efficient solution to the problem of constraint infeasibility in autonomous control, offering a superior alternative to traditional slack-variable approaches.