I came across this site just now, as I was experimenting with an automaton quite similar to GOL. It's quite simple - it may already have been invented by someone else.
I've learned that GOL can be used to create whole little programs, but it gets quite messy, so I wanted to see if I could change the rules a little to make it easier. I think my system works quite well for this purpose - I'm working on a binary adder, and I'm pretty sure I can do it - but there are some behaviours that I haven't been able to achieve.
I first implemented the algorithm in Netlogo, which is a fun little program you might want to check out if you haven't. Now I've downloaded Golly and made a rule table, and it seems to be working, as far as I can tell.
I'll write the rules here, and some of the things I've found so far.
The rules:
There are four states a tile can be in; disabled, inactive, fading, active (or 0, 1, 2, 3).
Disabled tiles stay disabled. The make up the walls of the game.
An active tile will always become a fading tile in the next turn, and a fading tile will always become inactive. An inactive tile will become active if exactly one of the four adjacent tiles is active. (I'm thinking of changing that to any odd number of active tiles, i.e. one or three.)
As a rule table:
Code: Select all
n_states:4
neighborhood:vonNeumann
symmetries:permute
var a={0,1,2,3}
var b={0,1,2,3}
var c={0,1,2,3}
var d={0,1,2,3}
var e={0,1,2}
var f={0,1,2}
var g={0,1,2}
1,3,e,f,g,3
2,a,b,c,d,1
3,a,b,c,d,2The patterns:
An obvious pattern is a path. You get "blips" of active tiles moving along the path, since the fading prevents them from going backwards.
Junctions are also simple; whenever a blip reaches a junction, it continues along all the paths except the one it came from.
A surprisingly easy thing is to make guns. They pop up all the time, it seems. The simplest one I've found consists of three tiles next to a path. Whenever a blip arrives in either direction, it starts shooting continuously in that direction. I've also found patterns which are guns in one direction but stop incoming blips in the other, and those that are guns in one direction but just let blips pass in the other direction.
Slightly trickier to find was a mirror; in one direction, it just lets the blip through, but in the other it sends one through and one back.
Another very useful pattern is a separating junction - blips from the left continue to the right, and blips from above continue down. This is very useful for constructing circuit-like patterns. (I haven't found one that works for all four directions, but that's not absolutely necessary.)
What I've been working on for a long time and still can't find, is a pattern that lets a blip through in only one direction. It's probably not needed for making circuitry, but it would make many patterns a lot easier.
EDIT: I was starting to think it was impossible, but I've finally found it. Yay! It was quite a clever little trick, if I may say so. My final one-way-machine is 5x5 tiles; I don't know if it can be made smaller, but I doubt it very much.
This just leaves one tiny little thing that would be pretty nice to solve. If we instead decided that an inactive tile surrounded by three active ones does become active, as I mentioned above, is it still possible to find a one-way-machine? I strongly suspect that it isn't, but I'm not sure how to prove that.
