For 1D elementary rules the list is {{-1}, {0}, {1}} , while for 2D 5-neighbor rules it is {{-1, 0}, {0, -1}, {0, 0}, {0, 1}, {1, 0}} . In this book such offset lists are always taken to be in the order given by Sort , so that for range r rules in d dimensions the order is the same as Flatten[Array[List, Table[2r + 1, {d}], -r], d - 1] . … A single step in evolution of a general cellular automaton with state a and rule number num is then given by Map[IntegerDigits[num, k, k^Length[os]] 〚 -1 - # 〛 &, Apply[Plus, MapIndexed[k^(Length[os] - First[#2]) RotateLeft[a, #1] &, os]], {-1}] or equivalently by Map[IntegerDigits[num, k, k^Length[os]] 〚 -# - 1 〛 &, ListCorrelate[Fold[ReplacePart[k #1, 1, #2 + r + 1] &, Array[0 &, Table[2r + 1, {d}]], os], a, r + 1], {d}]

Implementation [of substitution systems] The rule for a neighbor-independent substitution system such as the first one on page 82 can conveniently be given as {1  {1, 0}, 0  {0, 1}} . … In this case, the evolution can be obtained using SSEvolveList[rule_, init_String, t_Integer] := NestList[StringReplace[#, rule]&, init, t] For a neighbor-dependent substitution system such as the first one on page 85 the rule can be given as {{1, 1}  {0, 1}, {1, 0}  {1, 0}, {0, 1}  {0}, {0, 0}  {0, 1}} And with this representation, the evolution for t steps is given by SS2EvolveList[rule_, init_List, t_Integer] := NestList[Flatten[Partition[#, 2, 1] /. rule]&, init, t] where the initial condition for the first example on page 85 is {0, 1, 1, 0} .

For the Klein–Gordon equation, however, there is an exact solution: u[t, x] = If[x 2 > t 2 , 0, BesselJ[0, Sqrt[t 2 - x 2 ]]]

The fraction of possible register machines that do this starting from initial condition {1, {0, 0}} decreases steadily with program length n , reaching about 0.76 for n = 8 . The most common number of steps before halting is always n , while the maximum numbers of steps for n up to 8 is {1, 3, 5, 10, 16, 37, 215, 1280} where in the last case this is achieved by {i[1], d[2, 7], d[2, 1], i[2], i[2], d[1, 4], i[1], d[2, 3]}

The lines inside each diagram correspond to virtual particles that in effect propagate only a limited distance, and have a distribution of energy-momentum and polarization properties that can differ from real particles. … But the number of diagrams grows rapidly with order, and in fact the k th order term can be about (-1) k α k (k/2)! … Ignoring parts that depend on particle masses the result (derived in successive orders from 1, 1, 7, 72, 891 diagrams) is 2 ( 1 + α /(2 π ) + (3 Zeta[3]/4 - 1/2 π 2 Log[2] + π 2 /12 + 197/144) ( α / π ) 2 + (83/72 π 2 Zeta[3] - 215 Zeta[5]/24 - 239 π 4 /2160 + 139 Zeta[3]/18 + 25/18 (24 PolyLog[ 4, 1/2] + Log[2] 4 - π 2 Log[2] 2 ) - 298/9 π 2 Log[2] + 17101 π 2 /810 + 28259/5184) ( α / π ) 3 - 1.4 ( α / π ) 4 + …), or roughly 2. + 0.32 α - 0.067 α 2 + 0.076 α 3 - 0.029 α 4 + … The comparative simplicity of the symbolic forms here (which might get still simpler in terms of suitable generalized polylogarithm functions) may be a hint that methods much more efficient than explicit Feynman diagram evaluation could be used.

Indeed, even working out for large n how many of the 2 n 2 possible configurations of a n × n grid of black and white squares contain no pair of adjacent black cells is difficult. Fitting the result to 2 h n 2 one finds h ≃ 0.589 , but no exact formula for h has ever been found. … (The solution of the so-called dimer problem in 1961 also showed that for complete coverings of a square grid by 2-cell dominoes h = Catalan/( π Log[2]) ≃ 0.421 .)

Ulam systems Having formulated the system around 1960, Stanislaw Ulam and collaborators (see page 877 ) in 1967 simulated 120 steps of the process shown below, with black cells after t steps occurring at positions Map[First, First[Nest[UStep[p[q[r[#1], #2]] &, {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}, #] &, ({#, #} &)[{{{0, 0}, {0, 0}}}], t]]] UStep[f_, os_, {a_, b_}] := {Join[a, #], #} &[f[Flatten[ Outer[{#1 + #2, #1} &, Map[First, b], os, 1], 1], a]] r[c_]:= Map[First, Select[Split[Sort[c], First[#1]  First[#2] &], Length[#]  1 &]] q[c_, a_] := Select[c, Apply[And, Map[Function[u, qq[#1, u, a]], a]] &] p[c_]:= Select[c, Apply[And, Map[Function[u, pp[#1, u]], c]] &] pp[{x_, u_}, {y_, v_}] := Max[Abs[x - y]] > 1 || u  v qq[{x_, u_}, {y_, v_}, a_] := x  y || Max[Abs[x - y]] > 1 || u  y || First[Cases[a, {u, z_}  z]]  y These rules are fairly complicated, and involve more history than ordinary cellular automata. … And as the pictures below show, this is true even just for parts of the rules above ( s alone yields outer totalistic code 686 in 2D, and rule 90 in 1D). Ulam also in 1967 considered the pure 2D cellular automaton with outer totalistic code 12 (though he stated its rule in a complicated way).

Thus, for example, the digit sequence of 3/8 in base 10 is 0.375. (Strictly, the digit sequence is 0.3750000000..., but the 0's do not affect the value of the number, so are normally suppressed.) … The pictures Digit sequences for various rational numbers, given in base 10 (above) and base 2 (below).

This turns out to be equivalent to the set of values of c for which starting at z = 0 the inverse mapping z  z 2 + c leads only to bounded values of z . … The pictures below show a generalization of this idea, in which gray level indicates the minimum distance Abs[z - z 0 ] of any point z in the Julia set from a fixed point z 0 . The first picture shows the case z 0 = 0 , corresponding to the usual Mandelbrot set.

Implementation [of repetitive array] The color of a cell at position {x, y} in the pattern shown is given by Extract[{{1, 0, 1}, {0, 1, 0}}, Mod[{y, x}, {2, 3}] + 1] .