fast and compact self stabilizing verification, computation, and fault detection of an mst
This paper demonstrates the usefulness of distributed local verification of proofs, as a tool for the design of algorithms. In particular, it introduces a somewhat generalized notion of distributed local proofs, and utilizes it for improving the memory size complexity, while obtaining time efficiency too. As a result, we show that optimizing the memory size carries at most a small cost in terms of time, in the context of Minimum Spanning Tree (MST). That is, we present algorithms that are both time and space efficient for constructing an MST, for verifying it, and for detecting the location of the faults. This involves several steps that may be considered contributions in themselves. First, we generalize the notion of local proofs, trading off the locality (or, really, the time complexity) for memory efficiency. This adds a dimension to the study of distributed local proofs, that has been gaining attention recently. Second, as opposed to previous studies that presented only the labels verification part of a proof labeling schemes, we present here also a space and time efficient distributed self stabilizing marker algorithm to generates those labels. This presents proof labeling schemes as an algorithmic tool. Finally, we show how to enhance a known transformer that makes input/output algorithms self stabilizing. It now takes as input an efficient construction algorithm and an efficient self stabilizing proof labeling scheme, and produces an efficient self stabilizing algorithm. When used for MST, the transformer produces a memory optimal (i.e., O (log n ) bits per node) self stabilizing algorithm, whose time complexity, namely, O ( n ), is significantly better even than that of previous algorithms that where not space optimal. (The time complexity of previous MST algorithms that used (log 2 n ) memory bits per node was O ( n 2 ), and the time for optimal space algorithms was O ( n | E |).) Our MST algorithm also has the important property that, if faults occur after the construction ended, then they are detected by some nodes within O (log 2 n ) time in synchronous networks, or within O (? log 2 n ) time in asynchronous ones. This property is inherited from the specific proof labeling scheme we construct. It answers an open problem posed by Awerbuch and Varghese (FOCS 1991). We also show that (log n ) time is necessary if the memory size is restricted to O (log n ) bits, even in synchronous networks. Another property is that if f faults occurred, then, within the required detection time above, they are detected by some node in the O ( f log n ) locality of each of the faults. We also show how to improve the above detection time and locality, at the expense of some increase in the memory.
self stabilization fault detection mst locality distributed algorithms distributed verification local proof checking