🔢 mathematics

Event-Triggered Discrete-Time Multivariable Extremum Seeking Systems

This paper proposes a discrete-time event-triggered extremum seeking framework for multivariable nonlinear systems that achieves practical convergence to an unknown optimum with exponential stability while significantly reducing actuation and communication efforts by updating control actions only when a state-dependent condition is met, rather than relying on periodic sampling.

Original authors: Victor Hugo Pereira Rodrigues, Tiago Roux Oliveira, Miroslav Krstić, Frank Allgöwer

Published 2026-07-29

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Victor Hugo Pereira Rodrigues, Tiago Roux Oliveira, Miroslav Krstić, Frank Allgöwer

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 trying to find the highest peak in a foggy mountain range, but you can't see the map, and you don't know where the top is. You have a robot that can take a step, measure the height, and then decide where to go next. This is the world of Extremum Seeking: a clever way for machines to find the "best" setting (like the maximum speed or minimum fuel use) without needing a perfect blueprint of how the system works. It works by wiggling the controls slightly back and forth (like a hiker shuffling their feet to feel the slope) to figure out which way is up.

Now, imagine that robot is running on a battery that is running low, or it's talking to a controller over a shaky, crowded Wi-Fi connection. If the robot checks its position and sends a message every single second, it might run out of power or clog the network before it even finds the peak. This is where Event-Triggered Control comes in. Instead of checking the time and sending a message on a strict schedule (like a clock ticking), the robot only speaks up when something important changes—like when it realizes it's taking a wrong turn. It's the difference between a parent checking on a sleeping child every five minutes versus only going in if they hear a noise.

This paper tackles a tricky puzzle: How do you combine these two ideas? Extremum Seeking usually needs a strict, rhythmic schedule to work its magic, but Event-Triggered Control hates schedules because it wants to save energy by being lazy. The authors ask: Can we make a robot that finds the peak efficiently and only talks when it absolutely has to, even if it's a complex machine with many moving parts?

The Lazy Hiker's Guide to Finding the Peak

The researchers in this paper have built a new kind of "smart robot" that solves this problem. They created a system that can optimize complex, multi-part machines (like a drone with four motors or a chemical plant with many valves) without needing to constantly check in.

The Old Way vs. The New Way
Traditionally, these optimization robots work like a metronome. They wiggle their controls, wait a fixed amount of time, measure the result, and wiggle again. This rhythm is essential for the math to work; it's like a drummer keeping a steady beat so the band stays in time. But this is wasteful. If the robot is already close to the top of the mountain, it doesn't need to send a message every single second. It could just chill and wait until it starts to drift off course.

The authors' new method replaces the metronome with a "smart alarm." The robot still wiggles and measures, but it only updates its control action when a specific condition is met: when the difference between what it thinks is happening and what it actually measured gets too big. It's like a driver who only checks the GPS when the car starts to drift out of the lane, rather than checking it every five seconds regardless of where the car is.

The Big Challenge: Multivariable Chaos
The paper specifically focuses on multivariable systems. Think of a single-variable system as a car with one gas pedal. A multivariable system is like a spaceship with thrusters on the front, back, left, and right. If you push the left thruster, it might accidentally push the nose down. These parts are "coupled," meaning they mess with each other.

The authors found that simply taking an existing "lazy" rule and applying it to a spaceship doesn't work. The math gets messy because the "wiggles" (dithers) used to find the peak can interfere with each other if the updates happen at weird, random times. The paper proves that their new "smart alarm" rule is special: it knows how to handle these tangled interactions. It ensures that even though the robot is updating its moves at irregular, aperiodic times (sometimes waiting a long time, sometimes updating quickly), it still manages to find the peak.

What They Found
Through rigorous math and computer simulations, the team showed that their system works.

It finds the peak: The robot successfully converges to the optimal setting, just like the old rhythmic method.
It saves massive effort: In their tests, the robot had to update its controls only 32 times over 6,000 steps. That's a huge reduction! Instead of checking in 6,000 times, it only spoke up 32 times.
It stays stable: Even with these long gaps between updates, the system didn't go crazy or crash. The math proves that the robot stays safe and keeps moving toward the goal.

The Catch (and the Proof)
The authors are very careful to say that this is a mathematical proof and simulation result, not a physical robot built in a lab yet. They proved that if you follow their rules, the system will work. They also explicitly ruled out the idea that you can just use any old "lazy" rule; the specific way they designed the trigger is crucial to keep the "wiggles" from canceling each other out.

In their simulation of a system with two inputs (like a drone with two main controls), they set the robot to start at a specific point and watch it climb. The results showed the robot's path smoothing out toward the target, while the "update events" (the times it sent a message) were scattered all over the place—sometimes 30 steps apart, sometimes closer. This aperiodic pattern is exactly what they wanted: a system that is efficient, resource-friendly, and smart enough to know when to stay silent.

Why It Matters
This isn't just about saving battery life on a toy. In the real world, many systems are "resource-constrained." Think of a satellite in space where every radio transmission costs precious fuel, or a network of sensors in a forest that runs on solar power. If these devices have to talk constantly, they die quickly. This paper offers a blueprint for making these devices "smart lazy." They can do the hard work of finding the best settings without burning out their batteries or clogging the network, all while guaranteeing they won't crash.

The authors conclude that while the math is complex, the idea is simple: stop checking the clock, and start listening to the machine. If the machine is doing fine, let it be. If it starts to wander, then wake it up. And thanks to their new rules, even the most complicated, multi-part machines can learn to do this without losing their way.

Technical Summary: Event-Triggered Discrete-Time Multivariable Extremum Seeking Systems

Problem Formulation
The paper addresses the challenge of real-time optimization for multivariable nonlinear static maps where the objective function is unknown and the system operates under resource constraints (limited sensing, communication, and actuation). Traditional Extremum Seeking (ES) schemes rely on periodic, time-triggered updates to generate gradient information through dithering and demodulation. However, these periodic requirements conflict with the goals of Event-Triggered Control (ETC), which aims to reduce resource usage by updating controls only when necessary. The core problem is the structural incompatibility between the periodic excitation required for gradient recovery in ES and the aperiodic philosophy of ETC, particularly in discrete-time multivariable settings where channel coupling and sampled-data effects complicate stability analysis.

Methodology
The authors propose a discrete-time event-triggered framework for multivariable gradient-based extremum seeking. The methodology integrates the following components:

System Model: The plant is modeled as a static nonlinear map $y[k] = Q(\theta[k])$ , locally approximated by a quadratic function with an unknown Hessian $H^*$ and optimizer $\theta^*$ .
Gradient Estimation: A standard discrete-time ES architecture is employed, utilizing periodic dither signals $S[k]$ and synchronous demodulation $M[k]$ to estimate the gradient $\hat{G}[k]$ .
Event-Triggering Mechanism: Instead of updating the control input $u[k]$ at every sampling instant, the input is updated only at discrete triggering instants $\{k_l\}$ . Between updates, the control input is held constant (Zero-Order Hold). The triggering condition is defined by a state-dependent inequality comparing the current gradient estimate $\hat{G}[k]$ to its last transmitted value $\hat{G}[k_l]$ . Specifically, an event is triggered when:
$\sqrt{\sigma}\|\hat{G}[k]\| - \alpha\|e[k]\| < 0$
where $e[k] = \hat{G}[k_l] - \hat{G}[k]$ is the measurement error, and $\sigma, \alpha$ are design parameters.
Stability Analysis: The analysis combines discrete-time averaging theory with Lyapunov-based methods.
- Averaging: The non-autonomous, time-varying closed-loop system is analyzed by constructing an associated average autonomous system. The authors demonstrate that the behavior of the original system approximates the average system within an $O(h)$ bound, where $h$ is the sampling period.
- Lyapunov Stability: A Lyapunov function is constructed for the average system to prove local exponential stability of the equilibrium point (where the gradient estimate is zero).
- Practical Convergence: By leveraging the closeness between the original and average trajectories, the authors prove that the actual system trajectories converge practically to a neighborhood of the unknown extremum.

Key Contributions

Theoretical Bridge: The paper establishes a theoretical link between two distinct paradigms: feedback optimization (ES) and resource-aware control (ETC) in a discrete-time multivariable context. It resolves the tension between the need for periodic excitation in ES and the aperiodic nature of ETC.
Multivariable Extension: Unlike previous continuous-time or scalar formulations, this work extends event-triggered ES to multivariable systems, explicitly accounting for channel coupling and the complexities of sampled-data dynamics.
Rigorous Stability Guarantees: The authors provide rigorous proofs for the practical convergence of system trajectories to the extremum neighborhood and the exponential stability of the average dynamics, despite the loss of uniform sampling.
Zeno Behavior Exclusion: The analysis demonstrates that the proposed triggering rule excludes Zeno behavior (infinite triggers in finite time) and, more importantly, ensures that consecutive triggering (updates at every single iteration) does not occur, guaranteeing a meaningful reduction in actuation events.

Results
Numerical simulations were conducted on a 2-input, 1-output nonlinear map with unknown parameters. The results indicate:

Convergence: The input vector $\theta[k]$ successfully converges to the unknown optimizer $\theta^*$ , and the output $y[k]$ approaches the extremum value.
Resource Efficiency: Over 6,000 iterations, the control law was updated only 32 times (an average inter-execution interval of 33.75 seconds), demonstrating a drastic reduction in actuation and communication effort compared to periodic implementations.
Performance: The optimization performance remains comparable to classical ES, with the gradient estimates converging to zero and all signals remaining bounded.

Significance and Claims
The paper claims that the proposed framework allows for the implementation of extremum seeking in resource-constrained digital and networked control systems without sacrificing the fundamental optimization mechanisms of classical ES. The authors emphasize that this is not a straightforward discretization of continuous-time event-triggered ES but a distinct design requiring a tailored analysis framework due to the specific challenges of discrete-time dynamics (sampling, input holding, and update constraints). The work highlights that appropriately designed triggering rules can preserve the essential gradient recovery mechanisms of ES while significantly reducing the number of input updates, making the method suitable for applications where sensing and communication resources are limited. The paper positions this work as a step toward bridging discrete-time control and event-triggered mechanisms in a practically meaningful way.

The Lazy Hiker's Guide to Finding the Peak

Technical Summary: Event-Triggered Discrete-Time Multivariable Extremum Seeking Systems

More like this