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!
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!
What would the rule convert this pattern into?shouldsee wrote:I would like a rule, that converts all 1's pattern into vertical zebra strips.
Code: Select all
x = 5, y = 5, rule = B3/S23
3obo$o$3b2o$b2obo$obobo!
Code: Select all
x = 40, y = 40, rule = B5678/S5:T40,40
5$15bo2$15bo2$15bo$14bobo$14bobo2$14b3o$14b3o!
Code: Select all
x = 40, y = 40, rule = B56/S5:T40,40
12$21bo$21b2o$16bo$18b6o2$18b6o$16bo$21b2o$21bo!
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!
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()
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()
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()
Having way to much free time, I determined that the correct rule is B3i4nt5ey6k73/S1e2k3ey4irt5i. Both phases emulated for fun:muzik wrote:and this?
Code: Select all
x = 6, y = 10, rule = B36/S125 2b2o$2b2o$2o2b2o$2o2b2o$2o2b2o$2o2b2o$2o2b2o$2o2b2o$2b2o$2b2o!
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!
This looks to me a specific class of alternating rulesCaenbe wrote: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?
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
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 wrote:This looks to me a specific class of alternating rulesCaenbe wrote: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, 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.pyCode: Select all
script
BTW, this updating scheme looks intimately related to the Q2R rule classCaenbe wrote: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?
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.
Doesn't tDryLife satisfy this perfectly?Saka wrote:Challenge: A rule where there is a oblique forerake, minimal states.
Oh yeah.BlinkerSpawn wrote:Doesn't tDryLife satisfy this perfectly?Saka wrote:Challenge: A rule where there is a oblique forerake, minimal states.
Code: Select all
@RULE Grow2VN3
@TABLE
n_states:3
neighborhood:vonNeumann
symmetries:rotate4reflect
010002
210001
022002
121200
012221
112222
221201
022222
011101
011111
Code: Select all
x = 9, y = 7, rule = Grow2VN3
A$3.A5$8.A!
929 for 4-cell:fluffykitty wrote: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 rule3-cell pattern: (To get 2 or 1-cell patterns, just remove the rightmost cell(s).)Code: Select all
@RULE Grow2VN3 @TABLE n_states:3 neighborhood:vonNeumann symmetries:rotate4reflect 010002 210001 022002 121200 012221 112222 221201 022222 011101 011111
Code: Select all
x = 9, y = 7, rule = Grow2VN3 A$3.A5$8.A!
Code: Select all
x = 14, y = 11, rule = Grow2VN3
A$3.A5$8.A4$13.A!
Code: Select all
x = 3, y = 1, rule = Grow2VN3
A.A!
Code: Select all
x = 3, y = 3, rule = Grow2VN3
2.A2$A.A!
4-cell can reach at least 943:PHPBB12345 wrote:929 for 4-cell:fluffykitty wrote: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 rule3-cell pattern: (To get 2 or 1-cell patterns, just remove the rightmost cell(s).)Code: Select all
removed with select+backspace
Code: Select all
x = 9, y = 7, rule = Grow2VN3 A$3.A5$8.A!
infinite growth:Code: Select all
x = 14, y = 11, rule = Grow2VN3 A$3.A5$8.A4$13.A!
quadratic growth:Code: Select all
x = 3, y = 1, rule = Grow2VN3 A.A!
Code: Select all
x = 3, y = 3, rule = Grow2VN3 2.A2$A.A!
Code: Select all
x = 16, y = 16, rule = Grow2VN3
A$3.A5$8.A8$15.A!
Code: Select all
x = 15, y = 16, rule = Grow2VN3
A3$.A11$14.A$11.A!
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
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!
Pleeaase somebody pleeaaaseSaka wrote: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.
What are the birth/survival conditions for the life and infected life states?Saka wrote:Pleeaase somebody pleeaaaseSaka wrote: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.
Code: Select all
x = 81, y = 96, rule = LifeHistory
58.2A$58.2A3$59.2A17.2A$59.2A17.2A3$79.2A$79.2A2$57.A$56.A$56.3A4$27.
A$27.A.A$27.2A21$3.2A$3.2A2.2A$7.2A18$7.2A$7.2A2.2A$11.2A11$2A$2A2.2A
$4.2A18$4.2A$4.2A2.2A$8.2A!
LifeGamedziner wrote:What are the birth/survival conditions for the life and infected life states?Saka wrote:Pleeaase somebody pleeaaaseSaka wrote: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.
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 wrote: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):I've also found different two rules where patterns reach some pretty high populations:Code: Select all
x = 15, y = 16, rule = Grow2VN3 A3$.A11$14.A$11.A!
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
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
@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
Code: Select all
x = 2, y = 4, rule = Growth2 A3$.A!
Code: Select all
x = 6, y = 4, rule = Growth2 4.A3$A4.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!Code: Select all
x = 11, y = 8, rule = Growth2 5.A2$A$6.A4$10.A!
How would cells "pass through" a virus cell? Would cells born from any infected cells also be infected?Saka wrote: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.
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.fluffykitty wrote: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 wrote:snip
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?Rocknlol wrote:Clarification requestSaka wrote:Rule 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.fluffykitty wrote:Method of record murder requestRocknlol wrote:snip
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.
The basic search process went like this:fluffykitty wrote: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
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 wrote:The basic search process went like this:fluffykitty wrote: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
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.
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.fluffykitty wrote: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).