Hard, firm, soft … Etherealware: Computing by Temporal Order of Clocking Hard, firm, soft … Etherealware: Computing by Temporal Order of Clocking

We define Etherealware as the concept of implementing the functionality of an algorithm by means of the clocking scheme of a cellular automaton (CA). We show, which functions can be implemented in this way, and by which CAs.


What is etherealware?
Computation takes place in dedicated hardware or on general-purpose hardware by dedicated software. Different functionality requires either changing the hardware (think ASIC, FPGA) or changing the software running on it. Firmware is an intermediate concept, where the hardware is modified by microprogramming a CPU or personalizing an FPGA.
Etherealware is the first way to use fixed hardware (certain cellular automata (CA) in this case), run fixed software (the same update rule for all cells, for all time, for all purposes), and still deliver diversity in the resulting function: by changing only the clocking scheme, the order in which the CA's cells are updated.

State-of-the-art
The study of synchronous CAs starts with Wolfram [1]. We use asynchronous CAs as deterministic devices with a finite number of computation steps, which is a new point of view.
Previously, asynchronous CAs have been treated as dynamical systems, where infinite computations are considered, and the focus lies on concepts like orbits, fixed points, ergodicity, transients, cycles and their periods, and long-term behavior. Also, randomness can be introduced to average over many possible asynchronous schemes. Papers in this respect are: Ingerson and Buvel [2], 1984, distinguish synchronous, random (completely asynchronous), and periodic clocking, which yield clearly distinguishable behavior.
Siwak [7], 2002, gives an overview of simulating machines, including CAs and SDSs, and unifies them under the concept of "filtrons." Lee et al. [8], 2003, give an asynchronous CA on the two-dimensional grid Z Â Z, which is Turing universal.
Macauley, McCammond, and Mortveit [12,13], 2007-2010, also treat SDSes, in particular ECAs. For each ECA, [13] gives the periodic states and the dynamics group. Conjecture 5.10 in [13] about Wolfram rule 57 coincides with our finding that ECA-57 generates the alternating groups on patterns of n bits. They verified this claim for n up to 8, while in [14] this is extended to n ≤ 10 and in this paper up to n ≤ 28.
Dennunzio et al. [15,16], 2012-2013, consider ACAs, every turing machine can be simulated by an ACA, with quadratic slowdown. Introducing a certain fairness measure, they show that injectivity and surjectivity are equivalent (μ-a.a.), and the existence of a diamond is equivalent to not μ-a.a. injectivity.

Notations: ECA and update rules
Here, continuing the work in [10,14], we again employ CAs as computing devices, whose work comes to an end, when the pattern transformation or function evaluation has been obtained. Also, the clocking, the temporal update rule, is completely deterministic and replaces the usual ways of representing an algorithm, either in software (initial data) or in hardware (choice of ECA and connecting graph). Thus, the algorithm resides exclusively in the clocking scheme. We therefore call functions computable in this way as "clocking-computable functions." The main additional contribution of this paper is the introduction of unfair clocking schemes.

Cellular automata: Neighborhoods and local update rules
We consider cellular automata (CA) on a torus or ring of n cells, that is index set Z=nZ, over the binary alphabet 0; 1 f g. Cell index wraparound, that is, c i ¼ c j for i jmodn, and the canonical cell names are c nÀ1 , c nÀ2 , …, c 1 , c 0 . We deal with elementary CAs (ECA) with three input cells, where the middle one is also the output cell. We repeat the definition of asynchronicity rules from ( [10], Section 2).
The set AS n of asynchronicity rules over Z=nZ consists in all words of length n over the alphabet <; ; > f gsuch that both "<" and ">" occur at least once. We also include the word " ⋯ ," the synchronous case, and have.
A rule AS ¼ AS nÀ1 ⋯ AS 0 ∈ AS n defines the firing order as follows: Cell c i fires simultaneously with cell c iÀ1 To ensure bijectivity, we must first have a locally bijective CA, and, furthermore, no two adjacent cells may fire simultaneously. Why this is so will be dealt with in Chapter 5. There are exactly 2 n À 2 bijective fair rules, those from <; > f g n \ < n , > n f g ; see also ([10], 4.1]).
A fair update step (bijective or not) can be decomposed into a sequence of elementary steps such that all cells fire exactly once during the execution of that sequence; see [3].

Unfair update schemes
We now include unfair updates, where some cells may fire less often than others (even not at all).
We start with elementary steps (μ steps in [10]). During one elementary step, any nonempty subset I ⊆ n À 1; n À 2; …; 1; 0 f g of indices may define the active cells.
These cells fire simultaneously, hence We define elementary steps as words s ¼ s nÀ1 ⋯s 1 s 0 ∈ 0; 1 f g n , with the meaning s i ¼ 1, if cell c i fires, and s i ¼ 0 if cell c i is inactive in this step.
A sequence of such elementary steps is upper indexed by the time step t ð Þ.
A fair update rule consists in a number of elementary steps such that every cell fires exactly once. The fair rule as ¼ "<><><>" for n ¼ 6 can be decomposed into (s 1 while the sequence (s 1 ð Þ ¼ 010001, s 2 ð Þ ¼ 101010) is unfair, since cell c 2 does not fire at all.
The number of bijective elementary steps is the number of words of length n over the alphabet 0; 1 f g, such that no adjacent 1's occur to ensure bijectivity. For n ¼ 3; 4; 5; 6 there are 3, 6, 10, 17 such steps, respectively. The sequence obeys the law n k ¼ n kÀ1 þ n kÀ2 þ 1. At least for n ¼ 3, …, 7, the sets are as follows: prepend a 0 to each pattern of length k À 1, prepend a 10 (a 01) to each pattern of size k À 1 terminating in 0 (in 1), and add the new pattern 10 kÀ1 . The sequence is used again in Section 5 and has been verified to coincide with OEIS A001610 up to n ¼ 24.
We also can define unfair bijective rules (full steps), where we first fix some subset of size 1 ≤ k ≤ n À 1 of active cells by a word a from 0; 1 f g n \ 0 n ; 1 n f g, a i ¼ 1 meaning that cell c i is active.
We next order adjacent active cells by the usual < , > signs. Hence, a run of r consecutive 1's (with wraparound) has 2 rÀ1 ways to fix the internal firing order. This order is independent of the other 1-runs, since the cells are separated by at least an inactive cell with a i ¼ 0. The number of bijective unfair rules on a torus of size n is where the pattern p avoids 0 n and 1 n and then the 1-runs in the pattern have lengths r 1 , r 2 , …, considering wraparound.

Patterns
We consider pattern conversions F n 2 ∋ v ↦ w ∈ F n 2 , where F n 2 can be identified with the set 0; 1; …; 2 n À 1 f g . From Definition ([10], Def. 3), by ECA AS v ð Þ ¼ w, we mean that the elementary CA with rule ECA maps v ∈ 0; 1 f g n to w ∈ 0; 1 f g n via the asynchronicity scheme AS. We define In [10,14], we considered five universality properties o ð Þ to iv ð Þ, where each v ↦ w makes use of a certain update rule AS applied several times. We only give a summary here. Property iv ð Þ is ruled out for any n ∈ N, while properties o ð Þ to iv ð Þ have only been verified experimentally, for n ≤ 15.
Some v is mapped to every w by varying the rule AS and the required number of time steps. There are 44 ECAs doing this.
All v are mapped to all w by varying the rule AS and the required number of time steps. There are 6 ECAs (rules 19, 23 (for n = 0 mod 2), 37 (for n = 0 mod 3), 41, 57, 105 (for n = 0 mod 4)) doing this (checked for n ≤ 15).
All v are mapped to all w at the same time, which time may vary for v but not for w, for different rules AS .
All v are mapped to all w at the same time, varying the rule AS. This is actually possible for the two survivors of property ii ð Þ; see Table 1. The required time roughly decreases with growing n, since we have 3 n À 2 nþ1 þ 1 rules to choose from for 2 n patterns w. Thus for higher n the probability to meet the conversion early on increases.
Eventually, all conversions may happen at all times for some update scheme. This property cannot be satisfied, for no ECA; see ( [14], Thm. 2).
For more details and results for QCAs consult Section 2 of [14] and Section 3 of [10].

Bijective functions
We first introduce the computer algebra system GAP and then give several examples.

GAP: Graphs, algorithms, programming
4.1.1. GAP and the alternating group A 2 n GAP [19] is a system for computational discrete algebra, in particular computational group theory. We use GAP to decide, whether certain fair or unfair update rules generate the full symmetric or alternating group S 2 n or A 2 n , respectively.
Our results so far: i.
The fair update rules for ECA-57 generate the full symmetric group S 8 for n ¼ 3.
ii. The fair update rules for ECA-57 generate the full alternating group A 2 n for n ¼ 4, …, 11.
ii; iii ð ÞFirst observe that all these rules consist of an even number of transpositions. Hence, we will at most obtain the alternating group A 2 n . This group comprises those bijective functions on 0; 1; …; 2 n À 1 f g which have positive sign as a permutation.
We checked ii ð Þ with GAP for certain sets of 5 fair rules for each of these sizes n, and GAP's function IsNaturalAlternatingGroup(G) returned true.
For iii ð Þ we have the canonical set of n elementary unfair update rules, with exactly one cell active in each rule. This set generates all fair and unfair update rules and hence is sufficient to decide on the group generated by all rules.
Again, GAP shows that indeed the alternating group is generated, for n ¼ 4, …, 28. We used 144 GB of RAM, which was sufficient for n ¼ 28 but not so for n ¼ 29. □ We believe that, apart from the special case n ¼ 3, we always obtain the alternating group.

Conjecture.
For every torus size n ∈ N, n ≥ 4, both the 2 n À 2 fair update rules, as well as the n elementary unfair update rules with a single active cell, are a generating set for the full alternating group on 2 n elements, using ECA-57. We give two realizations of the function byNine : x ↦ 9x mod 16 in Table 2.
Observe that the first 23 steps only implement the permutation 08 ð Þ 2A ð Þ, consisting of two transpositions. The final 24th step is almost identical to the whole function.   Table 3. Exponentiation x ↦ 3 x in F 17 .

Non-bijective global rules and in-degree distributions
In Section 2.2, we have said that, in order to ensure bijectivity, we must first have a locally bijective CA, and furthermore, no two adjacent cells may fire simultaneously. Here is why: Example.
We start with the effect of AS i = "" for the locally bijective ECA-57. We consider four adjacent cells and the effect of between the two middle cells, which are thus updated simultaneously, s ¼ 0110. We obtain the patterns 0011 and 0101 twice, while missing 0001 and 0111. Hence the image is smaller than the full 2 4 by 2 or by a factor 7/8 in general.
We have #(domain) = in-degreeÂ#(range) for every in-degree. Also, the overall sum is Any additional simultaneous firing may increase the losses. Additional in-degree distributions (loss patterns) for ECAs and QCAs may be found in ( [10], Table 8).
We restate Theorem 3 (i) from [14]: We assume an ECA that generates at least the alternating group A 2 n , when using temporal rules from <; > f g n \ < n , > n f g . Let f : F n 2 ! F n 2 be any non-bijective function on n symbols, where we require n ≥ 4 for ECA.

Algorithm for non-bijective functions
The computation of a non-bijective function can be decomposed into 3 steps: Step I. We start in the middle: Shrink the 2 n singletons of the domain to the desired distribution on the range. Find a sequence of elementary steps, necessarily including non-bijective ones, which generates the same distribution of counts in the image space as for the original function. Usually there are more than one of these sequences with the same complexity. Values/patterns as such do not yet play a role; therefore the requirements are usually easy to meet in a variety of ways, and the sequence of necessary elementary steps is short.
Step II. Bijectively map the input of the original function to the input of any of the results of Step I in such a way that the desired image counts are matched. Only the occurence counts must be observed, while, within this restriction, pattern values can be permuted.
Step III. Bijectively map the output from Step I to the output of the desired function, considering the flow within Steps II and I in that order. Now all values matter and cannot be permuted. However, this step takes place on a subset of size |Im f ð Þ| instead of 2 n .
In Steps II and III we use the meet-in-the-middle approach, applying update rules starting both from the input (identity) and the desired function values to take advantage of the birthday paradox: In this way, 2 Á ffiffi ffi # p patterns are sufficient to generate ffiffi ffi # p Á ffiffi ffi # p ¼ # potential matches in the middle (here # ≈ |A 2 n |), a considerable saving in both space and time.

5.3.
Example of a non-bijective function multiplication up to 3 Â 3 ¼ 9 on the torus of size n ¼ 4 The 4-bit input is interpreted as a pair of numbers from the set 0; 1; 2; 3 f g , whose product, the output, lies within the set 0; 1; 2; 3; 4; 6; 9 f g .

Step I
The image consists of 7 patterns with occurence counts 7 (0000), 2 (0010,0011,0110), and 1 (0001,0100,1001). In Step I, we thus have to shrink the set of patterns present from 16 to 7 in such a way that (any) 7 patterns are mapped to the same one, and additionally 3 sets of two patterns are joined within each set. Finally, the three remaining input patterns stay on their own.
An exhaustive search over sequences with 4 update rules, starting and ending with a nonbijective one, yields 72 such sequences with the desired shrinking factor, one example is the sequence s 1;…;4 ð Þ ¼ 0011; 1101; 0110; 0111 of active cells.
All patterns in hex Active cells Occurrence counts

After
Step I, the output pattern 2 has frequency 7. Therefore, 2 has to match 0 in Step III, while 0,1,2,3,4,8,C are matched to 5,7,8,9,A,B,E in any order in Step II. Thus, we already have 7! different possibilities for Step II.
Similarly, we can maps 0110 and 1001 to either 1; 4 f g, 3; C f g, or 6; F f g and so forth. Let c run through the occurrence counts, here c ¼ 7, 2 and 1 are actually taken, and let then p c ð Þ be the number of output patterns with in-degree c, here p 7 bijective functions consistent with the count distribution to choose from in Step II. One of these is given in the left column of Table 4.

Step III
The outcome of Steps I + II completely fixes the necessary permutation for Step III. However, we do not have to deal with 2 n values, but only |Im f ð Þ| are relevant, in our example 7 instead of Step II Step I Step III  Table 4. Steps II, I, and III for multiplication up to 3 Â 3 ¼ 9.

IN
Step II Step I Step III IN Step II Step I Step III In total, 13 + 4 + 15 = 32 steps are required to compute this multiplication function ( Table 5).

Efficiency
In the case of unfair bijective functions, any subset of cells may fire simultaneously, provided that no adjacent cells are contained in the set.
We define local efficiency of a bijective update sequence by two properties: • No cell is active during two consecutive time steps (these two would cancel each other).
• No active cell can be moved to the previous time step.
Global efficiency-which shortest update sequence generates a certain function/permutationis beyond the scope of this paper (it is dealt with implicitly by brute force in a breadth-first manner).

Lemma 3.
A sequence of rules is bijective and efficient, if s t ð Þ k ¼ 1 ðcell c k active in step tÞ implies that. iii. at least one of s  In Table 6, we denote several figures describing the number of efficient bijective update schemes (including unfair ones). The number of rules is denoted by #S n ð Þ; it can be found as A001610 in OEIS [18]; see also Section 2.2.2. The number of nonzero entries in the matrix A is #A n ð Þ. The quotient #A n ð Þ/#S n ð Þ is the average number of 1's in each row/column.
We denote by # n t ð Þ the number of effective bijective update schemes of length t on a torus of size n. Essentially, # n t ð Þ ¼ Θ λ n ð Þ t À Á .
Let r n ð Þ ¼ lim t!∞ #n t ð Þ λ n ð Þ t . Then r n ð Þ gives the constant hidden in the Landau symbol Θ.
We have # n t ð Þ= λ n ð Þ t Á r n ð Þ À Á ! 1. Finally, is the number of steps necessary such that # n T n ð Þ ð Þ≈ |A 2 n | ¼ 2 n !=2. Invoking the birthday paradox by the meet-in-the-middle approach, we therefore expect to require T n ð Þ=2 steps each, starting from the initial identity permutation and backwards from the desired function, to achieve a match yielding the function evaluation.
The asymptotic behavior, as far as we can infer from the range n ¼ 3, …, 24, is We can compare the asymptotic number T n ð Þ of elementary steps necessary for unfair update rules with the lower bound on the (full) steps for fair rules. Lemma 4 ([10], Section 5, Lemma 1(i)).
Remarkably, as far as the experimental results for n ≤ 24 indicate, the number T n ð Þ of elementary steps is only a constant factor ( ≈ 2:4) higher than the lower bound for full update steps. If that result remains valid for all n ∈ N, and the reported values strongly suggest this, this would mean that the typical full step can be replaced by no more than 2..3 elementary unfair steps, independent of n.
As can be appreciated, n ¼ 5 might be feasible for an attack by meet-in-the-middle, but n ¼ 6 and above is certainly no candidate for this brute-force approach. Dealing with these sizes will require a more intelligent approach, for instance using group-theoretic techniques like representation theory, applied to the alternating group.

Conclusion
We have seen that many functions are clocking-computable, namely, the even bijective ones and the non-bijective ones with enough "loss" in their image.
The elementary cellular automaton ECA-57 can be used to implement an etherealware computing device: The computed function is a result only of the clocking order.
Temporal order of activating the CA cells is thus a new way to encode algorithms, a "volatilization of information".
We increased the size for example programs from n ¼ 3 in [10,14] to n ¼ 4 and are confident to also be able to tackle the case n ¼ 5.
From n ¼ 6 onwards, we shall need more mathematical concepts, e.g., from group theory.