Many sensors in control systems do not report on a fixed clock. Event-triggered sensors transmit only when a signal has changed by more than a threshold, so the receiver sees a staircase: a value that is held constant, then jumps, at irregular, state-dependent times. Recurrent models built to remember and transform input streams assume the opposite, namely one input per fixed time step. A modeler then has two poor options. The first is to step the recurrent network at the fine clock rate, which re-creates the periodic-sampling waste that event triggering was meant to remove. The second is to step it once per event, which throws away elapsed time and breaks the rotation-based memory that the best fixed-weight recurrent networks depend on. We propose a third option. Split the reservoir into a linear memory part and a nonlinear part. Because the event-triggered input is piecewise constant, the linear part can be advanced exactly over any gap in closed form, at a cost of $O(N)$ per event. The nonlinear part is evaluated only at events or when a prediction is requested.
Here a reservoir is a recurrent network whose internal weights are random and fixed, with only a linear readout trained by ridge regression. The memory–nonlinearity trade-off is the observation that the more a recurrent system warps its state to compute nonlinear functions, the faster it forgets. In this design, memory lives in a linear continuous-time flow that is never squashed, nonlinearity lives in features read from that flow, and the time axis is physical seconds rather than step counts. The intended result has two parts. First, memory and delayed-nonlinear performance measured in seconds should be largely unaffected by how irregular the event stream is. Second, compute should scale with the number of events rather than the clock rate. We test whether such a reservoir, trained from data, can serve as the prediction model inside model-based event-triggered control of a plant whose equations are unknown.
Core Claim
Let the memory state $m(t)\in\mathbb{C}^N$ evolve as $\dot m = A m + B u(t)$. Here $A = S - \lambda I$, with $S$ a random skew-symmetric matrix (purely rotational dynamics) and $\lambda>0$ a small damping that guarantees fading memory. If the input $u$ is held at value $u_k$ between event times $t_k$ and $t_{k+1}$, with gap $\Delta_k = t_{k+1}-t_k$, then the update
$$m(t_{k+1}) = e^{A\Delta_k} m(t_k) + A^{-1}\left(e^{A\Delta_k}-I\right) B u_k$$
is exact, not an approximation. In the eigenbasis of $A$ it is a diagonal multiply, so it costs $O(N)$ regardless of $\Delta_k$. Elapsed time is written into the phases of $m$. A nonlinear module reads $m$ only at the moments an output is needed: either a static random-feature layer $z=\phi(W m + b)$, or a small nonlinear echo-state module updated once per event. A linear readout is then trained on $[m, z]$.
The claim has three parts. Memory in physical time survives arbitrary event timing. Nonlinearity costs nothing between events. And the event times themselves, which in send-on-delta sampling encode "the signal moved by $\delta$ here," are preserved as information rather than discarded. None of the decoupled reservoirs in the literature has this combination.
Relation to Prior Work
The most direct precedents use structural decoupling but assume uniform steps. Edge of Stability Echo State Network mixes a nonlinear reservoir with a linear orthogonal one via a convex weight $\beta$. Residual Reservoir Memory Networks feeds a linear ring-memory reservoir into a nonlinear residual module. Orthogonality in Additive Echo State Networks separates an additive orthogonal memory from nonlinear processing. We reuse their central idea, that memory should be held linear and orthogonal. What we change is that their transition $O x[t-1]$ counts steps, and we replace it with a flow that counts seconds.
Two theoretical results motivate why the separation must be strict. The inverse approximation theorem in Inverse Approximation Theory for Nonlinear Recurrent Neural Networks shows that stably approximable nonlinear recurrent maps must forget exponentially fast. A refined information processing capacity metric frames memory and nonlinearity as competing for a fixed capacity budget. Our design keeps nonlinearity out of the recurrence entirely, which is why we expect it to escape the nonlinear-RNN bound.
One result constrains the design and is the reason it exists. Orthogonal RNNs and Long-Memory Tasks shows that orthogonal transitions act as clocks that solve fixed-delay copying but fail when delays vary. The same paper finds that identity-like accumulation is needed for adding tasks. We read the variable-delay failure as a symptom of clocks that tick per step instead of per second. The mix of eigenvalue frequencies in $S$ near zero gives the system accumulator-like directions alongside rotational ones.
On the irregular-time side, Random Controlled Differential Equations builds continuous-time reservoirs over interpolated paths and is robust to randomly missing points. However, it is offline, it uses general log-ODE or random-feature integration, and it is untested on state-dependent staircase signals. We exploit the staircase structure to get exact, cheaper updates in a streaming setting.
On the control side, Model-Based Nonlinear Periodic Event-Triggered Control places an Euler predictor of a known plant at the actuator to lengthen intervals between transmissions. Event-triggered learning shows that interval statistics reveal when the predictor has gone wrong, but only for linear Gaussian models. Both supply the closed-loop setting. Neither offers a data-driven nonlinear predictor, and that is the role we test the reservoir in.
Research Program
We will build the event-clocked reservoir in three variants. The first uses static random nonlinear features of $m$. The second uses an event-updated nonlinear module driven by $m$. The third is a per-tick version of the same architecture, used as a compute-matched control.
We will then extend two standard measurements to physical time. Memory capacity becomes the sum, over delays $s$ seconds, of squared correlations between $u(t-s)$ and its best linear reconstruction. The delayed-nonlinear task from the Edge of Stability paper is restated with delays in seconds.
The input streams come from a send-on-delta sampler applied to the same continuous random signals, at several thresholds $\delta$. This varies both the event rate and the timing irregularity, and the timing irregularity is state-dependent rather than random. A short analysis will bound the memory of the flow in seconds as a function of the damping $\lambda$ and the frequency spread of $S$. We will also characterize when information carried by event timing is recoverable: in send-on-delta sampling the timing is informative, whereas under random dropout it is not.
Finally, we place the trained reservoir as the actuator-side predictor in model-based periodic event-triggered control on the inverted pendulum. The reservoir is learned from logged closed-loop data with no access to the plant equations. We also test whether shifts in inter-event intervals can trigger recursive-least-squares refits of the readout, which would extend the monitoring idea of Event-triggered learning to a nonlinear predictor.
Baselines
The naive reference is a standard leaky echo state network stepped once per event, with no knowledge of elapsed time. It shows how much event timing breaks an ordinary reservoir. The Edge of Stability paper's own numbers show leaky networks are weak even on uniform steps: memory capacity of 30.40±3.76 against 98.43±0.11 for its edge-of-stability network at 100 neurons. We will report it at matched size and expect it to collapse as irregularity grows.
The strongest accuracy competitor is the edge-of-stability network stepped at the fine clock with zero-order-hold input. It sees exactly the information we see and has the documented best memory–nonlinearity behavior on uniform steps: memory capacity 98.43±0.11 with 100 neurons, and NRMSE below 0.5 up to delay 16 under strong nonlinearity, both from Edge of Stability Echo State Network. It gets the same neuron count and the same ridge-regression readout, and its $\beta$, spectral radius, and input scaling are tuned on the same validation grid size as our $\lambda$ and frequency scale. Beating it means matching its time-domain memory capacity and delayed-nonlinear NRMSE within one standard deviation while using at least five times fewer floating-point operations at the sparsest thresholds. We do not claim to exceed it in accuracy. If it is clearly more accurate at equal neuron count, the claim fails.
The strongest event-rate competitor is the same edge-of-stability network stepped per event, with $\Delta_k$ appended as an extra input. Beating it means higher time-domain memory capacity and lower delayed-nonlinear error at equal compute. Residual Reservoir Memory Networks is run the same two ways, per tick and per event with $\Delta_k$. On regular data it reports a 19.9% average accuracy gain over standard echo state networks on archive classification.
For irregular-path classification, Random Controlled Differential Equations is the reference. It reports average accuracy of 0.741 against 0.738 for SigPDE on its 16 multivariate datasets under its own protocol. We will rerun it on our event-sampled versions rather than compare against that figure directly.
In control, the references are zero-order-hold periodic event-triggered control, with a 0.47 s average interval, and the Euler model-based variant with the true plant model, with an average interval over 2.5 s, both reported in Model-Based Nonlinear Periodic Event-Triggered Control. A data-learned reservoir predictor that clearly exceeds 0.47 s and approaches the Euler figure without plant equations would count as success. Reaching the Euler figure is not required.
The key ablation replaces the exact flow with a fixed orthogonal step applied once per event, regardless of $\Delta_k$. This keeps everything else identical and isolates the contribution of advancing memory in physical time. A second ablation sets the damping-free frequencies of $S$ to a single scale, to test whether a spread of timescales is what supplies accumulator-like behavior.
Why not just…?
Why not just run the best reservoir at the fine clock? It will probably be as accurate as ours, and we treat it as the accuracy ceiling. The objection the field raises against periodic sampling, made in Current trends and future directions in event-based control, applies equally to computation. Each tick costs $O(N^2)$ even when nothing has changed, so on a sleeping embedded node the predictor would undo the savings that event triggering bought. The compute-versus-accuracy curves across thresholds settle this. If the per-tick model's advantage at equal compute is negligible, our contribution reduces to an efficiency trick, and we will say so.
Why not just feed the elapsed time as an extra input to a per-event reservoir? This is the simplest real threat. In a nonlinear reservoir, $\Delta_k$ enters through a squashing function and must be learned implicitly by the readout. It cannot rotate a stored memory by the right angle, and that inability is the failure mode documented for variable delays in Orthogonal RNNs and Long-Memory Tasks. The per-event baseline with $\Delta_k$ input tests this directly, and we expect its time-domain memory capacity to fall as timing irregularity rises. If it does not, the exact flow is unnecessary.
Why not just use Random Controlled Differential Equations, which already handle irregular data? They are the closest continuous-time reservoir. Their reported robustness, however, is to randomly missing points, and their integration does not exploit the fact that event-triggered inputs are constant between jumps. Whether their log-ODE features stay stable on state-dependent staircases is untested. Head-to-head classification on send-on-delta-sampled archive data, with per-sample inference cost reported, will show whether our exact linear update is better or merely cheaper.
Why not just use an Euler predictor, as model-based triggering already does? It works well when the plant equations are known: the interval rises from 0.47 s to over 2.5 s on the pendulum. It needs $\dot x = f(x,u)$, though, and the black-box setting has no $f$. We include it with the true model as an upper reference and test whether a data-learned reservoir closes most of the gap.
Why not just use a leaky reservoir with tuned leak rates or several timescales? Even on uniform steps, tuned leaky networks fall well short of decoupled orthogonal memory on memory capacity, delayed-nonlinear tasks, and long autonomous generation, per the Edge of Stability paper. Under irregular timing, leaking per event mis-scales decay by an unknown amount. The leaky baseline is retained to show this.
Decisive Experiments
The first experiment carries most of the evidence. We plot time-domain memory capacity and delayed-nonlinear NRMSE against send-on-delta threshold for every model at $N=100$ and $N=400$, alongside cumulative operations. The proposal succeeds if three things hold. The event-clocked reservoir's curve stays flat as irregularity grows while the per-event baselines decline. It tracks the per-tick edge-of-stability network within noise. And it uses a fraction of that network's compute, a fraction that shrinks as events become rarer. The fixed-step ablation should behave like the per-event baselines. If it does not, the exact flow is not the active ingredient.
The second experiment repeats the comparison on a subset of the UEA and UCR archives converted to event streams. It reports accuracy and inference cost against Random Controlled Differential Equations and Residual Reservoir Memory Networks, and adds autonomous generation on the multiple-superimposed-oscillator benchmark with event-sampled teacher signals.
The third is the closed-loop pendulum test. We report average inter-transmission interval, Lyapunov convergence, and the minimum observed inter-event time, the last as a check against Zeno-like triggering bursts in which the interval between events collapses toward zero. We then inject a plant change mid-run and test whether interval-shift detection with readout refitting restores the intervals.
A negative outcome on the first experiment, where the per-event baseline with $\Delta_k$ input matches us, would falsify the core claim. We treat that as the main risk.
References
- Edge of Stability Echo State Network
- Residual Reservoir Memory Networks
- Orthogonality in Additive Echo State Networks
- Inverse Approximation Theory for Nonlinear Recurrent Neural Networks
- A refined information processing capacity metric allows an in-depth analysis of memory and nonlinearity trade-offs in neurocomputational systems
- Orthogonal RNNs and Long-Memory Tasks.
- Random Controlled Differential Equations
- Model-Based Nonlinear Periodic Event-Triggered Control for Continuous-Time Systems with Sampled-Data Prediction
- Event-triggered Learning
- Current trends and future directions in event-based control