Simple function involving the sum of two cosines whose frequencies ratio is the golden ratio.

g[x_] := Abs[Cos[x] + Cos[N[GoldenRatio] x]];
ArrayPlot[CellularAutomaton[{g[Total[#]] &, {}, 1}, {{1}, 0}, 200],ColorFunction -> GrayLevel]

If you take a very slowly growing continuous value CA but look very far in its future evolution you can find something interesting

ArrayPlot[
 CellularAutomaton[{Mod[Total[#]/2.96, 1] &, {}, 1}, {{1}, 0}, 
{{1000, 1300}, {-90, 90}}], PixelConstrained -> 2]

Here's a nested structure from the Standard Deviation of the Square Root of the argument

ArrayPlot[
 CellularAutomaton[{StandardDeviation[#^.5] &, {}, 1}, {{1}, 0}, 25], 
 ColorFunction -> "Rainbow"]

ArrayPlot[
 CellularAutomaton[{Mod[
     Total[FactorInteger[FromDigits[#, 3]][[All, 1]]], 4] &, {}, 
   1}, {{4}, 1}, 400], ColorRules -> {1 -> White}, ImageSize -> Full]

If anyone wants more quasiperiodic awesomeness, here's a superposition of five cosines whose wave vectors form a pentagon (this gives a ten fold symmetry, but if you take any direction you will find no repeating pattern):

PlaneWave[x_List, k_List] := Cos[k.x];
c1 = 1/4*(Sqrt[5] - 1);
c2 = 1/4*(Sqrt[5] + 1);
s1 = 1/4*(Sqrt[10 + 2*Sqrt[5]]);
s2 = 1/4*(Sqrt[10 - 2*Sqrt[5]]);
kvectors = {{0, 1}, {s1, c1}, {s2, -c2}, {-s2, -c2}, {-s1, c1}};
DensityPlot[
 Abs[Total@Map[PlaneWave[{x, y}, #] &, kvectors]], {x, -40, 40}, {y, -40, 40}, 
ColorFunction -> GrayLevel, PlotPoints -> 50]

Graphics3D[
 Cuboid /@ 
  Position[CellularAutomaton[{123214, {7, 1}, {1, 1}}, {{{1}}, 0}, 
    10], 1],
 ViewVertical -> {-1, 0, 0}, Background -> RGBColor[0.84, 0.92, 1.]]

Yes, this is neat. Have you seen this:

Quasicrystal Animation with Mathematica

Slicing the evolution of 2D Totallistic 3-Color Rule 344373765 across the y-axis and animating the slices resembles a Kraken rising from the sea.

I like how you found the singularity-like behavior.

This one fades out more impressive.

ArrayPlot[CellularAutomaton[{Fold[BesselJ, #] &, {}, 1}, {{1.}, 1./(\[Pi] E)}, 100]]

A background 0 is too dry and this observation was shadowing in here by the Planck ground state idea (as an element of a functional space with eigenvalue != 0 ( $\frac{1}{2} \hbar \omega$ in a relevant case)); so one feels oneself seeing $\frac{1}{\pi e}$ as an eigenvalue of a not formulated quantum problem .... oh oh oh, today is Sunday ...

By the way, Todd, did somebody at the Summer School jam into quantum cellular automata?

You can upload GIFs - I fixed it for you. Very nice. But the point of this Code Jam is to use not integer rule specification --- we are using functions as rules --- see some code above. Some folks also misunderstood this and there area a few posts with integer rule specification. It is OK - they all look great. But it would be nice to find some cool looking CAs with functions as rules. You should also post code not only the output.

These numerical rules are interesting because they depend on the precision. It appears that the general effect is valid, of having a detailed inner structure. However the exact details are difficult to compute numerically.

Compare with increased precision

g2[x_] := Abs[Cos[x] + Cos[SetPrecision[GoldenRatio, 100]* x]];
ArrayPlot[CellularAutomaton[{g[Total[#]] &, {}, 1}, {{1}, 0}, 200], 
 ColorFunction -> GrayLevel]

Very cool. Reminds me of shifted 225 combined with ordinary rule 225 (see e.g. p.58 ).

Nice. One thing apparent from the first picture is that it fades out on the top left diagonal. I like how you found the singularity-like behavior. Encouraging for the digital physics people who try to find CAs for the universe.

why do you consider these to be simple programs?

becuase they are short in length - if so, would that make any program that is simply a function call to CelularAutomaton, perhaps surrounded by visual display commands such as ArrayPlot simple?

because the algorithm used in the built-in CellularAutomaton function is hidden (i don't know if it's written in WL or in C or uses hash tables or what it is actually DOING when it is evaluated) and one only has to type CellularAutomaton?

stephen wrote in NKS that a complex cellular automaton is not a simple program.

for example, is the forest fire CA a simple program?

it can be written using the CellularAutomaton function (http://forum.wolframscience.com/archive/topic/720-1.html) or it can be written in a way which is very simple to understand (http://www.cs.berkeley.edu/~fateman/papers/cashort.pdf)

btw - one can see in the unpublished Fateman manuscript, the program written in LISP which IMO is simply awful looking and essentially unreadable and when compared to the program written in WL is a very clear example of why WL is a MUCH better language for writing computer simulation programs.

does simplicity refer to readability or to the ease with which one can understand the CA?

e.g. the Game of Life as written using CellularAutomaton is very short but totally opaque (at least to me) while if it is written in another way (e.g. see http://library.wolfram.com/infocenter/MathSource/5216 - see the LifeGame program in the last section) it is easy to understand.

this is actually a very important question because as Kovas Boguta has pointed out in his article (i attach it becuase it is not readily available to everyone) "NKS seeks to introduce a basic, empirical science that investigates the behavior of very simple programs." and as Boguta points out in the original unedited version of this article in the NKS Forum (http://forum.wolframscience.com/showthread.php?s=6e483fc3d86a53032f8cd96e48e7a500&threadid=271&highlight=kovas+boguta) "NKS seeks to introduce a basic, empirical science investigating the behavior of very simple programs. A very important part of the intellectual structure of NKS is how this relates to modeling nature--but although interesting in its own right and important for justifying the entire enterprise, this tie-in with the natural world is absolutely not the subject of the core science. "

note - actually, the insightful comments of Boguta actually indicate that NKS really should have been called NS becuase it is proposing an entirely new field of study - although Richard Feynman would say that it is not a science at all because it does not study nature (https://www.youtube.com/watch?v=lL4wg6ZAFIM).

i apologize for the length of this post and ask for the moderator's indulgence. i am posting this here becuase while i was planning to discuss this at the 2015 Wolfram Technology Conference in October, my health prevents my doing it there. also, the Wolfram community deserves to understand what NKS is all about becuase it has been horribly distorted and totally misrepresented by so many others (e.g. those who claim that stephen views the universe as a CA which he most definitely does not - he uses a trivalent causal net as a model as explained in NKS) and who don't even understand the 'science' that stephen is actually introducing which is totally original, whether one is interested in it or not. and WL is an integral part of the NKS research program (which stephen siads is one of the reasons he created WL)

Attachments:

Compare this to the version where the total is renormalized so the argument to Sin ranges from 0 to 2Pi

ArrayPlot[
 CellularAutomaton[{Sin[Total[N@#] 2 Pi/3] &, {}, 1}, {{1}, 0}, 250]]

That gives something random looking whereas renormalizing to make it range from 0 to Pi instead gives similar behavior. I wonder what the uniform regions are like.

Not in this codejam. Everything from that is here in this discussion.

Funny you should mention "quantum" because this year we had several people doing related projects. ne person simulated a D-Wave device and another was researching the type of CA with quantum mechanics described by t'Hooft.

because a program using CellularAutomaton runs extremely fast, i'd like to follow up on the use of CellularAutomaton for rules that are anonymous functions. i have tried the 1D forest fire CA using a rule involving pattern matching and i get error messages that i can't even understand. i realze that pattern matching is not especially fast (http://blog.wolfram.com/2011/12/07/10-tips-for-writing-fast-mathematica-code/) but being able to use pattern-matching based update rules (inclusing those that involve , __ and __) within CellularAutomaton would allow us to use it with a great many CA models. what are the restrictions and limitations on using these sorts of rules in CellularAutomaton?

Here it is:

pyro =
          (treeGrowIgnite = #/. {0 :> Floor[1 + p - Random[]], 1 :> Floor[2 + f - Random[]]};
           forestIgnite = TreeGrowIgnite //. 
                                  {{2, c___, 1} -> {2, c, 2},
                                   {1, c___, 2} -> {2, c, 2},
                                   {a___, 2, 1, b___} -> {a, 2, 2, b},
                                   {a___, 1, 2, b___} -> {a, 2, 2, b}};
             forestNew = forestIgnite /. 2 -> 0)&

the first 2 pattern matching replacement rules are apparently not needed becuase they represent wrap around b.c. which are used by default in CellularAutomaton.

note: sorry that this code appears so badly. i write it in one way but in the preview window, what i write is changed into something which is unreadable and sometimes terms are even dropped or changed. i don't know why.

Todds answer was so clear and professional, nevertheless you dig in again

it bothers me a great deal that stephen uses terms like "simple program" without defining what simple means.

Question: Is the following a simple program?

In[17[:= N[I^I, 18]
Out[17]= 0.207879576350761909 + 0.*10^-19 I

with $Mathematica$, yes. Otherwise you have some trouble relying on Leonhard Eulers clarification what the logarithm is. If I understand Stephen Wolfram a little bit he follows the idea of Richard P Feynman, that quantum electrodynamics is in a way far to complicated (or elaborated (or elegant)) because a photon or electron do for sure not do such calculations during scattering: Feynman proposed to search for another way to understand that unbelievable efficiency, correctness and parallelism that particles show. Feynman was also one of the first to discuss physics and computation. And Mr Wolfram pushed simple programs as a candidate.

If you look into the garden you see effortless growing plants, Erwin Schrödinger asked about cleavage, Albert Einstein detected that there is no such thing as central time, but instead of that something propagates, evolves, steps, does the right thing to keep things running ... that step is hoped to be simple, because every entity does it, only we do not see: what and how.

Please accept my apologies, my post intended neither to attack posts nor its posters.

Terms like simple programs, which

cannot be meaningfully defined in a rigorous way

invoke discussions and discussion means by chance to disagree in a way.

I tend to muse about simple programs under the aspect of a triple $\{ protocol, algorithms, data\}$. Data include units and specify the matter, data are dumb algorithms (Charles Petzold), algorithms do the work and a protocol is needed to do I/O.Lets stay in the area of getting intuition: Is it simple to travel from Pisa to Chicago?

If the data is your own body, the algorithm is walking and swimming and the protocol is self-motivation, it is impossible.

If the data is a plane maintained by an airline, the algorithm is flying and the protocol is boarding to that plane, it is simple.

Progress is made by changing the protocols or better inventing new protocols, implementing data and algorithms (in the widest sense) to them, letting people do things they never dreamt off. $Mathematica$ did excatly that in its realm.

In Heisenbergs book "The Part and The Whole" one finds discussions about the symbol as a mental picture to bring facts to understanding and keep things (which are by no means simple) simple.

Now for something completly different. Expressions like

ArrayPlot[CellularAutomaton[{Count[
     Last[Last[TuringMachine[2016, {1, Mod[#1, 2]}, #2 Total[#1]]]], 1] &, {}, 1}, {{1}, 0}, 100]]

gave reason to ask why they are considered as simple programs. In a way they are accepted as programs by the question, right?

Why then

N[I^I, 18]

is considered not to be program? It is in the same syntax, follows the same protocol as the above CA program, but invokes other algorithms.

This code from Simulating Cellular Automata: A Challenge for Programming Languages

Clear[MySmokey]
MySmokey[n_Integer (* units *),
  p_ (* plant probability *),
  f_ (* fire probability *) ,
  m_Integer (* steps *)] :=
 With[{fcomp = Compile[{rand}, Evaluate[Floor[2 + f - rand]]],
   pcomp = Compile[{rand}, Evaluate[Floor[1 + p - rand]]]},
  Module[{forestPreserve, forestIgnite, spreadFire, treeGrowIgnite},
   forestPreserve = Table[Random[Integer], {n}];
   SetAttributes[treeGrowIgnite, Listable];
   treeGrowIgnite[0] := pcomp[Random[]];
   treeGrowIgnite[1] := fcomp[Random[]];
   forestIgnite[{path___?(# === 1 &), 2, rem___, 
      1}] := {spreadFire[path, 2], spreadFire[rem, 2]} /. 2 -> 0;
   forestIgnite[{1, rem___, 2, 
      path___?(# === 1 &)}] := {spreadFire[2, rem], 
      spreadFire[2, path]} /. 2 -> 0;
   forestIgnite[{rem__}] := {spreadFire[rem]} /. 2 -> 0;
   spreadFire[l___, 2, 1, r___] := 
    Sequence[spreadFire[l, 2], spreadFire[2, r]];
   spreadFire[l___, 1, 2, r___] := 
    Sequence[spreadFire[l, 2], spreadFire[2, r]];
   spreadFire[rem__] := rem;
   (* Stopping criterion *)
   NestList[forestIgnite[treeGrowIgnite[#]] &, forestPreserve, m]
   ]
  ]

Clear[trees]
trees = MySmokey[100, 0.3, 0.2, 99];

(* Simulation from 1994 or 2011, see http://www.cs.berkeley.edu/~fateman/papers/cashort.pdf *)
Map[Show[Graphics[RasterArray[#]], AspectRatio -> Automatic] &, 
 Map[Join[Table[
      Table[0, {Length[First[trees]]}], {Length[trees] - #}], 
     Reverse[Take[trees, #]]] &, Range[Length[trees]]] /. 
  Thread[{0, 
     1} -> (Map[RGBColor, Table[Random[], {2}, {3}]] /. 
      RGBColor[{x__}] -> RGBColor[x])]]

still works, giving a timeline (vertical) of the life of one row (horizontal) of randomly set out trees. The pictures from The functional form of CellularAutomaton - A forest fire rule in the forestfire51stripped.nb show the evolution of a whole {100,100} forest under fire.

MySmokey[] does not use the CellularAutomaton[] built-in function, as stated. It still remains to call pyro from CellularAutomaton[] or to refactor pyro to do that ...

i need to note that the pyro function given in my earlier reply was copied from the Fateman manuscript and is incorrect. Fateman took pyro from a program in one of my books - i don't know which book and i don't have copies of any of them - and he may have mistyped it in the manuscript (if not, i don't know how he ran the program) which might have been noticed by one of his co-authors except that as Fateman notes: "this is an old paper that sat unchanged and unpublished for years because several co-authors did not want their names to be associated with their programs or this paper." anyway, TreeGrowIgnite in the second line below should obviously be treeGrowIgnite

pyro = (treeGrowIgnite = # /. {0 :> Floor[1 + p - Random[]], 1 :> Floor[2 + f -Random[]]}; forestIgnite = TreeGrowIgnite //. {{2, c___, 1} -> {2, c, 2}, {1, c___, 2} -> {2, c, 2}, {a, 2, 1, b} -> {a, 2, 2, b}, {a, 1, 2, b} -> {a, 2, 2, b}}; forestNew = forestIgnite /. 2 -> 0)&

let me add a comment here: when judging the aesthetics of computer programming in various programming languages (as i did in comparing Fateman's LISP program and my WL program) one needs to keep in mind that a program might be 'ugly' not becuase of the programming language it is written in, but because its author writes ugly code. One of the advantages of a WL program is that it can be quite aesthetically pleasing. of course, that's a subjective judgment. for myself, conciseness is extremely important - Jon McLoone discusses this in a Wolfram blog (http://blog.wolfram.com/2012/11/14/code-length-measured-in-14-languages/). and Hacker News discusses Jon's blog (https://news.ycombinator.com/item?id=4783975). I also like 'write only' code which is why i like using nested anonymous functions - e.g. SocNetFunction in my ABM article (http://library.wolfram.com/infocenter/Articles/1175/) and bowlOfCherries in my WL tutorial note set (http://library.wolfram.com/infocenter/MathSource/5216). finally, it might be of interest to look at the relationship between the Game of Life (the CA that has had the greatest impact in a wide range of scientific fields) and the Prisoner's Dilemma (the exemplar in Game Theory). this is discussed in the attached pdf and it might be interesting to attempt to implement the Prisoner's Dilemma using the CellularAutomaton function.

Attachments: