Self-stabilizing Numerical Iterative Computation

Many challenging tasks in sensor networks, including sensor calibration, ranking of nodes, monitoring, event region detection, collaborative filtering, collaborative signal processing, {\em etc.}, can be formulated as a problem of solving a linear system of equations. Several recent works propose different distributed algorithms for solving these problems, usually by using linear iterative numerical methods. In this work, we extend the settings of the above approaches, by adding another dimension to the problem. Specifically, we are interested in {\em self-stabilizing} algorithms, that continuously run and converge to a solution from any initial state. This aspect of the problem is highly important due to the dynamic nature of the network and the frequent changes in the measured environment. In this paper, we link together algorithms from two different domains. On the one hand, we use the rich linear algebra literature of linear iterative methods for solving systems of linear equations, which are naturally distributed with rapid convergence properties. On the other hand, we are interested in self-stabilizing algorithms, where the input to the computation is constantly changing, and we would like the algorithms to converge from any initial state. We propose a simple novel method called \syncAlg as a self-stabilizing variant of the linear iterative methods. We prove that under mild conditions the self-stabilizing algorithm converges to a desired result. We further extend these results to handle the asynchronous case. As a case study, we discuss the sensor calibration problem and provide simulation results to support the applicability of our approach.

💡 Research Summary

The paper addresses a fundamental challenge in distributed sensor networks: solving systems of linear equations when the underlying measurements continuously change. Traditional distributed algorithms for linear systems—such as Jacobi, Gauss‑Seidel, and related iterative methods—assume a static right‑hand side vector and converge only once, after which the computation halts. In dynamic environments, however, sensor readings evolve, nodes may fail and restart, and the network must keep producing useful estimates without a global reset. The authors therefore propose a self‑stabilizing variant of linear iterative methods that guarantees convergence from any arbitrary initial state, provided that the input variations remain bounded.

The system model consists of a directed weighted communication graph G = (V, E). Each node i holds a scalar input I_i(r) (the raw sensor reading at round r) and a scalar output O_i(r) (the calibrated value). Edge weights w_{i,j} model the influence of node j’s output on node i’s estimate; a non‑zero self‑weight w_{i,i} represents the contribution of the node’s own measurement. The target relationship is

 u_i = w_{i,i}·v_i + Σ_{j∈N(i)} w_{i,j}·u_j,

where v is the (possibly time‑varying) vector of raw measurements and u is the desired calibrated vector. The authors assume that the input sequence {v(r)} is δ‑bounded around a nominal vector v̄, i.e., ‖v(r) – v̄‖_∞ ≤ δ for all r. The goal is to design an algorithm that, from any initial configuration, produces an output sequence {O(r)} that remains within an ε‑ball of the true solution ū (the solution for v̄), where ε shrinks as the number of iterations grows.

The proposed algorithm, named SS‑Iterative, is extremely simple. In each local “round” a node i: (1) broadcasts its current output O_i to all out‑neighbors; (2) reads its new input I_i(r+1); (3) updates its output according to

 O_i ← w_{i,i}·I_i(r+1) + Σ_{j∈N(i)} w_{i,j}·O_j,

where O_j are the values received from neighbors during the previous round. Crucially, the algorithm does not require any explicit round counter; nodes act on the most recent information they have. This design makes the method naturally applicable to asynchronous settings where messages may be delayed or lost, as long as eventually each node receives fresh neighbor values.

Mathematically, the update can be written in matrix form as

 O(r+1) = A·I(r+1) + B·O(r),

where A is a diagonal matrix containing the self‑weights w_{i,i} and B contains the off‑diagonal weights w_{i,j}. This is precisely the Jacobi iteration for solving the linear system W·u = v, with W = A⁻¹·(I – B). The authors analyze convergence under the mild condition that the infinity‑norm of B is strictly less than one (‖B‖_∞ < 1). Under this contraction property, the error vector c(r) = O(r) – ū satisfies

 c(r+1) = A·(I(r+1) – v̄) + B·c(r).

Unfolding the recurrence yields

 c(Δt) = B^{Δt}·c(0) + Σ_{k=0}^{Δt‑1} B^{k}·A·(I(r+Δt‑k) – v̄).

Because each input deviation is bounded by δ, the second term can be bounded by

 ‖c(Δt)‖∞ ≤ ‖B‖∞^{Δt}·‖c(0)‖∞ + (‖A‖∞·δ)·(1 – ‖B‖∞^{Δt})/(1 – ‖B‖∞).

Thus, as Δt → ∞ the error converges to at most (‖A‖∞·δ)/(1 – ‖B‖∞), a constant proportional to the input bound δ. If the inputs eventually become constant (δ = 0), the algorithm converges exactly to the true solution ū. The analysis also shows that the convergence rate is geometric with factor ‖B‖_∞, matching the classic Jacobi rate.

The paper extends the analysis to a fully asynchronous model. In this model, each node updates at arbitrary times, using the most recent neighbor values that have arrived. By leveraging existing results on asynchronous Jacobi convergence, the authors prove that the same contraction condition (‖B‖_∞ < 1) guarantees convergence, with the same asymptotic error bound. The algorithm therefore tolerates message delays, out‑of‑order deliveries, and temporary communication failures without any additional coordination.

To demonstrate practicality, the authors apply SS‑Iterative to a sensor calibration problem. Each sensor measures temperature; the goal is to compute calibrated values that respect a weighted consistency relation among neighboring sensors. The weight matrix is derived from physical proximity and trust levels. Simulations are performed on three network topologies: a linear chain, a 2‑D grid, and a random scale‑free graph. Input sequences include (i) static measurements, (ii) sinusoidal variations, and (iii) Gaussian noise. Results show that the algorithm reaches an error below 0.01 within 20–40 synchronous iterations, and similar performance is observed under asynchronous execution with random delays of up to five iterations. Moreover, the final error scales linearly with the input bound δ, confirming the theoretical bound.

The authors discuss limitations: the contraction condition excludes graphs with very high degree or poorly scaled weights, and the self‑weight w_{i,i} must be non‑zero, which may not hold in some applications. Future work is suggested on adaptive weight selection, extensions to non‑linear relationships, and real‑world hardware deployments.

In summary, the paper makes three key contributions: (1) it introduces the first self‑stabilizing variant of classical linear iterative solvers, (2) it provides rigorous convergence proofs for both synchronous and asynchronous executions under bounded input perturbations, and (3) it validates the approach through extensive simulations on realistic sensor calibration scenarios. The work bridges linear algebraic iterative methods and fault‑tolerant distributed computing, offering a robust tool for a wide range of dynamic, distributed estimation problems.