trajectory-based-controlled-invariants - SKILL.md Agent Skill

name: trajectory-based-controlled-invariants description: "Compute controlled invariant sets for linear discrete-time systems using trajectory-based approach with convex feasible points. Use for MPC design, control invariant set computation, feasibility guarantees, and discrete-time system analysis. Keywords: controlled invariant, MPC, trajectory-based, convex feasible points, discrete-time systems, recursive feasibility."

Trajectory-Based Controlled Invariants

Description

A trajectory-based approach to computing controlled invariant sets for linear discrete-time systems. Introduces convex feasible points concept for invariant set characterization and provides MPC schemes with recursive feasibility guarantees without precomputed terminal sets.

Activation Keywords

controlled invariant
controlled invariant set
trajectory-based invariants
convex feasible points
MPC recursive feasibility
discrete-time system invariance
控制不变集
MPC 可行性
轨迹方法不变集

Tools Used

exec: Run Python scripts for system analysis
read: Load system models, reference papers
write: Save invariant set computations

Core Concepts

1. Convex Feisible Points

Definition: A finitely long state trajectory that provides new characterization of controlled invariance.

Key Properties:

Provides necessary condition for control invariance
Can be verified with finite trajectory length
Combines with backward fixed-point algorithm

2. Controlled Invariant Sets

Sets where system state can remain indefinitely under proper control.

Traditional Methods:

Backward reachability
Fixed-point iteration

Trajectory-Based Innovation:

Uses finite trajectories instead of infinite analysis
Reduces computational complexity
Enables practical MPC design

3. MPC without Terminal Sets

Two proposed MPC schemes:

Direct feasibility guarantee via trajectory constraints
Recursive feasibility through convex feasible points

Advantages:

No need for precomputed terminal sets
Online feasibility verification
Reduced offline computation burden

Instructions for Agents

Step 1: System Modeling

Given discrete-time linear system:

x(k+1) = Ax(k) + Bu(k)

Identify:

State matrix A
Input matrix B
State constraints X
Input constraints U

Step 2: Trajectory Analysis

Generate candidate trajectories
Verify convex feasible point conditions
Check trajectory constraints satisfaction

Verification criterion:

Trajectory must remain in X for all steps
Control inputs must satisfy U constraints
Must provide convex hull feasible for continuation

Step 3: Invariant Set Computation

Use backward fixed-point algorithm:

def compute_maximal_invariant(A, B, X, U, iterations=100):
    """Compute maximal controlled invariant set."""
    current_set = X
    for i in range(iterations):
        # Backward reachable set
        predecessor = backward_reach(A, B, current_set, U)
        # Intersection with constraints
        current_set = predecessor ∩ X
        if current_set.is_empty():
            break
    return current_set

Step 4: MPC Design

Construct MPC scheme:

def mpc_trajectory_based(x_current, horizon, A, B, X, U, convex_feasible_point):
    """MPC with trajectory-based feasibility guarantee."""
    # Optimization problem
    # Variables: x(0:N), u(0:N-1)
    # Constraints:
    #   - Dynamics: x(k+1) = Ax(k) + Bu(k)
    #   - State: x(k) ∈ X
    #   - Input: u(k) ∈ U
    #   - Feasibility: convex_feasible_point condition
    # Objective: minimize cost function
    
    return optimal_sequence

Step 5: Feasibility Verification

Check recursive feasibility:

Verify convex feasible point at each iteration
Ensure existence of feasible continuation
Validate constraint satisfaction

Use Cases

Use Case 1: Safety-Critical Control

Scenario: Robot navigation with obstacle avoidance

Application:

Define safety constraints (avoid obstacles)
Compute controlled invariant safe set
Design MPC guaranteeing perpetual safety
No precomputation of terminal safe set needed

Use Case 2: Resource Management

Scenario: Tank level control with limits

Application:

State constraints: tank level bounds
Input constraints: pump capacity
Compute invariant operating region
MPC maintains feasibility indefinitely

Use Case 3: Power System Control

Scenario: Generator scheduling with stability constraints

Application:

State: power output, frequency
Input: control signals
Invariant set ensures stability
Trajectory-based simplifies computation

Mathematical Formulation

Convex Feisible Point Definition

A trajectory {x(0), x(1), ..., x(N)} is a convex feasible point if:

State constraints: x(k) ∈ X for all k
Input constraints: u(k) ∈ U satisfies x(k+1) = Ax(k) + Bu(k)
Convexity: There exists convex combination enabling continuation

Optimization Problem

minimize   Σ J(x(k), u(k))
subject to x(k+1) = Ax(k) + Bu(k), k = 0, ..., N-1
           x(k) ∈ X, k = 0, ..., N
           u(k) ∈ U, k = 0, ..., N-1
           convex_feasible_point(x(N)) = true

Error Handling

Infeasible Initial State

Problem: Current state outside invariant set

Solution:

Check feasibility before MPC execution
If infeasible, use recovery maneuver
Plan trajectory to invariant set boundary

Invariant Set Computation Failure

Problem: Algorithm doesn't converge

Solution:

Increase iteration limit
Check constraint compatibility
Verify system controllability
Adjust numerical precision

Numerical Issues

Problem: Convex hull computation unstable

Solution:

Use robust convex hull algorithms
Increase trajectory length
Apply regularization techniques

Examples

Example 1: Double Integrator

System:

A = [[1, 1], [0, 1]]
B = [[0], [1]]
X = {x: |x₁| ≤ 10, |x₂| ≤ 2}
U = {u: |u| ≤ 1}

Process:

Generate trajectories with N=10
Identify convex feasible points
Compute maximal invariant set
Design MPC with horizon 5

Example 2: Room Temperature Control

System:

A = 0.95  # Decay rate
B = 1.0   # Heating effect
X = [18°C, 25°C]
U = [0kW, 5kW]

Application:

Compute temperature invariant interval
MPC maintains comfortable temperature
No terminal set precomputation

Resources

Paper: arXiv:2604.07225 - "A Trajectory-based Approach to Controlled Invariants"
Code: scripts/compute_invariant_set.py
References: references/discrete_time_control.md

Related Skills

kuramoto-control-theory: Synchronization control
robust-regret-control: Robust MPC design
ml-complexity-management: Complexity analysis for control

Notes

Applicable to linear discrete-time systems only
Numerical stability depends on trajectory length
Convexity assumption required
MPC horizon affects computational load