Rule request thread

[calcyman]

Hint: if you store stripes horizontally instead of vertically, the pattern has a much more compact RLE. Here's your pattern rotated through 90 degrees:

Code: Select all

x = 56, y = 53, rule = B3/S23
56o2$56o2$56o2$56o2$56o2$56o2$56o2$56o2$56o2$56o2$56o2$56o2$56o2$56o2$
56o2$56o2$56o2$56o2$56o2$56o2$56o2$56o2$56o2$56o2$56o2$56o2$56o!

[Bullet51]

I would like a rule, that converts all 1's pattern into vertical zebra strips.

What would the rule convert this pattern into?

Code: Select all

x = 5, y = 5, rule = B3/S23
3obo$o$3b2o$b2obo$obobo!

[shouldsee]

Thank you clayman, I am now adopting horizontal strips.

I have made some naive attempts of "zebrastriping", namely alternating between zebrastrips and all-0/all-1 states. The neighborhood is similar to 2x2, but in my case it's 1x2.

Think about a 1x2 box, I can represent it as 00,01,10,11. Now if I have several of them lined head-to-tail vertically, this should give a 0-1 sequence.

A zebrastrip can be represented as either 01010101 or 10101010.
I have made clock4.py to emulate
0000->1010->1111->0000

clock2.py to emulate
0000->1010->0000
1111->0101->1111

Now consider a specific rule (B56/S5 or B5678/S5) where tiling of both zebra-strips and all-same are mapped to themselves. In B56/S5, zebra-strips tend to decay into all-0's. But by applying clock2 and B56/S5 alternatively, we can achieve interesting behaviour quenched at the surface. I even found a puffer in B5678/S5+clock2.

Run the following pattern in custom_advance.py with "clock2.py" as input script. Make sure you align top-left corner to (0,0) or any (even,even) point, and make a selection before you run.(The script only advance inside)

A puffer in B5678/S5+clock2

Code: Select all

x = 40, y = 40, rule = B5678/S5:T40,40
5$15bo2$15bo2$15bo$14bobo$14bobo2$14b3o$14b3o!

A spaceship in B56/S5+clock2

Code: Select all

x = 40, y = 40, rule = B56/S5:T40,40
12$21bo$21b2o$16bo$18b6o2$18b6o$16bo$21b2o$21bo!

B568/S35+clock4.py

Code: Select all

x = 100, y = 100, rule = B568/S35:T100,100
52o2bobo5bobo4bob5o2bob2o2bo3b3o4b4o$54b4o3bobob2obobob3ob2ob4o3bo2bo
4bo2bo$54obo2b2ob2o4bob2obob4ob2o2bob2obo2b2obo4bo$55bob2o2bo2b2ob9o5b
2ob4ob2o3b2obo$55obo3b2obob7obo3b3obo3b2ob2o2bobob3o$54bo3b2o2b3ob3obo
b2ob2o2b6o2bo6bobo2bo$55o2bob2o2bo4bob3o4bobob3o3bob4ob3ob2o$54b2o2b2o
4bobobob4ob3o3b4obob4o2b2ob3o$55o3bobo5b2o2bob3ob4ob3o2bobob4o2b2obo$
54bob3obobo2bo3b3ob4o3b3ob3ob2o3b2o2bo$59obo2bobo4bo2bobobob2o2bobobob
2o2b2o2bo$54bobobo2bo3b4o2bobo8bo3bobobobo3b2o$54obobobob2ob4ob2obo5bo
bobobob6o2bo2bobo$55bo3bobob2obobo2b6o2b4ob3ob2o2b2o$54obobob2o6bo3b3o
bob6o2bob3obo2b3ob2o$56b5o3bobo3bo2bo2b4o4bo2bo3bob2o3b2o$56o2bo2bob4o
b2ob2o3bobob3ob5ob4obo3bo$56bo2bobob7o2b2obo2bo6bobob2obo2b2ob2o$54obo
2bo2b2ob3o2bob2ob3o2bo3bobob2ob3obo$54bo5bobo2b7o4b3ob4o2bob2o3bob4o$
53o2bobob4o5bobob2o2b2ob5o2b2o2bo2b4o$54b3o4bo2bob3o3b2o4b2o3bo6bo5bo$
50o4bo2bo3bobo3b5obob4o2bo3bob2obob2o2b3o$55bobo4bo2bo2b2obob2o5bo4bo
3bo3bo5bo$49o5bo3bob2o2b2obo2b2obob2obo2bobob2ob2obo2bo2bobo$62bo3bo2b
4o2b3obob3o3bo3bo5bo$50o2b3ob2o6bo2bo2bo2b2o3bobo2bo2b2o3b3obo2b2o$54b
ob2o2b2obo4bobobo4bobo4bobob3ob2o2b2o$57obo4b2o3bo3b3ob3o3bob4o2bo4b5o
$56b3obo3bo2b2ob2o3bo4bo2bo3bob6ob4o$54o2bobobobob5o3b3ob2o2bobo3bob2o
b6ob2o$56b6ob5o2bob3o2bob3o3b2ob2o4b4obo$54o2bo2b2o2bo2b3o2b3o2bob3obo
bo2bob3obob2o$57bobobo2bobob5ob2o2b2o3bo3bobobob2ob4o$54o4b2o4b2obob2o
2bobo2b3obo4b3ob5o2bo$54b5o6bo2bobo4b4obo2b2ob2o2b4o4b2o$54o3bo3bob2o
2bo3b3o2bo3bo2b2ob2ob2o3bob2obo$58bobob2ob2o2bo3bob3obo2bo3bobo2bo3b5o
$54o3b4o2bo4b2obobob4ob2ob3o2b2obob3obobo$55bob5o5b2obob2o3bo2b3o2bo4b
o3b5o$54ob6obo2bo3b6obobobo2bo2bo2b3obo2b4o$54b2o2b2o2bo2b4obob3o2bo2b
4ob2ob6o2b2obo$53o2b3ob2ob2obobobob3o2b4o2b3obo3b2obobobobo$54bo4bob2o
2bob2o2b2o2b2o3b8obo2bob2ob2o$52o3b2o2b4o2b3ob12obob3ob3o4bo2b2o$57b3o
5bob2o2b4ob3obobobob2ob2o2b2o3b2o$52o2bo2bo3b5o3b2o3bobobo3bob2obo2b4o
b3o$55bo2b4obo2bo3bo2b5obob2o4bo3bo6bo$53o2bobo2bob5o2b2o5b2obo2bo2b2o
2b2o3b4o$54b6o4bo3b2ob3ob4ob4obobobob2ob2obobo$54obo2b2o2b2obob2o3b2o
2b6o2bo3bobo2bo2b3o$56bob5o2b5obob2ob5ob2obo2b2o3b3obobo$55o3b2o3bobob
ob2o2b5ob2o2b4o4b2obo$55bobo7bobo5b2ob3o3bo2b3obo3bo5bo$53o4bo2bo3b2ob
2obobob4obo2b2o2bo2bobo2bo3b2o$54b2ob3ob2o2bo4bo5b2obo2bob4o2bo3b3o$
53obob2o2b2ob3o3b2ob2o3bo2b2o2bob6o3bo2bo$56b2o2b2o2bo2b3ob2ob3ob2ob2o
bobobobob5o2bo$52o5bo3b3obo2b3o4bobo4bobob4obobob3o$54bobo2bo3b2o2b2o
5bo2bobob2ob2o4b6ob2o$51o3b4o2b4obo2bo6bob2o3bob5o5bo3bo$54bob4o3bo3b
2obobo5b2ob2ob2o4bob3ob2obo$50o4b4o4b4ob3ob2obobo3bobo7b2o2bobo2bo$54b
o2bob4o2bo5b3ob2o2bo7bo3b3o2bob2o$50o5b3o2bobo2b3o8b4o3bo2bobob2o3bobo
bo$33bo2bo20b2obo3b5ob3ob6obo2b2obobobo4b4o$33o4b14o5b2o3bo2b4obob3o2b
2obo2b4obo2b2o2b4o$33bo2bo17bob2o4b5ob2o2b2o6b2o2b2o3bo4b2o$53o2b2o3b
2o2b2o5bo3b2ob2o2b2obob3ob2ob3o2bo$12bo2bo38b2obo4bo2bo3bo3bo2b2o2bobo
2b2o3b2o3b2o$12o4b39obob2o3b2obob3obobo3bob3ob2o5b4o3b2o$12bo2bo39bobo
3bobobo2b7o3bobob2o2b3o2bobo4b2o$2b53o3b2o4bob2obo3b2o3bob2o3b2obobo3b
obo2bo$54b3ob4obo2bobobo2bo3bobo2bobobobobobo2bo2b2o$3b51o2b2o2b5o2b3o
2b2o3b2o2bobo3b5o2b2o2bo$54bo7b3o4bob4ob2obo2b2o2bo5b2obo3bo$2b52o2bo
2b3obob2ob2ob2ob3o4bo4b3o3bob2o2bo$54b3obobo2b3o4b6o3b6obobo4bo2bo2bo$
56o2b2o2bobo5b2o2bob2ob6o3bob2o2b2o$57bo5bob2ob3ob3ob2obob3o2b2o2bob6o
bo$55o2b2ob3o6b2obobo2b2ob2obo2b4o4b5o$54b4ob2obo3b4ob2obob3o3b2o3bobo
2b2o2b3o$55obobob6o2b2o4bo2b2o4bob4o4bob3obo$54b4o2b2obobo4b3o2b3o2b3o
b3o2bo2b2obo2bo$55o4b4obo5bo2bobobo2bo3bobo4b3o2b2obo$55bobob6ob2obo2b
5o2b2o2b7ob2ob3obo$54o2bo2b3ob2ob2o11bo2bobo2b4ob3ob4o$54bo2b4o2bobob
3ob2o2bo5bobo3b2obo2b2ob2obo$54ob3o5bo2bo2bo3b2obo5b2o2b3o2bo2bo3bo$
54bo3b4o2bo5bo3b6o2bo5bob3obo$55o7b2ob3obo2bo3b2ob8obob4obo2b2o$54bob
2ob3ob4o6b2o4bo2bo7b2obo3bo$53ob2o6b3o4bo2b3obo3bo4b2ob3ob2o2b2obo$54b
3obobobo2bo4b2obo2bobo2b3o2b4obo3b2o$52o3b3o3b4o4b2obo2bob3obob3o2bob
5ob3o$54bo3b2o3bo3b2o2bobobob2ob7ob2obo6bo$52o2b4obo4bobo3bo6b2obob2ob
obo6bobobo$55b10ob3o2b3o4bobo2b6obob2o4b2o$51o5bob3ob2o2bo2b2obo2b4obo
2b2o7b2o5bo$55b3obobo4b5o2b2o2b3o2bobob3o4bob4o!

custom_advance.py

Code: Select all

# Output an adjacency matrix for current selection to clipborad in a "Mathematica" list fomart 
# Use AdjacencyGraph[] in Mathematica for downstream processing.
# Author: Feng Geng(shouldsee.gem@gmail.com), May 2016.

import golly as g
from glife import *
import numpy as np
import hashlib

stepmax=int(g.getstring('steps to advance','100'))
sel=g.getselrect()
step=1
script=g.getstring('script to apply','clock2.py') #change here to your desired script
update_interval=2
while step<=stepmax:
	execfile(script)	
	g.advance(0,1)
	step=step+1
	if step%update_interval:
		g.update()

clock2.py

Code: Select all

# Invert all cell states in the current selection.
# Author: Andrew Trevorrow (andrew@trevorrow.com), Jun 2006.
# Updated to use exit command, Nov 2006.
# Updated to use numstates command, Jun 2008.

from glife import rect
from time import time
import golly as g

r = rect( g.getselrect() )
if r.empty: g.exit("There is no selection.")

oldsecs = time()
maxstate = g.numstates() - 1

for row in xrange(r.top, r.top + r.height):
    # if large selection then give some indication of progress
    newsecs = time()
    if newsecs - oldsecs >= 1.0:
        oldsecs = newsecs
        g.update()
    for col in xrange(r.left, r.left + r.width):
	if row%2==0:
		a=g.getcell(col, row)
		b=g.getcell(col, row+1)
		if a+b==2:
			anew=0
			bnew=1
		elif a+b==0:
			anew=1
			bnew=0
		elif a+b==1:
			if a==1:
				anew=0
				bnew=0
			else:
				anew=1
				bnew=1
		
		g.setcell(col, row, anew)
		g.setcell(col, row+1, bnew)
	

if not r.visible(): g.fitsel()

clock4.py

Code: Select all

# Invert all cell states in the current selection.
# Author: Andrew Trevorrow (andrew@trevorrow.com), Jun 2006.
# Updated to use exit command, Nov 2006.
# Updated to use numstates command, Jun 2008.

from glife import rect
from time import time
import golly as g

r = rect( g.getselrect() )
if r.empty: g.exit("There is no selection.")

oldsecs = time()
maxstate = g.numstates() - 1

for row in xrange(r.top, r.top + r.height):
    # if large selection then give some indication of progress
    newsecs = time()
    if newsecs - oldsecs >= 1.0:
        oldsecs = newsecs
        g.update()
    for col in xrange(r.left, r.left + r.width):
	if row%2==0:
		a=g.getcell(col, row)
		b=g.getcell(col, row+1)
		if a+b==2:
			anew=0
			bnew=1
		elif a+b==0:
			anew=1
			bnew=0
		elif a+b==1:
			if a==1:
				anew=1
				bnew=1
			else:
				anew=0
				bnew=0
		
		g.setcell(col, row, anew)
		g.setcell(col, row+1, bnew)
	

if not r.visible(): g.fitsel()

[toroidalet]

and this?

Code: Select all

x = 6, y = 10, rule = B36/S125
2b2o$2b2o$2o2b2o$2o2b2o$2o2b2o$2o2b2o$2o2b2o$2o2b2o$2b2o$2b2o!

Having way to much free time, I determined that the correct rule is B3i4nt5ey6k73/S1e2k3ey4irt5i. Both phases emulated for fun:

Code: Select all

x = 5, y = 3, rule = B3i4nt5ey6k7e/S1e2k3ey4irt5i
b3o$o3bo$b3o!

Code: Select all

x = 4, y = 2, rule = B3i4nt5ey6k7e/S1e2k3ey4irt5i
4o$4o!

[Caenbe]

If possible, I would like a template for the following family of reversible rules:

Take any rule where the B list is the complement of the S list. (e.g. B2678/S01345)
Update cells asynchronously in this order:
T=4n: (even,even)
T=4n+1: (odd,even)
T=4n+2: (odd,odd)
T=4n+3: (even,odd)

Also, has this type of reversible rule been studied before?

[shouldsee]

If possible, I would like a template for the following family of reversible rules:

Take any rule where the B list is the complement of the S list. (e.g. B2678/S01345)
Update cells asynchronously in this order:
T=4n: (even,even)
T=4n+1: (odd,even)
T=4n+2: (odd,odd)
T=4n+3: (even,odd)

Also, has this type of reversible rule been studied before?

This looks to me a specific class of alternating rules

BTW, I think such rule is best simulated by a script.

Under such simulation:
B02568/S1347 gives some transient chaos
B1458/S02367 gives a common oscillator.
B1348/S02567 gives a common glider and gives some oscillators.

4rule.py

Code: Select all

# This script calculate and emulate a B0 composite from the current emulated rule. (Try B024/S0123 or B678/S1278)
# Author: Feng Geng(shouldsee.gem@gmail.com), Sep 2016.

import golly as g
from glife import *

rule=g.getrule()
rule=rule.split(':')[0]
rule=g.getstring('rule to alternate',rule)
numstep=int(g.getstring('number of steps to run','1000'))

#def makerule(b,s):
#	return(''.join)

ruleB=rule.split('/')[0][1:]
ruleS=rule.split('/')[1][1:]

S=['S']
B=['B']

beven=['B']
seven=['S']
bodd=['B']
sodd=['S']

for i in range(9):
	if i%2==0:
		if str(i) in ruleB:
			beven.append(str(i))
		if str(i) in ruleS:
			seven.append(str(i))
	if i%2==1:
		if str(i) in ruleB:
			bodd.append(str(i))
		if str(i) in ruleS:
			sodd.append(str(i))


rbeven=''.join(beven)
rseven=''.join(seven)
rbodd=''.join(bodd)
rsodd=''.join(sodd)
r1='/'.join([rbeven,rseven]);
r2='/'.join([rbodd,rseven]);
r3='/'.join([rbodd,rsodd]);
r4='/'.join([rbeven,rsodd]);
r=[r1,r2,r3,r4];
g.note(str(r))
gen=int(g.getgen());
gen0=gen;
while gen<numstep+gen0:
	gen=int(g.getgen());
	g.setrule(r[gen%4]);
	g.run(1)
	if gen%4==0:
		g.update()
	if g.empty():
		break

[Caenbe]

If possible, I would like a template for the following family of reversible rules:

Take any rule where the B list is the complement of the S list. (e.g. B2678/S01345)
Update cells asynchronously in this order:
T=4n: (even,even)
T=4n+1: (odd,even)
T=4n+2: (odd,odd)
T=4n+3: (even,odd)

Also, has this type of reversible rule been studied before?

This looks to me a specific class of alternating rules

BTW, I think such rule is best simulated by a script.

Under such simulation:
B02568/S1347 gives some transient chaos
B1458/S02367 gives a common oscillator.
B1348/S02567 gives a common glider and gives some oscillators.

4rule.py

Code: Select all

script

Sorry, I should have clarified that the (even,even), etc. refers to the coordinates of the cells being updated. The rule stays the same throughout.

[shouldsee]

If possible, I would like a template for the following family of reversible rules:

Take any rule where the B list is the complement of the S list. (e.g. B2678/S01345)
Update cells asynchronously in this order:
T=4n: (even,even)
T=4n+1: (odd,even)
T=4n+2: (odd,odd)
T=4n+3: (even,odd)

Also, has this type of reversible rule been studied before?

BTW, this updating scheme looks intimately related to the Q2R rule class
According to this paper by Kari and Taati

Code: Select all

The symbols are updated in iterated succession of  two  updating  stages:  at  the  first  stage,  the  symbols  on  the  even  sites  (the  black  cells  of  the chess board) are updated, and at the second stage, the symbols on the odd sites.  

You can find a Q2RvN golly ruletable here made by alexv.

[Saka]

Challenge: A rule where there is a oblique forerake, minimal states.

[BlinkerSpawn]

Challenge: A rule where there is a oblique forerake, minimal states.

Doesn't tDryLife satisfy this perfectly?

[Saka]

Challenge: A rule where there is a oblique forerake, minimal states.

Doesn't tDryLife satisfy this perfectly?

Oh yeah.
NEW CHALLENGE:
Rule with at least 3 slopes of knightship, natural.

[fluffykitty]

Since everyone is making challenges, I suggest:
Challenge: Make a 3-state von Neumann neighborhood rule which produces the largest number of state 1 or 2 cells from a 1-cell seed. (Or 2 or 3 cells, within a 4x4 or 9x9 square respectively.)
My records are 81, 360, and 534, in the rule

Code: Select all

@RULE Grow2VN3
@TABLE
n_states:3
neighborhood:vonNeumann
symmetries:rotate4reflect
010002

210001
022002

121200

012221

112222
221201

022222

011101
011111

3-cell pattern: (To get 2 or 1-cell patterns, just remove the rightmost cell(s).)

Code: Select all

x = 9, y = 7, rule = Grow2VN3
A$3.A5$8.A!

[PHPBB12345]

Since everyone is making challenges, I suggest:
Challenge: Make a 3-state von Neumann neighborhood rule which produces the largest number of state 1 or 2 cells from a 1-cell seed. (Or 2 or 3 cells, within a 4x4 or 9x9 square respectively.)
My records are 81, 360, and 534, in the rule

Code: Select all

@RULE Grow2VN3
@TABLE
n_states:3
neighborhood:vonNeumann
symmetries:rotate4reflect
010002

210001
022002

121200

012221

112222
221201

022222

011101
011111

3-cell pattern: (To get 2 or 1-cell patterns, just remove the rightmost cell(s).)

Code: Select all

x = 9, y = 7, rule = Grow2VN3
A$3.A5$8.A!

929 for 4-cell:

Code: Select all

x = 14, y = 11, rule = Grow2VN3
A$3.A5$8.A4$13.A!

infinite growth:

Code: Select all

x = 3, y = 1, rule = Grow2VN3
A.A!

quadratic growth:

Code: Select all

x = 3, y = 3, rule = Grow2VN3
2.A2$A.A!

[Saka]

Not a challenge:
I would like a rule where there are 3 live states: Life, virus, and infected life. When cells pass through a virus blob, the cells turn into infected life. Once an infected life cell has 5 or more infected neighbors, it turns into a virus cell, which is stationary.

[fluffykitty]

Since everyone is making challenges, I suggest:
Challenge: Make a 3-state von Neumann neighborhood rule which produces the largest number of state 1 or 2 cells from a 1-cell seed. (Or 2 or 3 cells, within a 4x4 or 9x9 square respectively.)
My records are 81, 360, and 534, in the rule

Code: Select all

removed with select+backspace

3-cell pattern: (To get 2 or 1-cell patterns, just remove the rightmost cell(s).)

Code: Select all

x = 9, y = 7, rule = Grow2VN3
A$3.A5$8.A!

929 for 4-cell:

Code: Select all

x = 14, y = 11, rule = Grow2VN3
A$3.A5$8.A4$13.A!

infinite growth:

Code: Select all

x = 3, y = 1, rule = Grow2VN3
A.A!

quadratic growth:

Code: Select all

x = 3, y = 3, rule = Grow2VN3
2.A2$A.A!

4-cell can reach at least 943:

Code: Select all

x = 16, y = 16, rule = Grow2VN3
A$3.A5$8.A8$15.A!

Also, what is the optimal growth for higher state counts or larger neighborhoods? I haven't experimented with those yet.

[Rocknlol]

Here's a 4-cell pattern that reaches 1164 (I'm assuming that the maximum bounding box for a 4-cell seed is 16 by 16):

Code: Select all

x = 15, y = 16, rule = Grow2VN3
A3$.A11$14.A$11.A!

I've also found different two rules where patterns reach some pretty high populations:

Code: Select all

@RULE Growth1

@TABLE

n_states:3
neighborhood:vonNeumann
symmetries:rotate4reflect

var a={1,2}
var b=a
var c=a
var d=a
var e={0,1}

0,0,0,e,1,2
0,0,0,a,2,a
0,0,1,0,a,a
0,0,2,0,2,1
0,0,1,a,1,1
0,0,1,2,b,1
0,a,b,c,d,1
1,0,0,0,a,0
1,0,1,2,2,2
1,0,a,1,a,0
1,1,2,1,2,2
1,1,2,2,2,0
2,0,0,0,e,e
2,0,1,2,1,1
2,0,2,1,2,1
2,1,1,1,2,1

Code: Select all

@RULE Growth2

@TABLE

n_states:3
neighborhood:vonNeumann
symmetries:rotate4reflect

var a={1,2}
var b=a
var c=a
var d=a
var e={0,1}

0,0,0,e,1,2
0,0,0,a,2,a
0,0,1,0,1,1
0,0,1,a,1,a
0,1,1,1,a,1
0,a,a,2,2,2
e,1,2,1,2,2
0,1,2,2,2,1
1,0,0,0,1,0
1,0,a,1,a,0
1,1,2,2,2,0
2,0,e,0,1,1
2,0,2,0,2,0
2,0,1,1,1,0
2,0,2,1,2,1
2,1,1,1,1,0

A 1-cell seed in Growth2 only gets up to 65, but for 2, 3, and 4-cell seeds I've found patterns that reach 9662, 10020, and 32104, respectively.

Code: Select all

x = 2, y = 4, rule = Growth2
A3$.A!

Code: Select all

x = 6, y = 4, rule = Growth2
4.A3$A4.A!

Code: Select all

x = 11, y = 8, rule = Growth2
5.A2$A$6.A4$10.A!

While the multi-cell seeds for Growth1 are comparatively lacking, the final population for a 1-cell seed in the rule is an impressive 15093!

[Saka]

Not a challenge:
I would like a rule where there are 3 live states: Life, virus, and infected life. When cells pass through a virus blob, the cells turn into infected life. Once an infected life cell has 5 or more infected neighbors, it turns into a virus cell, which is stationary.

Pleeaase somebody pleeaaase

[Gamedziner]

Not a challenge:
I would like a rule where there are 3 live states: Life, virus, and infected life. When cells pass through a virus blob, the cells turn into infected life. Once an infected life cell has 5 or more infected neighbors, it turns into a virus cell, which is stationary.

Pleeaase somebody pleeaaase

What are the birth/survival conditions for the life and infected life states?

[Saka]

Not a challenge:
I would like a rule where there are 3 live states: Life, virus, and infected life. When cells pass through a virus blob, the cells turn into infected life. Once an infected life cell has 5 or more infected neighbors, it turns into a virus cell, which is stationary.

Pleeaase somebody pleeaaase

What are the birth/survival conditions for the life and infected life states?

Life
B3S23

[fluffykitty]

Here's a 4-cell pattern that reaches 1164 (I'm assuming that the maximum bounding box for a 4-cell seed is 16 by 16):

Code: Select all

x = 15, y = 16, rule = Grow2VN3
A3$.A11$14.A$11.A!

I've also found different two rules where patterns reach some pretty high populations:

Code: Select all

@RULE Growth1

@TABLE

n_states:3
neighborhood:vonNeumann
symmetries:rotate4reflect

var a={1,2}
var b=a
var c=a
var d=a
var e={0,1}

0,0,0,e,1,2
0,0,0,a,2,a
0,0,1,0,a,a
0,0,2,0,2,1
0,0,1,a,1,1
0,0,1,2,b,1
0,a,b,c,d,1
1,0,0,0,a,0
1,0,1,2,2,2
1,0,a,1,a,0
1,1,2,1,2,2
1,1,2,2,2,0
2,0,0,0,e,e
2,0,1,2,1,1
2,0,2,1,2,1
2,1,1,1,2,1

Code: Select all

@RULE Growth2

@TABLE

n_states:3
neighborhood:vonNeumann
symmetries:rotate4reflect

var a={1,2}
var b=a
var c=a
var d=a
var e={0,1}

0,0,0,e,1,2
0,0,0,a,2,a
0,0,1,0,1,1
0,0,1,a,1,a
0,1,1,1,a,1
0,a,a,2,2,2
e,1,2,1,2,2
0,1,2,2,2,1
1,0,0,0,1,0
1,0,a,1,a,0
1,1,2,2,2,0
2,0,e,0,1,1
2,0,2,0,2,0
2,0,1,1,1,0
2,0,2,1,2,1
2,1,1,1,1,0

A 1-cell seed in Growth2 only gets up to 65, but for 2, 3, and 4-cell seeds I've found patterns that reach 9662, 10020, and 32104, respectively.

Code: Select all

x = 2, y = 4, rule = Growth2
A3$.A!

Code: Select all

x = 6, y = 4, rule = Growth2
4.A3$A4.A!

Code: Select all

x = 11, y = 8, rule = Growth2
5.A2$A$6.A4$10.A!

While the multi-cell seeds for Growth1 are comparatively lacking, the final population for a 1-cell seed in the rule is an impressive 15093!

There go all my records...How did you even find these? (New records: 15903, 15903 (Growth1, place a state 2 cell far away), 15903 (same thing), 32104)

[Rocknlol]

Not a challenge:
I would like a rule where there are 3 live states: Life, virus, and infected life. When cells pass through a virus blob, the cells turn into infected life. Once an infected life cell has 5 or more infected neighbors, it turns into a virus cell, which is stationary.

How would cells "pass through" a virus cell? Would cells born from any infected cells also be infected?

snip

There go all my records...How did you even find these? (New records: 15903, 15903 (Growth1, place a state 2 cell far away), 15903 (same thing), 32104)

I got to those two rules by taking your rule, expanding the table so that it had every transition for its symmetry, and iterating through each transition, changing it if a seed would produce a bigger population. For Growth1, I only changed a transition if the 1-cell seed was larger. For Growth2, I did the same for 2-cell seeds.

I started work on a Growth3 rule, but I stopped halfway through because the script I made to find 3-cell seeds was too slow. I'll restart the search once I've improved its speed.

[fluffykitty]

Rule request

Clarification request

snip

Method of record murder request

I got to those two rules by taking your rule, expanding the table so that it had every transition for its symmetry, and iterating through each transition, changing it if a seed would produce a bigger population. For Growth1, I only changed a transition if the 1-cell seed was larger. For Growth2, I did the same for 2-cell seeds.

I started work on a Growth3 rule, but I stopped halfway through because the script I made to find 3-cell seeds was too slow. I'll restart the search once I've improved its speed.

What did you write the script in? Can it be modified for higher states? (I think 4 states will hit 1 million cells. Maybe even higher than we could ever imagine (or even simulate)) How fast is it? Does it keep searching after it runs out of optimizations to make? Can it be run with different rules? Have you tried running it with the minimal rule (000000, 010002, 020000)? Can you publish it?

Also, note to other people: The two minimal rules for 4-state VN are the 3-state minimal rule and (000000, 010002, 020003, 030000) Also, another (not very) interesting thing: Growth2 only beats Growth1 at 4-cell seeds. Not exactly its intended purpose

[Rocknlol]

What did you write the script in? Can it be modified for higher states? (I think 4 states will hit 1 million cells. Maybe even higher than we could ever imagine (or even simulate)) How fast is it? Does it keep searching after it runs out of optimizations to make? Can it be run with different rules? Have you tried running it with the minimal rule (000000, 010002, 020000)? Can you publish it?

Also, note to other people: The two minimal rules for 4-state VN are the 3-state minimal rule and (000000, 010002, 020003, 030000) Also, another (not very) interesting thing: Growth2 only beats Growth1 at 4-cell seeds. Not exactly its intended purpose

The basic search process went like this:

1. Change one transition rule. This can be automated, but I just used a text editor to do this.

2. Check all valid seeds to see if the current record has been broken. If it has, keep the changed transition. Since there are only a few distinct 1 and 2-cell seeds, automating this step isn't really important for those numbers, but the number of distinct seeds takes off at 3 cells so using a script becomes more necessary for those.

3. Repeat steps 1 and 2 until you've gone a full cycle through all the transition rules without changing any.

In short, most of what I did was manual tweaking. I did use a simple python script to look at 3 and 4-cell seeds, but there's still a lot that I did that could be automated. I'd be happy to post the script, but I'd like to clean it up a bit first, so I'll post it in a couple of days, hopefully along with a new record for the 3-cell seed.

The seed-searching script does have a few limitations, the biggest that it only looks at seeds composed entirely of state 1 cells. That's probably the main obstacle to looking at higher-state rules, the other being that it'd be much more of a pain to do step 1 manually.

Speed was/is also a big obstacle. How the script worked is that is looked at every possible seed without caring about translations, rotations, or reflections, which made for a lot of redundancy. I got rid of that problem with 3-cell seeds by having a different script enumerate all the distinct seeds and just going through a folder with all of them, but the number of distinct 4-cell seeds is large enough that the seeds would either have to be stored in a different way or checked for redundancy on the fly.

I ran it with the minimal rule, but the highest population I could for any n-cell seed was only 5n.

[fluffykitty]

What did you write the script in? Can it be modified for higher states? (I think 4 states will hit 1 million cells. Maybe even higher than we could ever imagine (or even simulate)) How fast is it? Does it keep searching after it runs out of optimizations to make? Can it be run with different rules? Have you tried running it with the minimal rule (000000, 010002, 020000)? Can you publish it?

Also, note to other people: The two minimal rules for 4-state VN are the 3-state minimal rule and (000000, 010002, 020003, 030000) Also, another (not very) interesting thing: Growth2 only beats Growth1 at 4-cell seeds. Not exactly its intended purpose

The basic search process went like this:

1. Change one transition rule. This can be automated, but I just used a text editor to do this.

2. Check all valid seeds to see if the current record has been broken. If it has, keep the changed transition. Since there are only a few distinct 1 and 2-cell seeds, automating this step isn't really important for those numbers, but the number of distinct seeds takes off at 3 cells so using a script becomes more necessary for those.

3. Repeat steps 1 and 2 until you've gone a full cycle through all the transition rules without changing any.

In short, most of what I did was manual tweaking. I did use a simple python script to look at 3 and 4-cell seeds, but there's still a lot that I did that could be automated. I'd be happy to post the script, but I'd like to clean it up a bit first, so I'll post it in a couple of days, hopefully along with a new record for the 3-cell seed.

The seed-searching script does have a few limitations, the biggest that it only looks at seeds composed entirely of state 1 cells. That's probably the main obstacle to looking at higher-state rules, the other being that it'd be much more of a pain to do step 1 manually.

Speed was/is also a big obstacle. How the script worked is that is looked at every possible seed without caring about translations, rotations, or reflections, which made for a lot of redundancy. I got rid of that problem with 3-cell seeds by having a different script enumerate all the distinct seeds and just going through a folder with all of them, but the number of distinct 4-cell seeds is large enough that the seeds would either have to be stored in a different way or checked for redundancy on the fly.

I ran it with the minimal rule, but the highest population I could for any n-cell seed was only 5n.

Wait...you found those rules manually? Replace all mentions of a script in my above post with the "change a transition does it improve a seed? no discard restart yes keep it restart" process. Will you make a script for automatically doing that process? A good feature would be the ability to interrupt a search and restart it later. As for compact storage of seeds, it might be a good idea to represent the position and state of the cells in hexadecimal (1 digit per axis up to 4 cell seeds).

[Rocknlol]

Wait...you found those rules manually? Replace all mentions of a script in my above post with the "change a transition does it improve a seed? no discard restart yes keep it restart" process. Will you make a script for automatically doing that process? A good feature would be the ability to interrupt a search and restart it later. As for compact storage of seeds, it might be a good idea to represent the position and state of the cells in hexadecimal (1 digit per axis up to 4 cell seeds).

It's something I'd like to try, but I'm not totally sure if I'd be up to the task. There was a bit of a lucky break in that in the rule you posted, state 1 cells were much more volatile than state 2 cells, so it wasn't that big of a deal that all the seeds I was looking at had only state 1 cells in them. If a different rule were to be used as a base, or if more states were added, then sorting out the redundant seeds would be much harder.

Automating the whole process is probably something that I'll try to chip away at, but it's likely to get done faster if I polish up what I have and post it on here so someone who's curious about this whole endeavor and has more Python knowledge than I do can make a script that isn't completely jury-rigged.

As for seed storage, putting the coordinates and states of the cells in one big file would probably be the most compact solution. Four-cell seeds are probably the largest one can go, anyway; there're just too many seeds to look at once you get to five cells and up.