1D range-4 B3/S23

[Hdjensofjfnen]

I don't know if you guys have actually found a p4 or p5 yet, but this one is definitely p6:

Code: Select all

x = 27, y = 20, rule = B/S
o2b3o3bob2obob2o3b3o2bo$o2b3o3bobo4b2o3b3o2bo$o2b3o3bo2bob2obo3b3o2bo$
o2b3o3b2obob2obo3b3o2bo$o2b3o3b2o4bobo3b3o2bo$o2b3o3bob2obo2bo3b3o2bo$
o2b3o3bob2obob2o3b3o2bo$o2b3o3bobo4b2o3b3o2bo$o2b3o3bo2bob2obo3b3o2bo$
o2b3o3b2obob2obo3b3o2bo$o2b3o3b2o4bobo3b3o2bo$o2b3o3bob2obo2bo3b3o2bo$
o2b3o3bob2obob2o3b3o2bo$o2b3o3bobo4b2o3b3o2bo$o2b3o3bo2bob2obo3b3o2bo$
o2b3o3b2obob2obo3b3o2bo$o2b3o3b2o4bobo3b3o2bo$o2b3o3bob2obo2bo3b3o2bo$
o2b3o3bob2obob2o3b3o2bo$o2b3o3bobo4b2o3b3o2bo!

I'll take the for us both, I guess.

[testitemqlstudop]

[stupidity redacted]

[testitemqlstudop]

Tip: Compile with "-O3 -Ofast -flto -march=native -mfpmath=both".

Updated code:

Code: Select all

#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <cstdlib>
#include <cstring>
#define USIZE 256

// uncomment to catagolue lifespan
// #define LSP

using namespace std;

class Life
{
public:
    bool Universe[USIZE][2];
    int UID; // the current universe

    Life()
    {
        memset(Universe, 0, sizeof Universe);
        UID = 0;
    }

    void randomise(int s, int e)
    {
        for(int i=s; i<=e; i++)
            Universe[i][UID] = rand()%2;
    }

    bool evolve() // returns whether or not it stabilised as p1: true = stabilised into p1
    {
        bool allOff = true, identical = true;
        int n = (UID + 1) % 2;
        for(int i=0; i<USIZE; i++)
        {
            int nCount = 0;
            for(int j=i-4; j<=i+4; j++)
            {
                if(j < 0 || j == i) continue;
                if(j >= USIZE) break;
                nCount += (int)(Universe[j][UID]);
            }
            if(!Universe[i][UID]) // B
            {
                if(nCount == 3) // 3
                    Universe[i][n] = 1;
                else
                    Universe[i][n] = 0;
            }
            else // S
            {
                if(nCount == 2 || nCount == 3) // 23
                    Universe[i][n] = 1;
                else
                    Universe[i][n] = 0;
            }
            if(Universe[i][n]) allOff = false;
            if(Universe[i][n] != Universe[i][UID]) identical = false;
        }
        UID = n;
        return allOff || identical;
    }

    string print()
    {
        string ans;
        for(int i=0; i<USIZE; i++)
        {
            if(Universe[i][UID]) ans += 'o';
            else ans += '.';
        }
        return ans + '\n';
    }

    void clear()
    {
        memset(Universe, 0, sizeof Universe);
        UID = 0;
    }

    void read(string s)
    {
        clear();
        if(s.length() != USIZE)
        {
            cout << "Invalid string." << endl;
            return;
        }
        for(int i=0; i<USIZE; i++)
            Universe[i][0] = (s[i] == 'o');
        UID = 0;
    }

    bool isperiodic(int period)
    {
        Life copy;
        memcpy(&copy, this, sizeof copy);
        for(int i=0; i<period; i++)
            copy.evolve();
        for(int i=0; i<USIZE; i++)
            if(Universe[i][UID] != copy.Universe[i][copy.UID]) return false;
        return true;
    }
};

#ifdef LSP
int lifespans[51];
#endif

int main()
{
    ofstream out("interesting.txt", ofstream::out | ofstream::app);
    int s=0;
    int p2=0, p3=0, p6=0;
#ifdef LSP
    for(;s < 5000000;)
#else
    for(;;)
#endif
    {
        Life life;
        life.randomise(61, 192);
        int l=0;
        while(!life.evolve() && l < 50) l++;
#ifdef LSP
        lifespans[l]++;
#endif
        if(l == 50)
        {
            if(life.isperiodic(3)) p3++;
            else if(life.isperiodic(2)) p2++;
            else if(life.isperiodic(6)) p6++;
            else
            {
                cout << "Interesting!" << endl;
                cout << life.print();
                out << life.print();
            }
        }
        s++;
        if(s % 100000 == 0)
            cout << s << " soups done, stats: " << p2 << " p2s, " << p3 << " p3s, " << p6 << " p6s" << endl;
    }
#ifdef LSP
    for(int i=1; i<51; i++)
        cout << "Soups that settled in " << i << " generations: " << lifespans[i] << endl;
#endif
}

[Hdjensofjfnen]

Ooo, new stats screen! Like it.
(Also, disregard how many posts I'm just spamming out right now.)
EDIT: Wow! The p2 is rarer than the p6?
EDIT: Final census for the first five million soups.

Code: Select all

100000 soups done, stats: 0 p2s, 3 p3s, 0 p6s
200000 soups done, stats: 0 p2s, 12 p3s, 0 p6s
300000 soups done, stats: 0 p2s, 17 p3s, 0 p6s
400000 soups done, stats: 0 p2s, 23 p3s, 0 p6s
500000 soups done, stats: 0 p2s, 34 p3s, 0 p6s
600000 soups done, stats: 1 p2s, 40 p3s, 0 p6s
700000 soups done, stats: 1 p2s, 47 p3s, 1 p6s
800000 soups done, stats: 1 p2s, 53 p3s, 2 p6s
900000 soups done, stats: 1 p2s, 61 p3s, 3 p6s
1000000 soups done, stats: 1 p2s, 69 p3s, 3 p6s
1100000 soups done, stats: 1 p2s, 73 p3s, 3 p6s
1200000 soups done, stats: 1 p2s, 82 p3s, 3 p6s
1300000 soups done, stats: 1 p2s, 90 p3s, 4 p6s
1400000 soups done, stats: 1 p2s, 91 p3s, 5 p6s
1500000 soups done, stats: 1 p2s, 96 p3s, 5 p6s
1600000 soups done, stats: 1 p2s, 104 p3s, 5 p6s
1700000 soups done, stats: 1 p2s, 104 p3s, 6 p6s
1800000 soups done, stats: 2 p2s, 110 p3s, 6 p6s
1900000 soups done, stats: 2 p2s, 121 p3s, 6 p6s
2000000 soups done, stats: 2 p2s, 124 p3s, 6 p6s
2100000 soups done, stats: 2 p2s, 132 p3s, 6 p6s
2200000 soups done, stats: 2 p2s, 139 p3s, 8 p6s
2300000 soups done, stats: 2 p2s, 143 p3s, 8 p6s
2400000 soups done, stats: 2 p2s, 152 p3s, 8 p6s
2500000 soups done, stats: 3 p2s, 160 p3s, 9 p6s
2600000 soups done, stats: 4 p2s, 166 p3s, 9 p6s
2700000 soups done, stats: 4 p2s, 172 p3s, 9 p6s
2800000 soups done, stats: 4 p2s, 180 p3s, 9 p6s
2900000 soups done, stats: 4 p2s, 189 p3s, 10 p6s
3000000 soups done, stats: 5 p2s, 193 p3s, 10 p6s
3100000 soups done, stats: 5 p2s, 198 p3s, 10 p6s
3200000 soups done, stats: 5 p2s, 208 p3s, 10 p6s
3300000 soups done, stats: 5 p2s, 217 p3s, 10 p6s
3400000 soups done, stats: 5 p2s, 228 p3s, 12 p6s
3500000 soups done, stats: 5 p2s, 235 p3s, 12 p6s
3600000 soups done, stats: 5 p2s, 243 p3s, 12 p6s
3700000 soups done, stats: 5 p2s, 250 p3s, 12 p6s
3800000 soups done, stats: 5 p2s, 259 p3s, 13 p6s
3900000 soups done, stats: 5 p2s, 268 p3s, 14 p6s
4000000 soups done, stats: 5 p2s, 274 p3s, 14 p6s
4100000 soups done, stats: 5 p2s, 287 p3s, 14 p6s
4200000 soups done, stats: 5 p2s, 294 p3s, 14 p6s
4300000 soups done, stats: 5 p2s, 299 p3s, 14 p6s
4400000 soups done, stats: 5 p2s, 306 p3s, 14 p6s
4500000 soups done, stats: 5 p2s, 309 p3s, 14 p6s
4600000 soups done, stats: 5 p2s, 318 p3s, 14 p6s
4700000 soups done, stats: 5 p2s, 326 p3s, 14 p6s
4800000 soups done, stats: 5 p2s, 334 p3s, 15 p6s
4900000 soups done, stats: 5 p2s, 342 p3s, 15 p6s
5000000 soups done, stats: 5 p2s, 346 p3s, 15 p6s
Soups that settled in 1 generations: 173
Soups that settled in 2 generations: 8791
Soups that settled in 3 generations: 122617
Soups that settled in 4 generations: 663198
Soups that settled in 5 generations: 1140860
Soups that settled in 6 generations: 1049074
Soups that settled in 7 generations: 813496
Soups that settled in 8 generations: 555545
Soups that settled in 9 generations: 292168
Soups that settled in 10 generations: 164023
Soups that settled in 11 generations: 91375
Soups that settled in 12 generations: 48260
Soups that settled in 13 generations: 24174
Soups that settled in 14 generations: 12504
Soups that settled in 15 generations: 6198
Soups that settled in 16 generations: 3746
Soups that settled in 17 generations: 1774
Soups that settled in 18 generations: 853
Soups that settled in 19 generations: 390
Soups that settled in 20 generations: 197
Soups that settled in 21 generations: 107
Soups that settled in 22 generations: 54
Soups that settled in 23 generations: 31
Soups that settled in 24 generations: 13
Soups that settled in 25 generations: 9
Soups that settled in 26 generations: 1
Soups that settled in 27 generations: 1
Soups that settled in 28 generations: 1
Soups that settled in 29 generations: 0
Soups that settled in 30 generations: 0
Soups that settled in 31 generations: 0
Soups that settled in 32 generations: 1
Soups that settled in 33 generations: 0
Soups that settled in 34 generations: 0
Soups that settled in 35 generations: 0
Soups that settled in 36 generations: 0
Soups that settled in 37 generations: 0
Soups that settled in 38 generations: 0
Soups that settled in 39 generations: 0
Soups that settled in 40 generations: 0
Soups that settled in 41 generations: 0
Soups that settled in 42 generations: 0
Soups that settled in 43 generations: 0
Soups that settled in 44 generations: 0
Soups that settled in 45 generations: 0
Soups that settled in 46 generations: 0
Soups that settled in 47 generations: 0
Soups that settled in 48 generations: 0
Soups that settled in 49 generations: 0
Soups that settled in 50 generations: 366

EDIT: Status:

Code: Select all

15000000 soups done, stats: 29 p2s, 1092 p3s, 35 p6s

[Gamedziner]

Code: Select all

x = 27, y = 1, rule = R4,C0,M0,S2..3,B3..3,NM:P2000,1
o2b3o3b2o4bobo3b3o2bo!
#C[[ ZOOM 7 ]]

[praosylen]

The longest c/3 partial:

Code: Select all

x = 32, y = 1, rule = R4,C0,M0,S2..3,B3..3,NM:P2000,1
2o4bo2bo4b2o3b2ob2o2bo4bo!
#C[[ ZOOM 8 ]]

No c/3 ships exist, at least according to my quick script. Will be searching other 1c/N speeds.
EDIT: No 1c/N speeds from 1 to 5 exist. Longest c/5 partial:

Code: Select all

x = 17, y = 1, rule = R4,C0,M0,S2..3,B3..3,NM:P2000,1
2o4b4o2bo2b2o!
#C[[ ZOOM 24 ]]

The c/6 search is taking a while. I'll try reconfiguring my script to search higher displacements as soon as that finishes (assuming it does finish sometime soon).
EDIT: There are no c/6 partials of significant length.

[AforAmpere]

This seems to be a longer C/3 partial:

Code: Select all

x = 32, y = 1, rule = R4,C0,M0,S2..3,B3..3,NM:P2000,1
2o4bo2bo4b2o3b2ob2o2bo4bo2bo4bo!
#C[[ ZOOM 8 ]]

[testitemqlstudop]

Wow, the last one looks honestly promising.

If Catagolue supports toruses in LtL, we can start searching this rule.

[wildmyron]

Code: Select all

x = 27, y = 1, rule = R4,C0,M0,S2..3,B3..3,NM:P2000,1
o2b3o3b2o4bobo3b3o2bo!
#C[[ ZOOM 7 ]]

That's a neat trick. Golly doesn't seem to allow the plane dimensions to be less than the neighbourhood size though. It also doesn't seem to allow bounded grids with one dimension unbounded, presumably because 0<(R*2).

This seems to be a longer C/3 partial:

Code: Select all

x = 32, y = 1, rule = R4,C0,M0,S2..3,B3..3,NM:P2000,1
2o4bo2bo4b2o3b2ob2o2bo4bo2bo4bo!
#C[[ ZOOM 8 ]]

If you look at the length of time the frontend lasts, this is the same as the first one.

If Catagolue supports toruses in LtL, we can start searching this rule.

apgsearch doesn't support toruses. But i remembered that lifelib's ruletables support arbitrary neighbourhoods up to range 6 (or is it 8?) which makes writing a ruletable for this rule an almost trivial exercise. I haven't found the documentation for this functionality so I used KnightGol.table as a reference. It doesn't use variables so I haven't either.

Code: Select all

n_states:2
neighbourhood:[(0,0),(-4,0),(-3,0),(-2,0),(-1,0),(1,0),(2,0),(3,0),(4,0),(0,0)]
symmetries:permute

# Birth on 3 neighbours:
0,1,1,1,0,0,0,0,0,1

# Death on < 2 neighbours:
1,0,0,0,0,0,0,0,0,0
1,1,0,0,0,0,0,0,0,0

# Death on > 3 neighbours:
1,1,1,1,1,0,0,0,0,0
1,1,1,1,1,1,0,0,0,0
1,1,1,1,1,1,1,0,0,0
1,1,1,1,1,1,1,1,0,0
1,1,1,1,1,1,1,1,1,0

Anyone want to come up with a canonical name so that apgsearch doesn't unneccessarily put hauls into different censi?

I was going to offer some options here, but I've made an execution decision instead:
https://catagolue.appspot.com/census/x1r4k2b3s23/8x32

Of course, all the soups would have to be in the symmetry 1x256.

Fortunately that's not true in this case. 1x256 is very inefficient because it requires 9 or 10 32x32 tiles to be active for all soups and the whole 32 rows of all tiles are calculated when there's only one active row. With 8x32 soups only 3 tiles are required and 8 soups are simulated simultaneously. This gives me an effective soup speed of 65k soups/s (about half of testitem's code). The same can be done for 16x16 but 1x16 soups are too small - even 1x32 soups are a bit small as there's only about 4 billion of them. To efficiently search this rule with apgsearch will require a custom soup generation symmetry. I believe something like 24x64 made from 6 sha256 hashes would be suitable. Object separation doesn't work properly in this case which results in a load of meaningless still life apgcodes which should just be ignored. All the apgcodes determined are for vertically aligned patterns. They can simply be rotated in Golly to give the correct pattern.

-- Actually I realised that the efficiency is worse than I estimated above. I was concerned about the statistics for oscillators (about 1/10th as common in the first few hauls), but then I realised that's because the individual soups are about 1/4 the size.

-- The rule name was perhaps not the best choice, because Catagolue strips off the x in the RLE rule name and then strips off the 1 - for whatever reason. What's left looks like a bit like an LtL rulestring but including a k. I'm open to suggestions if anyone thinks this should be changed before uploading hauls to a custom symmetry.

[Saka]

I was going to offer some options here, but I've made an execution decision instead:
https://catagolue.appspot.com/census/x1r4k2b3s23/8x32

I dont know if you've noticed, but I also searched it, although it didnt work as well.
https://catagolue.appspot.com/census/x7x2xb3s23-1d/C1

I'll try 8x32

[wildmyron]

I was going to offer some options here, but I've made an execution decision instead:
https://catagolue.appspot.com/census/x1r4k2b3s23/8x32

I dont know if you've noticed, but I also searched it, although it didnt work as well.
https://catagolue.appspot.com/census/x7x2xb3s23-1d/C1

I'll try 8x32

I hadn't noticed. I don't think it's really worthwhile running this search with the standard soup symmetries - better to run testitem's code instead.

Did you use my ruletable or write it yourself? I seem to remember you've searched a few of these ruletable rules. What is the method you use to import them into apgsearch? I managed to figure something out but mostly from reading the code and lifelib example notebooks.

[Saka]

I hadn't noticed. I don't think it's really worthwhile running this search with the standard soup symmetries - better to run testitem's code instead.

Did you use my ruletable or write it yourself? I seem to remember you've searched a few of these ruletable rules. What is the method you use to import them into apgsearch? I managed to figure something out but mostly from reading the code and lifelib example notebooks.

Yes, the soups are mostly giving still lives and the known oscillators.

Yes, I wrote the ruleTable:

Code: Select all

n_states:2
neighborhood:[(0,0), (-4, 0), (-3, 0), (-2, 0), (-1, 0), (1, 0), (2, 0), (3, 0), (4, 0), (0,0)]
symmetries:permute
0,1,1,1,0,0,0,0,0,1
1,0,0,0,0,0,0,0,0,0
1,1,0,0,0,0,0,0,0,0
1,1,1,1,1,0,0,0,0,0
1,1,1,1,1,1,0,0,0,0
1,1,1,1,1,1,1,0,0,0
1,1,1,1,1,1,1,1,0,0
1,1,1,1,1,1,1,1,1,0

It is saved as B3S23-1D.table in a folder within the apgluxe files.
Searching ruleTables in apgluxe is simple, you just put the path to the ruleTable as the rule, for example

Code: Select all

./apgluxe -n 1000000 -k foo --rule 'rules/B3S23-1D.table'

[wildmyron]

Searching ruleTables in apgluxe is simple, you just put the path to the ruleTable as the rule, for example

Code: Select all

./apgluxe -n 1000000 -k foo --rule 'rules/B3S23-1D.table'

Thank you. That is much simpler than the hoops I was jumping through. Somehow I didn't realize that apgsearch could accept a rule table directly.

We should settle on a name. What does the 'x7x2x' represent in the rulestring? I think it's worth having at least some reference to the range in the rule name - there are just so many things that b3s23-1d could refer to.

[Hunting]

I hadn't noticed. I don't think it's really worthwhile running this search with the standard soup symmetries - better to run testitem's code instead.

Did you use my ruletable or write it yourself? I seem to remember you've searched a few of these ruletable rules. What is the method you use to import them into apgsearch? I managed to figure something out but mostly from reading the code and lifelib example notebooks.

Yes, the soups are mostly giving still lives and the known oscillators.

Yes, I wrote the ruleTable:

Code: Select all

n_states:2
neighborhood:[(0,0), (-4, 0), (-3, 0), (-2, 0), (-1, 0), (1, 0), (2, 0), (3, 0), (4, 0), (0,0)]
symmetries:permute
0,1,1,1,0,0,0,0,0,1
1,0,0,0,0,0,0,0,0,0
1,1,0,0,0,0,0,0,0,0
1,1,1,1,1,0,0,0,0,0
1,1,1,1,1,1,0,0,0,0
1,1,1,1,1,1,1,0,0,0
1,1,1,1,1,1,1,1,0,0
1,1,1,1,1,1,1,1,1,0

Wow, rule table supports specific neighborhood? I thought neighborhood have to be Moore, Von Neumman, Hexagonal and Margolus. Otherwise Golly will report error.

[Saka]

Thank you. That is much simpler than the hoops I was jumping through. Somehow I didn't realize that apgsearch could accept a rule table directly.

We should settle on a name. What does the 'x7x2x' represent in the rulestring? I think it's worth having at least some reference to the range in the rule name - there are just so many things that b3s23-1d could refer to.

Glad to help.

I'm not sure what the xNxN stuff is about, it might be a unique ID so that another ruletable with the same name doesnt get mixed into the census of another ruletable. Perhaps we could use the wolfram rulestring, or something like "1D-R4-B3-S23"?

Wow, rule table supports specific neighborhood? I thought neighborhood have to be Moore, Von Neumman, Hexagonal and Margolus. Otherwise Golly will report error.

It's only for apgluxe/newer.

[Macbi]

I'm running some 1x256 soups. They're slower, but the catagolue page will make more sense.

[testitemqlstudop]

I'll upload some hauls. So what I do is just save Saka's ruletable into a file and after compiling apgluxe, it will automatically upload to x7x2xb3s23-1d/1x256?

In the meantime, here's a ~20M soups/second brute force oscillator searcher, configured to search for p4 and p5 oscillators:

Code: Select all

#include <iostream>
#include <bitset>
#include <iomanip>
using namespace std;

class Life2
{
public:
    uint64_t Universe[2];
    int UID;

    Life2()
    {
        Universe[0] = 0; Universe[1] = 0;
        UID = 0;
    }

    void evolve()
    {
        uint64_t u = Universe[UID];
        // convert into normal GOL, pft!
        // credits to Yan Guidon from hackaday.io
        uint64_t L1 = u >> 3, L2 = u, L3 = u << 3;
        uint64_t S20 = L1 ^ L3, S21 = L1 & L3;
        uint64_t S31 = L1 | L3, S30 = S20 ^ L2;
        S31 = S31 & L2; S31 = S31 | S21;
        uint64_t S0 = (S30>>1) ^ S20;
        S0 = (S30<<1) ^ S0;
        uint64_t S0C = (S30<< 1) | S20;
        uint64_t S20_= (S30<< 1) & S20;
        S0C = (S30>>1) & S0C;
        S0C = S0C | S20_;
        uint64_t S1 = S31>>1 ^ S0C;
        S1 = S31<<1 ^ S1;
        S1 = S21 ^ S1;
        uint64_t INH = S31<<1 & S21;
        uint64_t S1_ = S31<<1 ^ S21;
        uint64_t C2 = S31>>1 & S0C;
        INH = INH | C2;
        uint64_t S2_ = S31>>1 ^ S0C;
        S2_ = S2_ & S1_;
        INH = INH | S2_;

        uint64_t X2 = S0 | L2;
        X2 = X2 & S1;
        X2 = X2 & ~INH; // The result is now in X2
        UID = (UID+1)%2;
        Universe[UID] = X2;
    }

    void print()
    {
        cout << setw(64) << setfill('.') << bitset<64>(Universe[UID]).to_string('.','o');
    }

    void tog(int loc)
    {
        Universe[UID] = Universe[UID] ^ (1 << loc);
    }

    bool isPeriodic(int p)
    {
        Life2 copy; copy.Universe[0] = Universe[UID];
        for(int i=0; i<p; i++)
            copy.evolve();
        return copy.Universe[copy.UID] == Universe[UID];
    }
};

Life2 life;

int p1, p2;
int st, width;

uint64_t total;
int s=0;
bool search(uint64_t start, uint64_t end)
{
    for(uint64_t pat=start; pat<end; pat++)
    {
        life.Universe[0] = (pat << st);
        if(life.isPeriodic(1)) continue;
        if(life.isPeriodic(p1))
        {
            cout << "Found p" << p1 << endl;
            life.print(); cout << endl;
            return 0;
        }
        if(life.isPeriodic(p2))
        {
            cout << "Found p" << p2 << endl;
            life.print(); cout << endl;
            return 0;
        }
        if(pat % 100000000 == 0)
            cout << "At pattern #" << pat << ", total " << end << " patterns, " << ((double)pat/end*100) << "% done" << endl;
    }
    return false;
}

int main()
{
    uint64_t start; cout << "Starting pattern [1]: "; cin >> start;
    uint64_t end; cout << "Ending pattern [1099511627776]: "; cin >> end;
    p1 = 4;
    p2 = 5;
    st = 11;
    width = 40;
    search(start, end);
}

Would it be trivial to modify LLS to search for the oscillators?

[Macbi]

Would it be trivial to modify LLS to search for the oscillators?

I thought about it a bit and don't see any easy way to do it.

[testitemqlstudop]

I mean, the only difference is the neighborhood....

[dani]

I mean, the only difference is the neighborhood....

then why don't you do it

The serious answer is that no software, besides maybe CoordCA, is well suited for arbitrary neighbourhoods. LLS most likely makes a lot of assumptions that only the standard 8 cell Moore neighbourhood has, for example the speed of light.

[77topaz]

Lifelib can handle arbitrary neighbourhoods and combines with apgsearch, though apgsearch requires the neighbourhood to have at least rotate4 symmetry.

[Saka]

Lifelib can handle arbitrary neighbourhoods and combines with apgsearch, though apgsearch requires the neighbourhood to have at least rotate4 symmetry.

No: https://catagolue.appspot.com/census/x7 ... 3-1d/1x256

[wildmyron]

I'll upload some hauls. So what I do is just save Saka's ruletable into a file and after compiling apgluxe, it will automatically upload to x7x2xb3s23-1d/1x256?

Yes, if you name the file "b3s23-1d.table".

In the meantime, here's a ~20M soups/second brute force oscillator searcher, configured to search for p4 and p5 oscillators:

Code: Select all

<snip bit twiddling perf boosted search code

That's a neat application of the CGoL boolean logic iterator. Apparently there's a solution with only 19 operations which is used in apgluxe. https://gitlab.com/apgoucher/lifelib/co ... ca20aa3d61

I ran the latest soup search code for ~8 billion soups. There were no "interesting" patterns found.

[fluffykitty]

Golly-compatible simulation method and all patterns posted in this thread:

Code: Select all

x = 3, y = 59, rule = B3/S23:T3,300+1
2o$b2o4$o$3o2$3o$2bo4$o$3o2$3o2$3o$2bo3$o$3o2$2o2$2o$2bo$2o$bo6$bo$b2o
$o$2bo$3o2$3o$o$2bo$2o$bo4$o$3o2$obo$obo$2bo2$3o$2bo!

[_zM]

1. Easier:

Code: Select all

x = 509, y = 1, rule = B3/S23:T512+3,1
obo5b2ob2ob4ob4ob3o4bo2bobo2b2ob3ob8o2bo2bobo2b2o2bo2bo3bobobo2bo2b4o
4b2obob3o5bobobobob2o3bobob2o2bobo6bo2bo6bo2b2obo3bo2b5ob4o3b4o5bo2b3o
b3obo3b2o7b3ob2obo2bob2o2b3o2b2o3b2obobob6o2b2obo2bobobo2b3o2bob2ob4o
2b5o2b2ob5obo9b2o3bob2o3bob2o2bo2bob2ob2ob2obo4bobo3b4ob2obob5ob3obo5b
2ob4obo2b2obo3bo4bob6ob2o5b2o2bo2b2o5bobob2obo2bo4b3o3b2o2bob2ob4obob
2obob7o2bobob5o2bob4o3bob2ob2ob2obo2bo!

2. I previously explored this rulespace too: viewtopic.php?f=11&t=3120&p=69288#p69288

3. I just found a rule with a spaceship: B2/S12678. Check the right edge here:

Code: Select all

x = 504, y = 1, rule = B2/S12678:T512+3,1
ob2ob5obob4ob3o2b3ob2ob3obo2bo4bobobo3b6o8bo2bo4bobo2bo2b3ob2o4bobo2b
4ob7o2b2ob4o6b4o2bo2b4o3b4o4bo3bobobo2bobobo2bo3bo2bob2obob2o2bo3bo2bo
2bob4ob2obob2obobob3obobob3o2bobob7ob4obo5bo4b9obo3bo2b2o2bobob4o2bo3b
o3b2obob3obo2b2obo2b2o3b2obo2bob3o2bo4b5obobob4obo3b3obobob3o3bo3bob2o
2bob2o4b3o4b5o2bo2bo3bobobo2b3ob3o2bo3b2ob2o2b2ob3o3bo2b7o2bo3bob2obo
3b2ob6o2bob2ob2obobobobob4o2b3ob2o!