These are the smallest (in terms of bits) one cell thick patterns to emit a glider, lightweight (LWSS), middleweight (MWSS) and heavyweight (HWSS) spaceship.

Glider

There are two 15-bit patterns.

Pattern #1 (13 cells alive)

Pattern #1 (RLE)

#CXRLE Pos=0,0
x = 15, y = 1, rule = B3/S23
5ob5ob3o!

Pattern #2 (12 cells alive)

Pattern #2 (RLE)

#CXRLE Pos=0,0
x = 15, y = 1, rule = B3/S23
5ob3o2b4o!

Please refer to 1-Cell Thick Patterns (2) for more information about this patterns.

Lightweight Spaceship

There is one 23-bit pattern.

Pattern #1 (17 cells alive)

Pattern #1 (RLE)

#CXRLE Pos=0,0
x = 23, y = 1, rule = B3/S23
4ob3ob5o4b5o!

It runs for 202 generations and produces the following:

Including the two LWSS.

Middleweight Spaceship

There are four 30-bit patterns.

Pattern #1 (22 cells alive)

Pattern #1 (RLE)

#CXRLE Pos=0,0
x = 30, y = 1, rule = B3/S23
3o2b3o3b3o3b13o!

It runs for 789 generations and produces the following:

Including the two MWSS (and two gliders).

Pattern #2 #4 (21 and 22 cells alive, respectively)

Pattern #2 (RLE)

#CXRLE Pos=0,0
x = 30, y = 1, rule = B3/S23
4o2b6o2b3o4b3ob5o!

Pattern #4 (RLE)

#CXRLE Pos=0,0
x = 30, y = 1, rule = B3/S23
4ob6o3b4o3b3ob5o!

Both run for 215 generations and produce the following:

Including the two MWSS.

Pattern #3 (26 cells alive)

Pattern #3 (RLE)

#CXRLE Pos=0,0
x = 30, y = 1, rule = B3/S23
4ob3ob9ob5ob5o!

It runs for 416 generations and produces the following:

Including the two MWSS (and two gliders).

Heavyweight Spaceship

There is one 30-bit pattern.

Pattern #1 (26 cells alive)

Pattern #3 (RLE)
#CXRLE Pos=0,0
x = 30, y = 1, rule = B3/S23
9o2b3ob5ob9o!

It runs for 914 generations and produces the following:

Including the two HWSS.

And now introducing… Life Letters!

FFNG, FSZE, and, MRNT are the smallest words that produce infinite growth.

Another curious word with the same property is AAPRO.

Perl script for Golly. It generates a given string $letters.

use strict;
my $letters="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
my $length = length($letters);
g_new("LIFE LETTERS");
my $j=0;
for (my $k=0;$k<$length;$k++) {
my $substr = substr $letters, $k, 1;
if ($substr eq 'A') {
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 2, 1);        
g_setcell($j+2, 1, 1);
g_setcell($j+2, 2, 1);
g_setcell($j+2, 3, 1);
g_setcell($j+2, 4, 1);    
$j = $j + 4;                
} elsif ($substr eq 'B') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 2, 1);                    
g_setcell($j+1, 4, 1);
g_setcell($j+2, 1, 1);
g_setcell($j+2, 3, 1);
$j = $j + 4;
} elsif ($substr eq 'C') {
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 4, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 4, 1);            
$j = $j + 4;
} elsif ($substr eq 'D') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 4, 1);
g_setcell($j+2, 1, 1);
g_setcell($j+2, 2, 1);
g_setcell($j+2, 3, 1);            
$j = $j + 4;
} elsif ($substr eq 'E') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 2, 1);
g_setcell($j+1, 4, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 4, 1);            
$j = $j + 4;
} elsif ($substr eq 'F') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 2, 1);
g_setcell($j+2, 0, 1);        
$j = $j + 4;
} elsif ($substr eq 'G') {
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 2, 1);
g_setcell($j+1, 4, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 2, 1);
g_setcell($j+2, 3, 1);
g_setcell($j+2, 4, 1);            
$j = $j + 4;
} elsif ($substr eq 'H') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 2, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 1, 1);
g_setcell($j+2, 2, 1);
g_setcell($j+2, 3, 1);
g_setcell($j+2, 4, 1);            
$j = $j + 4;
} elsif ($substr eq 'I') {
g_setcell($j, 0, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 1, 1);
g_setcell($j+1, 2, 1);
g_setcell($j+1, 3, 1);
g_setcell($j+1, 4, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 4, 1);            
$j = $j + 4;
} elsif ($substr eq 'J') {
g_setcell($j, 3, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 4, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 1, 1);
g_setcell($j+2, 2, 1);
g_setcell($j+2, 3, 1);
g_setcell($j+2, 4, 1);            
$j = $j + 4;
} elsif ($substr eq 'K') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 1, 1);
g_setcell($j+1, 3, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 4, 1);            
$j = $j + 4;
} elsif ($substr eq 'L') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 4, 1);
g_setcell($j+2, 4, 1);            
$j = $j + 4;
} elsif ($substr eq 'M') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 1, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 1, 1);
g_setcell($j+2, 2, 1);
g_setcell($j+2, 3, 1);
g_setcell($j+2, 4, 1);            
$j = $j + 4;
} elsif ($substr eq 'N') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 1, 1);
g_setcell($j+1, 2, 1);
g_setcell($j+1, 3, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 1, 1);
g_setcell($j+2, 2, 1);
g_setcell($j+2, 3, 1);
g_setcell($j+2, 4, 1);            
$j = $j + 4;
} elsif ($substr eq 'O') {
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 4, 1);
g_setcell($j+2, 1, 1);
g_setcell($j+2, 2, 1);
g_setcell($j+2, 3, 1);            
$j = $j + 4;
} elsif ($substr eq 'P') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 2, 1);
g_setcell($j+2, 1, 1);
$j = $j + 4;
} elsif ($substr eq 'Q') {
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 3, 1);
g_setcell($j+1, 4, 1);
g_setcell($j+2, 1, 1);
g_setcell($j+2, 2, 1);
g_setcell($j+2, 3, 1);
g_setcell($j+2, 4, 1);            
$j = $j + 4;
} elsif ($substr eq 'R') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 2, 1);
g_setcell($j+2, 1, 1);
g_setcell($j+2, 3, 1);
g_setcell($j+2, 4, 1);            
$j = $j + 4;
} elsif ($substr eq 'S') {
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 2, 1);
g_setcell($j+1, 4, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 2, 1);
g_setcell($j+2, 3, 1);            
$j = $j + 4;
} elsif ($substr eq 'T') {
g_setcell($j, 0, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 1, 1);
g_setcell($j+1, 2, 1);
g_setcell($j+1, 3, 1);
g_setcell($j+1, 4, 1);
g_setcell($j+2, 0, 1);        
$j = $j + 4;
} elsif ($substr eq 'U') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 4, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 1, 1);
g_setcell($j+2, 2, 1);
g_setcell($j+2, 3, 1);
g_setcell($j+2, 4, 1);        
$j = $j + 4;
} elsif ($substr eq 'V') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j+1, 4, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 1, 1);
g_setcell($j+2, 2, 1);
g_setcell($j+2, 3, 1);            
$j = $j + 4;
} elsif ($substr eq 'W') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 2, 1);
g_setcell($j+1, 3, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 1, 1);
g_setcell($j+2, 2, 1);
g_setcell($j+2, 3, 1);
g_setcell($j+2, 4, 1);            
$j = $j + 4;
} elsif ($substr eq 'X') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 2, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 1, 1);
g_setcell($j+2, 3, 1);
g_setcell($j+2, 4, 1);            
$j = $j + 4;
} elsif ($substr eq 'Y') {
g_setcell($j, 0, 1);
g_setcell($j, 1, 1);
g_setcell($j, 2, 1);
g_setcell($j+1, 2, 1);
g_setcell($j+1, 3, 1);
g_setcell($j+1, 4, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 1, 1);
g_setcell($j+2, 2, 1);        
$j = $j + 4;
} elsif ($substr eq 'Z') {
g_setcell($j, 0, 1);
g_setcell($j, 3, 1);
g_setcell($j, 4, 1);
g_setcell($j+1, 0, 1);
g_setcell($j+1, 2, 1);
g_setcell($j+1, 4, 1);
g_setcell($j+2, 0, 1);
g_setcell($j+2, 1, 1);
g_setcell($j+2, 4, 1);        
$j = $j + 4;
}
}

Using the standard ‘life digits‘ these are the smallest numbers that can produce infinite growth for each base from 2 to 10:

Base 02: 16-digits: 0011001000100011
Base 03: 11-digits: 21011121122
Base 04: 10-digits: 0023321310
Base 05: 08-digits: 40101123
Base 06: 07-digits: 0253033
Base 07: 07-digits: 0051165
Base 08: 07-digits: 140732
Base 09: 07-digits: 140732
Base 10: 06-digits: 140732

Surprise! Dean Hickerson thought that the smallest number that produces infinite population growth was 154299.

“Using the standard ‘life digits‘ what is the smallest number base that can produce infinite growth?”

asks knightlife in a post at ConwayLife.com.

As always, a quick modification of my script in Perl for Golly, wait 7 minutes and… profit.

The string in question is 0011001000100011 and has 16 “bits“.

Pattern (RLE)

#CXRLE Pos=0,0
x = 51, y = 5, rule = B3/S23
3ob3obobob3ob3obob3ob3ob3obob3ob3ob3obobo$obobobobobobobobobobobobobob
obobobobobobobobobobobo$obobobobobobobobobobobobobobobobobobobobobobob
obobo$obobobobobobobobobobobobobobobobobobobobobobobobobo$3ob3obobob3o
b3obob3ob3ob3obob3ob3ob3obobo!

It produces two block-laying switch engines, and achieves stability at generation 1507:

And also, happy birthday to me!

It is time for a list of the patterns that have maximum final noninfinite population for each minimal bounding box.

1 x 39

Pattern (RLE)

#CXRLE Pos=0,0
x = 39, y = 1, rule = B3/S23
3o7b4ob5ob4o2b4o2b6o!

It runs for 13617 generations and produces the following:

Final population: 3866 cells (including, thirty-eight gliders).

2 x 12

Pattern (RLE)

#CXRLE Pos=0,0
x = 12, y = 2, rule = B3/S23
4b3o3b2o$4o2bob4o!

It runs for 8854 generations and produces the following:

Final population: 2194/2202/2218 cells [note the pulsar] (including, thirty-nine gliders).

3 x 9

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
o2b2ob3o$2o3bo2bo$4ob4o!

It runs for 14121 generations and produces the following:

Final population: 2660/2663 cells  (including, forty-one gliders and a spaceship).

4 x 7

Pattern (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
bob2obo$2o2b2o$ob2o$2o2bobo!

It runs for 14988 generations and produces the following:

Final population: 2697/2695 cells  (including, forty-six gliders).

5 x 5

There are two patterns:

Pattern #1 (RLE)

#CXRLE Pos=0,0
x = 5, y = 5, rule = B3/S23
o2b2o$obobo$ob3o$o3bo$ob3o!

Pattern #2 (RLE)

#CXRLE Pos=0,0
x = 5, y = 5, rule = B3/S23
o2b2o$obobo$2ob2o$o3bo$ob3o!

They run for 6582 generations and produce the following:

Final population: 1990 cells  (including, thirty-three gliders).

In this post, I resume the study of the minimum length of an n-cell thick pattern that exhibits infinite growth.

Details on 4-cell thick patterns were pending.  Find out about them here.

4-cell thick

There are thirty-one minimum-length 4-cell thick patterns that exhibit infinite growth. They fit inside a 4 x 7 rectangle.

• Pattern #1 #3 #30 (15, 15, and 14 alive cells, respectively)

Pattern #1 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
5b2o$2b5o$2o2bobo$obob2o!

Pattern#3 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
5b2o$ob5o$bo2bobo$obob2o!

Pattern#30 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
o2b2obo$2bo3bo$bo3b2o$o2b4o!

They produce a block-laying switch engine, and achieve stability at generation 2780:

The final population includes eleven gliders.

• Pattern #2 #5 #6 #7 #8 #9 #10 #11 #15 #16 #18 #28 #29 (14, 14, 15, 14, 15, 14, 15, 13, 14, 15, 14, 16, and 16 alive cells, respectively)

Pattern #2 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
5b2o$o2b2obo$2bo2bo$6o!

Pattern #5 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
4b3o$bo2bobo$2bo2bo$6o!

Pattern #6 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
4b3o$bo2b3o$2bo3bo$6o!

Pattern #7 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
4b3o$b2obobo$5bo$6o!

Pattern #8 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
4b3o$b2ob3o$6bo$6o!

Pattern #9 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
4b3o$obobobo$5bo$6o!

Pattern #10 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
4b3o$obob3o$6bo$6o!

Pattern #11 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
3bo2bo$bobo2bo$o2bob2o$ob2obo!

Pattern #15 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
2bob3o$bo2bobo$5bo$6o!

Pattern #16 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
2bob3o$bo2b3o$6bo$6o!

Pattern #18 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
2b2obo$2obob2o$b2o3bo$obo3bo!

Pattern #28 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
b6o$o$2o2bobo$3obobo!

Pattern #29 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
b6o$o3bo$2o2bobo$3o3bo!

They produce a block-laying switch engine, and achieve stability at generation 656, (658 for pattern #11, #18):

The final population includes two gliders.

• Pattern #4 (13 alive cells)

Pattern #4 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
4b3o$bo2bo$2o3b2o$obob2o!

It produces a glider-making switch engine, and achieves stability at generation 825:

• Pattern #12 (17 alive cells)

Pattern #12 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
3bo2bo$4ob2o$2b2o2bo$4ob2o!

It produces a block-laying switch engine, and achieves stability at generation 514:

The final population includes one glider.

• Pattern #13 (14 alive cells)

Pattern #13 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
3b2o$o2bob2o$ob2obo$3o3bo!

It produces a block-laying switch engine, and achieves stability at generation 2089:

The final population includes six gliders.

• Pattern #14 #17 (11, and 11 alive cells, respectively)

Pattern #14 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
2bo2bo$o2bobo$o2bobo$o4b2o!

Pattern #17 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
2b2obo$o4bo$o2bobo$o4b2o!

It produces a block-laying switch engine, and achieves stability at generation 428:

There are no gliders in the final population.

• Pattern #19 #20 (15, and 15 alive cells, respectively)

Pattern #19 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
2b3obo$b2o2b2o$3ob2o$o4bo!

Pattern #20 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
bo4bo$b2ob3o$2o2bo$ob3obo!

They produce a block-laying switch engine, and achieve stability at generation 5534:

The final population includes sixteen gliders.

• Pattern #21 #27 (15, and 12 alive cells, respectively)

Pattern #21 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
bo3bo$b4obo$2bo2b2o$2ob2obo!

Pattern #27 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
b2o3bo$bobo2bo$o5bo$obob2o!

It produces a block-laying switch engine, and achieves stability at generation 2914 (2913 for pattern #27):

The final population includes four gliders.

• Pattern #22 #23 #24 (14, 14, and 13 alive cells, respectively)

Pattern #22 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
bo3bo$o2b4o$o3bo$3o2b2o!

Pattern #23 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
bo3bo$o2b4o$o3b2o$3o3bo!

Pattern #24 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
bo3b2o$o2b3o$o3bo$3o2bo!

They produce a block-laying switch engine, and achieve stability at generation 915:

The final population includes five gliders.

• Pattern #25 (16 alive cells)

Pattern #25 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
bobobo$2bo2bo$4o2bo$3ob3o!

It produces a block-laying switch engine, and achieves stability at generation 4697:

The final population includes eighteen gliders.

• Pattern #26 (15 alive cells)

Pattern #26 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
bob3o$b2o3bo$bo3b2o$obob3o!

It produces a glider-making switch engine, and achieves stability at generation 1291:

• Pattern #31 (16 alive cells)

Pattern #31 (RLE)

#CXRLE Pos=0,0
x = 7, y = 4, rule = B3/S23
obo2b2o$b3o2bo$4bobo$3ob3o!

It produces a block-laying switch engine, and achieves stability at generation 3799:

The final population includes eight gliders.

Couldn’t hold my curiosity any longer: “What is the minimum length of an n-cell thick pattern that exhibits infinite growth?”

From November 1997 to October 1998 Paul Callahan found several compact patterns that exhibit infinite growth. Two of these patterns give useful upper and a lower bounds, respectively.

1-cell thick

Minimum-length pattern that exhibits infinite growth:  1 x 39

5-cell thick

Minimum-length 5-cell thick pattern that exhibits infinite growth: 5 x 5

What’s in between 1-cell thick and 5-cell thick patterns? How about 2-cell thick, 3-cell thick, and 4-cell thick patterns? I have modified my script in Perl for Golly to explore this question.

See details below for 2-cell thick and 3-cell thick patterns…

2-cell thick

There is only one minimum-length 2-cell thick pattern that exhibits infinite growth and fits inside a 2 x 12 rectangle. Initially, there are 17 alive cells.

Pattern (RLE)

#CXRLE Pos=0,0
x = 12, y = 2, rule = B3/S23
o2b2ob4obo$6ob2o2bo!

It produces a block-laying switch engine, and achieves stability at generation 2638:

The final population includes five gliders.

3-cell thick

There are twenty minimum-length 3-cell thick patterns that exhibits infinite growth and fit inside a 3 x 9 rectangle.

• Pattern #1 (initially, there are 12 alive cells)

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
7b2o$5bobo$3ob5o!

It produces a block-laying switch engine, and achieves stability at generation 2338:

The final population includes nine gliders.

• Pattern #2 (initially, there are 14 alive cells)

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
6b3o$bob2o2bo$4obob2o!

It produces a glider-making switch engine, and achieves stability at generation 8084:

• Pattern #3 (initially, there are 15 alive cells)

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
3bo4bo$5ob3o$o2b2o2b2o!

It produces a block-laying switch engine, and achieves stability at generation 995:

The final population includes five gliders.

• Pattern #4 #5 (initially, there are 18 alive cells)

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
3b3o2bo$o2bob3o$9o!

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
3b3obo$o2bob3o$9o!

Both produce the same glider-making switch engine, and achieve stability at generation 3454:

• Pattern #6 (initially, there are 16 alive cells)

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
2bo4b2o$3o2b2obo$obob5o!

It produces a block-laying switch engine, and achieves stability at generation 4589:

The final population includes nineteen gliders.

• Pattern #7 (initially, there are 17 alive cells)

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
b2o4b2o$3ob3obo$obo2b4o!

It produces a glider-making switch engine, and achieves stability at generation 1480:

• Pattern #8 (initially, there are 16 alive cells)

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
b2o2b2obo$o2b2o2b2o$3obo2b2o!

It produces a block-laying switch engine, and achieves stability at generation 657:

The final population includes two gliders.

• Pattern #9 (initially, there are 17 alive cells)

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
b2o2b4o$3ob3obo$obo4b2o!

It produces a glider-making switch engine, and achieves stability at generation 1231:

• Pattern #10 #16 #17 (initially, there are 14, 15, and 16 alive cells)

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
b2ob2o2bo$2ob2ob2o$o2bo4bo!

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
o4bo2bo$b2ob2ob2o$o2b2ob3o!

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
o4bob2o$b4o2b2o$o2b2ob3o!

They produce a glider-making switch engine, and achieve stability at generation 2147:

• Pattern #11 #12 #13 #14 (initially, there are 16, 17, 18 and 18 alive cells, respectively)

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
b3ob3o$2obobob2o$o2bo3b2o!

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
b3ob4o$2obobob2o$2o3bo2bo!

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
b3ob4o$2obobob2o$2o2bo2b2o!

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
b3ob4o$2ob3ob2o$2o5b2o!

They produce the same glider-making switch engine that achieves stability at generation 4883:

• Pattern #15 (initially, there are 16 alive cells)

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
b4o2b2o$b2obobo$obobob3o!

It produces a block-laying switch engine, and achieves stability at generation 1883:

The final population includes three gliders and a lightweight spaceship.

• Pattern #18 #19 (initially, there are 16 and 16 alive cells, respectively)

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
o3b3obo$2b2o2b3o$3ob2o2bo!

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
o3b3obo$2b2obob2o$3obobobo!

They produce a block-laying switch engine, and achieve stability at generation 2873:

The final population includes five gliders.

• Pattern #20 (initially, there are 16 alive cells)

Pattern (RLE)

#CXRLE Pos=0,0
x = 9, y = 3, rule = B3/S23
o2b2o2b2o$ob2ob2obo$2o2bobobo!

It produces a glider-making switch engine, and achieves stability at generation 2918:

“What’s the smallest one cell high pattern to emit a glider?”

asks Macbi in a post at ConwayLife.com

I have modified my script in Perl for Golly, which explored all possible one-cell thick patterns, in order to provide a specific answer to the previous question.

It took five seconds to get the results…

My preliminary approach was to to detect escaping gliders

The shortest patterns that produce escaping gliders are the following two 15-bit patterns:

Pattern #1

Pattern (RLE)

#CXRLE Pos=0,0
x = 15, y = 1, rule = B3/S23
5ob5ob3o!

Initially, there are 13 alive cells. The pattern runs for 522 generations and produces this:

Final population: 150 cells (including four gliders).

Pattern #2

Pattern (RLE)

#CXRLE Pos=0,0
x = 15, y = 1, rule = B3/S23
5ob3o2b4o!

Initially, there are 12 alive cells. As shown in the previous post, the pattern runs for 3183 generations and produces this:

Final population: 1059 cells (including six gliders).

Recently, I have programmed a script in Perl for Golly. It explores all possible patterns of height 1. The method is the exhaustive enumeration of sequences that don’t contain any isolated live cells or pairs of live cells.

This task has been done before by Paul Callahan in October 1998, when he did an exhaustive search to find the smallest undimensional example which exhibits infinite growth (that is, the population tends to infinity, or at least is unbounded). However, it seems that the only result he reported to a private mailing list of Life enthusiasts was the one that he was searching for: a 39×1 pattern that produces two block-laying switch engines.

I ignore how much time Callahan needed to generate such a discovery, but with today’s computers, we can accomplish this feat in less than two days. (Assume a well-designed script that also ignores patterns with only a mix of 3 and/or 4-cell groups; note that removing symmetrical patterns also helps to improve the overall speed.)

The purpose here is to comment on the patterns that my script found in terms of their increasing final population.

7-bit patterns

The first and only pattern that verifies the restrictions above is the following:

Pattern (RLE)

#CXRLE Pos=0,0
x = 7, y = 1, rule = B3/S23
7o!

It runs for 14 generations and produces the following:

Four beehives. Final population: 24 cells.

8-bit patterns

There is a pattern with larger final population:

Pattern (RLE)

#CXRLE Pos=0,0
x = 8, y = 1, rule = B3/S23
8o!

It runs for 48 generations and produces this:

Final population: 40 cells.

9 and 10-bit patterns

Adding 1 or 2 bits does not produce patterns with higher nor equal final population with respect to the 8-bit case.

11-bit patterns

There is a pattern with larger final population:

Pattern (RLE)

#CXRLE Pos=0,0
x = 11, y = 1, rule = B3/S23
7ob3o!

It runs for 185 generations and produces the following:

Curiously enough, the initially asymmetrical pattern becomes symmetrical (this happens at generation 24).

“Patterns with no initial symmetry tend to become symmetrical. Once this happens the symmetry cannot be lost, although it may increase in richness.”
Martin Gardner, The fantastic combinations of John Conway’s new solitaire game “life”
Scientific American 223 (October 1970): 120-123.

Final population: 104 cells.

12, 13, and 14-bit patterns

Again, adding up to 3 bits does not produce patterns with higher nor equal final population with respect to the 11-bit case.

15-bit patterns

There is a pattern with larger final population:

Pattern (RLE)

#CXRLE Pos=0,0
x = 15, y = 1, rule = B3/S23
5ob3o2b4o!

Note that 15-bit does not mean 15-cell (live cells and dead cells are bits). It runs for 3183 generations and produces this:

It reminds me of a bat. Final population: 1059 cells (including six gliders).

16, 17, and 18-bit patterns

Again, adding up to 3 bits does not produce patterns with higher nor with equal final population with respect to the 15-bit case.

19-bit patterns

The only interesting pattern is:

Pattern (RLE)

#CXRLE Pos=0,0
x = 19, y = 1, rule = B3/S23
5ob3o2b4ob3o!

After 37 generations this 17-bit pattern becomes something identical to the above-mentioned 15-bit pattern after 37 generations also. The number of interesting generations and final population are thus the same in both cases. Note that both patterns are similar except for the additional blinker.

20 and 21-bit patterns

No patterns with higher/equal final population with respect to the 19-bit case.

22-bit patterns

The only interesting pattern is:

Pattern (RLE)

#CXRLE Pos=0,0
x = 22, y = 1, rule = B3/S23
5ob3o2b4o4b3o!

After 118 generations this 22-bit pattern becomes identical to the above-mentioned 15-bit pattern after 118 generations also. The number generations and final population are the same in both cases. Note that again, both patterns are similar except for the additional blinker.

23-bit patterns

The only interesting pattern is:

Pattern (RLE)

#CXRLE Pos=0,0
x = 23, y = 1, rule = B3/S23
5ob3o3b3o2b6o!

After 13 generations this 23-bit pattern becomes equal to the above-mentioned 15-bit pattern after 13 generations also. Same number of generations and final population ensues. Note that again, both patterns are similar except for 3-cell & 5-cell combination that in the long term behaves identically to a 4-cell.

This is the last occurrence of a relative of that 15-bit pattern relative.

24-bit patterns

There is a pattern with larger final population:

Pattern (RLE)

#CXRLE Pos=0,0
x = 24, y = 1, rule = B3/S23
5o2b4o2b3o5b3o!

It runs for 5029 generations and produces the following:

Final population: 1206 cells (including twenty-two gliders).

25-bit patterns

There is a pattern with larger final population:

Pattern (RLE)

#CXRLE Pos=0,0
x = 25, y = 1, rule = B3/S23
8o3b4o2b3o2b3o!

It runs for 5685 generations and produces the following:

Final population: 1804 cells (including again twenty-two gliders).

26 and 27-bit patterns

No patterns with higher/equal final population with respect to the 25-bit case.

28-bit patterns

There is a pattern with larger final population:

Pattern (RLE)

#CXRLE Pos=0,0
x = 28, y = 1, rule = B3/S23
3ob5ob3o2b8o2b3o!

It runs for 5909 generations and produces this:

Final population: 1888 cells (including twenty-four gliders).

29-bit patterns

No patterns with higher/equal final population with respect to the 28-bit case.

30-bit patterns

There is a pattern with larger final population:

Pattern (RLE)

#CXRLE Pos=0,0
x = 30, y = 1, rule = B3/S23
4o4b4o3b11ob3o!

It runs for 4770 generations and produces the following:

Final population: 2116 cells (including eighteen gliders).

31 and 32-bit patterns

No patterns with higher/equal final population with respect to the 30-bit case.

33-bit patterns

There are two patterns that produce the same, larger, final population:

Pattern (RLE)

#CXRLE Pos=0,0
x = 33, y = 1, rule = B3/S23
3ob5o4b3o2b9o3b3o!

Pattern (RLE)

#CXRLE Pos=0,0
x = 33, y = 1, rule = B3/S23
4ob8o4b4ob5ob5o!

The first one runs for 6387 generations while the second one runs for 6385 generations. After 64 generations the output of the first pattern becomes the same as the output of the second pattern after 62 generations (but shifted to the left by one cell). Both patterns produce the same output:

Final population: 2332 cells (including twenty-four gliders).

34-bit patterns

There is a pattern with larger final population:

Pattern (RLE)

#CXRLE Pos=0,0
x = 34, y = 1, rule = B3/S23
7ob3ob8ob4ob4ob3o!

It runs for 9362 generations and produces the following:

Final population: 2642 cells (including twenty-six gliders and four spaceships).

35-bit patterns

There is a pattern with larger final population:

Pattern (RLE)

#CXRLE Pos=0,0
x = 35, y = 1, rule = B3/S23
6ob3ob8o5b5o3b3o!

It runs for 12543 generations and produces the following:

Final population: 3072 cells (including thirty six gliders).

36-bit patterns

There is a pattern with larger final population:

Pattern (RLE)

#CXRLE Pos=0,0
x = 36, y = 1, rule = B3/S23
8o2b3ob4o2b6o2b3o2b3o!

It runs for 7784 generations and produces the following:

Final population: 3164 cells (including, again, thirty six gliders).

37-bit patterns

There is a pattern with larger final population:

Pattern (RLE)

#CXRLE Pos=0,0
x = 37, y = 1, rule = B3/S23
5o2b8ob4o3b3ob5o2b3o!

It runs for 9720 generations and produces the following:

Final population: 3384 cells (including, again, thirty six gliders).

38-bit patterns

There is a pattern with larger final population:

Pattern (RLE)

#CXRLE Pos=0,0
x = 38, y = 1, rule = B3/S23
6o2b3o2b5o2b5o3b4o2b4o!

It runs for 14911 generations and produces the following:

Final population: 3554 cells (including, forty four gliders).

39-bit patterns

There is a pattern with larger final population. Of course! It is Callahan’s pattern:

Pattern (RLE)

#CXRLE Pos=0,0
x = 39, y = 1, rule = B3/S23
8ob5o3b3o6b7ob5o!

It runs forever. It produces two block-laying switch engines, and achieves stability at generation 1483:

Final population: infinite (including, two gliders and infinite blocks).

]]> http://infinitegrowth.wordpress.com/2008/06/10/unidimensional-patterns/feed/ 1 DvD http://infinitegrowth.wordpress.com/2008/06/10/yet-another-rabbits-relative/ http://infinitegrowth.wordpress.com/2008/06/10/yet-another-rabbits-relative/#comments Tue, 10 Jun 2008 00:51:00 +0000 DvD http://infinitegrowth.wordpress.com/?p=8 ]]>

Rabbits is a 9-cell methuselah (stabilizes at time 17331) found by Andrew Trevorrow (one of the developers of the almighty Golly simulator) in 1986.

The methuselahs section on Dean Hickerson’s Game of Life page is a good source for several rabbits relatives; however I did not find there the following 12-cell pattern, which fits inside a 5×4 square.

Someone probably found this pattern earlier, but I don’t think it has been mentioned before.  It runs for 17426 generations. As far as I know, only three other rabbits relatives last longer than that.

Pattern (RLE)

#CXRLE Pos=0,0
x = 5, y = 4, rule = B3/S23
5o$2bobo$obobo$2o!