Skip to content

Gossip Phase Averaging

Distributed averaging protocol — instantiates Decentralized Phase Locking

Spreads a shared phase estimate hop-by-hop across a shifting peer graph by repeatedly averaging with whoever is reachable, respecting that phase wraps around.

The other coupling laws move a unit's own oscillation toward its neighbours'. Gossip Phase Averaging moves information instead: each round, a node exchanges its current phase estimate with the few peers it can reach and shifts toward their average, and over many rounds a common estimate diffuses across the whole population — even one whose links keep changing and partitioning. This is the protocol member of the family, and its defining discipline is that phase lives on a circle: you cannot average angles as plain numbers (the mean of 350° and 10° is not 180°), so it averages direction vectors, weights peers by freshness, and — critically — keeps the converged estimate separate from the act of firing. Agreeing on a number is not the same as everyone acting at the same moment, and this protocol never conflates the two.

Example

A mesh of ≈300 low-power environmental sensors is scattered through a building with no infrastructure and no master clock; links flicker as nodes sleep and radio conditions shift. To agree on a common phase for a coordinated hourly reporting window, each node keeps a phase estimate as a unit vector on the circle. Every round it hears from whatever handful of neighbours are awake, adds their vectors weighted by how recently each was heard, and renormalises — nudging its own estimate toward the local consensus. Because the averaging is vector-based, nodes straddling the 0/2π wrap converge cleanly instead of splitting to opposite sides of the circle. After enough rounds the estimate is uniform across the mesh despite constant churn; only then do nodes begin firing on it, keeping estimate-convergence and event-coordination as two separate steps.

How it works

The distinguishing features are information diffusion over a live graph and the geometry that ordinary averaging gets wrong:

  • Pairwise averaging, repeated. A node does not entrain to a neighbour; it moves its estimate a step toward the average of the estimates it collected this round. Consensus emerges from many such local averages, not from any direct correction.
  • Circular, not scalar. Estimates are averaged as vectors on the phase circle so that wraparound is handled correctly — the single most common way naive averaging fails here.
  • Freshness-weighted and churn-tolerant. Older contributions are discounted and missing peers are simply skipped, so the protocol keeps converging as the topology changes underneath it.
  • Estimate before action. The converged estimate is treated as an input to firing, never as firing itself.

Tuning parameters

  • Fan-out — how many peers each node averages with per round. More peers converge faster but cost bandwidth and battery.
  • Averaging step size — how far a node moves toward the local average each round. Large steps are fast but can oscillate; small steps are stable but slow.
  • Freshness weighting — how sharply stale contributions are discounted. Aggressive discounting tracks a changing truth but throws away sparse evidence.
  • Circular representation — vector versus angle arithmetic; using scalar angles is the classic correctness bug, not a tuning choice you can skip.
  • Estimate-to-action threshold — how converged the estimate must be before nodes act on it.

When it helps, and when it misleads

Its strength is coordinating a population with no master and no stable topology — dynamic, churning, partitionable graphs where direct entrainment can't reach. It degrades gracefully: nodes that drop out simply stop contributing, and the rest keep averaging.

Its failure modes are specific. Scalar averaging silently breaks at the wraparound and locks the mesh to a spurious mean; convergence crawls on sparse graphs; and a single stale or malformed estimate can drag the consensus if freshness and fault handling are weak. The classic misuse is to treat estimate-convergence as if it were functional coordination — the nodes "agree on the number" yet still fire at different real instants because no one closed the loop from estimate to action. The discipline is vector averaging, freshness weighting, and keeping the estimate and the firing explicitly distinct.

How it implements the components

  • local_coupling_topology — it runs over the peer graph itself, tolerating churn and partition; who exchanges estimates with whom each round is the substrate it operates on.
  • phase_observation_channel — the thing that travels is a phase estimate carrying freshness metadata, propagated hop-by-hop across the mesh rather than sensed directly.

It does not apply a direct entrainment correction (reciprocal_coupling_law — Adaptive Pulse-Coupled Update or Nearest-Neighbor Phase Nudging), span two disconnected clusters (multiscale_phase_bridge — Bridge Oscillator Link), or verify that the agreed phase is actually realised locally (coherence_and_order_parameter_panel — Local Coherence Probe).

Notes

The most important boundary is the one between estimate and event: this protocol delivers agreement on a phase value, not synchronised action. A separate firing rule must turn the converged estimate into a coordinated moment, and a mesh that skips that step can look fully converged on the dashboard while its nodes still act out of step.

References

Distributed (gossip) average consensus lets a network agree on a value through repeated local averaging with no coordinator. Applied to phase it needs circular statistics — averaging unit vectors on the circle — because the quantity is an angle, not a scalar; this is a standard and easily-missed correction.