New Period 3 Billiard table discovered

[FunnyBeginner]

Hello,
I wrote i search programm for Billiard tables and i found this 3 period patter:

Code: Select all

x = 14, y = 14, rule = B3/S23:P60,60
6b2o$6b2o2$4b6o$3bo6bo$3b2o2b2obo$2obo4bobob2o$2obo2bobobob2o$4b6o2$4b
8o$4bo6bo$7b2o$7b2o!

I post it because I didn't find this patter in the WIKI.
What do you think about it? Can I add it to the WIKI?

Your FunnyBeginner

[FunnyBeginner]

Now i let ran the programm for an hour and found this new period 7:

Code: Select all

x = 14, y = 14, rule = B3/S23:P60,60
6b2o$6b2o2$4b6o$3bo6bo$3bob2o3bo$2obobo2bobob2o$2obo3b2obob2o$3b2o3bob
o$3bo2bo3bo$4b6o2$6b2o$6b2o!

If you are interessted in my little C-programm, i can make it userfriendly and upload it.

[FunnyBeginner]

Here is a 4 period oscillator: A half of a beehive is builded and destroyed inside the box.

Code: Select all

x = 15, y = 13, rule = B3/S23:P60,60
6b2ob2o$6b2ob2o2$4b7o$2obo5bobob2o$2obo2b2o3bob2o$3b2o3bo2bo$2obo2b2o
3bob2o$2obo5bobob2o$4b7o2$4b2ob2o$4b2ob2o!

Another symetric period 4 oscillator:

Code: Select all

x = 15, y = 13, rule = B3/S23:P60,60
6b2ob2o$6b2ob2o2$4b7o$2obo3bo3bob2o$2obo2b3o2bob2o$3bo2bobo2bo$2ob3o3b
3ob2o$2obo7bob2o$4b7o2$4b2ob2o$4b2ob2o!

[twinb7]

I can't say I've seen most of these before!

[FunnyBeginner]

Here is another period 3 with a 7x5 Rotor.

Code: Select all

x = 21, y = 13, rule = B3/S23:P60,60
9b2ob2o$9b2ob2o2$7b7o$3b2obo7bob2o$4bob2o2bo2b2obo$bo2bobo2bobo2bobo2b
o$obobob4ob4obobobo$bo2bobo7bobo2bo$4bo2b7o2bo$3b2o11b2o$7b2ob2o$7b2ob
2o!

[FunnyBeginner]

Period 2 with a 4x7 Rotor:

Code: Select all

x = 15, y = 12, rule = B3/S23
4b2ob2o$4b2ob2o2$4b7o$3bo7bo$3bobo3bobo$2obob2ob2obob2o$2obo7bob2o$4b
7o2$4b2ob2o$4b2ob2o!

[FunnyBeginner]

Now i improved my programm and it can generate such big oscillators:
Its a 9x9 Rotor with a period of 4.

Code: Select all

x = 17, y = 17, rule = B3/S23
4bob2ob2obo$4b2obobob2o2$4b3o3b3o$2obobo5bobob2o$2ob2o2b3o2b2ob2o$3bo
2bo3bo2bo$2obobobobobobo$2obo3bobo3bob2o$3bobobobobobob2o$3bo2bo3bo2bo
$2ob2o2b3o2b2ob2o$2obobo5bobob2o$4b3o3b3o2$4b2obobob2o$4bob2ob2obo!

It was difficult to stabilize because 3 cells of the hull are oscillating too. Fortunally i have snakes
Can a give the name "Big Smiley", if noone discovered this patter before me?

[velcrorex]

Your period 7 seems to have the same rotor as the Burloaferimeter, so I wouldn't entirely call it new.

That said, it's cool you've written a program to search for patterns. Could you share about how your program works?

[FunnyBeginner]

Of course here is the C-Code for the programm. Its in German.
The main idea is that you first create the surrounding. Then it uses brute force and tries every possible configuration of cells inside the box except the 4 corners which must always be dead cells.
Then it calculates the next 10 Positions by apllying the Game of Life rules, so i can find maximal Period 10 Oscillators.
The key is that it doesnt calculates the outside of the patter. It just assumes that it is already stabiliced.
This means that the user must find the stabilisation himself.
The problem is that you cant calculate more than 2^30 different positions (i found the p7 oscilator which has (36-4) inside cells because the last column is empty. I agree that it is basicly the same as the Burloaferimeter).
For bigger structures I use the symetry. This means that i place cells only on the half or even the quater of the field.
The other cells are just copies of the original room.
With this trick I was able to find the 9x9 rotor on a 5x5 field. A 10x10 field would also only requiere a 5x5 original field because the symetry axis is between the cells. In the other case the symetry line is in the middle row and column.
For a 11x11 field you would need an original field of 6x6. This is a bit too much for brute force.
I hope i could give you an idea and if you have questions, feel free to ask

Your (advanced) Beginner

Code: Select all

#include <stdio.h>
#include <stdlib.h>

int Feld[10][15][15];
void Neustart();
void Anzeige(int Tiefe);
void BerechneFeld(int StartZeile,int StartSpalte,int Endzeile, int Endspalte);//berechnet den Teil des Feldes
int PeriodeBestimmen(int StartZeile,int StartSpalte,int Endzeile, int Endspalte);//berechnet moegliche Periode
void OszillatorSuchen(int StartZeile,int StartSpalte,int Endzeile, int Endspalte);
void NaechstesFeld(int StartZeile,int StartSpalte,int Endzeile, int Endspalte);//nachste Moeglichkeit
int FeldNichtLeer(int StartZeile,int StartSpalte,int Endzeile, int Endspalte);
void BillardOszillatorSuchen(int StartZeile,int StartSpalte,int Endzeile, int Endspalte);
void FeldSpeichern();

int Born[9];
int Surv[9];//ob zelle ueberlebt
int AchsenSymetrieY=0;
int AchsenSymetrieX=0;

int main()
{
    Neustart();//leert das Feld und Born Survive setzen
    //OszillatorSuchen(5,5,8,8);
    AchsenSymetrieY=1;
    AchsenSymetrieX=1*AchsenSymetrieY; //nur 1 wenn yAchsensymetrisch auch 1

    BillardOszillatorSuchen(2,2,10,10);
    return 0;
}

void BillardOszillatorSuchen(int StartZeile,int StartSpalte,int Endzeile, int Endspalte)
{
    Neustart();
    int i,j;
    //rand erstellen
    for (i=StartZeile;i<=Endzeile;i++)
    {
        Feld[0][i][StartSpalte-1]=1;
        Feld[0][i][Endspalte+1]=1;
    }
    for (j=StartSpalte;j<=Endspalte;j++)
    {
        Feld[0][StartZeile-1][j]=1;
        Feld[0][Endzeile+1][j]=1;
    }
    Anzeige(0);

    NaechstesFeld(StartZeile,StartSpalte,Endzeile,Endspalte);
    int ZahlDurchlaufe=0;
    int ZahlGefundenerObjekte=0;
    int Periode,MaximalePeriode=0;
    do
    {
        ZahlDurchlaufe++;
        NaechstesFeld(StartZeile,StartSpalte,Endzeile,Endspalte);
        if (FeldNichtLeer(StartZeile,StartSpalte,Endzeile,Endspalte)==0)break;
        BerechneFeld(StartZeile-1,StartSpalte-1,Endzeile+1,Endspalte+1);//innenbereich und rand berechnen
        Periode=PeriodeBestimmen(StartZeile-1,StartSpalte-1,Endzeile+1,Endspalte+1);//checken ob oszilliert
        if (MaximalePeriode<Periode)
            MaximalePeriode=Periode;
        if (Periode>=2)
        {
            ZahlGefundenerObjekte++;
            Anzeige(0);
            printf("Periode ist %d\n",Periode);
            //FeldSpeichern();
        }
    }while(1);
    printf("ZahlDurchlaufe war %d\n",ZahlDurchlaufe);
    printf("ZahlGefundenerObjekte war %d\n",ZahlGefundenerObjekte);
    printf("MaximalePeriode war %d\n",MaximalePeriode);

}

void OszillatorSuchen(int StartZeile,int StartSpalte,int Endzeile, int Endspalte)
{
    Neustart();
    NaechstesFeld(StartZeile,StartSpalte,Endzeile,Endspalte);
    int ZahlDurchlaufe=0;
    int ZahlGefundenerObjekte=0;
    int Periode,MaximalePeriode=0;
    do
    {
        ZahlDurchlaufe++;
        NaechstesFeld(StartZeile,StartSpalte,Endzeile,Endspalte);
        if (FeldNichtLeer(StartZeile,StartSpalte,Endzeile,Endspalte)==0)break;
        BerechneFeld(1,1,13,13);
        Periode=PeriodeBestimmen(1,1,13,13);
        if (MaximalePeriode<Periode)
            MaximalePeriode=Periode;
        if (Periode>=1)
        {
            ZahlGefundenerObjekte++;
            Anzeige(0);
            printf("Periode ist %d\n",Periode);
        }
    }while(1);
    printf("ZahlDurchlaufe war %d\n",ZahlDurchlaufe);
    printf("ZahlGefundenerObjekte war %d\n",ZahlGefundenerObjekte);
    printf("MaximalePeriode war %d\n",MaximalePeriode);

}

int FeldNichtLeer(int StartZeile,int StartSpalte,int Endzeile, int Endspalte)
{
    int i,j;
    for(i=StartZeile;i<=Endzeile;i++)
        for(j=StartSpalte;j<=Endspalte;j++)
        {
            if (Feld[0][i][j]!=0) return 1;
        }
    return 0;//ist leer
}

void FeldSpeichern()
{
    FILE *datei;
    datei=fopen("Geloest.txt","w");
    int i,j;

    for (i=0;i<=14;i++)
    {
        for (j=0;j<=14;j++)
        {
            if (Feld[0][i][j]==1)
                fprintf(datei,"x");
            else
                fprintf(datei,"-");
        }
        fprintf(datei,"\n");

    }

    fclose(datei);

}


void NaechstesFeld(int StartZeile,int StartSpalte,int Endzeile, int Endspalte)
{
    int i,j;
    int MittelSpalte=(Endspalte+StartSpalte)/2;
    int jMax=Endspalte;
    if (1==AchsenSymetrieY)
        jMax=MittelSpalte;//mittelwert

    int MittelZeile=(Endzeile+StartZeile)/2;
    int iMax=Endzeile;
    if (1==AchsenSymetrieX)
        iMax=MittelZeile;

    for(i=StartZeile;i<=iMax;i++)
        for(j=StartSpalte;j<=jMax;j++)
        {
            if ((i==StartZeile||i==Endzeile)&&(j==StartSpalte||j==Endspalte)) continue;//ecken nie ausfuellen
           if (AchsenSymetrieY==0 && AchsenSymetrieX==0)
           {
                Feld[0][i][j]++;
                if (Feld[0][i][j]==2)
                    Feld[0][i][j]=0;
                else
                    return;//fertig
           }
           if (AchsenSymetrieY==1 && AchsenSymetrieX==0)
           {
                Feld[0][i][j]++;
                if (j!=MittelSpalte)//damit nicht das gleiche Feld doppelt ist
                    Feld[0][i][MittelSpalte+(MittelSpalte-j)]++;// weil symetrisch
                if (Feld[0][i][j]==2)
                {
                    Feld[0][i][j]=0;
                    Feld[0][i][MittelSpalte+(MittelSpalte-j)]=0;// weil symetrisch
                }else
                    return;
           }

            if (AchsenSymetrieY==1 && AchsenSymetrieX==1)//die 3. und letzte Moeglichkeit
           {
                Feld[0][i][j]++;
                if (j!=MittelSpalte)//damit nicht das gleiche Feld doppelt ist
                    Feld[0][i][MittelSpalte+(MittelSpalte-j)]++;// weil symetrisch
                if (i!=MittelZeile)
                    Feld[0][MittelZeile+(MittelZeile-i)][j]++;
                if (j!=MittelSpalte && i!=MittelZeile)
                    Feld[0][MittelZeile+(MittelZeile-i)][MittelSpalte+(MittelSpalte-j)]++;//punktsymetrie
                if (Feld[0][i][j]==2)
                {
                    Feld[0][i][j]=0;
                    Feld[0][i][MittelSpalte+(MittelSpalte-j)]=0;
                    Feld[0][MittelZeile+(MittelZeile-i)][j]=0;
                    Feld[0][MittelZeile+(MittelZeile-i)][MittelSpalte+(MittelSpalte-j)]=0;//punktsymetrie
                }
                else
                    return;//fertig
           }

        }

}

int PeriodeBestimmen(int StartZeile,int StartSpalte,int Endzeile, int Endspalte)//berechnet moegliche Periode
{
    int Tiefe,MoeglichePeriode;
    int i,j;
    for (Tiefe=1;Tiefe<=8;Tiefe++)
    {
        MoeglichePeriode=Tiefe;
        for(i=StartZeile;i<=Endzeile;i++)
            for(j=StartSpalte;j<=Endspalte;j++)
            {
                if (Feld[Tiefe][i][j]!=Feld[0][i][j])//wenn nur eine zelle nicht passt
                    MoeglichePeriode=0;//keine periode gefunden
            }
        if (MoeglichePeriode>=1)
            return MoeglichePeriode;

    }
    return 0;

}

void BerechneFeld(int StartZeile,int StartSpalte,int Endzeile, int Endspalte)
{
    int Tiefe,LebendeNachbarn;
    int i,j;
    for (Tiefe=0;Tiefe<=8;Tiefe++)
        for(i=StartZeile;i<=Endzeile;i++)
            for(j=StartSpalte;j<=Endspalte;j++)
            {
                LebendeNachbarn=Feld[Tiefe][i-1][j-1]+Feld[Tiefe][i-1][j]+Feld[Tiefe][i-1][j+1]+Feld[Tiefe][i][j-1]+Feld[Tiefe][i][j+1]+Feld[Tiefe][i+1][j-1]+Feld[Tiefe][i+1][j]+Feld[Tiefe][i+1][j+1];
                if (1==Feld[Tiefe][i][j])//zelle lebt
                    Feld[Tiefe+1][i][j]=Surv[LebendeNachbarn];//falls zelle ueberlebt
                else
                    Feld[Tiefe+1][i][j]=Born[LebendeNachbarn];//zelle war tot, nun vllt geboren
            }

}


void Anzeige(int Tiefe)
{
    printf("\n\n");
    int i,j;
    for (i=0;i<=14;i++)
    {
        printf("\n");
        for (j=0;j<=14;j++)
        {
            if (1==Feld[Tiefe][i][j])
                printf("X");
            else printf("-");
        }
    }
    printf("\n");

}


void Neustart()
{
    Born[0]=0;
    Born[1]=0;
    Born[2]=0;
    Born[3]=1;//bei 3 nachbarn geboren
    Born[4]=0;
    Born[5]=0;
    Born[6]=0;
    Born[7]=0;
    Born[8]=0;

    Surv[0]=0;
    Surv[1]=0;
    Surv[2]=1; //ueberlebt bei 2 oder 3 Nachbarn
    Surv[3]=1;
    Surv[4]=0;
    Surv[5]=0;
    Surv[6]=0;
    Surv[7]=0;
    Surv[8]=0;


    int Tiefe;
    int i,j;
    for (Tiefe=0;Tiefe<=9;Tiefe++)
        for (i=0;i<=14;i++)
            for (j=0;j<=14;j++)
                Feld[Tiefe][i][j]=0;
    return;
}

[mniemiec]

I wrote i search programm for Billiard tables and i found this 3 period patter:

The "meat" of billiard table oscillators is in the rotor (i.e. the cells that change). Most billiard tables have a variety of different stator arrangements, whose differences are usually considered unimportant (except if you want to synthesize a specific one from gliders). This particular P3 is basically a Stillater in a much larger box. In both cases, the rotor is 3/4 of a 2x2 box, with 1 bit on in generations 0+2, and the other two diagonally-connected ones on in generations 1+2.

Now i let ran the programm for an hour and found this new period 7:

This is just a Burloaferimiter in a larger box.

Here is a 4 period oscillator: A half of a beehive is builded and destroyed inside the box.

The rotor of this one looks familiar, although I can't find it on the Wiki. The rotor can be smaller (in terms of population) by replacing the block-pairs on the sides with tubs, and those on the top and bottom with buns and/or bookends.

Another symetric period 4 oscillator:

I don't know if I have seen this one before.

Here is another period 3 with a 7x5 Rotor.

This is just two Stillaters at opposite ends of the same box.

Period 2 with a 4x7 Rotor:

This is a Light Bulb in a larger box.

Its a 9x9 Rotor with a period of 4.

This doesn't look familiar.

A good place to look for known oscillators is Dean Hickerson's oscillator stamp collections, that I believe are available on Paul Callahan's web site.

That said, it's cool you've written a program to search for patterns. Could you share about how your program works?
I wrote a program under DOS many years ago that did something similar. You feed in a template consisting of must-be-alive cells, must-be-dead cells, and mutable cells (plus a few other attributes for rotation and reflections), and it just tries all possibilities, running two copies of the pattern, one every step, and one every other step. Whenever generation n and 2n match, this is a successful period n pattern. It is generally a good idea to surround the field with 2 rows of dead cells, to handle cases where oscillators want to escape the borders of the box. Since such cells are fixed, adding them is essentially free anyway.

If generation n matches generation 0, this is an oscillator; if it doesn't, it's an unstable pattern that eventually stabilizes, and gets discarded. Command-line parameters filter by period (for example, when I'm looking for most things, periods 1 and 2 are too abundant, and not interesting, so I only emit things of periods 3 and higher.) Spaceships can be found by adding an offset between starting and ending generation, although this often finds many false positives that must be filtered out by hand.

I've used this to find things with upwards of 25-28 free cells, but it becomes compuationally very expensive for large sizes. By adding reflections and/or rotations, much larger rotors can be found. I don't recall finding many useful results in Life (as most of the things it found were already known), but the program has found many useful small results in other rules that had not been as thoroughly explored.

I also wrote a variant of it for colorized Life - you feed in a known oscillator or spaceship, and it tries every 2- and 4- colorization of all living cells, outputting all recurring colorizations and discarding any unstable ones.

[FunnyBeginner]

OK, I looked up in Dean Hickerson's collecton and found my oscillators, but not the 9x9 Smiley.
As you wrote a programm, did it use simple brute force on a given area or can it use a sort of backtracking, which also finds all solutions, but much faster.
By the way i wrote a simple still life finder base on a genetic algorithm which finds a still life for a given number of cells. The fitness i measured in the number of unwanted born cells and unwanted dieing cells.
Do you know how to use a genetic algorithm for oscillations or spaceships?

[mniemiec]

OK, I looked up in Dean Hickerson's collecton and found my oscillators, but not the 9x9 Smiley.

This may very well be a new oscillator. Billiard-tables whose sides temporarily collapse aren't technically billiard tables (although, in this case, with the addition of the snakes that totally encapsulate the sides it IS a true billiard table). Nevertheless, such oscillators can be quite interesting on their own. Dave Buckingham's "Extremely Impressive" was the first such oscillator found.

You can also make this one slightly smaller (and also more symmetrical) by using two blocks on each side rather than three:

Code: Select all

x = 17, y = 17, rule = B3/S23
4bob2ob2obo$4b2obobob2o2$4b3o3b3o$3bobo5bobo$3b2o2b3o2b2o$2obo2bo3bo2b
ob2o$2obobobobobobob2o$3bo3bobo3bo$2obobobobobobob2o$2obo2bo3bo2bob2o$
3b2o2b3o2b2o$3bobo5bobo$4b3o3b3o2$4b2obobob2o$4bob2ob2obo!

As you wrote a programm, did it use simple brute force on a given area or can it use a sort of backtracking, which also finds all solutions, but much faster.

No, it uses brute force searching. It does have one optional optimization that should only be turned on for rules with single monolithic birth or survival conditions (e.g. birth on 3-6 is OK, but not 3-4 and 6-7): if any non-viable over-population is found anywhere, it is pointless to add more cells, because over-population can never be remedied. (This is not the case in rules with more than one set of conditions; for example, with birth on 3-4 and 6-7, 5 is not viable, but adding one additional cell yields 6, which is.)

By the way i wrote a simple still life finder base on a genetic algorithm which finds a still life for a given number of cells. The fitness i measured in the number of unwanted born cells and unwanted dieing cells.

My still-life enumerator does not use genetic algorithms (i.e. it uses a single non-adjustable pre-programmed algorithm), but does something similar. Every cell contains a state (0=dead, 1=alive, -1=unspecified - i.e. presumed dead, but may later be changed to definitely dead or definitely alive), a number of living neighbors, and a number of degrees of freedom (i.e. the number of unspecified neighbors). In addition to being arranged in a matrix in the usual way, unspecified cells are also placed in a linked list, in order of stability (which is determined based on state and neighbors) and degrees of freedom.

The program then takes guesses (i.e. try 0 and recurse, then try 1 and recurse) for every unspecified cell. The order ensures that the program attempts to correct unstable cells before stable ones, and then, whenever possible, ones close to the center of the pattern (i.e. with the least degrees of freedom) rather than ones near the edges - it doesn't make sense to have an un-rescuable lump and then attempt to grow longer and longer snake arms on the edges, since that will also be un-rescuable. In most cases, unstable cells with few degrees of freedom cannot be rescued by adding adjacent neighbors, so such cells usually cause subsequent recursion to be abandoned early, before much time is wasted on it. The algorithm is fairly optimal; Peter Raynham's original still-life searcher used to require computation of around O(4^n), while mine is arund O(2.45^n), and since the number of still-lifes appears to be arond O(2.45^n) also, this cannot be improved.

The program essentially grows patterns like crystals that must obey certain rules, fixing the structure in the center, and experimenting with the edges, and fixing them later as the edges expand.

Do you know how to use a genetic algorithm for oscillations or spaceships?

I'm not really that familiar with genetic algorithms. However, my program is currently adapted to find oscillators (and spaceships are partially implemented, but not currently working). Oscillators may be viewed as still-lifes in a cylindrical asymmetric 3D automata, with the three axes of x, y, time, with time looping around. Every cell at position ((t+1)%period,x,y) has 9 neighbors at (t,x+[-1,0,1],y+[-1,0,1]) and relies solely on them, and not itself. This is very similar to growing three-dimensional crystals, as above. The only difference from still-lifes is the neighborhood (and dimension), and the rule used - otherwise, it's the same.

Spaceships are virtually identical to oscillators, except the cylinder has an offset before being joined.

Both oscillators and spaceships with glide symmetry could be searched by adding a twist or a flip where the cylinder connects. This could be especially useful for spaceships - e.g. the four basic Life spaceships are period 4, but modulo 2, so a P2 search could find them.

I can't speak for other search programs, but I've found that mine works well up for still-lifes around 24 bits; in the low 20s, some minor issues arise that need to be addressed manually (e.g. certain pattern geometries for which searching explicitly would greatly increase the search space, and the order of magnitude). For period-2 oscillators, the computation time increases dramatically (since every added bit effectively adds two - one in each generation), and 21 bits took around a week or more to compute. Higher periods are even worse - I've never even be able to search up to 12 bits, at which the first known higher-period oscillators appear. The next smallest ones currently known are 18 bits (pseudo-object - LWSS on LWSS), so unless you have a program that can search significantly learger sizes, the search results will be very sparse.

[FunnyBeginner]

The program essentially grows patterns like crystals that must obey certain rules, fixing the structure in the center, and experimenting with the edges, and fixing them later as the edges expand.

The next smallest ones currently known are 18 bits (pseudo-object - LWSS on LWSS), so unless you have a program that can search significantly learger sizes, the search results will be very sparse.

The idea with the growing seems to be optimal, but you can also start in the left row and not in the center.
Each row of cells is only effected by its neighbors rows. Therefore you can build it row by row.

Code: Select all

x = 5, y = 4, rule = B3/S23:P60,60
bo2bo$obobo$o2b2o$b2obo!

In this exmaple the first 4 rows are correct because they keep the first 3 rows stable.
If the program does not find a 5th row that keeps the 4 first ones stable it return back. It is like solving the 8-Queenspuzzle with backtracking.


Here is an unfinished LWSS:

Code: Select all

x = 4, y = 4, rule = B3/S23:P60,60
bo$o$o$4o!

The first 4 rows are correct and a programm could detect it bacause after 4 generations it moves 2 spaces and the first 2 rows of the spaceship stay correct. This trick can be used to find (un)finished c/3 ships with period 3. I hope you got the idea.

[mniemiec]

The idea with the growing seems to be optimal, but you can also start in the left row and not in the center. Each row of cells is only effected by its neighbors rows. Therefore you can build it row by row.

In practice, most searches are constrained by pre-setting the center cell of the field to alive, everything left of it to dead, and all rows above it to dead - so, effectively, the seed cell is always at the top left corner of the object, and the crystal always grows downward. Allowing upward growth can also be useful in some specialized situations.

[BobShemyakin]

This is my configuration of cells inside the box:

Code: Select all

x = 78, y = 69, rule = B3/S23
2b2obo23b2ob2o$2bob2o23b2ob2o$6b2o$6bo22b7o$7bo20bo7bob2o$6b2o20bo2b3o
2bob2o$2b2obo19b2obobo3bobo$2bob2o19b2obobo3bobob2o$2o26bo2bobo2bob2o$
o24b2ob4ob4o$bo23b2obo2bobo2bo$2o26bobo3bobob2o$2b2obo22bobo3bobob2o$
2bob2o19b2obo2b3o2bo$25b2obo7bo$29b7o2$31b2ob2o$31b2ob2o7$2b2obo25b2o
18b2ob2o$2bob2o25b2o18b2ob2o$6b2o$6bo22b6o14b7o$7bo20bo3bo2bo12bo7bo$
6b2o20b2o4b2o12bob2ob2obo$2b2obo19b2obo6bob2o6b2obo2bobo2bob2o$2bob2o
19b2obobo2bobob2o6b2obo7bob2o$6b2o20bobo2bobo12bo7bo$6bo21bobo2bobo9b
2ob2o5b2ob2o$7bo17b2obo2b2o2bob2o6b2obob2ob2obob2o$6b2o17b2obo6bob2o9b
ob2ob2obo$2b2obo23b6o13bo7bo$2bob2o43b7o$31b2o$31b2o18b2ob2o$51b2ob2o
9$2o4b2o26b2o15bo18b2o$o5bo25bo2bo14bobo17b2o$bo5bo24b3o16bo$2o4b2o60b
6o$2b2obo24b7o12b5o13bobo2bobo$2bob2o23bo3bo3bo10bo5bo12bo6bo$6b2o18bo
2bobo3bobo2bo7bo2b2obo9b2ob2o5bob2o$6bo18bobobo2bobo2bobobo3b2obobobob
ob2o6b2obo2bobobob2o$7bo18bo2b2obobob2o2bo4b2obobo3bob2o9bobo2bobo$6b
2o21bo7bo10bobo3bo9b2obo2bobobob2o$6bo23b7o8b2obobo3bob2o6b2ob2o5bob2o
$7bo37b2obobobobob2o9bo6bo$6b2o24b3o13bo2b2obo12bobo2bobo$31bo2bo13bo
5bo13b6o$31b2o16b5o$70b2o$51bo18b2o$50bobo$51bo!

FunnyBeginner wrote: For bigger structures I use the symetry.

Obviously, you only use mirror. You can also use turn on 180:

Code: Select all

x = 54, y = 43, rule = B3/S23
2b2obo20b2o$2bob2o20b2o$6b2o$6bo17b6o$7bo15bo6bo$6b2o15bob3o2bo$2b2obo
14b2obobo2bobob2o$2bob2o14b2obo4bobob2o$6b2o15bobo2bobo$6bo13b2obobo4b
ob2o$7bo12b2obobo2bobob2o$6b2o15bo2b3obo$2b2obo17bo6bo$2bob2o18b6o2$
26b2o$26b2o9$2o4b2o18b2o18b2o$o5bo19b2o18b2o$bo5bo$2o4b2o16b4o16b6o$2b
2obo17bo4bo14bobo2bobo$2bob2o17bob2obo14bo6bo$6b2o12b2obo2bobob2o8b2ob
2o5bob2o$6bo13b2ob2obobob2o8b2obo2bobobob2o$7bo15bo4bo14bobo2bobo$6b2o
15bo4bo14bobo2bobo$6bo13b2obobob2ob2o8b2obobobo2bob2o$7bo12b2obobo2bob
2o8b2obo5b2ob2o$6b2o15bob2obo14bo6bo$23bo4bo14bobo2bobo$24b4o16b6o2$
24b2o20b2o$24b2o20b2o!

Or turn 90:

Code: Select all

x = 89, y = 70, rule = B3/S23
25b2o2b2o19b2o2b2o2b2o15b2o2b2o2b2o$2b2obo19b2o2b2o19b2o2b2o2b2o15b2o
2b2o2b2o$2bob2o$6b2o15b10o15b12o13b12o$6bo15bo3bo6bo10b2obo12bo8b2obo
7bo4bo$7bo14bob2obo3bobo10b2obob2ob4ob2obo8b2obob2ob2o4bobo$6b2o11b2ob
o2b4ob2obob2o10bob2obo2bob2obob2o8bo2bobob5obob2o$2b2obo13b2obo7bob2ob
2o10bo5bobo4bob2o8bo2bo3bo5bob2o$2bob2o16bo2bob2ob2obo10b2obob3o5b2obo
8b2ob2obo3bo2b2obo$2o20bob2ob2obo2bo10b2obobo6bobobo8b2obo2b3o5bobo$o
18b2ob2obo7bob2o10bobobo6bobob2o8bobo5b3o2bob2o$bo17b2obob2ob4o2bob2o
10bob2o5b3obob2o8bob2o2bo3bob2ob2o$2o20bobo3bob2obo10b2obo4bobo5bo8b2o
bo5bo3bo2bo$2b2obo16bo6bo3bo10b2obob2obo2bob2obo8b2obob5obobo2bo$2bob
2o17b10o14bob2ob4ob2obob2o8bobo4b2ob2obob2o$47bo12bob2o8bo4bo7bob2o$
25b2o2b2o17b12o13b12o$25b2o2b2o$48b2o2b2o2b2o15b2o2b2o2b2o$48b2o2b2o2b
2o15b2o2b2o2b2o6$25b2o2b2ob2o16b2o2b2ob2o$2b2obo19b2o2b2ob2o16b2o2b2ob
2o$2bob2o$6b2o15b11o14b11o$6bo12b2obo9bobo9b2obo11bo$7bo11b2ob2o2bob2o
4bo9b2obo2bob2ob2o2bo$6b2o14bo3b2obo4bob2o9bobob2obo2bobob2o$2b2obo16b
o6bob2obob2o9bobo4bobo2bob2o$2bob2o13b2obob4obobo2bo9b2obo2b3obob2obo$
6b2o11b2obobo7bobo9b2obobo7bobo$6bo15bo2bobob4obob2o9bob2obob3o2bob2o$
7bo11b2obob2obo6bob2o6b2obo2bobo4bobob2o$6b2o11b2obo4bob2o3bo9b2obobo
2bob2obobo$2b2obo16bo4b2obo2b2ob2o9bo2b2ob2obo2bob2o$2bob2o16bobo9bob
2o9bo11bob2o$23b11o14b11o2$23b2o2b2ob2o16b2o2b2ob2o$23b2o2b2ob2o16b2o
2b2ob2o7$25b2o2b2o2b2o$2o4b2o17b2o2b2o2b2o$o5bo$bo5bo15b12o$2o4b2o11b
2obobo6bo3bo$2b2obo13b2obo3b2obo4b2o$2bob2o16bo4bob2o4bob2o$6b2o14b2o
3bo5bobob2o$6bo12b2obo2bobob5obo$7bo11b2obob2obo7bo$6b2o14bo7bob2obob
2o$6bo15bob5obobo2bob2o$7bo11b2obobo5bo3b2o$6b2o11b2obo4b2obo4bo$22b2o
4bob2o3bob2o$22bo3bo6bobob2o$23b12o2$23b2o2b2o2b2o$23b2o2b2o2b2o!

FunnyBeginner wrote: the symetry axis is between the cells. In the other case the symetry line is in the middle row and column.

The symmetry axis may be positioned midway between the cells of the middle row (or column). Then ensue the even-odd patterns:

Code: Select all

x = 68, y = 67, rule = B3/S23
30b2o2b2o$2o4b2o22b2o2b2o$o5bo$bo5bo20b10o$2o4b2o16b2obobo6bobo$2b2obo
18b2obo4b2o4bo$2bob2o21b2o2bo2bo2b2ob2o$6b2o19bobo2b2o2bobob2o$6bo17b
2obo2b2o2b2o2bo$7bo16b2obo4b2o4bo$6b2o19bo2b2o2b2o2bob2o$6bo17b2obobo
2b2o2bobob2o$7bo16b2ob2o2bo2bo2b2o$6b2o19bo4b2o4bob2o$27bobo6bobob2o$
28b10o2$30b2o2b2o$30b2o2b2o8$2b2obo25b2o2b2o19b2o2b2o$2bob2o25b2o2b2o
19b2o2b2o$2o$o28b10o15b10o$bo23b2obo10bo10b2obo10bo$2o23b2obob8obo10b
2obob8obo$2b2obo22bobo6bobob2o10bobo6bobob2o$2bob2o22bobob4obobob2o10b
obobo2bobobob2o$6b2o17b2obo3bo2bo3bo10b2obo3b4o3bo$6bo18b2obo10bo10b2o
bo10bo$7bo20bo3bo2bo3bob2o10bo3b4o3bob2o$6b2o17b2obobob4obobob2o7b2obo
bobo2bobobob2o$2b2obo19b2obobo6bobo10b2obobo6bobo$2bob2o22bob8obob2o
10bob8obob2o$28bo10bob2o10bo10bob2o$29b10o15b10o2$31b2o2b2o19b2o2b2o$
31b2o2b2o19b2o2b2o6$31b2o2b2o$2b2obo25b2o2b2o$2bob2o$2o4b2o21b10o$o5bo
21bo3bo2bo3bo$bo5bo20bobo6bobo$2o4b2o17b2obob2o4b2obob2o$2b2obo19b2obo
2bo4bo2bob2o$2bob2o22b2o8b2o$2o4b2o17b2obo2bo4bo2bob2o$o5bo18b2obob2o
4b2obob2o$bo5bo20bobo6bobo$2o4b2o20bo3bo2bo3bo$2b2obo23b10o$2bob2o$31b
2o2b2o$31b2o2b2o!

FunnyBeginner wrote: For a 11x11 field you would need an original field of 6x6. This is a bit too much for brute force.

In addition to brute force, you can use a little tricks.
Can be excluded from the calculation of the original structure, destroying the external border. Such a condition may be the presence in the first (last) column (row) only a single life in three consecutive cells along the border.
Another trick is to calculate in parts. Today you calculate with a blank first column, tomorrow - with a life in the 2nd cell of the first column, the next day - with a life in the 3 cell of the first column, etc.
You can use the principle of cross-linking, as it does for life on the torus. On the torus as the boundary of the last column (row) is the first column (row). To mirror it for the last column as the boundary to use the last column (symmetry axis between cells) or the penultimate column (symmetry axis in the middle column).
Then the calculation will be carried out only by the original field. Copy only need boundary where cross-linking.

Bob Shemyakin