Strict definitions

[g0t0]

I found that there are no strict definition of one oscillator.

Is this one oscillator?

Code: Select all

x = 15, y = 14, rule = B3/S23
b2o9b2o$o2bo7bo2bo$3o9b3o$3b9o$2bo2b5o2bo$2b2o2b3o2b2o3$2b2o2b3o2b2o$
2bo2b5o2bo$3b9o$3o9b3o$o2bo7bo2bo$b2o9b2o!

What about this?

Code: Select all

x = 17, y = 17, rule = B3/S23
2b2o$o2bo3$2obo$2bobo2b2o$3bo4bo$4bo$4bo2bo2b2o$8bo2bo3$8b2obo$10bobo
2b2o$11bo4bo$12bo$12bo2bo!

I think the first is and the second not.

[NNlk05]

You can use Catagolue's object page to find if two patterns are interacting or not. If they are interacting, then its one object.

[Disaster16439]

You can use Catagolue's object page to find if two patterns are interacting or not. If they are interacting, then its one object.

Catagolue is not fool-proof. Go to say D2_+2 and xp15. There’ll be a lot of bi-pentadecathons, but a lot of them simply don’t interact, however their envelopes do so Catagolue does not separate them.

Edit 1:

Here’s an example:

https://catagolue.hatsya.com/object/xp1 ... zcfc/b3s23

Even worse, the envelopes don’t even overlap, they just touch.

[SecondTypist]

You can use Catagolue's object page to find if two patterns are interacting or not. If they are interacting, then its one object.

Catagolue is not fool-proof. Go to say D2_+2 and xp15. There’ll be a lot of bi-pentadecathons, but a lot of them simply don’t interact, however their envelopes do so Catagolue does not separate them.

Edit 1:

Here’s an example:

https://catagolue.hatsya.com/object/xp1 ... zcfc/b3s23

Even worse, the envelopes don’t even overlap, they just touch.

Code: Select all

#CSYNTH xp15_3v3y24r4z9g9y24r4zcfc costs 7 gliders (pseudo).

[g0t0]

You can use Catagolue's object page to find if two patterns are interacting or not. If they are interacting, then its one object.

Catagolue is not fool-proof. Go to say D2_+2 and xp15. There’ll be a lot of bi-pentadecathons, but a lot of them simply don’t interact, however their envelopes do so Catagolue does not separate them.

Edit 1:

Here’s an example:

https://catagolue.hatsya.com/object/xp1 ... zcfc/b3s23

Even worse, the envelopes don’t even overlap, they just touch.

Code: Select all

#CSYNTH xp15_3v3y24r4z9g9y24r4zcfc costs 7 gliders (pseudo).

The worse case:

Code: Select all

x = 385, y = 259, rule = B3/S23
15$213b2o$212bobo$206b2o4bo$204bo2bo2b2ob4o$204b2obobobobo2bo$207bobob
obo$207bobob2o$208bo2$221b2o$212b2o7bo$212b2o5bobo$219b2o7$209b2o$210b
o$207b3o9b2o$207bo11bobo$219bo10$172bo$172b3o$175bo$174b2o3$166b2o$
166bo$163b2obo49b2o$163bo2b3o4b2o40bobo$164b2o3bo3b2o34b2o4bo$166b4o
37bo2bo2b2ob4o$166bo15b2o23b2obobobobo2bo$167b3o12bobo25bobobobo$170bo
13bo25bobob2o$165b5o14b2o25bo$165bo$167bo56b2o$166b2o47b2o7bo$215b2o5b
obo$222b2o7$212b2o$213bo$210b3o$210bo19$254b2o$254bo$256bo$236b2o14b5o
$237bo13bo$237bobo12b3o$238b2o15bo$252b4o$247b2o3bo3b2o$247b2o4b3o2bo$
255bob2o$255bo$254b2o3$235b3o8b2o$237bo8bo61b2o$236bo10b3o58bo$249bo
60bo$290b2o14b5o$291bo13bo$291bobo12b3o$292b2o15bo$306b4o$301b2o3bo3b
2o$301b2o4b3o2bo$309bob2o$309bo$308b2o3$300b2o$300bo$301b3o$303bo11$
268bo$266b3o$265bo$265b2o$118bo$118b3o$121bo$120b2o3$112b2o141b2o$112b
o141bobo5b2o$109b2obo141bo7b2o$109bo2b3o4b2o132b2o$110b2o3bo3b2o$112b
4o151bo$112bo15b2o133b2obobo$113b3o12bobo131bobobobo$116bo13bo128bo2bo
bobobob2o$111b5o14b2o127b4ob2o2bo2bo$111bo151bo4b2o$113bo147bobo$112b
2o147b2o19$157bo$155b3o$154bo$154b2o7$144b2o$143bobo5b2o$143bo7b2o$
142b2o2$156bo$152b2obobo$151bobobobo$148bo2bobobobob2o$148b4ob2o2bo2bo
$152bo4b2o$150bobo$150b2o!

Code: Select all

x = 156, y = 165, rule = B3/S23
5$53b2o$52bobo$46b2o4bo$44bo2bo2b2ob4o51b2o$44b2obobobobo2bo50bobo$47b
obobobo47b2o4bo$47bobob2o46bo2bo2b2ob4o$48bo50b2obobobobo2bo$102bobobo
bo$61b2o39bobob2o$52b2o7bo41bo$52b2o5bobo$59b2o55b2o$107b2o7bo$107b2o
5bobo$114b2o4$49b2o$50bo$47b3o$47bo56b2o$105bo$102b3o$102bo8$12bo$12b
3o$15bo$14b2o3$6b2o$6bo$3b2obo$3bo2b3o4b2o$4b2o3bo3b2o$6b4o136b2o$6bo
15b2o122bo$7b3o12bobo123bo$10bo13bo103b2o14b5o$5b5o14b2o103bo13bo$5bo
123bobo12b3o$7bo122b2o15bo$6b2o136b4o$139b2o3bo3b2o$139b2o4b3o2bo$147b
ob2o$147bo$146b2o3$127b3o8b2o$129bo8bo$128bo10b3o$141bo31$10bo$10b3o$
13bo$12b2o2$148b2o$4b2o142bo$4bo145bo$b2obo125b2o14b5o$bo2b3o4b2o118bo
13bo$2b2o3bo3b2o118bobo12b3o$4b4o124b2o15bo$4bo15b2o124b4o$5b3o12bobo
118b2o3bo3b2o$8bo13bo118b2o4b3o2bo$3b5o14b2o125bob2o$3bo145bo$5bo142b
2o$4b2o2$140b2o$140bo$141b3o$143bo10$96bo$94bobo11bo$95b2o9b3o$105bo$
49bo55b2o$47b3o$46bo$46b2o4$95b2o$94bobo5b2o$94bo7b2o$36b2o55b2o$35bob
o5b2o$35bo7b2o62bo$34b2o67b2obobo$102bobobobo$48bo50bo2bobobobob2o$44b
2obobo49b4ob2o2bo2bo$43bobobobo53bo4b2o$40bo2bobobobob2o48bobo$40b4ob
2o2bo2bo48b2o$44bo4b2o$42bobo$42b2o!

[SecondTypist]

Here is a suggestion. It is probably clunky and can be improved:
Each period of the oscillator is composed of various polyplets. If, at any point in the evolution of the oscillator, any individual polyplet or group of polyplets can be removed from the oscillator and the tampered-with pattern evolves in such a way that after the tampered-with pattern has been run for however long it would take the untampered pattern to return to its original state, the tampered-with pattern returns to its original state (not the original state of the untampered pattern), and over the tampered with pattern’s evolution, no polyplets have been created that weren’t in the untampered pattern, no polyplets from the untampered pattern have been changed to different polyplets or moved to another period, and all polyplets remain (while being in the same exact period) that were from the untampered pattern and had part of the tampered-with pattern required for some of its cell’s birth, then it is not a single “strict” oscillator. If this is false for a specific pattern, then it is a single “strict” oscillator.
By this definition, the two unices sharing a duoplet is a single oscillator, which is how it should be.

[TheWayOfTheCon]

This is mainly a copied post from my sandbox thread.

I had a half-baked idea regarding measuring the frequency of evolutionary sequences.

The measuring process goes as follows:

• Take all n-plets with a certain number of cells

• See how many eventually evolve into the sequence of interest

• Divide the number of n-plets that evolved into the sequence by the total number of possible n-plets

Take this traffic light predecessor for example:

Code: Select all

x = 5, y = 3, rule = B3/S23
2bo$2ob2o$2bo!

Let's figure out its frequency among tetraplets. There are 22 tetraplets.

Code: Select all

x = 54, y = 31, rule = B3/S23
4o6b3o7b3o7b2obo6b2o8b2o$13bo8bo9bo9b2o8bo$53bo7$2o8b2o8b2o8b2o8b2o8b
2o$2bo9bo8b2o8bo9bo8b2o$2bo8bo20bo7bo7$obo7bo9bo9bo9bo9bo$bobo7b2o8b2o
8bobo7bo9bo$13bo7bo10bo9bo8bo$43bo6bo7$bo8bo9bobo7bo$obo7b2o9bo9b2o$b
o8bo11bo7bo!

And we see that two of them evolve into that specific predecessor.

So 2 out of 22 (or 1/11) of all tetraplets evolve into the sequence.

Thus, the sequence's frequency among tetraplets is 1/11, or 9.1%. You could scale this up for pentaplets, hexaplets, etc. or do it with different sequences. This method almost certainly isn't perfect, because I'm assuming that all n-plets have about the same rarity. Additionally, this method could undermine the perceived frequency of some sequences. But it could lead to something more strict regarding calculating how frequent certain sequences are.

EDIT: Remembered that all polymonioes are also polyplets, a lot of corrections.

[g0t0]

This is mainly a copied post from my sandbox thread.

I had a half-baked idea regarding measuring the frequency of evolutionary sequences.

The measuring process goes as follows:

• Take all n-plets with a certain number of cells

• See how many eventually evolve into the sequence of interest

• Divide the number of n-plets that evolved into the sequence by the total number of possible n-plets

Take this traffic light predecessor for example:

Code: Select all

x = 5, y = 3, rule = B3/S23
2bo$2ob2o$2bo!

Let's figure out its frequency among tetraplets. There are 22 tetraplets.

Code: Select all

x = 54, y = 31, rule = B3/S23
4o6b3o7b3o7b2obo6b2o8b2o$13bo8bo9bo9b2o8bo$53bo7$2o8b2o8b2o8b2o8b2o8b
2o$2bo9bo8b2o8bo9bo8b2o$2bo8bo20bo7bo7$obo7bo9bo9bo9bo9bo$bobo7b2o8b2o
8bobo7bo9bo$13bo7bo10bo9bo8bo$43bo6bo7$bo8bo9bobo7bo$obo7b2o9bo9b2o$b
o8bo11bo7bo!

And we see that two of them evolve into that specific predecessor.

So 2 out of 22 (or 1/11) of all tetraplets evolve into the sequence.

Thus, the sequence's frequency among tetraplets is 1/11, or 9.1%. You could scale this up for pentaplets, hexaplets, etc. or do it with different sequences. This method almost certainly isn't perfect, because I'm assuming that all n-plets have about the same rarity. Additionally, this method could undermine the perceived frequency of some sequences. But it could lead to something more strict regarding calculating how frequent certain sequences are.

EDIT: Remembered that all polymonioes are also polyplets, a lot of corrections.

Is this relevant to the topic at hand?

I'll post this in an appropriate thread outside of the sandbox when I get time.

Is the thread appropriate?

[TheWayOfTheCon]

I'll post this in an appropriate thread outside of the sandbox when I get time.

Is the thread appropriate?

It was the most appropriate I could think of outside of just making my own. I though "strict definitions" fit the theme of my post well.

[g0t0]

I'll post this in an appropriate thread outside of the sandbox when I get time.

Is the thread appropriate?

It was the most appropriate I could think of outside of just making my own. I though "strict definitions" fit the theme of my post well.

Why? Your thought seem to arbitrary.

[g0t0]

Here is a suggestion. It is probably clunky and can be improved:
Each period of the oscillator is composed of various polyplets. If, at any point in the evolution of the oscillator, any individual polyplet or group of polyplets can be removed from the oscillator and the tampered-with pattern evolves in such a way that after the tampered-with pattern has been run for however long it would take the untampered pattern to return to its original state, the tampered-with pattern returns to its original state (not the original state of the untampered pattern), and over the tampered with pattern’s evolution, no polyplets have been created that weren’t in the untampered pattern, no polyplets from the untampered pattern have been changed to different polyplets or moved to another period, and all polyplets remain (while being in the same exact period) that were from the untampered pattern and had part of the tampered-with pattern required for some of its cell’s birth, then it is not a single “strict” oscillator. If this is false for a specific pattern, then it is a single “strict” oscillator.
By this definition, the two unices sharing a duoplet is a single oscillator, which is how it should be.

v1.2
Fix a bug about flip.
Modify the -1 mode.

Code: Select all

/*
** Theoretical Life Ash Counter (TLAC) v1.2
** By g0t0 (Modify this and the version number if someone update the program)
**
** This project aims to count ash objects strictly according to the definition.
**
** Sparks now are standalone objects in the maximum step mode.
**
** Bug list:
** The oscillators in different phases will be different object.
**
** v0.1 2026/8/20
** v1.0 2026/8/20
** v1.1 2026/9/15
** v1.2 2026/9/15
*/

#include <algorithm>
#include <iostream>
#include <map>
#include <vector>

int cells[128][128], field[2][128][128];

namespace dsu {
    /* The Disjoint Set Union algorithm */

    int parent[16384], weight[16384];

    void init(int num) {
        for (int i = 1; i <= num; ++i) {
            parent[i] = i;
            weight[i] = 1;
        }
    }

    int find_root(int x) {
        return parent[x] == x ? x : (parent[x] = find_root(parent[x]) /* Path compression */);
    }

    void merge(int x, int y) { /* Oops, I can't use 'union' as the name of the function */
        x = find_root(x);
        y = find_root(y);
        if (weight[x] > weight[y]) std::swap(x, y);
        parent[x] = y;
        weight[y] += weight[x];
    }
}

std::vector<std::vector<int>> rotate(std::vector<std::vector<int>> origin) {
    /* Clockwise 90 degrees */
    int height = origin.size(), width = origin[0].size();
    std::vector<std::vector<int>> obj(width, std::vector<int>(height));
    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            obj[j][height - i - 1] = origin[i][j];
        }
    }
    return obj;
}

std::vector<std::vector<int>> flip(std::vector<std::vector<int>> origin) {
    /* Flip vertically */
    int height = origin.size(), width = origin[0].size();
    std::vector<std::vector<int>> obj(height, std::vector<int>(width));
    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            obj[i][width - j - 1] = origin[i][j];
        }
    }
    return obj;
}

std::vector<std::vector<int>> standard_form(std::vector<std::vector<int>> o0) {
    auto o1 = rotate(o0);
    auto o2 = rotate(o1);
    auto o3 = rotate(o2);
    auto o4 = flip(o0);
    auto o5 = rotate(o4);
    auto o6 = rotate(o5);
    auto o7 = rotate(o6);
    return std::max({o0, o1, o2, o3, o4, o5, o6, o7});
}

int main() {
    /*
    ** The code now run in bounded grid.
    ** It now can count all the pseudo still lifes / oscillators.
    */

    using std::cin;
    using std::cout;

    cout << "Please input height and width of the grid (<= 100): ";
    int height, width;
    cin >> height >> width;
    cout << "Please input the pattern:\n";
    int total = 0, (*front)[128] = ::field[0], (*back)[128] = ::field[1];
    for (int i = 1; i <= height; ++i) {
        for (int j = 1; j <= width; ++j) {
            char c;
            cin >> c;
            if (!(c == ' ' || c == '.')) {
                front[i][j] = cells[i][j] = ++total;
            }
        }
    }
    cout << "Please input the maximum step (-1 for no limit): ";
    int step;
    cin >> step;
    dsu::init(total);

    const int dir[8][2] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};

    /* Merge interacting cells */

    int run;
    do {
        run = false;
        for (int i = 1; i <= height; ++i) {
            for (int j = 1; j <= width; ++j) {
                int cnt = 0, flag = 0;
                for (int d = 0; d < 8; ++d) cnt += front[i + dir[d][0]][j + dir[d][1]] > 0;
                if (front[i][j]) {
                    /* Case 1: Live, underpopulation, MERGE */
                    if (cnt < 2) flag = 2;
                    /* Case 2: Live, remains, merge */
                    else if (cnt <= 3) flag = 1;
                    /* Case 3: Live, overpopulation, merge */
                    else flag = 2;
                } else {
                    /* Case 4: Dead, underpopulation, not merge(quasi) */
                    if (cnt < 3) back[i][j] = 0;
                    /* Case 5: Dead, borns, merge */
                    else if (cnt == 3) flag = 1;
                    /* Case 6: Dead, overpopulation, merge(pseudo) */
                    else flag = 2;
                }
                if (flag) {
                    int first = 0;
                    for (int x = -1; x <= 1; ++x) {
                        for (int y = -1; y <= 1; ++y) {
                            int cur = front[i + x][j + y];
                            if (cur) {
                                if (first) dsu::merge(cur, first);
                                else first = cur;
                            }
                        }
                    }
                    if (flag == 1) back[i][j] = first;
                    else back[i][j] = 0;
                }
                if (!back[i][j] != !cells[i][j]) run = true;
            }
        }
        std::swap(front, back);
        -- step;
    } while (run && step); // Repeat until the pattern turn to the origin state (may can be optimize)

    if (step < 0) {
        memcpy(cells, front, sizeof(cells));
    }

    /* Count all things */

    std::map<std::vector<std::vector<int>>, int> objects;
    for (int i = 1; i <= total; ++i) {
        if (dsu::parent[i] == i) {
            int minj = 1000, maxj = 0, mink = 1000, maxk = 0;
            for (int j = 1; j <= height; ++j) {
                for (int k = 1; k <= width; ++k) {
                    if (cells[j][k] && dsu::find_root(cells[j][k]) == i) {
                        minj = std::min(minj, j);
                        maxj = std::max(maxj, j);
                        mink = std::min(mink, k);
                        maxk = std::max(maxk, k);
                    }
                }
            }
            if (minj == 1000) continue;
            std::vector<std::vector<int>> obj(maxj - minj + 1, std::vector<int>(maxk - mink + 1));
            for (int j = minj; j <= maxj; ++j) {
                for (int k = mink; k <= maxk; ++k) {
                    if (cells[j][k] && dsu::find_root(cells[j][k]) == i) obj[j - minj][k - mink] = 1;
                }
            }
            ++objects[standard_form(obj)];
        }
    }
    cout << "Objects:\n";
    for (auto p : objects) {
        auto obj = p.first;
        int cnt = p.second;
        cout << "Count: " << cnt << '\n';
        for (auto row : obj) {
            for (int cell : row) {
                if (cell) cout << 'o';
                else cout << '.';
            }
            cout << '\n';
        }
    }
}

I think the code can show my definition.

[NNlk05]

Where to draw the line between a corderoid and an engineered spaceship?

Take this amazing corderoid by Naszvadi:

Some engineering in a rule I saw go by in Catagolue recent hauls, first explored by LaundryPizza03:

...

Some more corderships are waiting to be made, with at least two other types of linear growth in this rule: p256 c/2 puffer with lots of debris and a 22c/512 switch engine

Code: Select all

x = 236, y = 10, rule = B37c/S2-c3-c4i6k
3bo3bo222b2o$2b3ob3o221b2ob2o$b2obobob2o220b2obo$bo2bobo2bo$b2obobob2o
$b2obobob2o$bo2bobo2bo$bo2bobo2bo$214b2o$b3o3b3o204b2o!

Done:

Code: Select all

x = 5439, y = 8071, rule = B37c/S2-c3-c4i6k
*very big corderoid*

This is on the scale of some engineered spaceship, and it certainly looks like one. However, it's missing one crucial part of an engineered spaceship: the helix. It does have track builders, et al.

Now look at this equally amazing corderoid in T-and-Tub:

Code: Select all

x = 6, y = 5, rule = B2cik3-cijn4cknqr5-anqy6ekn7/S1c2acn3-aijq4cjktw5ejny6aen7c8
4bo$obo$2o2b2o$obo$4bo!

This remains uncorderized. I believe it's hard but still possible.

Success!
This is not optimized:

Code: Select all

x = 104, y = 679, rule = B2cik3-cijn4cknqr5-anqy6ekn7/S1c2acn3-aijq4cjktw5ejny6aen7c8
54bo$53bobo$38b2o14bo14b2o$39bo29bo$38b2o29b2o$52bo4bo$51b3o2b3o5$52b
o4bo$51b3o2b3o6$3bo$bobobo94bo$98bobobo$2obob2o47bo$3bo49b3o41b2obob2o
$bo3bo94bo$98bo3bo4$95bo$89bo2bo$91b2o$88b2ob2obo$52bo4bo31bobo$51b3o
2b3o5$52bo4bo$51b3o2b3o5$52bo4bo$51b3o2b3o3$15bo$14b3o71bo$87b3o$88bo
$85b3ob3o$84bob2ob2obo$54bo28b3obobob3o$53b3o28bo7bo2$85bo5bo$84bo7bo
$84bo7bo$84bo3bo3bo$85b2obob2o$83bo2bobobo2bo$86b5o$74bo5bobo3b2ob2o3b
obo$52bo4bo17bo3b2o5b2ob2o5b3o$51b3o2b3o29bo9bo$82bo5bo5bo4$52bo4bo$51b
3o2b3o4$75bo$52bo4bo15bobobo$51b3o2b3o$72b2obob2o$75bo$15bo57bo3bo$14b
3o5$54bo$53b3o10$52bo4bobo28bo$51b3o3b3o27b3o$88bo$85b3ob3o$84bob2ob2o
bo$83b3obobob3o$52bo4bo26bo7bo$51b3o2b3o$85bo5bo$84bo7bo$84bo7bo$84bo
3bo3bo$52bo4bo27b2obob2o$51b3o2b3o24bo2bobobo2bo$86b5o$80bobo3b2ob2o3b
obo$15bo62b3o5b2ob2o5b3o$14b3o61bo9bo9bo$82bo5bo5bo4$54bo$53b3o10$52b
o4bobo$15bo35b3o3b3o$13bobobo$86bo3bo$13bobobo67bo2bo2bo$14b3o$10b3ob
obob3o31bo4bo30bo$14bobo34b3o2b3o26b2o3b2o$84b2ob3ob2o$84b2ob3ob2o$11b
o3bo3bo67b3o$14bobo$13b2ob2o19b2o13bo4bo27bo2bo2bo$13bobobo19bo13b3o2b
3o19bo7b2ob2o$14b3o20b2o38b2o5b4ob4o3bo2bo$15bo61bob2o2b2ob2ob2ob2o2b
3o$74bo4bo6b5o7bo$86b5o$27bobo58bo$25bob3obo$25b7o$28bo$23bo2b2ob2o2b
o20bo$23b2o7b2o19b3o$26b2ob2o42bobobo$74bobo$26bo3bo38bo3b5o3bo$23bob
o5bobo33bo5bobobo5bo$23b3o5b3o32bo5b7o5bo$27bobo36b2o3bob5obo3b2o$25b
obobobo36bob2o2bobo2b2obo$21b2obo2bobo2bob2o35b9o$22b4o5b4o38b2ob2o$23b
3o5b3o18bo22bo$24b4ob4o18b3o18b2obob2o$27bobo40b4o3b4o$72bo2bo2bo$70b
o9bo$14bo59bobo$13b3o36bo4bo16b3o$51b3o2b3o13bobobobo$73bo3bo10bo$74b
obo10b3o3$52bo4bo$51b3o2b3o3$87bobo$14bo$12bobobo$88bo$13bobo69b2obob
2o$14bo$13b3o38bo31bobobo$53b3o30b5o3$87bobo7$52bo$51b3o5$52bo4bo$51b
3o2b3o5$15bo36bo4bo$15bo35b3o2b3o$13b5o69bobo$12bo5bo$10bob2o3b2obo65b
o3bo$84bo7bo$10bobo5bobo62b3o5b3o$84bo7bo2$11bo2bobo2bo$10b3o5b3o33bo
29bo3bo3bo$7bo2bob2o3b2obo2bo29b3o27bo3b3o3bo$9bob4ob4obo59b2obo2b3o2b
ob2o$9bo2b2o3b2o2bo58b2ob3o2bo2b3ob2o$7b2o13b2o56bobo4b3o4bobo$5b3o4b
obobobo4b3o53b2o5b5o5b2o$6bo8bo8bo2bobo50bo4bo5bo4bo$9bo4b3o4bo5b3o45b
o3bo8bo8bo$8bo6bo6bo26bo24b3o5bo4bobo4bo$49b2o3b2o25bo13bo$49bo5bo$54b
2o2$28bo$14b3o11bo59bo$28bo45bobo$88bo$52bo4bo30bo$27bobo21b3o2b3o16b
o12bo$26b5o41b2obob2o9bo$26b2ob2o$28bo44bobobo$73b5o$28bo23bo4bo$17bo
10bo22b3o2b3o$17bo10bo45bobo9bo$15b5o64b3o$16bobo65bob2o$15b2o70b2o$87b
o4$54bo$53b3o7$85bobobobo$14bobo66bob3ob3obo$14b3o68b2o3b2o$83bo2bo3b
o2bo$81bo3bo5bo3bo$84bo7bo$83bobo5bobo$86bo3bo$15bo70bobobo$15bo36bo4b
o29b3o$15bo35b3o2b3o24bobo5bobo$82b3o7b3o$83b2o2bobo2b2o$14bobo57bo9b
2obobob2o$13b5o57bo$13b2ob2o34bo4bo$15bo35b3o2b3o2$15bo$15bo$15bo5$54b
o18bobobo$53b3o18bobo2$73bobobo$73bo3bo$71b4ob4o$71b4ob4o$71bo2bobo2b
o$72bo2bo2bo$74b3o$75bo7$52bo4bobo$51b3o3b3o5$52bo4bo$51b3o2b3o26bobo
bobo$83bob3ob3obo$85b2o3b2o$83bo2bo3bo2bo$81bo3bo5bo3bo$84bo7bo$83bob
o5bobo$86bo3bo$86bobobo$15bo38bo32b3o$14b3o36b3o27bobo5bobo$82b3o7b3o
$83b2o2bobo2b2o$84b2obobob2o13$52bo4bobo$51b3o3b3o4$12b2obob2o$10bobo
bobobobo31bo4bo$9b4ob3ob4o29b3o2b3o$8b3ob7ob3o$7b3obo2b3o2bob3o$8bo2b
9o2bo64bobo$11b3o3b3o66b5o$11b2o5b2o67b3o$11bob5obo66b5o$11b2o5b2o67b
3o$12b2o3b2o$11bobobobobo34bo$15bo26b2o9b3o$14b3o25bo30bo$13b5o10bo13b
2o28b2o$14b3o10bobo43bo$15bo9b2o3b2o2$26bobobo$25bobobobo43bo$26b2ob2o
44bo$73b5o$26b2ob2o41bo5bo$70bob2o3b2obo$28bo$25b7o38bobo5bobo$28bo$25b
o5bo$25bo2bo2bo20bo18bo2bobo2bo$23b2o3bo3b2o17b3o16b3o5b3o$20bo3b2o5b
2o3bo30bo2bob2o3b2obo2bo$19bo2bob2ob3ob2obo2bo31bob4ob4obo$18b2o3b3ob
obob3o3b2o30bo2b2o3b2o2bo$17b4o3b3o3b3o3b4o27b2o13b2o$19b2o3b9o3b2o14b
o4bo7b3o4bobobobo4b3o$19bo17bo13b3o2b3o7bo8bo8bo$23bo2bobobo2bo35bo4b
3o4bo6bo$68bo6bo6bo4b3o6$74b3o$54bo$53b3o5$13bobo$12b5o$12bo3bo71bo$11b
2obob2o68bobobo$9b2ob5ob2o67bobo$9b2o2bobo2b2o64bob5obo$10bo2bobo2bo67b
obobo$11bo2bo2bo66bo2bobo2bo$13b3o69bo2bo2bo$14bo72b3o$88bo$52bo$51b3o
5$52bo4bo$51b3o2b3o9$54bo$53b3o$14bobo$88bo$11bo7bo67b3o$9bob2o5b2obo
62bo2b3o2bo$14bobo66bo9bo$9bo11bo60b3o3bo3b3o$10bob3ob3obo62b2o2b3o2b
2o$84b9o$88bo2$13bobobo$13b5o$10bob7obo64bobobobo$11bo3bo3bo63bobo2bo
2bobo$12bo5bo10bo54bobo3bobo$28bo23bo21bo9bobobobobo$51b3o21bo10bo3bo
5$52bo4bo$51b3o2b3o5$26bobobo44bo$26b2ob2o42bobobo$25bob3obo42bobo$23b
2obobobob2o37bob5obo$24b4ob4o21bo18bobobo$25b7o21b3o15bo2bobo2bo$16bo
bo7bo3bo41bo2bo2bo$17bo9bobo44b3o9b2o$18b2o55bo9b2o$18bo67bo$85b2o9$14b
obo69bobobo$14b3o68b2o3b2o$84b9o$87bobo$85bobobobo2$87b3o2$52bo4bo29b
3o$51b3o2b3o27b2ob2o$87b3o2$87b3o$83bob2obob2obo$81bobobo2bo2bobobo$80b
2o3b2obob2o3b2o$79b4o3b2ob2o3b4o$13bobobo56bo3b3o15b3o$13b2ob2o36bo20b
o3bo2b2o4bo4b2o2bo$12bob3obo34b3o28bobo3bobo$10b2obobobob2o62b2o7b2o$
11b4ob4o$12b7o$13bo3bo$14bobo3$75bo$71b2obobob2o$70b3ob3ob3o$69b13o$70b
2o3bo3b2o$71b2o5b2o$72bo5bo3$72bo5bo$72bobobobo$70b5ob5o$72bo5bo$73b2o
b2o$52bo4bobo14bobo$51b3o3b3o7$86bobobo$85b2o3b2o$54bo29b9o$53b3o31bo
bo$85bobobobo2$87b3o2$15bo71b3o$14b3o69b2ob2o$87b3o2$87b3o$83bob2obob
2obo$81bobobo2bo2bobobo$80b2o3b2obob2o3b2o$79b4o3b2ob2o3b4o$78b3o15b3o
$79bo2b2o4bo4b2o2bo$84bobo3bobo$83b2o7b2o5$52bo4bobo$51b3o3b3o5$13b2o
b2o$11bobo3bobo2$10b2o7b2o$11bo7bo34bo$53b3o2$14b3o71bo$86bobobo$9bob
obo3bobobo65bobo$8b2o4b3o4b2o64bobo$8b5obobob5o63bo3bo$7bob2o2b2ob2o2b
2obo62b5o$8bo3bob3obo3bo62bob3obo$7b2o5bobo5b2o59bo2bo3bo2bo$9bo11bo6b
o56b7o$8b2o11b2o4b3o17b2o37bo3bo$47bo20bo18bobo$47b2o18b2o$68bo2$13bo
3bo$13b2ob2o$13bobobo9bobo$14b3o9bo3bo43bobo$15bo8b3obob3o$27b3o41bo7b
o$26bobobo21bo16bob2o5b2obo$26b2ob2o20b3o20bobo$27bobo39bo11bo$25b3ob
3o38bob3ob3obo2$26b2ob2o2$73bobobo$23b11o39b5o$14bo55bob7obo$13b2o39b
o16bo3bo3bo$28bo24b3o16bo5bo14$14bo$11b3ob3o$10b2obobob2o69bo$9b3ob3o
b3o68bo$10b3o3b3o66b2o3b2o$11bo5bo66b2o5b2o$85b3ob3o2$52bo$51b3o$11bo
5bo69b3o$10b3o3b3o68bobo$11bobobobo68b5o$85b2obob2o$86b2ob2o$88bo$88b
o$88bo$54bo$53b3o8$15bo$14b3o$15bo71bobo$13bobobo68bo3bo$12b2o3b2o67b
o3bo$15bo69b3ob3o$87bobo$14b3o69b5o$87b3o$87b3o$13bobobo69bobo$13bo3b
o68bobobo$12b7o65b2obobob2o$10bo4bo4bo63bob2ob2obo$9b2obo2bo2bob2o30b
o30b2ob5ob2o$51b3o34bo$9bo11bo60bo4bobo4bo$6b2o2bob3ob3obo2b2o55bobo2b
7o2bobo$7b3ob2ob3ob2ob3o5bo52b4ob3ob4o$8b2obob5obob2o5bo45bo5bo2bobob
obobobo2bo$75bo5bo13bo$88bo$88bo$88bo$54bo$53b3o4$27bobo45bo$24bob2ob
2obo42bo$25bo2bo2bo40b2o3b2o$24bobobobobo38b2o5b2o$28bo43b3ob3o4$74b3o
$25b7o42bobo$26b5o42b5o$25bo5bo40b2obob2o$28bo25bo18b2ob2o$52bobobo18b
o$75bo$51b2obob2o17bo2$51b2o3b2o$53bobo$51bobobobo$51bo5bo$50bo7bo$53b
obo$51bo2bo2bo$53b3o$54bo!

It is significantly smaller, but it does have a helix "spine" (sort of) like the original Caterpillar.
Where to draw the line?

EDIT: To give a sense of scale:

From left to right: 1st corderoid in this post, t'n't corderoid, smallest b3s23 demonoid, leaf bug "Bounding box variant", the oldest and newest versions of Solifuge.

2026-09-17_20-42.png (14.64 KiB) Viewed 100 times

[NooneAtAll3]

Where to draw the line between a corderoid and an engineered spaceship?

...nowhere?

corderoids are subcategory of engineered spaceship, even wiki says so (https://conwaylife.com/wiki/Corderisation)

being an engineered spaceship isn't about the exact way information is passed inside to construct some forward part and deconstruct behind one - it's about being made out of individually-understandable (by human) pieces, with precise set of interactions - which are then connected together via those interactions

it doesn't matter whether your pieces are spaceships moving block/active region forward or line of blocks growing at the nose and being destroyed aft - it's still human-comprehensible as individual pieces by nature of being spread out in time and space