Anonymous Ring Research Articles

On Recognizing a String on an Anonymous Ring

We consider the problem of recognizing whether a given binary string of length n is equal (up to rotation) to the input of an anonymous oriented ring of n processors. Previous algorithms for this problem have been ``global'' and do not take into account ``local'' patterns occurring in the string. In this paper we give new upper and lower bounds on the bit complexity of string recognition. For periodic strings, near optimal bounds are given which depend on the period of the string. For Kolmogorov random strings an optimal algorithm is given. As a consequence, we show that almost all strings can be recognized by communicating Θ (n log n) bits. It is interesting to note that Kolmogorov complexity theory is used in the proof of our upper bound, rather than its traditional application to the proof of lower bounds.

Self-Stabilizing Ring Orientation Using Constant Space

The ring-orientation problem requires all processors on an anonymous ring to reach agreement on a direction along the ring. A self-stabilizing ring-orientation protocol eventually ensures that all processors on the ring agree on a direction, regardless of the initial states of the processors on which the protocol is started. In this paper we present two uniform deterministic self-stabilizing ring-orientation protocols for rings with an odd number of processors using only a constant number of states per processor. The first protocol operates in the link-register model under the distributed daemon, and the second protocol operates in the state-reading model under the central daemon. Both protocols do not assume an upper bound on the length of the ring and are therefore applicable to dynamic rings. As an application of our techniques we are able to prove that under the central daemon on an odd-length ring, the link-register model and the state-reading model are equivalent in the sense that any self-stabilizing protocol for the one model can be transformed to an equivalent, self-stabilizing protocol in the other model.

A gap theorem for the anonymous torus

We characterize the class of functions computable on an anonymous torus, where each processor does not know the dimension n of the torus but only an upper bound m of n. We show that any computable function can be computed exchanging O( n√ m) messages. Surprisingly, we prove a “gap” theorem showing that all non-constant computable functions have message complexity Ω(n√m). From these results we obtain that to compute any non-constant computable function, the input collection algorithm is the optimal one. Analogous results are obtained for the case that the torus is non-square and for the anonymous ring.

Better computing on the anonymous ring

We consider a bidirectional ring of n processors, where processors are anonymous, i.e., are indistinguishable. In this model it is known that “most” functions (in particular XOR and orientation) have worst case message complexity Θ( n 2) for asynchronous computations, and Θ( n log n) for synchronous computations. The average case behavior is different; an algorithm that computes XOR asynchronously with O(n n messages on the average is known. In this paper we give tight bounds on the average complexity of various problems. We show the following: • •An asynchronous deterministic algorithm that computes any computable function with O( n log n) messages, on the average (improving the O(n n algorithm). A matching lower bound is proven for functions such as XOR and orientation. • •An asynchronous probabilistic algorithm that computes any computable function with O( n log n) expected messages on any input, using one random bit per processor. A matching lower bound is proven. • •A Monte-Carlo asynchronous algorithm that computes any computable function with O( n) expected messages on any input, using one random bit per processor, with fixed error probability ε > 0. • •A synchronous algorithm that computes any computable function optimally in O( n) messages, on the average. • •A synchronous probabilistic algorithm that computes any computable function optimally in O( n) expected messages on any input, using one random bit per processor • •Lower bounds on the complexity of Monte-Carlo algorithms that always terminate.

Computing on an anonymous ring

The computational capabilities of a system of n indistinguishable (anonymous) processors arranged on a ring in the synchronous and asynchronous models of distributed computation are analyzed. A precise characterization of the functions that can be computed in this setting is given. It is shown that any of these functions can be computed in O ( n 2 ) messages in the asynchronous model. This is also proved to be a lower bound for such elementary functions as AND, SUM, and Orientation. In the synchronous model any computable function can be computed in O ( n log n ) messages. A ring can be oriented and start synchronized within the same bounds. The main contribution of this paper is a new technique for proving lower bounds in the synchronous model. With this technique tight lower bounds of θ( n log n ) (for particular n ) are proved for XOR, SUM, Orientation, and Start Synchronization. The technique is based on a string-producing mechanism from formal language theory, first introduced by Thue to study square-free words. Two methods for generalizing the synchronous lower bounds to arbitrary ring sizes are presented.

Language complexity on the synchronous anonymous ring

A set of n nondistinct processors, organized as a ring and operating synchronously, have to compute a function of their initial values. Every computable function can be computed with O(n log n) messages, while some functions can be computed with as few as O(n) messages. We prove a necessary and sufficient condition for a regular language to be recognized with O(n) messages. Languages that do not satisfy this condition are ‘hard’ to compute, i.e., their recognition requires Ω(n log n) message. The condition is an extension of the notion of counter-free regular languages. These results give a gap theorem for recognizing regular languages on the synchronous anonymous ring. In contrast, we show a family of nonregular languages, computing thresholds, that obtain any intermediate complexity in the range ϴ(n) to ϴ(n log n).