Elsevier

Applied Mathematics and Computation

Volume 318, 1 February 2018, Pages 92-108
Applied Mathematics and Computation

A new reconstruction and the first implementation of Goto’s FSSP algorithm

https://doi.org/10.1016/j.amc.2017.05.015Get rights and content

Abstract

The firing squad synchronization problem (FSSP) on cellular automata has been studied extensively for more than fifty years, and a rich variety of synchronization algorithms has been proposed. Goto’s FSSP algorithm (Goto 1962) has been known as the first minimum-time FSSP algorithm, however the paper itself had been a completely unknown one in the research community of cellular automata for a long time due to its hard accessibility. In the present paper, we reconstruct the Goto’s FSSP algorithm and present the first small-state implementation. The implementation is realized on a cellular automaton having 165-state and 4378 state-transition rules and the realization is far smaller than Goto (1962) imagined, where he thought that it would require many thousands of thousands states. It is shown that the reconstructed algorithm uses a quite different synchronization mechanism in comparison with the designs employed in Waksman (1966), Balzer (1967), Gerken (1987) and Mazoyer (1987). We show that the algorithm has Θ(nlog n) minimum-state-change complexity for synchronizing n cells. The algorithm is optimum not only in time but also in state-change complexities. We show that the reconstructed algorithm can be generalized as to the initial general’s position and its implementation on a cellular automaton with 434 internal states and 13,328 state-transition rules is also given. The general purpose of this investigation is to achieve more insights into the structure of the classical minimum-time FSSP solutions and such insights would be helpful in the design of new FSSP algorithms.

Introduction

We study a synchronization problem that gives a finite-state communication protocol for synchronizing large-scale cellular automata. The synchronization in cellular automata has been known as the firing squad synchronization problem (FSSP) since its development, in which it was originally proposed by Myhill in Moore [8] to synchronize all/some parts of self-reproducing cellular automata. The problem has been studied extensively for more than fifty years, and a rich variety of synchronization algorithms has been proposed not only for one-dimensional (1D) arrays but also for multi-dimensional arrays.

Historically, the FSSP problem was first studied by McCarthy and M. Minsky [7] who presented a 3n-step non-minimum-time algorithm for 1D cellular array of length n. In 1962, the first minimum-time, i.e. (2n2)-step synchronization algorithm was presented by Goto [3], with each cell having many thousands of thousands states (according to Goto’s statements in Goto  [4]). Afterward, Waksman [18], Balzer [1], Gerken [2], and Mazoyer [5] presented a 16-state, 8-state, 7-state, and 6-state minimum-time synchronization algorithm, respectively, thus decreasing the number of states required for the synchronization.

In the present paper, we reconstruct Goto’s FSSP algorithm and present the first small-state implementation on a finite-state automaton. The Goto’s algorithm has been known as the first FSSP algorithm to synchronize 1D array in minimum-time. The first minimum-time algorithm was presented as a technical lecture note in Goto [3]. The paper has been usually cited as the first minimum-time FSSP algorithm, but the original paper had been a completely unknown one for a long time in the community of cellular automata due to its hard accessibility, until Umeo [10] gave a talk on the reconstruction of the Goto’s algorithm at the first IFIP cellular automata workshop in 1996.

In this paper, specifically, we attempt to answer the following questions:

  • What is the first Goto’s FSSP algorithm?

  • What is the difference among many minimum-time FSSP algorithms, such as Goto [3], Waksman [18], Balzer [1], Gerken [2], and Mazoyer [5]?

    • Waksman [18], Balzer [1] and Gerken [2] algorithms are based on a recursive halving marking and they are two-sided recursive algorithms.

    • Mazoyer [5] is a one-sided FSSP algorithm which is based on a recursive division with a 1/3 ratio.

    • The reconstructed algorithm we show here is quite different from the above designs. It is based on an exponential marking and it is a non-recursive FSSP algorithm.

  • How many states are required for its implementation?

    • It has been said by Goto himself [4] that many thousands of thousands states would be required for its realization.

    • It is shown that the reconstructed algorithm we show here is realized on a finite-state automaton only with 165 states and 4378 state-transition rules, where these amounts are far smaller than being thought.

  • How can we synchronize 1D arrays without calling itself recursively?

    • It is shown that the reconstructed algorithm consists of two operation phases, the first one is an exponential marking and the second one is a synchronization phase which calls a simple 3n-step FSSP algorithm.

  • What is the state-change complexity of the reconstructed algorithm for synchronizing n cells?

    • A state-change complexity is an important complexity measure to evaluate the efficiency of cellular automata, motivated by energy consumption in certain SRAM-type memory systems.

    • We show that the reconstructed algorithm has Θ(nlog n) minimum-state-change complexity for synchronizing n cells.

    • The algorithm is optimum not only in time but also in state-change complexity.

  • Can we generalize the reconstructed algorithm to the case where the initiator can be located at any position of the array, while keeping the minimum-time optimality?

    • Yes, it can be generalized so that the synchronization operation can be started from any position of the array. It is shown that the generalized FSSP (GFSSP) algorithm constructed here can synchronize any 1D array of length n in minimum n2+max(k,nk+1) steps, where the general is located on the kth cell from the left end.

    • The GFSSP algorithm is optimum not only in time but also in state-change complexity.

    • The realized minimum-time GFSSP algorithm can be implemented on a cellular automaton with 434 internal states and 13328 state-transition rules and has a minimum-state-change complexity.

Section 2 gives a definition of the FSSP. In Section 3 we present a reconstruction of the Goto’s FSSP algorithm and give the first small-state implementation of the reconstructed algorithm. We also give a generalization of the reconstructed algorithm as to the initial position of the general and consider the algorithms from a point of state-change complexity. Section 4 gives a summary of the paper and several discussions on the reconstruction.

Section snippets

FSSP on one-dimensional array

The FSSP is formalized in terms of the model of cellular automata. Consider a 1D array of finite state automata. All cells (except the end cells) are identical finite state automata. The array operates in lock-step mode such that the next state of each cell (except the end cells) is determined by both its own present state and the present states of its right and left nearest neighbors. All cells (soldiers), except one general cell at the left end of the array, are initially in the quiescent

Background of this research

The first minimum-time synchronization algorithm presented by Goto [3] was not published as a journal paper. According to communications with Prof. Goto1 that the first author had, the original lecture note Goto [3] had not been available, and the only existing

Conclusions

We have presented a reconstruction of the minimum-time Goto’s FSSP algorithm and given the first small-state implementation of the algorithm. The implementation is realized on a cellular automaton with 165 states and 4378 transitions rules. A 165-state realization on a cellular automaton would be a reasonable one in the number of states required, taking in consideration that the reconstructed minimum-time algorithm has Θ(nlog n) minimum-state-change complexity. However, the authors think that

Acknowledgments

A part of this work is supported by JSPS 16K00026. The authors would like to thank reviewers for many helpful comments and suggestions to improve the paper.

References (18)

There are more references available in the full text version of this article.
View full text