ConwayLife.com

Posted: **March 14th, 2019, 2:36 pm**

I spent a little time years back playing around with Critters, which is one of the most striking reversible CAs I know of. I think it is a very useful way of breaking incorrect human intuition about what makes things reversible or not. In Critters, you can literally crash a bunch of glider-like patterns into a big mess, then run the mess backwards and get them all back.

There was some recent news about "time reversal" that got me thinking again about reversibility.

I think very few people (present company excepted I hope) appreciate the point that there is no fundamental problem with perceiving "time's arrow" within physical laws that are completely reversible (whether or not actual physics is reversible, a point I lack the understanding to address).

I.e., you can embed computation in reversible physics (classical dynamics or a CA like critters). That point is beyond debate. Next, assuming you can embed intelligence in computation (AI), and assuming consciousness is a necessary outcome of self-referential intelligence (strong AI hypothesis), then it follows that conscious beings can inhabit reversible physics. (A couple of jumps in that logic, but if there is anything preventing consciousness in any dynamic systems, there is no reason to think it hinges on reversibility).

With reversible physical laws, you can unscramble an egg provided you haven't lost any information about how it was scrambled. But if you run it backwards from an approximation with even a small error, it will stay scrambled. By contrast, if you scramble an egg from any initial state it will still be scrambled when you're done. That's why "reverse movie" events are so unlikely.

Back to Critters, it is a nearly ideal platform for constructing these unscrambling events. What can't you do? Well, you can't build a CGOL-like glider gun because if you kept running it back to the no-glider state, there would be no way to keep track of how far back it went after that (but maybe that's fixable). You can't build AND and OR gates without figuring out what to do with the information "lost" in the process. For all that, it can still be done (e.g. Fredkin gates). You can even have two isolated systems in a Critters-like universe running opposite to each other according to the ordinary understanding (gliders can uncrash in one region while others crash together some distance away).

Our perception of time's arrow may simply be that our consciousness always works as a forward movie. The flow of time is just the result of the way consciousness itself emerges from computation, combining information and attempting (in a reversible universe) to erase information (by definition impossible) and thus folding it into microstates that we interpret as entropy.

The paragraph above describes the "forward movie". The action consists of the results we want to keep, while the discarded past state is a random-looking cloud. No matter how you started the forward movie (up to small changes) you get a similar outcome and a cloud. When you run the "backward movie", you are extracting past state from the cloud. This works fine as long as the cloud is exactly as you left it. But make a small change to the cloud, and you will not retrieve anything like the past state.

So in short, entropy is fixed, not increasing in a deterministic system, but we model it as increasing in thermodynamic terms because we model the cloud as random, made up of many microstates (corrections welcome in case I have made a big mistake here). In fact, the cloud (because it is deterministic) has a unique microstate preserving a a record of the past.

I'm not sure why this matters so much to me. I think it is because in the outside world, and even in the Life community, it seems to be taken as a given that you need irreversible computation to explain a lot of things. Of course, it is convenient because all the past states need to reside somewhere if they are not discarded. It would be interesting some day to seem the same level of activity put into reversible CAs as we see for CGOL.

Posted: **March 14th, 2019, 2:41 pm**

You also can’t synthesise any periodic objects. I was talking about how limited reversible rules are just the other day at my home.

Posted: **March 14th, 2019, 2:47 pm**

Moosey wrote:You also can’t synthesise any periodic objects. I was talking about how limited reversible rules are just the other day at my home.

There are ways around this. It depends a bit on initial conditions. You can definitely get oscillators as the result of glider collisions in Critters, though you will necessarily also need to get some gliders out as well.

In effect, Life has the useful property that many things can be turned into empty space, but that is clearly an outcome that loses information and is irreversible. If instead the synthesis collisions emit particles that move away from the synthesis, you can have a reversible CA that appears locally to permit this kind of synthesis. I do not know how to get that to work in Critters, but I do not think the problem is with reversibility as such. What you see as a synthesized oscillator is really a periodic oscillator and some gliders flying off into the distance. Run it in reverse and they will eventually undo the synthesis.

I also had a speculative idea for a glider gun that could exist in a reversible CA. Say it is running with 10 gliders now receding. Reverse it back a full period and you have 9 gliders, 8, etc. Suppose that when you go back to 0, it begins firing gliders in the opposite direction. Now you can reverse it as far back as you want without losing state. Critters cannot do this as described (it conserves the number of live cells) but there is no conflict with the need for reversibility.

Maybe the question is what do infinite growth and synthesis look like in a reversible CA? It is simply incorrect to say "you can't do it." The problem is that unlike Life, you don't have the carpet of empty space to sweep the past under. But there appears to be no problem at all with sending the complete record of a collision off into space. In fact, give that space around the active pattern is empty and infinite, you have something analogous to an open system in which entropy can be reduced locally by sending it outside the system.

Also of relevance: Simulation of irreversible automata. I don't know Toffoli's construction, but this result implies that there is a 3D reversible CA that embeds Life. Presumably an irreversible operation like a vanishing collision of gliders would keep enough information in the 3D embedding to run it in reverse.

Posted: **March 15th, 2019, 12:01 am**

I think it's fair to say that there's been a lot less exploration of reversible rules on this forum, particularly by the long term active members, but there certainly has been some interest. There are a few discussions which have happened here which I'll just list below for reference.

Reversible Wireless World - a second-order reversible CA along with a few closely related variants. Probably the most active topic on this board relating to reversible CA.

The Single Rotation Rule - A Margolus neighbourhood rule with population conservation.

Salt, a 3D reversible, universal CA - Also referred to as Busy Boxes. Includes some discussion of the 2D Salt rule as well. As noted by Andrew at the end of the thread Golly comes with 3D.lua which can simulate the Busy Boxes CA.

A brief discussion about reversible CA.

I wrote a script to generate Golly ruletables which emulate CA with asynchronous update of cells over 4 generations. Requires an initialisation script to correctly initialise the universe. According to the original request a certain class of these rules are reversible.

There's also been various discussions and explorations of Billiard Ball Machines (BBM), HPP and other lattice gases in a few different threads.

Reversible logic gates but not in a reversible CA:
Challenge: Minimal Toffoli gate - various implementations of Toffoli gates in CGoL.

Posted: **March 16th, 2019, 1:37 pm**

Quantum collapse is technically irreversible (your input is infinite wave function and your output is X location of interference pattern). Before the collapse the time might be reversible indeed. The only model which has complete reversible quantum reality is multiverse, and inside such robust models - you can address CGOL as reversible as well. Take an infinite list of all life states. Think about a snake that covers the whole infinite grid - this makes life state irrational number from inside [0,1] interval. Now CGOL is just a function f:[0,1]->[0,1). The reversion of state y is the subset of all numbers {xi} such that f(xi) = y. Grey goo is trying to work with finite sets of this sort, along the lines of multiverse.

Reversibility in my opinion is not connected with consciousness only turing completeness.

What is interesting in reversible rules to me is cryptography. Using critters as proof of work. Encrypt/decrypt your messages with 1M iterations of critters sounds to me as better idea than other encryption strategies. We can write a small encryption library for this purpose and try to compete with the big names.

EDIT @wildmyron I can't seem to find computational and construction universal reversible rules (assume you get half plane filled with "particles" and the other half empty).

I also couldn't find even the simplest Salt construction, someone posted 3d patterns - but I'm looking for 2d reversible universal CA.

EDIT2 @pcallahan I think this could be very helpful for the margolius 2d tiling.

Posted: **March 31st, 2019, 1:45 am**

This is mostly to record my own thoughts, but I would appreciate any discussion.

I am finally trying to pin down the known reversibility results in specific terms as they could apply to "Life-like" CA (something that has confused me over the years). I think a useful analogy is "heat" and "cooling", capturing some of the issues of entropy but in a more mechanical sense of what you need to embed computation in reversible rules--mostly, you need a way to remove the "heat" consisting of lost states that irreversible rules discard automatically. So as I work through this, I think "Aha, that's where we put the cooling fins!"

Start with wikipedia on Reversible cellular automata (RCA in the following).

CGOL, which is irreversible, can be embedded in a 3D RCA. Another way to make an RCA from any CA is to use a second-order CA. "However, the behavior of the reversible cellular automaton determined in this way may not bear any resemblance to the behavior of the cellular automaton from which it was defined."

Hertling 1998 proves (though I have not tried to follow the reasoning) that a 2D CA with a Garden of Eden, like Life, cannot be embedded in a 2D RCA, at least not by preserving locality in the way we'd expect (a key restriction that we may want to reconsider).

So with respect to CGOL (Conway's Game of Life), that leaves us with the 3D embedding. Rather than work through the theory, let's just start with something simple and tangible. We have a 3D integer grid ℤ×ℤ×ℤ or in other words, triples (i, j, k) of integers, and for each triple, there is a cell C(i,j,k) 0 ("dead") or 1 ("live").

Define the CGOL transition L(i, j, k) as applied to the cell C(i,j,k) and its neighbors C(i±1, j±1, k), C(i±1, j, k), C(i, j±1,k). (I'll assume everyone here can write this function out.)

Apply the above transition rule directly, and you get CGOL on each layer separately for some fixed value of k. It is irreversible. One way to embed it in a reversible rule (there are other ways) is to use a Margolus-like transition between layers. Apply this rule at each step, alternating between even and odd values of k (⊕ is xor):

(C(i, j, k), C(i, j, k+1)) → (C(i, j, k), L(i, j, k)⊕C(i, j, k+1))

This rule is its own inverse. That is, whatever the particulars of L(i, j, k), it cancels itself out when you apply the rule twice. (It won't help find a previous step in CGOL, but that's not the point.)

Now place the initial Life pattern in the plane k=0. Fill all other planes with 0. (This approach will work for any CA rule in which all zeros produce zeros). Abuse the definition of L to apply to an entire pattern p, and extend ⊕ to apply to planes, and 0 to an entire plane full of zeros. Then the first generation of the rule consists of these layers:

... 0, 0, 0, 0, p, 0, 0, 0, 0, ...

Apply the rule for even k, and the next generation is:

... 0, 0, 0, 0, p, L(p), 0, 0, 0, 0, …

Apply for odd k, and we get:
… 0, 0, 0, 0, L(p), L(p), L(L(p)), 0, 0, 0, ...

Again for even k.
… 0, 0, 0, 0, L(p), L(L(p))⊕L(p), L(L(p)), L(L(L(p))), 0, 0, ...

Note that layer k at step k always has the kth generation of CGOL. So it is a faithful embedding of Life rules. The way it implements reversibility is just to keep an entire history of past generations, though some of them get scrambled with xor. The final generation is always available because it is xor’d with 0. (Note that if you reverse the rule to generations prior to 0 you get the exact same results.)

This is not especially interesting from the standpoint of reversibility, but it illustrates the idea of adding an explicit “cooling system” to an irreversible rule to make it reversible. In this case, the cooling fins are on every Life cell. Effectively, it accepts “cool” zeros and produces “hot” pseudorandom bits for all the information it throws away in the process of applying Life rules.

Moving to 3D is kind of a cheat because we are really just storing history in an obvious way. A more interesting question is whether you could implement unit Life cell in a less contrived RCA like critters. The problem here is the result of Hertling 1998, but maybe the situation is not quite settled.

What I’m imagining here (in addition to an energy source to deal with live cell conservation in Critters) is a set of devices with explicit cooling systems to remove the excess gliders that are always emitted when computing an irreversible function. Instead of sending the “heat” off into a convenient 3rd dimension, we could have channels around cells to carry off history/wasted information/heat.

There is still a problem (not surprisingly, since we can’t get a truly local embedding according to Hertling 1998). Consider an n×n grid of Life cells. This throws away O(n^2) bits every generation, but any 2D disposal system can only remove O(n) of them around the boundary every generation.

The problem is not fatal if you accept a slowdown. Instead of calculating generations at a constant clock tick, a reversible Life cell could determine first if there is room in the cooling channel, like waiting for a spot in a garbage conveyor. Until there is room, it would hold its state and stay dormant. This could be adaptive to the cell values. For instance, empty regions of Life are reversible, so the “heat” is proportional to the number of live cells in sparse patterns.

So in short, I think Critters could simulate Life with an infinite source of new gliders and an O(n) slowdown, where n is the number of live cells. It would be a difficult construction assuming its possible.

Finally, it’s worth observing that real chips are more or less 2D and require 3D space to eliminate waste heat. Ordinary engineering does not remove heat in anything like the controlled fashion described above, but it might become necessary e.g. for nanotechnology.

Posted: **March 31st, 2019, 11:55 am**

Follow up (and new post) on the general method of making a reversible d+1 CA used above. I am not sure what the standard method is, and settled on using the 1D Margolus transition after convincing myself I could also make a second-order CA but XOR after shifting layers (so we are XORing with 0s and not a previous state with values). I'm sure there are other ways, but I like the simplicity of the 1D Margolus neighborhood.

Am I alone in trusting a computer example more than a mathematical proof? I always worry that I will fudge some step in the argument. So I decided to use the approach to convert an irreversible 0D CA (or just a state machine) to a 1D reversible CA and then run an example I could look at.

The 0D rule uses states corresponding to non-negative integers (finite-bounded to make it an FSA) and applies:
0 → 0
n → n-1 if n>0

So it counts down to 0 and then stays at 0 (at which point it is irreversible). Call that rule t(n) and define an array v of values. Then the reversible CA rule is (applied alternate for even and odd i):
(v[i+0], v[i+1]) → (v[i+0], t(v[i+0])⊕v[i+1])
In this case ⊕ is applied to integers by treating them as bit vectors containing their binary representation.

For implementing with fixed-length arrays, it is reasonable to add a periodic boundary condition. The CA rule is still reversible in that case, but it comes with a penalty in terms of simulating the original rule. In general, we can read the state of the original CA as long as we are XORing with 0. With periodic boundaries, we eventually collide with the past history ("heat") at which point, we lose the state that we really want to run in the original rule. Again, my intuition (and I find it useful at least) is to think of this as converting an irreversible rule like Life to a reversible rule with infinite cooling capacity. Once you set a finite limit, it only works until your immediate surroundings reach a state of high entropy (only in a rough sense, though, because it is fully reversible, but it is pseudorandom).

Some Python code to illustrate converting 0D to 1D:

Code: Select all

def transition(n):
  return n - 1 if n > 0 else 0


def reversible_rule(a, b):
  return a, transition(a) ^ b


def apply_rule(values, offset):
  for i in range(offset % 2, len(values), 2):
    b_ix = (i + 1) % len(values)
    values[i], values[b_ix] = reversible_rule(values[i], values[b_ix])
  return 1 - offset


def to_string(values):
  return  " ".join(["%d" % x for x in values])

values = [6, 0] +[0] * 10

print(to_string(values))
# run 10 steps of the rule
offset = 0
for step in range(10):
  offset = apply_rule(values, offset)
  print(to_string(values))

print("now reverse")
# now reverse and run 10 in reverse
offset = 1 - offset
for step in range(10):
  offset = apply_rule(values, offset)
  print(to_string(values))

The repl.it link

Output:

Code: Select all

6 0 0 0 0 0 0 0 0 0 0 0
6 5 0 0 0 0 0 0 0 0 0 0
6 5 4 0 0 0 0 0 0 0 0 0
6 0 4 3 0 0 0 0 0 0 0 0
6 0 4 3 2 0 0 0 0 0 0 0
6 5 4 0 2 1 0 0 0 0 0 0
6 5 0 0 2 1 0 0 0 0 0 0
6 0 0 0 2 0 0 0 0 0 0 0
6 0 0 0 2 0 0 0 0 0 0 0
6 5 0 0 2 1 0 0 0 0 0 0
6 5 4 0 2 1 0 0 0 0 0 0
now reverse
6 5 0 0 2 1 0 0 0 0 0 0
6 0 0 0 2 0 0 0 0 0 0 0
6 0 0 0 2 0 0 0 0 0 0 0
6 5 0 0 2 1 0 0 0 0 0 0
6 5 4 0 2 1 0 0 0 0 0 0
6 0 4 3 2 0 0 0 0 0 0 0
6 0 4 3 0 0 0 0 0 0 0 0
6 5 4 0 0 0 0 0 0 0 0 0
6 5 0 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 0 0 0 0

Posted: **November 13th, 2019, 3:07 am**

Whilst exploring literature relating to Reversible Partitioned Cellular Automata I came across a paper describing self-replication in a 2D RPCA labelled SR_8. In this CA, cells are divided into 5 partitions (4 for von Neumann neighbourhood plus centre) with each partition being in one of 8 states. This is equivalent to a regular CA on the von Neumann neighbourhood with 32,768 states[*]. The self replicating worms are modelled on Langton's Loops and are programmed with a sequence of commands which controls their shape, the position of their daughters, and a branching command which facilitates replication. Details: Self-reproduction in a reversible cellular space, K. Morita and K. Imai, Theoretical Computer Science, Vol 168 (2), 1996, pp 337-366.

As I understand it, the local function of the CA is defined only for the configurations of interest, ensuring that there are no duplicated resulting states. This implies that the remaining undefined transitions can be chosen to ensure the local function of the PCA is bijective, and therefore the global CA is reversible.

This is quite a different beast to the "Life-like" CA described in the previous few posts, but I though it was relevant to this thread. There are also various other papers by the same research group which describe computation universal RPCA with only 2-states on a variety of neighbourhoods. Some of these have been discussed on the Partitioned Cellular Automata thread.

[*] Corrected number of states of equivalent CA on von Neumann neighbourhood. Thank you PHPBB12345.

Posted: **November 14th, 2019, 11:24 pm**

wildmyron wrote: November 13th, 2019, 3:07 amThis is equivalent to a regular CA on the von Neumann neighbourhood with 390,625 states.

Actually is 32768 states.

Posted: **April 9th, 2024, 8:00 am**

Check generation 1000:

Code: Select all

#C [[ STOP 1000  ]]
x = 30, y = 19, rule = test
6.B2$5.2B2.A$5.2A.BA2BAB6.B.B.B$5.2B2.AC10.A.A$3.2B3A.B.A2B7.B.2B.A$
3.2A4BCAC2A2.A.B3A6.2B$2.B2.B3ABC2B4.A3B5.2BA$3.ABC.BABACA3.A.2ACA.A
2.3A$.B.2A.A2.B2CBA2.A.3BCBA3B$A3.B.B3A2C2B.B3.ABA2B.BA.A$7.A3B.CBA2.
AB.BC2A5.B$5.B.B.ABA2C2.2BABA2BA4.A$5.2A.BAB2CA2B.2A.AB3.B.B$7.ABABA
2B5.B5.2A$8.A.BAB7.A3.ABAB$7.AB$7.AB$7.A!

@RULE test

@COLORS
0  40  40  40
1  40 160  40
2 160  40  40
3 240 240 240

@TABLE
n_states:4
neighborhood:Moore
symmetries:permute

var a1={1,3}
var a2=a1
var a3=a1
var a4=a1
var a5=a1
var a6=a1
var a7=a1
var a8=a1
var d1={0,2}
var d2=d1
var d3=d1
var d4=d1
var d5=d1
var d6=d1
var d7=d1
var d8=d1

0, d1, d2, d3, d4, d5, d6, d7, d8, 0
2, d1, d2, d3, d4, d5, d6, d7, d8, 1
0, a1, d1, d2, d3, d4, d5, d6, d7, 0
2, a1, d1, d2, d3, d4, d5, d6, d7, 1
0, a1, a2, d1, d2, d3, d4, d5, d6, 0
2, a1, a2, d1, d2, d3, d4, d5, d6, 1
0, a1, a2, a3, d1, d2, d3, d4, d5, 1
2, a1, a2, a3, d1, d2, d3, d4, d5, 0
0, a1, a2, a3, a4, d1, d2, d3, d4, 0
2, a1, a2, a3, a4, d1, d2, d3, d4, 1
0, a1, a2, a3, a4, a5, d1, d2, d3, 0
2, a1, a2, a3, a4, a5, d1, d2, d3, 1
0, a1, a2, a3, a4, a5, a6, d1, d2, 0
2, a1, a2, a3, a4, a5, a6, d1, d2, 1
0, a1, a2, a3, a4, a5, a6, a7, d1, 0
2, a1, a2, a3, a4, a5, a6, a7, d1, 1
0, a1, a2, a3, a4, a5, a6, a7, a8, 0
2, a1, a2, a3, a4, a5, a6, a7, a8, 1
1, d1, d2, d3, d4, d5, d6, d7, d8, 2
3, d1, d2, d3, d4, d5, d6, d7, d8, 3
1, a1, d1, d2, d3, d4, d5, d6, d7, 2
3, a1, d1, d2, d3, d4, d5, d6, d7, 3
1, a1, a2, d1, d2, d3, d4, d5, d6, 2
3, a1, a2, d1, d2, d3, d4, d5, d6, 3
1, a1, a2, a3, d1, d2, d3, d4, d5, 2
3, a1, a2, a3, d1, d2, d3, d4, d5, 3
1, a1, a2, a3, a4, d1, d2, d3, d4, 2
3, a1, a2, a3, a4, d1, d2, d3, d4, 3
1, a1, a2, a3, a4, a5, d1, d2, d3, 3
3, a1, a2, a3, a4, a5, d1, d2, d3, 2
1, a1, a2, a3, a4, a5, a6, d1, d2, 2
3, a1, a2, a3, a4, a5, a6, d1, d2, 3
1, a1, a2, a3, a4, a5, a6, a7, d1, 2
3, a1, a2, a3, a4, a5, a6, a7, d1, 3
1, a1, a2, a3, a4, a5, a6, a7, a8, 2
3, a1, a2, a3, a4, a5, a6, a7, a8, 3

Evolution can be reversed by exchanging cellstates 1 and 2.

added later: Check around T = 1000 through T = 2000:

Code: Select all

x = 64, y = 62, rule = demo:T64,62
.CBCACB2C.CA4BCACBCBCBAB.CA2.B2AB.2ABA2B.C2BC7.A.ACB.BC.B$A.2CB3.BACB
2A3B3A.3BA.BC.C2BAC2.A.BCB.C.BCBC2B.2CABACBC.B2AC$3C2B.CA.BC.2BC.2CA.
A.CB.ACB.2C2.A.C.ABCABA.B.B.B2.ACAC2BC2BA.C$BA2C.C2A.A.C.2C2A.C.C2B.
3CBA2B2.2A.A2C3BCAB.B.C.B.BA2.BCB.BA.C$.CA.A.2CA2BCACBAB2A.BACAB3.B.A
.2B2CA.A4C.3A3.ACBCBC.AB.ABC$A.A2.2A2.A.A2CBA2B2.A.2CBAC.C2B2AC.ABAB
2AB.A.BA2C.B.C2A2B2ABC2.B$2ABC2.A2CBC.CAB2CAC.ABA2C.A2C2ACB.3A.CB2AC.
2A3BAC.2B.B2.ACB3C$BAB2CB2A3.C.A3C2.BC2B.C.A.2C2A2CB2A.C.A2.B2.B2.C.C
.BACB.BA2B.A$B2C.A.A2.2ABA.B3CBA.AC.BCA3BABA.3CABCB.A.ACAB.3CAB.C.B2A
BCBA$C.ACBA3B2.2AC2B2.BC.3BCBA2B.ACABC.3B3CA.BC.BA.C2A.A2BACA3.B$.2B.
CABCA2BCBA2B2A.CA2B.CBA2.BA2BA.2C.2B.B2.2AC.3A.A.A2B.5CB$.CA.AC2.A.C.
B2ACBA.B.C5BCB.AC.A2BA2C2A2BA2.A.A3B.AC2BA2.CB.A$B.4B3C2.CACB.BC3B2.
2BACABABCAB2CAC.2B2A.BAC2AC3BAC.CAC3.2B$.C.A.C2B.ACBC.2BAB2A.2C3BC2A
2.B2.C4BCBCA.2BA2CACBAC2A2BA.2AC$.C.2C.2C2B2.A.AB2.AB2.A.2BCACBCABC.B
2.B2ABC.A2.CBC3A.2CB.3ABA$2AB.C3.AC2.A.3BCAC.BC2AC.B2C.AC2.CB2CB2.AB.
C.BAC.BA.A.B2.C.CA$2.2C2.2C2B3AC.2A2B3.5B.C2BC2B.C.C.A2C2.CBA2CBAB4CA
2CAB.AB$B.A.CB2.BC.ACB2CBA.2A2C.ABCB2.CAB.2B.C2A2C2.A.C3.B.C.BC.C.AB
2.B$CB2.BACB.AC2AB.CAB.BC4.B2C2A.C.2BC2A3.A.C.AC2.C.ACB2A.2CACB.A$B.B
CABAB.A2B.A.BC.3A3.C2BC.B2.C2.C.AC3A.BC2AC2AB2C.B2.C3ABCA$C.C2A3C.C.B
AB3.AC.BCA2.C2A2BAB2.CBAC.C3.BAB2A.AC2.AC.BC2B4C$BCBAC2BABCA.2A.2BCAC
A2C.C.2C.B.B.ACA.B.C.AC2.A.C.C2.2B.CA2.B3.A$.2AC.CBA.CACA.C.AB.A.2ACB
CBC.A2.2AC.2CB2ABA2C.A2C3A2CBA2.C2ABAC$2AB2.2ACACBCA.BCA.BA.AB2.CB.2B
2.CA2CBA2BC2BC2.2ABA2CB2A2.CBA.3C$.2A2BC.2B2.BA2.2CB2C.C.2B.BC.C.5ACA
.2CA.CACA2B2CBCBA2.CAC2.AB$C3B.BC2ACA.CA2.2CAC2ABC3B.A2C.2BA2.2B2.AB.
4BCB2.BCB.BA.CB.B$2CABA.BCACB.A3.C2B3A2.BA5.CAC.A2CB3.2CA2C.A2.2C2.B
2.A2.2CA$.2B.3ABACB.A.C.B.C4B2.AC.AC.B.2A.C5.B3C.CB.2B2ACB.C.4BC$.2C.
B.A4CABA2BACB.BAB.B2.B.AC2.CBA2.CA2CA.CB.A2C.BC2.A2.CAC.BA$CB.CA.A3.A
.CACB.BA.A3.A.B3C2BAC3A2.2ABC.B2CBA.BC.B.2CBAC.ABC$B2AB2.ACA2B.A3B.C.
C2ABCBA.A2BACA2.ABAC.A2BC4A.BAC.2AB2ABC.ABC$CA.C2.2C.A2BACB.CACACB2CA
2.A2.2B.C2BAC.3CA3.CBCA.BC4B2A.ACBA$C.2A.A2CBCAC2.C.C.CB.A.5C2.5ABABA
.CBC.A3BACA.A2BCB2.5C$2.2BAC2B.AB.2B.3C2.B2.ACAB2CA.2C3A2.2B.3BA2.2CB
CBC3BC2.CAC$2CB.B.A.C3ABABCBABA.C.AB.CBAB3A.AC.B.CBA3BA.A2B2C.AB.A.2B
C.CB$B.2C.2A2BCA2CB.2ACA.CABA2B.2CB.CAC2B2.CA.BCBA2B.2C.B2.ABC.ABC.2A
$2.2A3C.C2A.AC.A.2B.2BA2B.ACB2.B2.A4BA.3A2BA.2C2.2ABC2BCA.A$3.A2BCB3A
2.B.B.B.C.B3ABC4.A2.3BABA3CACB2ABC.2BAC2B.B.A2B$.5C4.B2.2CACABCACA.BA
2CAC.C2ABACB2ACBCAB.ABAC.C2BA.BA.ABCBC$.2ABA.A.CBCB.A.B2.C.3C.ACB.BC
2ACA2C.B.CB.2CAB2A2.CA.C.B.AB2ACAB$2BAC3.A.C.3A.B.CAB3CBC2B.C2.AC.BC.
BC.CB2.2CABA2B.B3C2ABABA2B$C.2CAB.A.4CA.AB.C.CACACBCA.BAC.C.A2BCACA2B
A2CBCBABA.CA.C.CB.AB$C2AC2.B.BAB2CA.AC2B.2CA4BC2A2BCAB.BCBCB2A2.A2B.B
CA.AC.3ACB2.B$CA.2A2.2B.3ACB.BC.C.ACACA2B3.2CBA.A.BC.B.B2.2C2B3C.CA6B
.A$2.2AC2.BCB.BAC.A2C2A2B2A.C3AC.B.B2CAB3AB2ACB.B.BAC.A2CA2BC2BAC$2CA
.A2C.C.BC.B.2A2B2.BC.B2CB2C.A2.A.A3B3.A2B.3C.C2B.BA.AB3.A$.C.C2B3.BAC
2B2CBABCA2C2.A.B.BCBC.2AB2A2C.2A2B2A4CAC.BA3CB2.A$B2.C2AB.3CBC2B2CBAB
.B2ACA.A3.AB3.C.2CB.2C.BACB.BC.3CBA2.CB2A$.B.C.CBC.BCA.BA2.C2ABABCABC
B2CA.A.A.2AC3B2.C3AC2A.ABC2.2AC2B.A$AB2CA2CB2C.A.CB2C.B2C2.A2CACBA.CA
.A.ABA2B.CB.3A2.AB6.AB.BAC$BA.2A.C.B2A.CBCA.4BCA.CAC3.BA.C2B2C.2ABC2A
2.A.BAB.BCAC2A.CB.B$.C2B2A.ABCB4.C.B3CAC.BCB.CBA.CBACA2BAB.2C2.C.A2BC
2B.A3B3.A$C2B2C.3CBCABAC2BA3.B.B.B3ABA2.A.C.CA.2BA3.A2.CBCBCAB.B.2C2.
C$AB6.BAC.2BACA.2A.BC2BCAC.2A.2BA.2B.C.2B.A.C2BA2B.CAC.2B.2ABC$AC.BA.
C2.2CBABCAC.ACBACBCB.B2.BC2AC.CAC2.AB.2CA3.AC.2BA.CB.2CAB$CA.A2.ACA2B
A.CAB2.C.CA.BA.BA.A.B2ABA2.BA2C.BAB.BC.ABC.2B2.C2.2C$CB2.AC2A4C2.2CAB
.A.A.B.2B2A2.CBAB.2B2A2.C2ABCB.BC.C3A3B.BCBA$.C.B2A2B.ABACBC2ACB2ABC.
C3BA.3A.B2CB.AB2A.BAC2.2CBA.A3.A.CBAC$C.A.C.2BC3.A2B.A4BC3.CBACA3B2C
3.C.B2.CBCA2CBC2B.A.A2BCABA$BC.3BA.CA.AB4.AC2B.BCAC.2A.5A.2CA.CACACAC
BC2ACB3CA2B2ACBC$3A3.C2B4A.A2BACA3C2B2A3C2.3A2CB.B4ACAB2C2B3CBCB2.C.A
BA$CB.3BCABCACABA.BC3BA2.2A.CA2BA.B2.A3.B2C.C.BA.BA.B2ABC2BAC.B!

@RULE demo

@COLORS
0  40  40  40
1  40 160  40
2 160  40  40
3 240 240 240

@TABLE
n_states:4
neighborhood:Moore
symmetries:permute

var a1={1,3}
var a2=a1
var a3=a1
var a4=a1
var a5=a1
var a6=a1
var a7=a1
var a8=a1
var d1={0,2}
var d2=d1
var d3=d1
var d4=d1
var d5=d1
var d6=d1
var d7=d1
var d8=d1

2, d1, d2, d3, d4, d5, d6, d7, d8, 1
0, a1, d1, d2, d3, d4, d5, d6, d7, 1
2, a1, d1, d2, d3, d4, d5, d6, d7, 0
0, a1, a2, d1, d2, d3, d4, d5, d6, 1
2, a1, a2, d1, d2, d3, d4, d5, d6, 0
2, a1, a2, a3, d1, d2, d3, d4, d5, 1
2, a1, a2, a3, a4, d1, d2, d3, d4, 1
2, a1, a2, a3, a4, a5, d1, d2, d3, 1
2, a1, a2, a3, a4, a5, a6, d1, d2, 1
2, a1, a2, a3, a4, a5, a6, a7, d1, 1
2, a1, a2, a3, a4, a5, a6, a7, a8, 1
1, d1, d2, d3, d4, d5, d6, d7, d8, 2
1, a1, d1, d2, d3, d4, d5, d6, d7, 2
1, a1, a2, d1, d2, d3, d4, d5, d6, 2
1, a1, a2, a3, d1, d2, d3, d4, d5, 2
1, a1, a2, a3, a4, d1, d2, d3, d4, 2
1, a1, a2, a3, a4, a5, d1, d2, d3, 3
3, a1, a2, a3, a4, a5, d1, d2, d3, 2
1, a1, a2, a3, a4, a5, a6, d1, d2, 2
1, a1, a2, a3, a4, a5, a6, a7, d1, 2
1, a1, a2, a3, a4, a5, a6, a7, a8, 2

ConwayLife.com

Any interest in reversible rules (and their implications)?

Any interest in reversible rules (and their implications)?

Re: Any interest in reversible rules (and their implications)?

Re: Any interest in reversible rules (and their implications)?

Re: Any interest in reversible rules (and their implications)?

Re: Any interest in reversible rules (and their implications)?

Re: Any interest in reversible rules (and their implications)?

Re: Any interest in reversible rules (and their implications)?

Re: Any interest in reversible rules (and their implications)?

Re: Any interest in reversible rules (and their implications)?

Re: Any interest in reversible rules (and their implications)?