Firing Squad Synchronization Problem Research Articles

Inductive definitions in logic versus programs of real-time cellular automata

Descriptive complexity provides intrinsic, i.e. machine-independent, characterizations of the main complexity classes. On the other hand, logic can be useful for designing programs in a natural declarative way. This is especially important for parallel computation models such as cellular automata, since designing parallel programs is considered a difficult task.This paper establishes three logical characterizations of the three classical complexity classes modeling minimal time, called real-time, of one-dimensional cellular automata according to their canonical variations: unidirectional or bidirectional communication, input word given in a parallel or sequential way.Our three logics are natural restrictions of existential second-order Horn logic with built-in successor and predecessor functions. These logics correspond exactly to the three ways of deciding a language on a square grid circuit of side n according to one of the three natural locations of an input word of length n: along a side of the grid, on the diagonal that contains the output cell – placed on the vertex (n,n) of the square grid–, or on the diagonal opposite to the output cell.The key ingredient to our results is a normalization method that transforms a formula from one of our three logics into an equivalent normalized formula that closely mimics a grid circuit.Then, we extend our logics by allowing a limited use of negation on hypotheses like in Stratified Datalog. By revisiting in detail a number of representative classical problems - recognition of the set of primes by Fisher's algorithm, Dyck language recognition, Firing Squad Synchronization problem, etc. - we show that this extension makes easier programming and we prove that it does not change the real-time complexity of our logics.Finally, based on our experience in expressing these representative problems in logic, we argue that our logics are high-level programming languages: they make it possible to express in a natural, complete and synthetic way the algorithms of the literature, based on signals – and even to design new inductive algorithms –, and to translate them automatically into cellular automata of the same complexity.

A faster algorithm for the Birthday Song Singers Synchronization Problem (FSSP) in one-dimensional CA with multiple speeds

In cellular automata with multiple speeds for each cell i there is a positive integer p_i such that this cell updates its state still periodically but only at times which are a multiple of p_i. Additionally there is a finite upper bound on all p_i. Manzoni and Umeo have described an algorithm for these (one-dimensional) cellular automata which solves the Firing Squad Synchronization Problem. This algorithm needs linear time (in the number of cells to be synchronized) but for many problem instances it is slower than the optimum time by some positive constant factor. In the present paper we derive lower bounds on possible synchronization times and describe an algorithm which is never slower and in some cases faster than the one by Manzoni and Umeo and which is close to a lower bound (up to a constant summand) in more cases.

Synchronization in Quantum-Dot Cellular Automata Circuits and Systems

Signal synchronization of large scale Quantum-dot Cellular Automata (QCA) circuits is one of the most complex QCA design challenges. More specifically, the QCA circuits synchronization problem, especially in the large circuits, is characterized as rather complex due to technology constraints. In this paper, by extensively analyzing the most important properties of the signal synchronization problem in QCA circuits, we propose an efficient design methodology to tackle the problem, based on the well-known from computer science, Firing Squad Synchronization Problem (FSSP). Comparing FSSP with the QCA circuits synchronization problem many similarities can be found. Among the numerous FSSP's algorithmic solutions in literature, the Mazoyer algorithm has proven to be the most efficient one. In this paper, a novel design and implementation in QCA technology of this algorithm is presented. Moreover, by the appropriate modification of the Mazoyer algorithm, we are able to propose a generic synchronization design methodology for QCA circuits and systems. This method is enhanced by a novel freezing technique, that makes it applicable to any QCA circuit and system as manifested by our corresponding simulation results. The proposed synchronization methodology is a universal design tool, that can be applied to exiting designs without increasing the complexity.

State-efficient realization of fault-tolerant FSSP algorithms

The firing squad synchronization problem (FSSP, for short) on cellular automata has been studied extensively for more than fifty years, and a rich variety of FSSP algorithms has been proposed. Here we study the classical FSSP on a model of fault-tolerant cellular automata that might have possibly some defective cells and present the first state-efficient implementations of fault-tolerant FSSP algorithms for one-dimensional (1D) and two-dimensional (2D) cellular arrays. It is shown that, under some constraints on the length and distribution of defective cells, any 1D cellular array of length n with p defective cell segments can be synchronized in $$2n-2+p$$ steps and the algorithm is realized on a 1D cellular automaton of length $$n, 2 \le n \le 50$$, having 164 states and 4792 transition rules. In addition, we give by far a smaller-state implementation of a 2D FSSP algorithm that can synchronize any 2D rectangular array of size $$m \times n$$, possibly including at most O(mn) isolated defective zones, exactly in $$2(m+n)-4$$ steps on a cellular automaton with only 6 states and 935 transition rules.

An Iterated Local Search to find many solutions of the 6-states Firing Squad Synchronization Problem

This paper proposes an optimization approach for solving a classical problem in cellular automata theory: the 6-states Firing Squad Synchronization Problem (FSSP). To this purpose, we introduce an original optimization function which quantifies the quality of solutions according only to the main goal of the problem without taking into account any side information about cellular automata computations. This function is used for a dedicated Iterated Local Search algorithm which finds several hundreds of new solutions of the FSSP. Note, that up to present only one human-designed solution was known which is optimal in time. Most of the new solutions found by our algorithm have lower complexity (in terms of number of transitions rules used). An analysis of the fitness landscape for FSSP explains why, counter-intuitively, local search strategy can achieve good results for FSSP.

Computability via Cellular Automata

This review addresses the issues of computations using cellular automata (CA). It is shown that the generality of the connectionism paradigm allows some methods applicable to neural networks to be transferred into the domain of CA. Some special issues of computability are discussed based on the examples of the density classification task, the firing-squad synchronization problem, and the queen-bee problem, as well as sorting algorithms and Atrubin’s parallel multiplication algorithm.

Revisiting the cutting of the firing squad synchronization

Various synchronization algorithms have been introduced in literature during the last decades to deal with the firing squad synchronization problem on cellular automata (CA). Among others defective CA algorithms, where the CA cell is able to transmit information without previous processing, have been also presented. In our case, originating from the classical Mazoyer’s paper, where a minimum-time solution is presented with 6 states, a one-dimensional CA where one cell may permanently fail is presented. In the proposed algorithm, the defective cell can neither process nor transmit information any longer, while it is considered that such dynamic defects may become apparent in any time step of computation. A thorough analysis of the synchronization, in terms of location and time at which cell fails, for the cells found in both sides of defective cell is delivered to decipher the corresponding maximal possible number of synchronized cells in each part of the cut, due to defect, CA array. The proposed algorithm is properly extended to consider more than one defective cells that may occur in the under study one-dimensional CA. Based on the aforementioned analysis, we provide the generalization of synchronization with multiple totally defective cells, while application examples of the generalized CA algorithm in case of two defective cells are also presented. Finally, another intriguing aspect refers to handling of states that could be tentatively characterized as unknown, in a confrontation similar to the previous defective state but also different, since now this(these) cell(s) are not stated as faulty but unknown. As a result, a new one-dimensional CA with less states, compared to the previous CA defective algorithms, able to synchronize the maximal possible number of cells in each part occurs.

A design of generalized minimum-state-change FSSP algorithms and their implementations

The firing squad synchronization problem (FSSP) on cellular automata has been studied extensively for more than 50 years, and a rich variety of FSSP algorithms has been proposed. Here we consider the FSSP from a view point of state-change complexity that models the energy consumption of SRAM-type storage with which cellular automata might be built. In the present paper, we propose minimum-state-change generalized FSSP (GFSSP) algorithms for synchronizing any one-dimensional (1D) cellular automaton, where the initial synchronization operation is started by any cell in the array. First, we construct two minimum-time, minimum-state-change GFSSP implementations on finite state automata: one is based on Goto’s algorithm, known as the first minimum-time FSSP algorithm that was reconstructed again recently in Umeo et al. (A new reconstruction and the first implementation of Goto’s FSSP algorithm, 2017), and the other is based on Gerken’s (Diplomarbeit, Institut fur Theoretische Informatik, Technische Universitat Braunschweig, pp 1–50, 1987) one. These implementations are optimal not only in time but also in the state-change complexity. The implementations of the minimum-time GFSSP algorithms are the first ones having the minimum-state-change complexity. In addition, we also present a six-state 145-rule non-minimum-time, minimum-state-change GFSSP implementation. The implemented GFSSP algorithm is the smallest one, known at present, in number of states of the finite state automaton.

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

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.

A Biologically-Motivated Synchronization Problem in Cellular Automata

We study a biologically-motivated synchronization problem that gives a finite-state protocol for synchronizing cellular automata. The synchronization in cellular automata has been known as firing squad synchronization problem since its development, in which it was originally proposed by J. Myhill in the book edited by Moore [1964] to synchronize all/some parts of self-reproducing cellular automata. The problem has been studied extensively for more than fifty years. It is defined as follows: given a one-dimensional array of n identical cellular automata, including a general at one end that is activated at time t = 0 , we want to design the automata such that, at some future time , all the cells will simultaneously and, for the first time , enter a special firing state. The problem has been referred to as achieving a macro-synchronization in micro-synchronization system and realizing a global synchronization using only local information exchange. In this paper, we present a survey on recent developments in designing optimum- and non-optimum-time synchronization algorithms and their implementations for one- and two-dimensional cellular arrays. Several simple, state-efficient mapping schemes are proposed for embedding one-dimensional firing squad synchronization algorithms onto two-dimensional arrays. The discussions are made from a viewpoint of biological systems, including fault-tolerance, self-replication, self-reproduction, self-repairing and growing nature-based systems. [1] E. F. Moore: The firing squad synchronization problem. in Sequential Machines, Selected Papers, E. F. Moore, ed., Addison-Wesley, Reading MA.,(1964), pp. 213-214. [2] H. Umeo: Firing squad synchronization problem in cellular automata. In Encyclopedia of Complexity and System Science , R. A. Meyers (Ed.), Springer, Vol.4(2009), pp.3537-3574.

The firing squad synchronization problem on CA with multiple updating cycles

Classical cellular automata have a single, global clock that allows all the cells to update their states simultaneously at every clock cycle. Here, we overturn this assumption and we study cellular automata where different cells can use different clocks cycles and, as a consequence, they update at different times. We show how it is possible to solve the firing squad synchronization problem in this new setting and propose a synchronization algorithm operating in time linear with respect to the automata size.

A class of time-optimum FSSP algorithms for multi-dimensional cellular arrays

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 not only for one-dimensional arrays but also for two-dimensional arrays. In the present paper, we propose a new class of time-optimum FSSP algorithms for multi-dimensional cellular arrays. The algorithm is based on a simple recursive-halving marking schema and it can synchronize any two-dimensional (2D) rectangular arrays of size m×n with a general at one corner in m+n+max(m,n)-3 optimum-steps. The algorithm is a natural expansion of the well-known one-dimensional (1D) FSSP algorithms proposed by Balzer (1967), Gerken (1987), and Waksman (1966) and it can be easily expanded to three-dimensional (3D) arrays, even to multi-dimensional arrays. The algorithm proposed is isotropic concerning the side-lengths of multi-dimensional arrays and this isotropic property yields algorithmic correctness and easy verification for the multi-dimensional time-optimum FSSP algorithms designed.

The minimum firing time of the generalized firing squad synchronization problem for squares

For almost all variations of the firing squad synchronization problem for elementary geometric figures such as lines, rings, squares, rectangles, and cubes, minimal-time solutions are known. However, in 2012 Umeo and Kubo introduced a very simple variation of this type and pointed out that its minimal-time solutions are unknown. In that variation, a problem instance is a square array of n columns and n rows and the position of the general is arbitrary. For this variation they constructed a solution that fires at time 2n−2 for any position of the general and wrote that it is not known whether this solution is minimal-time or not. We determine the exact value of the minimum firing time of this variation. For some problem instances this value is smaller than 2n−2 and hence the 2n−2 time solution is not minimal-time. Our result does not solve the problem of existence or non-existence of minimal-time solutions of the variation. However the result gives one necessary condition for solutions to be minimal-time.

The firing squad synchronization problem with sub-generals

The Firing Squad Synchronization Problem (FSSP), one of the most well-known problems related to cellular automata, was originally proposed by Myhill in 1957 and became famous through the work of Moore. The first solution to this problem was given by Minsky and McCarthy, and a minimal time solution was given by Goto. A considerable amount of research has also dealt with variants of this problem. In this paper, we introduce a new state called the sub-general to the original problem and propose the FSSP with sub-generals. In particular, we consider the case of one sub-general and determine the position of the sub-general in the array that minimizes the synchronization time. Moreover, we determine the minimal time to solve this problem and show that there exists no minimal time solution for any length of array. However, we show that the total time of our algorithm approaches arbitrarily close to the minimal time.

A State-Efficient Zebra-Like Implementation of Synchronization Algorithms for 2D Rectangular Cellular Arrays

The firing squad synchronization problem on cellular automata has been studied extensively for more than forty years, and a rich variety of synchronization algorithms has been proposed for not only one-dimensional (1D) but two-dimensional (2D) arrays. In the present paper, we propose a simple and state-efficient mapping scheme: zebra-like mapping for implementing 2D synchronization algorithms for rectangular arrays. The zebra-like mapping we propose embeds two types of configurations alternately onto a 2D array like a zebra pattern, one configuration is a synchronization configuration of 1D arrays and the other is a stationary configuration which keeps its state unchanged until the final synchronization. It is shown that the mapping gives us a smallest, known at present, implementation of 2D FSSP algorithms for rectangular arrays. The implementation itself has a nice property that the correctness of the constructed transition rule set is clear and transparent. It is shown that there exists a nine-state 2D cellular automaton that can synchronize any (m x n) rectangle in (m+n+max(m,n)-3) steps.

A Simple Optimum-Time FSSP Algorithm for Multi-Dimensional Cellular Automata

The firing squad synchronization problem (FSSP) on cellular automata has been studied extensively for more than forty years, and a rich variety of synchronization algorithms have been proposed for not only one-dimensional arrays but two-dimensional arrays. In the present paper, we propose a simple recursive-halving based optimum-time synchronization algorithm that can synchronize any rectangle arrays of size m*n with a general at one corner in m+n+max(m, n)-3 steps. The algorithm is a natural expansion of the well-known FSSP algorithm proposed by Balzer [1967], Gerken [1987], and Waksman [1966] and it can be easily expanded to three-dimensional arrays, even to multi-dimensional arrays with a general at any position of the array.

Synchronizing square arrays in optimum-time

The firing squad synchronization problem on cellular automata has been studied extensively for more than 50 years, and a rich variety of synchronization algorithms have been proposed for not only one-dimensional (1D) arrays but also 2D arrays. In this paper, we construct a survey on a design and implementation of optimum-time synchronization algorithms for 2D square arrays.

On Minimal-Time Solutions of Firing Squad Synchronization Problems for Networks

The goal of this work is to show that if a minimal-time solution exists for a fundamental computation primitive, synchronizing networks of finite-state processors (formally known as the firing squad synchronization problems for directed and undirected networks), then there must exist „extraordinarily fast” algorithms for exactly solving the diameter problem in the standard RAM model of computation. These results can therefore be interpreted either as evidence that such minimal-time solutions for synchronization do not exist or as a potentially major algorithmic leap forward in the study of the diameter problem. We conjecture that the former is true. These results essentially complete the program outlined in [K. Kobayashi, Theoret. Comput. Sci., 259 (2001), pp. 129--143] to show that there exist a wide range of natural topologies for which it seems highly unlikely that there exist minimal-time solutions.

Faster synchronization in P systems

In the field of molecular computing, in particular P systems, synchronization is an important requirement for composing or sequentially linking together congenial P system activities. We provide a deterministic algorithm to the Firing Squad Synchronization Problem, for digraph-based P systems, which runs in 3e + 11 steps, where e is the eccentricity of the general. Our algorithm uses a convenient framework, called simple P modules, which embraces the essential features of several popular types of P systems.

The Firing Squad Synchronization Problems for Number Patterns on a Seven-Segment Display and Segment Arrays

The Firing Squad Synchronization Problem (FSSP), one of the most well-known problems related to cellular automata, was originally proposed by Myhill in 1957 and became famous through the work of Moore [1]. The first solution to this problem was given by Minsky and McCarthy [2] and a minimal time solution was given by Goto [3]. A significant amount of research has also dealt with variants of this problem. In this paper, from a theoretical interest, we will extend this problem to number patterns on a seven-segment display. Some of these problems can be generalized as the FSSP for some special trees called segment trees. The FSSP for segment trees can be reduced to a FSSP for a one-dimensional array divided evenly by joint cells that we call segment array. We will give algorithms to solve the FSSPs for this segment array and other number patterns, respectively. Moreover, we will clarify the minimal time to solve these problems and show that there exists no such solution.