# Search NKS | Online

1 - 10 of 24 for Ceiling

Other examples [of cellular automaton computation]
Rule 152 and rule 144, which effectively compute Ceiling[n/2] and Ceiling[n/4] , respectively, are shown below with n = 18 initial black cells.

Lengths of [number] representations
(a) n , (b) Floor[Log[2, n] + 1] , (c) Tr[FixedPointList[Max[0, Ceiling[Log[2, #]]] &, n + 2]] - n - 3 , (d) 2 Ceiling[Log[3, 2n + 1]] , (e) Floor[Log[GoldenRatio, √ 5 (n + 1/2)]] .

Multicolor Turing machines [from 2-color TMs]
Given rules in the form on page 888 for a Turing machine with s states and k colors the following yields an equivalent Turing machine with With[{c = Ceiling[Log[2, k]]}, (3 2 c + 2c - 7) s] states (always less than 6.03 k s ) and 2 colors:
TMToTM2[rule_, s_, k_] := # /. MapIndexed[ #1 First[#2] &, Union[Map[# 〚 1, 1 〛 &, #]]] &[ With[{b = Ceiling[Log[2, k]] - 1}, Flatten[Table[ {Table[{Table[{{m, i, n, d}, c} {{m, Mod[i, 2 n - 1 ], n - 1, d}, Quotient[i, 2 n - 1 ], 1}, {n, 2, b}, {i, 0, 2 n - 1}], Table[{ {m, i, 1, d}, c} {{m, -1, 1, d}, i, d}, {i, 0, 1}], Table[ {{m, -1, n, d}, c} {{m, -1, n + 1, d}, c, d}, {n, b - 1}], {{m, -1, b, d}, c} {{0, 0, m}, c, d}}, {d, -1, 1, 2}], Table[{{i, n, m}, c} {{ i + 2 n c, n + 1, m}, c, -1}, {n, 0, b - 1}, {i, 0, 2 n - 1}], With[{r = 2 b }, Table[ If[i + r c ≥ k, {}, Cases[rule, ({m, i + r c} {x_, y_, z_}) {{i, b, m}, c} {{x, Mod[y, r], b, z}, Quotient[y, r], 1})]], {i, 0, r - 1}]]}, {m, s}, {c, 0, 1}]]]]
Some of these states are usually unnecessary, and in the main text such states have been pruned. Given an initial condition {i, list, n} the initial condition for the 2-color Turing machine is
With[{b = Ceiling[Log[2, k]]}, {i, Flatten[IntegerDigits[list, 2, b]], b n}]

By inserting k = 6 Ceiling[Length[subs]/6] in the definition of TS1ToCT from page 1113 one can construct a cyclic tag system of this kind to emulate any one-element-dependence tag system.

The number of distinct sequences at step t in these three systems is respectively Ceiling[t/2] , t and Fibonacci[t+1] (which increases approximately like 1.618 t ).

For any number x the first n digits are given by
Ceiling[NestList[(2 - Mod[-#, 1]) 2 &, x 2 , n - 1] - 2]
Even rational numbers such as 3/2 do not yield simple digit sequences.

Note that each step in the evolution of any additive cellular automaton can be computed as
Mod[ListCorrelate[w, list, Ceiling[Length[w]/2]], k]
(See page 1087 for a discussion of partial additivity.)

[Examples of] reducible systems
The color of a cell at step t and position x can be found by starting with initial condition
Flatten[With[{w = Max[Ceiling[Log[2, {t, x}]]]}, {2 Reverse[IntegerDigits[t, 2, w]] + 1, 5, 2 IntegerDigits[x, 2, w] + 2}]]
then for rule 188 running the cellular automaton with rule
{{a : (1 | 3), 1 | 3, _} a, {_, 2 | 4, a : (2 | 4)} a, {3, 5 | 10, 2} 6, {1, 5 | 7, 4} 0, {3, 5, 4} 7, {1, 6, 2} 10, {1, 6 | 11, 4} 8, {3, 6 | 8 | 10 | 11, 4} 9, {3, 7 | 9, 2} 11, {1, 8 | 11, 2} 9, {3, 11, 2} 8, {1, 9 | 10, 4} 11, {_, a_ /; a > 4, _} a, {_, _, _} 0}
and for rule 60 running the cellular automaton with rule
{{a : (1 | 3), 1 | 3, _} a, {_, 2 | 4, a : (2 | 4)} a, {1, 5, 4} 0, {_, 5, _} 5, {_, _, _} 0}

The number of steps for which a cell at position n will survive can be computed as
Module[{q = n + k - 1, s = 1}, While[Mod[q, k] ≠ 0, q = Ceiling[(k - 1)q/k]; s++]; s]
If a cell is going to survive for s steps, then it turns out that this can be determined by looking at the last s digits in the base k representation of its position.

For any sequence s this can be done using
Module[{c, m = 0}, Map[c[#] = {m, m += Count[s, #]/Length[s]} &, Union[s]]; Function[x, (First[RealDigits[2 # Ceiling[2 -# Min[x]], 2, -#, -1]] &)[Floor[Log[2, Max[x] - Min[x]]]]][ Fold[(Max[#1] - Min[#1]) c[#2] + Min[#1] &, {0, 1}, s]]]
Huffman coding of a sequence containing a single 0 block together with n 1 blocks will yield output of length about n ; arithmetic coding will yield length about Log[n] .