baba is life

Strategy:

First wrote out survival/birth conditions - for tile T, "tile had baba" Y, and "tile had neighbor" C, we have the following initial conditions:

- TY TYC [TYC2 TYC3] TYC4 .. TYC8
- TC TC2 [TC3] TC4 .. TC8

We want the bracketed ones to end up as "BABA" which we will call X.

The clear solution here was to first combine C into Y on Y tiles to better separate out "survival" versus "propagation" via the rule C ON Y IS Y.

- TY TY2 [TY3 TY4] TY5 .. TY9
- TC TC2 [TC3] TC4 .. TC8

Then, we have to figure out an efficient and effective way to reduce the counts, move non-bracketed conditions to the zero condition (T) and turn the bracketed conditions into TX.

The best technique I've found so far is to use OPEN and SHUT to subtract one at a time.

By setting T HAS T IS SHUT, we can use C AND Y IS OPEN twice to  obtain:

- T [TY TY2] TY3 .. TY7
- T [TC] TC3 .. TC6

At this point we can "rescue" the lowest-count bracket. Let's turn things into G (Ghost, an arbitrary pre-baba tile) so we can make all the final BABA all at once.

We use three rules at the same time:

- C NOT ON C IS G
- Y NOT ON Y IS G
- Y AND C IS OPEN

The NOT ON ... IS takes priority before the subtraction via OPEN, so we end up with:

- T [TG TY] TY2 .. TY6
- T [TG] TC2 .. TC5

We can repeat a similar operation by then using the following three rules, at the same time turning G into X (BABA), and cleaning up the extra intermediate tiles. As before, NOT ON ... IS takes priority.

- G IS X
- Y NOT ON Y IS X
- C AND Y IS EMPTY

Producing:

- T [TX TX]
- T [TX]

After this point, the propagation rules could be made - basically, just a method to get C and Y to the correct locations. MAKE is unsuccessful because it doesn't produce if the tile is covered, so we will just make moving elements that move to the correct locations all at once.

Let's arbitrarily define four elements to move up, down, left, and right, called U D L R to distinguish them from the properties UP DOWN LEFT RIGHT. (Of course, we'll need to make the rules U IS UP, D IS DOWN... etc. as well as U&D&L&R IS MOVE)

We'll use conversion here to produce Y on existing tiles,

1. BABA IS U AND D AND L AND R AND Y
2. L AND R IS C + U AND D IS L AND R AND C
3. L AND R IS C

This produces C and Y in the correct spots and cleans up after.

===

The rules are:

STATIC RULES:
	To establish the cycling rules:
		CLOUD AND WATER AND LAVA IS TELE AND SHIFT // BELT IS SHIFT
	To define boundaries of the board:
		WALL EAT ALL
 	To define the propagation elements (UDLR):
		PILLAR IS UP // STATUS IS DOWN // STAR IS LEFT // MOON IS RIGHT
		PILLAR AND STATUE AND STAR AND MOON IS MOVE
	To convert TYC(n) into TY(n+1), separating survival and propagation:
		ROSE ON FRUIT IS FRUIT
 	To allow count reduction:
		FRUIT AND TILE HAS TILE IS SHUT
CYCLING RULES:
	== STEP 1 (INIT PROPAGATION) ==
		BABA IS PILLAR AND STATUE AND STAR AND MOON AND FRUIT
	== STEP 2 (PROPAGATION TO CORNERS) ==
		STAR AND MOON IS ROSE      ; PILLAR AND STATUE IS STAR AND MOON AND ROSE
	== STEP 3 (FINISH PROPAGATION + WAIT FOR TYC -> TY CONVERSION) ==
		STAR AND MOON IS ROSE
	== STEP 4 (REDUCE COUNTS) ==
		FRUIT AND ROSE IS OPEN
	== STEP 5 (REDUCE COUNTS) ==
		FRUIT AND ROSE IS OPEN
	== STEP 6 (CONVERT LOWEST BRACKET TO BABA) ==
		ROSE NOT ON ROSE IS GHOST  ; FRUIT NOT ON FRUIT IS GHOST ; FRUIT AND ROSE IS OPEN
	== STEP 7 (CONVERT TY TO TX, MAKE BABA, CLEANUP) ==
		FRUIT NOT ON FRUIT IS BABA ; ROSE AND FRUIT IS EMPTY     ; GHOST IS BABA