Alternating rules

[EricG]

Brian,

I've been intrigued by your rule and pattern collection, but unfortunately, I've been reluctant to run Square Cell once I realized I had to hook up an external keyboard to my Macbook in order to use the numeric keypad versions of "+" and "-". (The macbook doesn't have a numeric keypad.) It may be that ExtremeEnthusiast is (or was) having the same problem. I haven't tried changing your source code, but it looks like a quick fix would be to replace VK_ADD and VK_SUBTRACT in Squarecell.java with some less problematic keys...

Or, if that seems too cheesy.... this stackoverflow page (especially the 2nd answer) gets into the details of the two "+" keys: http://stackoverflow.com/questions/1560 ... g-plus-key
As for the "-" keys, the keycodes (on my machine at least) are 109 on the numeric keypad and 189 on the regular keyboard. Finally, for completeness, Page-Up and Page-Down do work on the mac, using the function key along with the up and down arrows.

For anyone else reading this far, just one of the nice things about Square Cell is that it allows you to work very easily in the Radius 2 neighborhood. And to get back on topic, that includes Brian's Cyclic rule family, in which you can alternate between different Radius 2 neighborhoods.

-- Eric

[bprentice]

Eric,

My software does not support keyboards with missing keys. I wrote this software for my own use so the human interface is setup exactly the way I like it. That being said, it is very easy to change the small set of keys that are used. Simply do the following:

$ cd "Java CA"*/Sq*l/Sq*
$ grep -n VK_ *.java
SquareCell.java if (keyCode == KeyEvent.VK_ENTER)
SquareCell.java else if (keyCode == KeyEvent.VK_N)
SquareCell.java else if (keyCode == KeyEvent.VK_R)
SquareCell.java else if (keyCode == KeyEvent.VK_ADD)
SquareCell.java else if (keyCode == KeyEvent.VK_SUBTRACT)
SquareCell.java if (keyCode == KeyEvent.VK_ENTER)
SquareCell.java else if (keyCode == KeyEvent.VK_SPACE)
SquareCell.java else if (keyCode == KeyEvent.VK_N)
SquareCell.java else if (keyCode == KeyEvent.VK_R)
SquareCell.java else if (keyCode == KeyEvent.VK_LEFT)
SquareCell.java else if (keyCode == KeyEvent.VK_RIGHT)
SquareCell.java else if (keyCode == KeyEvent.VK_UP)
SquareCell.java else if (keyCode == KeyEvent.VK_DOWN)
SquareCell.java else if (keyCode == KeyEvent.VK_ADD)
SquareCell.java else if (keyCode == KeyEvent.VK_SUBTRACT)
SquareCell.java else if (keyCode == KeyEvent.VK_PAGE_UP)
SquareCell.java else if (keyCode == KeyEvent.VK_PAGE_DOWN)
SquareCell.java else if (keyCode == KeyEvent.VK_HOME)

Change any of these lines to your preferences and do:

$ makejar

I changed VK_ADD to VK_EQUALS
and VK_SUBTRACT to VK_MINUS

and it worked as expected.

If you are interested in any of the other programs namely:

Base Square Cell
Hexagonal Cell
Triangular Cell
Billiards
Square Cell 1D
or either of the Applets,

do the same for those.

Brian

[Pteriforever]

In my opinion the program's fairly decent, but really confusing.

[Pteriforever]

B3S348+B2S356 has even more fun stuff than I thought. There are at least four reactions in which a puffer can hit a blinker and reverse direction, but one sends the puffer the other way with just the right timing to perform the same reaction again with its own output. This leads to this awesome growing ship:

Code: Select all

x = 7, y = 42, rule = comb625
2.A.A$.5A$.A.A.A$A5.A2$.A3.A$A5.A$.5A$.A3.A$.A3.A$3.A10$3.A$3.A$3.A8$
.5A$A2.A2.A8$3.A$3.A$3.A!

[Pteriforever]

Might want to try the nearby B3S0348+B2S356 too. A very similar puffer still works, there are two new spaceship velocities, and sometimes naturally occurring guns (!)

Code: Select all

n_states:3
neighborhood:Moore
symmetries:permute
var a={1,2}
var b={1,2}
var c={1,2}
var d={1,2}
var e={1,2}
var f={1,2}
var g={1,2}
var h={1,2}
var s={0,1,2}
var t={0,1,2}
var u={0,1,2}
var v={0,1,2}
var w={0,1,2}
var x={0,1,2}
var y={0,1,2}
var z={0,1,2}
0,1,1,1,0,0,0,0,0,2
1,1,1,1,1,1,1,1,1,2
1,1,1,1,1,0,0,0,0,2
1,1,1,1,0,0,0,0,0,2
1,0,0,0,0,0,0,0,0,2
0,2,2,0,0,0,0,0,0,1
2,2,2,2,2,2,2,0,0,1
2,2,2,2,2,2,0,0,0,1
2,2,2,2,0,0,0,0,0,1
1,s,t,u,v,w,x,y,z,0
2,s,t,u,v,w,x,y,z,0

[bprentice]

George Maydwell introduced his excellent software, ModernCA, here:

viewtopic.php?f=11&t=719#p5048

To allow pattern editing, I coded rule families called "George Maydwell" for Square Cell, Hexagonal Cell and Triangular Cell. These three simulators together with many example patterns based on George's ideas can be obtained here:

http://bprentice.webenet.net/Java%20Squ ... ograms.zip

To view an example load this applet:

http://bprentice.webenet.net/Square%20C ... pplet.html

Select the rule family "George Maydwell" using the New World dialog, set the world to random states, and run the simulation to watch an amazingly complex and beautiful display.

For another example load pattern "User Patterns/EP001.sqc".

Brian Prentice

[Pteriforever]

Code: Select all

x = 80, y = 201, rule = jelly
30.2A2.2A3.2A3.2A2.2A2$32.2A5.2A5.2A$10.2A3.2A2.2A3.2A12.A2.A12.2A3.
2A2.2A3.2A$31.A2.A10.A2.A$10.2A5.2A5.2A6.2A4.A2.A4.2A6.2A5.2A5.2A$9.A
2.A10.A2.A26.A2.A10.A2.A$16.A2.A14.A10.A14.A2.A$9.A2.A3.A2.A3.A2.A5.A
3.A6.A3.A5.A2.A3.A2.A3.A2.A$16.A2.A8.A5.A10.A5.A8.A2.A$16.A2.A8.A3.A
14.A3.A8.A2.A$17.2A11.A18.A11.2A$35.A8.A$35.A.A4.A.A$36.A6.A5$31.A16.
A$28.A22.A$28.A3.A14.A3.A$28.A4.A.A8.A.A4.A$19.2A10.A4.A6.A4.A10.2A$
29.A.A4.A6.A4.A.A$2A2.2A12.A2.A10.A2.A8.A2.A10.A2.A12.2A2.2A$21.2A.A
3.A6.A8.A6.A3.A.2A$2.2A15.2A7.A6.A8.A6.A7.2A15.2A$32.4A8.4A$28.A5.A.A
6.A.A5.A$29.2A3.A.A6.A.A3.2A$21.A2.2A.A24.A.2A2.A2$31.A.A12.A.A$27.A
3.A.A12.A.A3.A2$22.A34.A$23.A.A28.A.A6$24.A.A26.A.A$27.A24.A$24.A30.A
$25.A.A24.A.A$2.2A2.2A64.2A2.2A$30.A18.A$4.2A23.A20.A23.2A21$34.A10.A
$35.A8.A2$33.A12.A$23.A.A5.A3.A8.A3.A5.A.A$25.A5.A3.A8.A3.A5.A$25.A7.
A12.A7.A2$29.A2.A14.A2.A2$29.A2.A14.A2.A$12.2A2.2A44.2A2.2A2$14.2A48.
2A39$15.2A2.2A38.2A2.2A2$17.2A42.2A38$21.2A2.2A26.2A2.2A2$23.2A30.2A
34$27.2A2.2A14.2A2.2A2$29.2A18.2A!

Another pattern for B3S135+B2S5. It's a rake for a different spaceship.

[Sphenocorona]

I came up with a challenge involving alternating rules. The challenge is to find a rule (with at maximum 8 rules it alternates between) that exhibits class 4 type complexity, that has at least one instance of each birth criteria B1, B2, B3, etc. and with as few survival criteria as possible, preferably that all patterns are pheonixes.

[Tropylium]

For a benchmark, a trivial solution can use three rules alternated and two survival conditions overall:
1) A/S
2) A/S
3) B3/S23

Things probably get harder if using B0 is disallowed.

[Sphenocorona]

Yes, B0 is disallowed, initially because it cannot be implemented well with RuleTable or RuleTree formats, and also now due the trivial solution you pointed out.

[bprentice]

I'm not sure that I understand the requirements of the challenge, but is this what you are looking for?

Code: Select all

#Rule = Cyclic 2
#Cycles = 5
#Cycle = 0
#States = 2
#Counts = 9
#SW 0,1
#NW 0,0,0,0,0
#NW 0,1,1,1,0
#NW 0,1,0,1,0
#NW 0,1,1,1,0
#NW 0,0,0,0,0
#RT 0,1,0,0,0,0,0,0,0
#RT 0,0,0,0,0,0,0,0,0
#RT 0,0,1,0,0,0,0,0,0
#RT 0,0,0,0,0,0,0,0,0
#RT 0,0,0,1,0,0,0,0,0
#RT 0,0,1,1,0,0,0,0,0
#RT 0,0,0,0,0,0,1,1,1
#RT 0,0,1,1,0,0,0,0,0
#RT 0,0,0,0,1,1,0,0,0
#RT 0,0,0,0,0,0,0,0,0
#Rows = 3
#Columns = 1
#L A2$A

Brian Prentice

[Sphenocorona]

I'm going to guess that is a SquareCell rule, which means at the moment I can't run it, so I can't verify that. What rules is that alternating and what order, exactly? Because if I know that then I can answer.

[bprentice]

If you have a Java enabled browser, you can run this applet:

http://bprentice.webenet.net/Square%20C ... pplet.html

and load the pattern "User Patterns/O001.sqc".

The rule is B1+B2+B3/S23+B678/S23+B45

[Sphenocorona]

I think I'm missing something there. The rule seems to die out almost completely with no spaceships/gliders; similar to a class 2 rule. I mean one that is more similar to B3/S23 or Rule 110.

[bprentice]

You wrote:

preferably that all patterns are phoenixes

My rule generates many copies of an oscillator, which is almost a phoenix, from a world set to random states.

The Life Lexicon included with Golly states that a ship cannot be a phoenix and that every finite phoenix eventually evolves into an oscillator.

[Sphenocorona]

That's not true for all cellular automata; the most basic counter-example would be Seeds (B2/S), where no cell ever survives to the next generation but there are plenty of spaceships with different speeds.

Also, I'll be posting what the states for Scraps alternate between on that topic later.

[bprentice]

Thanks for clarifying your challenge requirements and for teaching me what phoenix really means. Here is my second attempt:

B18/S8+B27/S58+B36/S05+B45/S14

I modified two lines in Square Cell's source code, ran it and hit the "test new random rule" button a few times and this rule turned up.

If anyone is interested in trying this themselves, let me know and I'll post the modified version of Square Cell on my web site.

[bprentice]

Here is another rule that satisfies your challenge requirements:

B18/S2+B27/S2+B36/S7+B45/S13

and here is an example gun:

Code: Select all

#Rule = Cyclic 2
#Cycles = 4
#Cycle = 0
#States = 2
#Counts = 9
#SW 0,1
#NW 0,0,0,0,0
#NW 0,1,1,1,0
#NW 0,1,0,1,0
#NW 0,1,1,1,0
#NW 0,0,0,0,0
#RT 0,1,0,0,0,0,0,0,1
#RT 0,0,1,0,0,0,0,0,0
#RT 0,0,1,0,0,0,0,1,0
#RT 0,0,1,0,0,0,0,0,0
#RT 0,0,0,1,0,0,1,0,0
#RT 0,0,0,0,0,0,0,1,0
#RT 0,0,0,0,1,1,0,0,0
#RT 0,1,0,1,0,0,0,0,0
#Rows = 54
#Columns = 142
#L 67.A6.A$68.A4.A2$65.A10.A7$58.A24.A2$55.A30.A$56.A28.A3$51.A38.A$52.
#L A36.A2$49.A42.A7$42.A56.A2$39.A62.A$40.A60.A3$2.A12.A110.A12.A$3.A10.
#L A112.A10.A2$A16.A106.A16.A15$A16.A106.A16.A2$3.A10.A112.A10.A$2.A12.
#L A110.A12.A

You can run this applet:

http://bprentice.webenet.net/Square%20C ... pplet.html

and load the pattern "User Patterns/G001.sqc".

[bprentice]

This challenge is turning out to be quite interesting. Here is another rule:

B18/S34+B27/S8+B36/S236+B45/S4

and here is an example diagonal gun:

Code: Select all

#Rule = Cyclic 2
#Cycles = 4
#Cycle = 0
#States = 2
#Counts = 9
#SW 0,1
#NW 0,0,0,0,0
#NW 0,1,1,1,0
#NW 0,1,0,1,0
#NW 0,1,1,1,0
#NW 0,0,0,0,0
#RT 0,1,0,0,0,0,0,0,1
#RT 0,0,0,1,1,0,0,0,0
#RT 0,0,1,0,0,0,0,1,0
#RT 0,0,0,0,0,0,0,0,1
#RT 0,0,0,1,0,0,1,0,0
#RT 0,0,1,1,0,0,1,0,0
#RT 0,0,0,0,1,1,0,0,0
#RT 0,0,0,0,1,0,0,0,0
#Rows = 40
#Columns = 40
#L 16.3A5.3A5.3A2$16.3A5.3A5.3A3$37.A.A$37.A.A$37.A.A6$37.A.A$37.A.A$37.
#L A.A$A.A$A.A$A.A3$37.A.A$37.A.A$37.A.A$A.A$A.A$A.A6$A.A$A.A$A.A3$5.3A
#L 5.3A5.3A2$5.3A5.3A5.3A

You can run this applet:

http://bprentice.webenet.net/Square%20C ... pplet.html

and load the pattern "User Patterns/DG002.sqc".

[c0b0p0]

Here is a nonexplosive alternating rule with a natural puffer in which all patterns are phoenixes. It is the only rule of that type I have found.

Code: Select all

@RULE Phoenix
@TABLE
n_states:3
neighborhood:Moore
symmetries:permute
var a={0,1,2}
var b={a}
var c={a}
var d={a}
var e={a}
var f={a}
var g={a}
var h={a}
var i={1,2}
0,1,1,0,0,0,0,0,0,2
0,1,1,1,1,0,0,0,0,2
0,2,2,2,0,0,0,0,0,1
0,2,2,2,2,2,0,0,0,1
i,a,b,c,d,e,f,g,h,0

The puffer is below. There is no known glider in this rule.

Code: Select all

x = 5, y = 17, rule = Phoenix
2.B$2.B$5B$B.B.B3$B.B.B$5B2$5B$B.B.B5$B.B.B$2.B!

The rule is B24/S + B35/S.

[Alexey_Nigin]

There is no known glider in this rule.

Here is one:

Code: Select all

x = 6, y = 3, rule = Phoenix
A3.2A$A$4.2A!

[c0b0p0]

@Alexey_Nigin: Interestingly enough, though both moving objects have the same engine, they do not have the same speed, as shown below. This could be useful for patterns with exotic growth rates.

Code: Select all

x = 131, y = 10, rule = Phoenix
115.A.A2.A3.A4.2A2$115.A.A2.A3.A4.2A5$A3.2A$A$4.2A!

Here is a glider eater.

Code: Select all

x = 46, y = 9, rule = Phoenix
42.A$43.3A3$40.3A$43.A$A3.2A$A$4.2A!

[BlinkerSpawn]

I've been recently looking into stabilizing B1 rules this way.
The most interesting of the ones I've gone through (which isn't saying much) is B13/S3 - B/S345678.
The only truly interesting pattern in this rule is this one, which is the most orderly breeder I've ever seen:

Code: Select all

x = 53, y = 47, rule = Fizzler
43.2A$44.2A$43.A.2A$42.3A.A$43.A3$42.A$49.2A$50.2A$49.A.2A$48.3A.A$
45.A3.A27$.2A$2.2A$.A.2A$3A.A$.A3$A!

The rule table, for those interested:

Code: Select all

@RULE Fizzler
B13/S3/K012
(Not to be confused with BSFKL notation)
@TABLE
n_states:3
neighborhood:Moore
symmetries:permute

var a = {0,1}
var b = {0,1}
var c = {0,1}
var d = {0,1}
var e = {0,1}
var f = {0,1}
var g = {0,1}
var A = {0,2}
var B = {0,2}
var C = {0,2}
var D = {0,2}
var E = {0,2}
var F = {0,2}
var G = {0,2}
var H = {0,2}

0,1,a,a,0,0,0,0,0,2
1,a,b,0,0,0,0,0,0,0
1,1,1,1,0,0,0,0,0,2
1,1,1,1,1,d,e,f,g,0
2,A,B,0,0,0,0,0,0,0
2,2,2,C,D,E,F,G,H,1

[BlinkerSpawn]

Adding B/S02345678 to get rid of the exploding duoplet allows more spaceship variety and less explosiveness:

Code: Select all

@RULE SafeFizzler
B13/S3 - B/S345678 - B/S2345678
@TABLE
n_states:4
neighborhood:Moore
symmetries:permute

var a = {0,1}
var b = {0,1}
var c = {0,1}
var d = {0,1}
var e = {0,1}
var f = {0,1}
var g = {0,1}
var A = {0,2}
var B = {0,2}
var C = {0,2}
var D = {0,2}
var E = {0,2}
var F = {0,2}
var G = {0,2}
var H = {0,2}
var I = {0,3}
var J = {0,3}
var K = {0,3}
var L = {0,3}
var M = {0,3}
var N = {0,3}
var P = {0,3}
var Q = {0,3}

0,1,a,a,0,0,0,0,0,2
1,a,b,0,0,0,0,0,0,0
1,1,1,1,0,0,0,0,0,2
1,1,1,1,1,d,e,f,g,0
2,A,B,0,0,0,0,0,0,0
2,2,2,C,D,E,F,G,H,3
3,3,0,0,0,0,0,0,0,0
3,I,J,K,L,M,N,P,Q,1

[shouldsee]

I guess it would be nice to have a script calculating the composite B0 rule that behaves identical as if it's alternating between a conjugate of rules.(input_rule and inverse of input_rule).i.e. if we alternate a strobing B0/S-8 rule and its inverse, we will get a non-strobing rule with B-0/S8.

Since Golly is only tricked to emulate B0 as alternating rules, we can't find the composite of B3/S23 with this script. Since its apparent composite (B56/S5) doesn't have a B0, thus ineffective (that's not right, without B0, this is still effective, see edit2).

EDIT1: though B56/S5 doesn't have a B0, but from my experiment it's still equivalent to alternating B3/S23. I haven't found a general proof anywhere yet, but it seems to be the general case that invert_to_B0.py would yield the correct alternating rule, regardless of whether the resultant rule has a B0 or not.

EDIT2:Furthermore, by experimenting with invert_advance.py, the relation of alternating rule is indeed reciprocal for B3/S23. i.e. alternating between B3/S23 and its inverse-rule is equivalent to B56/S5. Interestingly, alternating between B56/S5 and its inverse-rule is equivalent to B3/S23!!!!

NOTE: The study of surface behavior can be dated back earlier.

invert_to_B0.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)
ruleB=rule.split('/')[0][1:]
ruleS=rule.split('/')[1][1:]
S=['S']
B=['B']
for i in range(9):
	if str(i) in ruleB:
		S.append(str(8-int(i)))
	if str(i) in ruleS:
		B.append(str(8-int(i)))

B=''.join(B)
S=''.join(S)
rule='/'.join([B,S])
# g.note(rule)
g.setrule(rule)

B3678/S34678(Day & Night) is invariant under this transformation