⚡ electrical engineering

Learning Input-Constrained Funnel Controllers from State Trajectory Data

This paper proposes an optimization-based framework that learns input-constrained funnel controllers directly from state trajectory data, enabling the synthesis of feedback controllers that enforce prescribed performance and hard input constraints without requiring expert control input data or policy reconstruction.

Original authors: Panagiotis S. Trakas, Omid Mirzaeedodangeh, Lars Lindemann

Published 2026-07-28

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Panagiotis S. Trakas, Omid Mirzaeedodangeh, Lars Lindemann

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 teaching a robot to walk through a crowded, narrow hallway without bumping into walls or tripping over its own feet. In the world of robotics and engineering, this is the job of a "controller"—a brain that tells the robot's motors exactly how hard to push. But there's a catch: real robots have limits. Their motors can only push so hard before they overheat or break (input constraints), and they need to move smoothly, not just get from point A to point B, but do it with a specific grace, speed, and safety margin (performance specifications).

For a long time, engineers have tried to solve this by either guessing the perfect rules (which is hard because the robot's body might be slightly different than the blueprint) or by watching an expert and trying to copy their every move. But what if you only have a video of the expert walking, with no audio of their commands? You can see where they went, but you don't know exactly how hard they pushed the buttons. This paper tackles that exact puzzle: how to teach a robot to walk perfectly and safely just by watching where it went, without ever seeing the secret control codes, provided you have a rough blueprint (a "nominal model") of how the robot moves.

The researchers, working at ETH Zurich, propose a clever new way to learn from "state trajectory data"—which is just a fancy term for a record of where the robot was at every moment in time. Instead of trying to reverse-engineer the expert's hidden button presses (a method called imitation learning that often fails when you don't have the button data), they treat the problem like a game of "design the perfect hallway." They want to draw a virtual, shrinking tunnel (called a "funnel") around the path the expert took. This tunnel represents the safe zone: if the robot stays inside this tunnel, it is moving fast enough, stopping accurately enough, and not wobbling too much.

The challenge is that the tunnel has to be shaped perfectly. If it's too wide, the robot is lazy and slow; if it's too narrow, the robot's motors might scream in protest because they have to work too hard to stay inside. The team developed a mathematical recipe that uses the recorded paths and the known blueprint of the system to automatically design this tunnel and, at the same time, invent a new set of rules for the robot to follow. They call this a "joint synthesis" because they build the tunnel and the controller together, like a key and a lock, ensuring they fit perfectly.

Here is the magic trick: The paper argues that you don't need to know the expert's secret commands to learn the behavior, but this only works if you have a basic model of the system's physics (a "nominal model") to start with. By looking at the smooth curves of the recorded paths, the algorithm figures out the "shape" of the tunnel that would naturally contain those paths. Then, it calculates a feedback gain—a kind of "steering sensitivity"—that tells the robot how hard to push to stay inside that tunnel, even if the robot's motors hit their maximum limit. The authors use a method called "active-set synthesis," which is like a smart trial-and-error process. It tries to fit the tunnel and the steering rules, checks if the robot's motors would get stuck, and if they do, it gently reshapes the tunnel or adjusts the rules until a solution is found that respects the motor limits.

To prove this works, the team ran simulations on a system that mimics two connected water tanks, where the goal is to keep the water levels at specific heights. They generated 30 different "expert" paths using various controllers, then threw away the secret commands and fed only the water level data and the system's physical parameters (the nominal model) into their new algorithm. The result? The algorithm successfully learned a single, simple set of rules that could guide the water levels to the target, staying strictly inside the learned "funnel" and never asking the pumps to push harder than they were allowed.

The paper doesn't just say "it looks like it works"; it provides two layers of mathematical proof. The first is a "conservative" guarantee: if the motors are strong enough to handle the worst-case scenario, the robot will definitely stay safe. The second is a "local" guarantee: if the recorded data is dense enough (lots of samples close together), the robot is guaranteed to stay safe right around those recorded paths. In their simulations, the new controller not only kept the water levels safe but also compensated for small errors in the tank's physical model, something that older, simpler methods often failed to do.

Ultimately, this work suggests that we can teach complex machines to perform with high precision and safety just by watching them move, using a rough model of their mechanics to fill in the gaps, without needing to know their internal secrets or having access to their control inputs. It's a step toward making robots that can learn from observation alone, adapting to their own physical limits while mimicking the graceful behavior of an expert. The authors note that while their method is promising, it relies on having a decent "nominal model" (a rough idea of how the system works) and that the mathematical proofs are currently based on simulations, leaving room for future work to test these ideas on real-world hardware.

Technical Summary: Learning Input-Constrained Funnel Controllers from State Trajectory Data

Problem Formulation
The paper addresses the challenge of designing feedback controllers for nonlinear control-affine systems that satisfy predefined performance specifications (transient and steady-state behavior) while strictly adhering to hard input constraints. Traditional Prescribed Performance Control (PPC) and Funnel Control (FC) methods often struggle under actuator limits: aggressive performance specifications may exceed available control authority, while conservative designs sacrifice performance. Furthermore, existing learning-based approaches typically require state-input pairs to reconstruct expert policies or learn safety certificates, whereas many practical scenarios (e.g., teleoperation, motion capture) provide only state trajectory data without corresponding control inputs. The core problem is to jointly synthesize a time-varying performance funnel and a feedback controller using state-only data, ensuring the learned behavior is feasible under hard actuator bounds without reconstructing the expert's control policy.

Methodology
The authors propose an optimization-based framework that jointly learns a performance funnel and a state-dependent feedback gain.

System Model and Assumptions: The system is modeled as $\dot{x} = f(x) + G(x)u$ with hard componentwise input constraints $|u_i| \leq \bar{u}_i$ . The approach assumes access to a nominal model $(\hat{f}, \hat{G})$ with bounded uncertainty and a compact set $X_c$ containing the demonstrated trajectories.
Funnel Parameterization: The performance funnel boundaries $\rho(t)$ $ρ (t)$ are parameterized using cubic B-splines. Constraints are imposed to ensure:
- Positivity: The funnel remains strictly positive.
- Data-Driven Bounds: The funnel boundaries lie within empirical quantile envelopes ( $\alpha$ and $\beta$ ) derived from the state trajectories, ensuring the funnel captures the dominant behavior of the demonstrations while being robust to outliers.
- Dynamics: Constraints on the first and second derivatives of the funnel ensure smoothness and limit the contraction rate.
Controller Parameterization: The controller combines nominal model compensation with a learned state-dependent gain. The control law is $u = \text{sat}_{\bar{u}}(u_d)$ , where the desired input $u_d$ compensates for nominal drift and funnel dynamics, and a diagonal gain matrix $K(\xi; w)$ (parameterized by Radial Basis Functions) provides feedback on the transformed error $\xi$ .
Synthesis Procedure: The joint synthesis problem is nonconvex due to the saturation operator. The authors develop a feasibility-driven active-set synthesis procedure:
- Outer Loop: Solves a linear program to find funnel parameters ( $\theta$ ) for a given contraction rate scaling factor $v$ .
- Inner Loop: For fixed funnel parameters, solves a sequence of convex quadratic programs to find the gain weights ( $w$ ). This loop iteratively updates the "saturation pattern" (which inputs are saturated vs. unsaturated) to handle the nonconvexity of the saturation function.
- Verification: A candidate pair is accepted only if the Lyapunov decrease condition is satisfied at all sampled demonstration points within the funnel, accounting for the actual saturated inputs.

Key Contributions

Data-Driven Joint Synthesis: A framework that learns both a time-varying performance funnel and an input-constrained PPC controller from state-only trajectories, without requiring expert input data or policy reconstruction.
Feasibility-Driven Active-Set Procedure: A novel algorithmic approach to solve the resulting nonconvex synthesis problem by iteratively fixing saturation patterns, allowing for explicit handling of input saturation during the learning process.
Complementary Theoretical Guarantees:
- A semi-global conservative certificate based on actuator authority, ensuring prescribed performance and input satisfaction if the control authority is sufficiently large relative to the system dynamics and model uncertainty.
- A local data-driven certificate ensuring these properties near sufficiently dense demonstrated trajectories, relying on Lipschitz regularity and data coverage rather than uniform actuator bounds.

Results
The method was validated on a nonlinear coupled-tank system with model uncertainty and hard input constraints.

Data Generation: 30 heterogeneous expert trajectories were generated using various PPC controllers with different gains and funnels.
Learning Outcome: The framework successfully learned a single closed-form controller and a unified funnel that captured the transient and steady-state behavior of the diverse demonstrations.
Performance: The learned controller maintained closed-loop trajectories strictly within the learned funnel for 20 unseen initial conditions. Crucially, the control inputs satisfied the hard actuator bounds in all simulations.
Comparison: Unlike model-free PPC which achieved only practical regulation due to unmodeled drift, the proposed model-based approach compensated for drift and achieved exponential convergence to the origin while respecting input limits.

Significance and Claims
The paper claims to address a previously unaddressed problem: the joint synthesis of performance specifications and controllers from state-only data under hard input constraints. The authors emphasize that their approach differs from imitation learning by not reconstructing an expert policy and from standard PPC by explicitly accounting for actuator saturation during the synthesis phase. The significance lies in providing a systematic way to extract feasible performance attributes from demonstrations and enforce them with a controller that is guaranteed to respect physical actuator limits, supported by both conservative theoretical bounds and data-driven local guarantees. The work is modest in its scope, focusing on nonlinear systems with known nominal models and bounded uncertainty, and acknowledges that the semi-global certificate may be conservative.

Technical Summary: Learning Input-Constrained Funnel Controllers from State Trajectory Data

More like this