Skip to content

Adaptive Pulse-Coupled Update

Local coupling method — instantiates Decentralized Phase Locking

Locks a population by having each unit nudge its own next firing the instant a neighbour's pulse arrives, with the nudge size adapting as the lock tightens.

Most coupling laws assume a unit can watch a neighbour's phase continuously. Adaptive Pulse-Coupled Update assumes it can't — it acts only on discrete events. Each unit runs its own cycle in the dark, and the only thing it ever learns about a neighbour is a pulse: a firing, a flash, a beacon. When one arrives, the receiver jumps its own phase a bounded amount toward (or away from) firing, then goes dark again until the next pulse. The defining twist is adaptive: the jump size is not fixed. It starts large so a scattered population converges fast, then shrinks as coherence rises so a nearly-locked group stops jostling itself out of lock. This is the event-driven, self-damping member of the coupling family — no continuous channel, just pulses and a gain that knows when to back off.

Example

A field of ≈200 battery-powered wildlife sensors needs to wake, sample, and radio in the same brief window each hour so their transmissions don't collide — but they have no shared clock and can't afford to listen continuously. Each node instead emits a short beacon at the top of its own cycle and sleeps otherwise. When a node hears a neighbour's beacon partway through its cycle, it advances its next beacon by a fraction of the remaining time. Early on, with nodes spread randomly across the hour, the jumps are large and the swarm collapses toward a common firing time within a few dozen cycles. As beacons start landing close together, each node senses the tightening (its corrections are getting smaller and rarer) and drops its jump gain, so the population settles into a stable shared window of ≈±150 ms instead of endlessly overshooting past one another. The result is a firefly-style common pulse[1] that emerged with no master node and almost no radio-on time.

How it works

What sets this method apart from continuous nudging is that timing information is quantised into events and the response decays with coherence:

  • Event-triggered, not sampled. A unit changes phase only when a pulse actually arrives; between pulses it free-runs. This is what lets it work over sparse, bursty, or radio-silent channels.
  • Bounded jump per pulse. Each pulse moves the receiver's phase by a limited amount along a phase-response shape — advancing when the pulse lands in one part of the cycle, delaying in another — never teleporting it to the neighbour's phase.
  • Gain that adapts to lock. The jump size scales down as local coherence rises (and back up if drift returns), so the same rule that pulls a scattered field together also stops kicking a settled one.

Tuning parameters

  • Jump gain (ε) — how far one pulse moves the receiver. High gain locks fast but overshoots and can trigger avalanche re-firing; low gain is gentle but slow to capture.
  • Adaptation schedule — how aggressively the gain decays as coherence rises. Fast decay protects a fresh lock but can freeze the population before stragglers are in; slow decay keeps pulling but jitters the locked core.
  • Refractory window — a dead time just after a unit fires in which it ignores pulses, preventing a chain of mutual re-triggering.
  • Response sign at reset — whether a pulse near the firing point advances or delays; this single choice decides whether the population converges to synchrony or to a spread-out splay state.

When it helps, and when it misleads

Its strength is operating on almost nothing: no continuous sensing, no timestamps, no master — just pulses. For many topologies a bounded pulse-coupled rule provably drives the population to a common phase from nearly any start[1], and the adaptive gain is what keeps that lock from rattling once achieved.

Its failure mode is that strong pulses plus transmission delay can produce avalanche over-synchronisation — units re-triggering one another into a tighter, more brittle lock than intended, the seed of a stampede. The classic misuse is to crank the gain to force a fast lock, or to run with a fixed high gain and drop the adaptation entirely, which throws away the one feature that damps the settled state. The discipline is to let the gain fall as coherence climbs and to keep a refractory guard so no pulse can echo straight back.

How it implements the components

  • reciprocal_coupling_law — this is the local law, in event-driven form: the bounded, pulse-triggered correction each unit applies to its own timing when a neighbour fires.
  • local_adaptation_and_retuning_rule — the jump gain retunes itself, shrinking as the lock tightens and re-opening when drift returns, so one rule serves both capture and hold.

It does not correct for how stale a pulse already is (delay_noise_and_detuning_budget — Delay-Compensated Local Coupling), watch whether the population is actually cohering (coherence_and_order_parameter_panel — Local Coherence Probe), or pull two disconnected groups together (multiscale_phase_bridge — Bridge Oscillator Link).

Notes

The sign of the response at the reset point is decisive: the same "nudge toward the pulse" rule can converge a population to zero-lag synchrony or drive it to an evenly-spread splay state, depending on whether a late-cycle pulse advances or delays firing. Choosing that sign is choosing the target state — it is not a free implementation detail.

References

[1] Pulse-coupled oscillators of the integrate-and-fire kind provably synchronise from almost all initial conditions under broad conditions — the Mirollo–Strogatz result — which is why a firefly-style beacon rule can lock a population with no leader. The guarantee is for the idealised, delay-free case; real pulses carry delay, which is what the adaptive gain and refractory window guard against. ↩