🔢 mathematics

Discrete-Time Event-Triggered Extremum Seeking

This paper proposes a discrete-time event-triggered extremum seeking control scheme that reduces unnecessary actuation and communication by updating inputs only when a state-dependent condition is met, while guaranteeing practical convergence and exponential stability through discrete-time averaging and Lyapunov analysis.

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

Published 2026-04-03

📖 4 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 vast, foggy mountain range. You can't see the top, and you don't have a map. All you have is a small, shaky compass (your sensor) and a pair of boots (your control system).

This paper presents a new, smarter way to climb that mountain.

The Old Way: The "Metronome" Hiker

Traditionally, if you were trying to find the peak using a method called Extremum Seeking, you would act like a hiker with a strict metronome.

The Routine: Every single second, you take a tiny step, check your compass, calculate the slope, and decide which way to go.
The Problem: Even when you are standing on flat ground or moving in a straight line, you still take that step and check the compass. You are burning battery and making noise (communication) even when you don't need to. It's like checking your watch every second just to see if it's still ticking, even when you aren't in a hurry.

The New Way: The "Smart" Hiker

The authors of this paper (Rodrigues, Oliveira, Krstic, and Allgöwer) propose a Discrete-Time Event-Triggered approach. Think of this as a hiker who only checks their compass when it actually matters.

Here is how it works, using simple analogies:

1. The "Do-Nothing" Zone (The Event Trigger)

Instead of checking the compass every second, the hiker has a rule: "I will only stop and recalculate my path if my current direction estimate changes significantly."

The Metaphor: Imagine you are driving a car on a straight highway. You don't need to steer the wheel every millisecond. You only turn the wheel if the road curves or if you drift slightly off course.
In the Paper: The system constantly monitors the "gradient" (the slope of the mountain). If the slope is steady, the system does nothing. It holds the last known good direction. It only "wakes up" to update the control input when a specific mathematical condition is met (the "event").

2. The Digital Clock (Discrete-Time)

The paper emphasizes that this happens in discrete time.

The Metaphor: Think of a digital clock that ticks once a second. It doesn't flow smoothly like an analog clock; it jumps from 1:00 to 1:01.
Why it matters: Real-world computers and sensors work in these "ticks." The authors realized that you can't just copy-paste a continuous-time theory (like a smooth river) into a digital system (like a bucket brigade). They built a new theory specifically for these "ticks," ensuring the hiker doesn't trip over their own feet when the clock jumps.

3. The "Freeze" Effect

Between the moments the hiker checks the compass, the control input is "frozen."

The Metaphor: Imagine a video game where you press a button to jump. In the old way, you might be pressing the button continuously. In this new way, you press it once, and your character keeps jumping until the game engine tells you to press it again.
The Benefit: This saves massive amounts of energy and communication bandwidth. In the simulation, the system ran for 1,000 steps but only updated its decision 19 times. That's a 98% reduction in work!

The Mathematical "Magic" (Simplified)

You might wonder: "If I stop checking the compass, won't I get lost?"

The authors used two powerful mathematical tools to prove you won't:

Averaging: They showed that even though the hiker only checks occasionally, the average path taken is just as good as if they checked every second. It's like taking a photo every 10 minutes of a movie; you still get the whole story, just with fewer frames.
Lyapunov Stability: This is a fancy way of saying, "We have a safety net." They proved mathematically that the hiker will never spiral out of control. Even with the "lazy" updates, the hiker is guaranteed to eventually reach the peak (or get very close to it) and stay there.

The Result: A Smarter, Greener System

The simulation results in the paper show that this "lazy" hiker reaches the top of the mountain just as fast as the "metronome" hiker, but with a fraction of the effort.

In summary:
This paper teaches us how to build control systems for robots, smart grids, or chemical plants that are resource-aware. Instead of shouting "I'm checking! I'm checking!" every second, the system whispers, "I'm still good," and only shouts when something actually changes. This saves battery, reduces network traffic, and makes digital systems much more efficient.

1. Problem Statement

The paper addresses the challenge of real-time optimization for nonlinear systems with unknown static maps. Specifically, it targets Extremum Seeking (ES) control, a model-free strategy used to drive a system's output to an unknown extremum (maximum or minimum) by adjusting the input based on output measurements.

The Core Problem:

Conventional Limitation: Traditional discrete-time ES implementations rely on periodic updates, where the control input is recalculated and transmitted at every fixed sampling interval. This leads to unnecessary actuation and communication overhead, which is inefficient for resource-constrained digital systems (e.g., embedded sensors, networked control systems).
The Gap: While event-triggered control (updating only when necessary) has been studied in continuous time, extending it to discrete-time is non-trivial. Discrete-time systems involve sampling, input holding, and specific update constraints that make a direct discretization of continuous-time event-triggered schemes invalid or unstable.

2. Methodology

The authors propose a Discrete-Time Event-Triggered Extremum Seeking (ET-ES) scheme. The methodology integrates model-free ES with a state-dependent triggering mechanism.

A. System Model

Plant: A nonlinear static map $Q[\theta]$ with an unknown extremum $Q^*$ , unknown Hessian $H^*$ , and unknown optimizer $\theta^*$ .
Input: The input $\theta[k]$ is the sum of an estimate $\hat{\theta}[k]$ and a sinusoidal dither signal $a \sin(\omega \epsilon k)$ .
Gradient Estimation: The gradient $\hat{G}[k]$ is estimated using demodulation (multiplying the output by the dither signal and low-pass filtering concepts inherent in the discrete averaging).

B. Control Law and Triggering Mechanism

Feedback Law: A static gradient-based tuning law is used: $u[k] = -K \hat{G}[k]$ .
Event-Triggering Condition: Instead of updating at every step $k$ , the control input is updated only at discrete triggering instants $\{k_l\}$ . Between updates ( $k \in [k_l, k_{l+1})$ ), the input is held constant.
Triggering Rule: A new update is triggered when the deviation between the current gradient estimate and the last transmitted value exceeds a threshold relative to the magnitude of the gradient itself.
$\sqrt{\sigma} |\hat{G}[k]| - \alpha |e[k]| < 0$
Where:
- $e[k] = \hat{G}[k_l] - \hat{G}[k]$ is the measurement error.
- $\sigma \in (0,1)$ and $\alpha$ are design parameters.
- This condition ensures updates occur only when the gradient estimate changes significantly relative to its current value.

C. Theoretical Analysis Framework

To prove stability, the authors employ a rigorous two-step analysis:

Discrete-Time Averaging: The system dynamics are analyzed using discrete-time averaging theory. The fast oscillations caused by the dither signal are averaged out to derive an autonomous average system.
Lyapunov Stability Analysis: A Lyapunov function is constructed for the average system to prove:
- Local Exponential Stability: The average dynamics converge exponentially to the equilibrium.
- Practical Convergence: The actual trajectories of the original system converge to a small neighborhood of the unknown extremum (the size of the neighborhood depends on the dither amplitude $a$ and sampling step $\epsilon$ ).
Zeno Behavior Avoidance: The authors prove that a lower bound exists for the inter-execution interval ( $k_{l+1} - k_l$ ), ensuring that the system does not trigger infinitely many times in a finite time (Zeno behavior), which is guaranteed by the discrete nature of the system (minimum interval is one sampling step).

3. Key Contributions

Novel Discrete-Time Framework: The paper provides the first rigorous design and analysis framework for event-triggered ES specifically tailored to discrete-time dynamics, distinguishing it from simple discretizations of continuous-time solutions.
Resource Efficiency: The scheme significantly reduces the number of control updates and communication events without sacrificing the convergence properties of classical ES.
Rigorous Stability Proof: It establishes practical exponential stability for the closed-loop system using a combination of discrete-time averaging and Lyapunov arguments, proving that the event-triggering mechanism does not compromise the fundamental optimization capability.
Zeno-Free Guarantee: Theoretical proof that the triggering mechanism avoids pathological behaviors (infinite triggering) inherent in some event-triggered designs.

4. Simulation Results

The authors validated the approach using a nonlinear map with parameters $H^* = -0.7$ , $Q^* = 2$ , and $\theta^* = 3$ .

Convergence: The input $\theta[k]$ successfully converged to the optimizer $\theta^* = 3$ , and the output $y[k]$ converged to the extremum $Q^* = 2$ .
Update Reduction: Over 1000 iterations, the control law was updated only 19 times (average inter-execution interval of ~9.47 seconds), compared to 1000 updates in a standard periodic scheme.
Signal Behavior: The gradient estimate $\hat{G}[k]$ converged smoothly to zero, and all signals remained bounded. The aperiodic nature of the updates was clearly demonstrated.

5. Significance and Impact

Digital Implementation: This work bridges the gap between theoretical event-triggered control and practical digital implementation, where sampling and communication constraints are dominant factors.
Resource-Aware Optimization: It offers a solution for applications where actuation is expensive, communication bandwidth is limited, or battery life is critical (e.g., wireless sensor networks, embedded control systems).
Foundation for Future Work: The paper sets the stage for extending event-triggered ES to multi-agent systems, networked environments, and systems with measurement noise or delays.

In conclusion, the paper successfully demonstrates that event-triggered mechanisms can be effectively integrated into discrete-time extremum seeking, offering a robust, resource-efficient alternative to traditional periodic control strategies while maintaining rigorous stability guarantees.