Well, if the machine has only two states, it has only a single bit of internal memory. This means (almost) all information is in the picture.
Brain dump:
A one-state TM has no hidden state -- this means that it has no way to look at the surroundings (only the current field), which makes them rather boring. (All you'll get is lines or planes of one color, they cannot sensibly navigate the second dimension.)
Two-state TMs are 'clever' enough to change the color after moving, which means they can draw corners and thereby use the whole 2d plane. They still have to put all information into the picture, meaning you get to see all the gory details of information flow. You don't have the transition table, but you can read most of it off the image. You'll see all paths or areas in which movement in a single direction can happen without changing the color. Everything else has to be left in the picture, which means it will constantly overwrite stuff. This, in turn, means that it'll likely use groups of colors for one purpose.
The start is boring: red - turn green & go up, green - turn black & go down, black - turn pink & move right (so far this could be done by a 1-state TM.) Pink does some state changes and introduces cyan, shortly after you'll see it 'sewing' to the left, leaving a thick structured line across the image, which is then expanded into a yellow-green covering of the whole black area (see how black/pink move right and cyan/yellow give turning directions and create yellow/green?) and then... ah, well just look at it.
Three-state TMs can hide quite a lot of information. As an example, the extra state can be used as a movement state, allowing non-destructive movement in one direction. (On jump mark (say, white), change to state #3 and keep going until you hit the next jump mark.) It can also be used to non-destructively look in one direction (e.g. for testing what color the left neighbor has). Combinations thereof can do pretty crazy stuff.
Adding more states basically just allows 'compressing' the picture more, which makes it more likely that you'll only see noise - especially if the TMs are randomly generated.
Original author here. It only has 3 states and 6 symbols, so the transition table is not that big. If you visualized it slow enough, you might be able to understand the process behind it, so to speak. Although sometimes, simple rules can yield chaotic behavior. Someone told me they were working on a fork with utilities to visualize the transitions, that might be helpful.
That was me but so far it's just something I'd like to see. If anyone else would like to tackle it I'd be happy to watch theirs.
The general idea is a graph of the states and transitions (laid out by d3 or something?), labeled by color with little arrows for the next direction, with the current state and transition highlighted. Also a magnified 'fat bits' view of the head's neighborhood. You'd only see these at the slower speeds where you can conceivably follow, like the marker around the head in the current system.
Also you'd want single-stepping to go with this. I have added that but not pushed it to the webpage or the repo. (There was some little bug I haven't got to.)
at the fastest speed, this looks like accumulated rain on a side window of a car driving on the freeway, being blown off, from the vantage point of someone in the car
After revisiting the thread and viewing some of the other good finds, this is still the most astonishing one I've seen. The end state is very pretty, and the final evolution continues in what appears to be a perplexing nearly-stable chaotic pattern.
Holy shit. And now for something completely different. We interrupt tonight's broadcast of "Slowly Growing Purple Lines" to present you "Flowing Glitter".
Wolframite here: these would make a good summer school project for our summer school (plug: the 2013 one is coming up, apply at https://www.wolframscience.com/summerschool/ if you're interested in this kind of stuff and want to do a 3-week project).
In fact I studied the space-filling behavior of precisely these 2D Turing machines in 2009. For low numbers of states and colors you can enumerate them exhaustively and calculate the distribution of space-filling efficiency (log-normal, if anyone is interested).
The full spectrum of behavior is quite fascinating to catalog. All these kinds of simple computational system have a character and 'zaniness' all their own.
Putting on a more scientific hat, it might be interesting to look at block-entropy measures and find interesting rulesets that way.
This is actually very good compared to other findings; the pattern starts to disappear and then regenerates itself in different ways. Accompanying horizontal lines look like an ocean.
Wow, I finally got a neat one via random. 4 states, 13 symbols, yields an interesting illusion of depth as "blocks" start moving towards and away from the viewer. Recommended two notches down from default speed, three down if you're patient.
I really appreciate this art of randomness, and in particular the fact that it is theoretically equivalent to any computing machine (given much, much more memory and states).
If it's a limited number of states in the automaton, and a limited amount of "tape" in the canvas, it's not a Turing machine, it's a Finite-State Automaton, which is easy to analyze for loops.
The world is finite, so every drawing eventually loops.
However, the state space is something like k * 2^18 * n^(2^18), where k is the number of states and n the number of symbols. For the default (4, 3) this is 3.125 * 10^125080, so you could be waiting for a while :)
Would every drawing have to loop? Pi doesn't. I personally don't actually know if there's something about this specifically that would force every drawing to loop, though.
Some of the more striking machines I found tonight. I spent a lot of time generating 2/23 machines, they tended to produce colorful and sometimes intricate "introductions", but most often ended in static.
You'll want to watch it about four notches down from "fastest".
This is a really cool project! It has a kind of AI feel to it. The website needs a way for users to vote on others' creations, and then they can be selectively "mutated" and evolved to produce really cool ones. The best ones will survive through upvotes. Who knows what you'd end up with?
The NKS-style question to ask here is: what computations are these doing? Totally unique-unto-themselves computations? Potentially useful computations? Computations analogous to familiar human ones? How would we know? Can we know? Do we run into the limits of undecidability?
The cyclic boundary conditions somewhat 'spoil' things, though. Maybe a particular rule was "destined to multiply input by 5" or "calculate log-2 of input" or something (given suitable encoding of input on the tape), but the computation is foiled as soon as the machine wraps around and starts interfering with itself.
Then again, the self-interference is what makes many of these patterns do the cool things they do.
For this particular canvas, no, as the canvas is finite.
Given enough time or space we can exhaust all states of the canvas and catch cycles. This applies to any finite canvas.
I would guess these are equivalent to regular languages because of the finite state. You can treat the different canvas states as states of a finite automaton. A finite automaton is a canvas turing machine by ignoring the canvas.
It is obvious, yeah. I wasn't implying you didn't know it was or anything, just explaining the first sentence to someone who might not have studied complexity theory.
Really cool how it just keeps on going, with the shadows of more towers appearing to stretch out from the city centers, and the lights of cars driving down the left and right sides. I've had it running at high speed for quite a while now and buildings keep rising up occasionally.
If your browser window is narrow, the "Fork Me on GitHub" link overlaps the "Pause" button. (But the overlapping part of the GitHub image is transparent, so it's not immediately obvious why "Pause" doesn't work.)
The page content fits just fine, so it seems silly to make the window larger; there's just this little bug.
Thanks, Scott! As a quick patch I just broke the line of buttons in two. (I didn't want to mess with the original code more than needed, but couldn't resist adding the new buttons.)
What would happen if these were constrained to run inside irregularly shaped "skins" and bred for "fitness" against some criteria. For example, take a look at Marsaglia's die hard tests for statistical randomness. Any machine that terminates would have a very low random coefficient, and any that turns to noise would have a very high random coefficient. Similarly, ones that repeat quickly could also be selected against. All that remains is to restrict the number of critters, as specified by the number of "skins" and "breed" new critters from old ones which were successful (with a "pleasing" statistical randomness coefficient).
I wonder if one could construct a metric for how 'interesting' a drawing is- then throw it at a genetic algorithm? I'm guessing most likely the system is inherently unstable, so two 'interesting' parents don't necessarily create 'interesting' offspring
The "Fork me on Github" banner overlaps the controls invisibly. With a narrow-ish window, I can't click the "num symbols" box, or half the "restart" button or most of the "pause" button.
If you slow it way down after it 'freezes' you can get an idea how it's caught in a loop. (I wonder how many people have noticed you can slow it way down to see the head move.)
Here are some of my favorites. One of them (Counter) behaves strangely. It doesn't appear to be stable, but it takes a long, long time to change appreciably. Another one (Sewing Machine) seems semi-stable in that it seems to settle around the same kind of almost-but-not-quite-chaotic pattern.
Counter: http://wry.me/hacking/Turing-Drawings/#5,3,1,1,0,3,1,3,2,1,2...
This one seems to behave like some kind of adder. Even at the highest speed setting it takes a long time to see much change, but the black lines seem to grow and move similar to how a binary adder operates.
"sunset and nightfall":
http://wry.me/hacking/Turing-Drawings/#2,15,0,3,1,1,1,3,1,10...
"shoreline EQ"
http://wry.me/hacking/Turing-Drawings/#2,22,1,6,2,0,6,0,0,21...