Free SKILL.md scraped from GitHub. Clone the repo or copy the file directly into your Claude Code skills directory.
npx versuz@latest install hiyenwong-ai-collection-collection-skills-hierarchical-control-gaasgit clone https://github.com/hiyenwong/ai_collection.gitcp ai_collection/SKILL.MD ~/.claude/skills/hiyenwong-ai-collection-collection-skills-hierarchical-control-gaas/SKILL.md---
name: hierarchical-control-gaas
description: "Hierarchical control synthesis for continuous-time systems using epsilon-general Approximate Alternating Simulation (epsilon-gAAS) relations. Enables formal controller design with coarser abstractions while maintaining correctness guarantees. Use when: (1) designing hierarchical controllers for continuous-time systems, (2) building formal abstractions for complex dynamical systems, (3) synthesizing safety-critical controllers with correctness guarantees, (4) applying simulation relations for model reduction in control design. Activation: hierarchical control, simulation relations, formal control synthesis, abstraction-based control, gAAS, continuous-time control refinement."
version: 1.0.0
author: Hermes Agent
license: MIT
metadata:
hermes:
source_paper: "Hierarchical Control for Continuous-time Systems via General Approximate Alternating Simulation Relations (arXiv:2604.28108)"
citations: 0
tags: [control-systems, formal-methods, hierarchical-control, abstraction, continuous-time]
---
# Hierarchical Control via ε-gAAS Relations
## Overview
The ε-general Approximate Alternating Simulation (ε-gAAS) relation enables hierarchical control synthesis for continuous-time systems by allowing larger mismatches between abstract and concrete models compared to existing simulation relations. This reduces computational complexity of controller synthesis while preserving correctness guarantees.
Source: Huang et al., arXiv:2604.28108 (Apr 2026)
## Core Concepts
### ε-gAAS Relation
Given concrete system Σ_c and abstract system Σ_a, an ε-gAAS relation R ⊆ X_c × X_a satisfies:
1. **Output approximation**: For all (x_c, x_a) ∈ R, ||H_c(x_c) - H_a(x_a)|| ≤ ε
2. **Forward simulation**: For each x_c and input u_c, exists u_a such that transitions stay within R (with ε tolerance)
3. **Alternating property**: The simulation alternates between concrete and abstract transitions
### Control Refinement
Given controller K_a for abstract system Σ_a, refine to concrete controller:
```
K_c(x_c) = K_a(H(x_c))
```
where H maps concrete states to abstract states.
## Implementation Pattern
```python
import numpy as np
from scipy.integrate import odeint
class GAASHierarchicalControl:
"""Hierarchical control via ε-gAAS relations."""
def __init__(self, concrete_system, abstract_system, epsilon, mapping_H):
"""
Args:
concrete_system: Concrete continuous-time system dynamics
abstract_system: Abstract system dynamics (simplified model)
epsilon: Maximum output mismatch tolerance
mapping_H: State mapping from concrete to abstract space
"""
self.sigma_c = concrete_system
self.sigma_a = abstract_system
self.epsilon = epsilon
self.H = mapping_H
def verify_gaas_relation(self, x_c, x_a):
"""Check if state pair satisfies ε-gAAS relation."""
output_error = np.linalg.norm(
self.sigma_c.output(x_c) - self.sigma_a.output(x_a)
)
return output_error <= self.epsilon
def refine_controller(self, abstract_controller):
"""Refine abstract controller to concrete system."""
def concrete_controller(x_c):
x_a = self.H(x_c)
u_a = abstract_controller(x_a)
return self.map_control(u_a, x_c)
return concrete_controller
def map_control(self, u_a, x_c):
"""Map abstract control input to concrete control input."""
# Domain-specific control mapping
# For linear systems: u_c = B_c^+ @ B_a @ u_a
# For nonlinear: use inverse dynamics or optimization
raise NotImplementedError
```
## Workflow
1. **Model concrete system** - Define Σ_c with dynamics ẋ = f(x, u), output y = h(x)
2. **Construct abstraction** - Create Σ_a with reduced state space (state quantization, order reduction)
3. **Establish ε-gAAS** - Prove relation R exists with bounded ε
4. **Synthesize abstract controller** - Design K_a on simplified model (computationally tractable)
5. **Refine to concrete** - Apply K_c(x_c) = K_a(H(x_c))
6. **Verify guarantees** - Output error bounded by ε, safety properties preserved
## When to Use
- **Formal control synthesis** with safety/stability guarantees
- **Large-scale systems** where direct controller synthesis is intractable
- **Safety-critical applications** requiring provable correctness
- **Multi-scale systems** with natural abstraction hierarchy
## Comparison with Existing Methods
| Method | Abstraction Type | Mismatch Tolerance | Continuous-time |
|--------|-----------------|-------------------|-----------------|
| ε-ASR | Approximate Simulation | Fixed ε | Yes |
| ε-Alt-SR | Alternating Simulation | Fixed ε | Discrete only |
| **ε-gAAS** | General Alternating | **Larger ε** | **Yes (novel)** |
## References
- Huang, Z., Li, S., Arcak, M., Zamani, M., Zhong, B. (2026). "Hierarchical Control for Continuous-time Systems via General Approximate Alternating Simulation Relations." arXiv:2604.28108.
- Related skills: [[dual-envelope-mpc]], [[finite-time-reachability-partial-control]], [[discounted-mpc-control]]