Exponential Leaky Integrator¶
Signal filter — instantiates Event-Rate Magnitude Encoding
Adds each event to a running total that decays exponentially, so recent events dominate and old ones fade — a rate with soft, boundary-free memory.
Exponential Leaky Integrator estimates rate with no window at all. It keeps a single running accumulator: each event adds a fixed increment, and between events the accumulator continuously leaks toward zero at a constant proportional rate. The steady-state level the accumulator settles at is proportional to the event rate, so reading the level is reading the rate. Its defining trait — the one that separates it from every windowed sibling — is that memory is soft and unbounded: no event is ever abruptly discarded at an edge, it simply contributes exponentially less as time passes. An event's influence halves every fixed interval and asymptotes toward nothing, so the estimate weighs the recent past heavily and the distant past faintly, with a smooth roll-off instead of a hard cutoff. One state variable, one decay constant, updated in place.
Example¶
Every Linux machine reports a load average — a number summarizing how busy the CPU has been. It is not a count in a bucket; it is a leaky integrator. The kernel samples the run queue and folds each sample into three accumulators that decay with time constants of one, five, and fifteen minutes, so the familiar triple 0.52 1.10 1.83 reads as: right now the machine is quieting down (the fast, one-minute integrator has already fallen), but it was under real pressure over the last quarter hour (the slow integrator, still remembering, sits high).
An operator glancing at those three numbers gets something a single bucket could never give: direction. Because each figure is the same events seen through a different decay constant, their spread tells the story. When the one-minute value sits well above the fifteen-minute value, load is climbing; when it sits below, a spike is fading out. No event was ever counted twice or dropped at a boundary — each contribution just faded on its own exponential schedule, and the three time constants turn one event stream into a fast, medium, and slow read of the same rate.
How it works¶
- Increment on each event. When an event arrives, add a fixed step to the accumulator. Nothing else about the event matters — only that it happened.
- Leak continuously. Between events, multiply the accumulator down by a constant proportional decay so its contribution shrinks smoothly with age; equivalently, apply the decay each tick.
- Read the level as the rate. At equilibrium the accumulator's height is proportional to the arrival rate, so the current level, scaled by the decay constant, is the decoded estimate — available at every instant with no window to fill.
- Choose one decay constant. The single time constant sets how far back the memory effectively reaches; there is no start, end, or reset boundary to align.
Tuning parameters¶
- Decay constant (time constant) — the master dial. A fast decay forgets quickly and tracks changes closely but wobbles; a slow decay is steady but sluggish. This one number sets the effective memory depth.
- Increment size — the weight each event adds. Scales the output units; larger increments raise the accumulator's operating level relative to the decay.
- Multiple parallel constants — running several integrators at different decay rates (as with load average) to expose trend direction, at the cost of more state and more numbers to read.
- Update rule — whether the leak is applied continuously, on a fixed tick, or lazily at each event; the last is cheapest but must scale the decay by the elapsed gap.
When it helps, and when it misleads¶
Its strength is minimal state and graceful memory: one number, updated in place, with no buffer of events to store and no boundary bookkeeping. The exponential roll-off is often exactly the right prior — recent evidence should matter more — and it never suffers the trailing-edge "cliff" a hard window produces when an old event abruptly drops out. It is the natural choice for embedded, high-throughput, or memory-constrained settings.
Its failure mode is that the memory is unbounded and biased toward the past. Because old events fade rather than vanish, a burst leaves a long exponential tail: the estimate stays elevated well after the burst is over, and a step change is approached only asymptotically, never reached, so the integrator systematically lags a rising signal.[1] The classic misuse is picking a slow decay for a nice smooth line and then reacting late to every real change, having been lulled by an estimate that is always a little behind. The guarding discipline is to choose the decay constant from the timescale of changes you must catch rather than from how calm the output looks, and to run a faster parallel integrator when early warning matters more than steadiness.
How it implements the components¶
reset_or_leak_rule— the exponential leak is this component in its purest form: instead of resetting or dropping events at a boundary, old contributions decay continuously toward zero at a fixed proportional rate.rate_decoder— decoding is reading the accumulator: its equilibrium level, scaled by the decay constant, is the current rate estimate, available at every instant.
It does not implement latency_precision_tradeoff_rule as an explicit switching rule between speed and certainty — that stated dial belongs to Rolling-Window Rate Estimator, its nearest smoothing twin; here the same speed-versus-stability behavior emerges implicitly from the single decay constant of the leak rule. Nor does it implement observation_window: it has no hard window to align or reset, which is precisely what separates it from Fixed-Window Event Count.
Related¶
- Instantiates: Event-Rate Magnitude Encoding — Exponential Leaky Integrator gives the archetype a boundary-free, single-state decoder with graceful forgetting.
- Sibling mechanisms: Fixed-Window Event Count · Rolling-Window Rate Estimator · Adaptive Window Widening · Inter-Event Interval Estimator · Poisson Rate Model · Spike-Rate Readout · Pulse-Density Modulation · Rate Saturation Clamp · Anti-Aliasing Bin Selection
Editorial Notes¶
Form Classification¶
Form family: Control, Automation & Runtime
Rationale: Exponential Leaky Integrator operates as a live operational control that automatically routes, enforces, adapts, or responds during execution because it adds each event to a running total that decays exponentially, so recent events dominate and old ones fade — a rate with soft, boundary-free memory.
Independent corroboration: The frozen evidence defines Exponential Leaky Integrator as 'Adds each event to a running total that decays exponentially, so recent events dominate and old ones fade — a rate with soft, boundary-free memory', so its operative form is Control, Automation & Runtime.
Review outcome: Independent reviewer agreement; high confidence.
Origin Attribution¶
Primary origin: Engineering & Design
Origin pattern: Convergent development
Present-day reach: Multi-domain
Rationale: Exponentially decaying integration originates in electrical and signal engineering through RC filters and first-order systems.
Related originating lineages:
- Neuroscience — Leaky-integrator neuron models independently made the mechanism canonical in neural computation.
- Systems Thinking & Cybernetics — Control theory materially generalized exponential state smoothing and memory.
Review outcome: Independent reviewer agreement; medium confidence.
References¶
[1] The leaky integrator is the continuous-time twin of the exponential moving average — an infinite-impulse-response low-pass filter whose weights decay geometrically with age. Like an RC circuit charging toward a new voltage, it approaches a step change asymptotically with a fixed time constant, which is why it never fully catches up to a sustained shift and always lags a rising input. withdrawn registry ↩