3D Geminoid challenge

[simsim314]

I don't think we have any 3d CA geminoid implementation. So the challenge is (1) to find a 3d rule that has reflectors, duplicators and construction arms, and then (2) to build 3d geminoid that moves in (dx, dy, dz).

[Redstoneboi]

Woah there buddy, don't you think you're going too fast there?
You seem to be planning way ahead of time considering your first step is to find a 3d rule with incredible capabilities.

[wildmyron]

I didn't get around to responding to this, but I think it's an interesting idea - though its scope is a bit beyond what I'll be able to tackle. However, to get things started I think it would be good to clarify what CA space this challenge is aimed at. Specifically: any restrictions on the number of states or the neighbourhoods that could be used? Should the CA be isotropic and the geminoid able to travel in multiple directions? Even if nobody has explicitly constructed such a beast it seems like it wouldn't be much of a challenge in an engineered ruleset with a dozen states to control the desired behaviour. In fact I'd wager building the simulator and effectively visualizing such a beastie could be an even bigger challenge than actually designing the ruleset and constructing the geminoid.

Which brings me to a secondary aspect to the challenge: Are there any suitable simulation tools available to realize the solutions to this challenge, or would they need to built as well? Pretty much all the tools that I can think of which accommodate 3D CA have limited universe sizes - generally of a size much less than what I expect will be required.

On a related note - while exploring some of the research with Partitioned Cellular Automata, I came across a few interesting papers with computation universal models and self-replicators in various PCA topologies. In particular, Self-reproduction in three-dimensional reversible cellular space by K. Imai et al. [Artificial Life, Vol. 8 (2), 2002, p.155-174]. This paper describes an extension of a 2D loop rule (implemented in a reversible PCA) to 3 dimensions. The resulting PCA has cells divided in 7 partitions (6 neighbours of 3D von Neumann neighbourhood plus centre) each of which can be in one of 9 states. The "worms", as they are referred to, can have a 3D shape and can be instructed to place their daughters in any desired position. It's not clear to me if subsequent attempts to build a daughter worm in the same location is handled gracefully or not.

[simsim314]

You seem to be plannyng way ahead of time considering your first step is to find a 3d rule with incredible capabilities.

I don't think it's incredible but you're right we need a 3d rule with glider reflector. Could be a good start.

Should the CA be isotropic

I guess it's preferable.

it wouldn't be much of a challenge in an engineered ruleset with a dozen states to control the desired behaviour.

You're right. I meant natural 3d rule. I agree is much less of a challenge for designed rules.

Are there any suitable simulation tools available to realize the solutions to this challenge, or would they need to built as well? Pretty much all the tools that I can think of which accommodate 3D CA have limited universe sizes - generally of a size much less than what I expect will be required.

I think this is part of the challenge here. Either the make a 3d golly like tool, or to have a small enough geminoid.

[Hunting]

26 neighbours seems too much to handle. Maybe we should come up with a 3D von-Neumann totalistic rule instead?

[simsim314]

26 neighbours seems too much to handle.

I don't think it's too much to the contrary I would have a totalistic rule even more fine tuned for different types of neighbors (common edge, vertex and face).

Maybe we should come up with a 3D von-Neumann totalistic rule instead?

von-Neumann totalistic rule will need more than 2 states. As if you have 1 state everything is define by B1 flag. It will either remain inside a box or explode. Thus it will depend on two states sum instead of the single neighbors sum.

------

I'm not sure about which software to use.... I think Ready has some support. We only need sparse 3d rule representation and evolution.

[Hunting]

Maybe we should come up with a 3D von-Neumann totalistic rule instead?

von-Neumann totalistic rule will need more than 2 states. As if you have 1 state everything is define by B1 flag. It will either remain inside a box or explode. Thus it will depend on two states sum instead of the single neighbors sum.

Oh yeah yeah yeah, I should think of it first before posting it. Damn.

[EvinZL]

I've been most interested in a certain neighborhood:
First each neighborhood can be given an index:
In binary: corner edge face;
where, for example, corner is:
1 if corners are included
0 if corners aren't included
and then the number can be transcribed into a decimal number.
for example:
von neumann = 1
moore = 7

So my neighborhood would be 3
because:
corners are weird.
or maybe 5
I don't have 3d neighborhood experience;
but 6 would be too overkill
I think

[blah]

First each neighborhood can be given an index:
In binary: corner edge face;
where, for example, corner is:
1 if corners are included
0 if corners aren't included
and then the number can be transcribed into a decimal number.
for example:
von neumann = 1
moore = 7

I think this notation is interesting.
1 and 4 both exhibit the property that, excluding B0, patterns in B1 rules always explode and patterns in non-B1 rules never leave their bounding region. I think I remember someone wrote a simulator a while back that used 4, and ran into this problem when they tried to find spacehips. Do any of the other neighbourhoods have this property? I think what we want is one without that property, and with a small neighbourhood size (so it can be simulated faster). In other words, we want non-B0 spaceships in as small a neighbourhood as possible.

The amount of neighbours, where the three bits are c, e, f, is (c*8+e*12+f*6). So the size of each neighbourhood is:
0: 0
1: 6
2: 12
3: 18
4: 8
5: 14
6: 20
7: 26
0 is ruled out by triviality. Unless you want to get into B0 rules or rules with more than 3 states, 1 and 4 are ruled out (and any others with the same property, if they exist). The remaining neighbourhood with the smallest size is 2, although I get the feeling it can't actually support non-B0 ships (can somebody prove this?). That would leave your suggestion of 5.

Let's be honest, though, this project is (probably) never going to get past the hand-waving vapourware stage.

[simsim314]

Are there any suitable simulation tools available to realize the solutions to this challenge, or would they need to built as well? Pretty much all the tools that I can think of which accommodate 3D CA have limited universe sizes - generally of a size much less than what I expect will be required.

I've written a sparse 3d simulator in python, with visualization in golly. It works slower than I hoped for but it's fine to start exploring rule space. It allows to search for rules with gliders and common ash objects etc.

Also I made a search utility inside FEV rule space. It's totalistic by type i.e. 6 faces, 12 edges and 8 vertices, but per each combination of types is unique (for example, total 3 active neighbors by faces, 10 by edges and 4 by vertices - define one flag). This ensures isometry, and allows much larger rule space than the totalistic rules. The totalistic barely got a glider, while this space is 5% contains nice gliders (tweaking a bit the settings though).

A save/load/run sparse simulation script for the 3d rules and patterns was also added. I've found several interesting rules with gliders of different kind. The most interesting in the repository are rules: 37, 65, 87. But I've Checked only the first 100.

The scripts and simple explanation can be found in github.

For example this is a puffer of rule79 in the git repository. You can see 4 different projections of it:

Code: Select all

x = 239, y = 206, rule = B3/S23
137b2o2$138bo2b2o$140bob2o$140bobo$141bo$141b2o$141b2o53$13b2o$14bo4$
9b2o$9b2o3$83bo$81b2obo$81bobo2b2o54bo$22b2o3bo4b2o3bo4b2o3bo4b2o3bo4b
2o3bo4b2o3bo4b3o2bo53b2o$23bo3b2o4bo3b2o4bo3b2o4bo3b2o4bo3b2o4bo3b2o4b
o2bo64bo3b2o4bo3b2o4bo3b2o4bo3b2o4bo3b2o4bo3b2o4bo2bo$14bo135b2o3bo4b
2o3bo4b2o3bo4b2o3bo4b2o3bo4b2o3bo4b3o2bo$12b3o194bobo2b2o$13b3o193b2ob
o$12b3o196bo$13b2o45$79bo$78bobo$79bobo$234bobo$237bo$5b2o225bo5bo$
231bo$5bo9b2o213bobo5bo$14b4o77bo$14b2obo76bobobo131bobobobo$15bobo77b
o139bo$14bo3bo75bo3bo133bobo$16b2o77bobo$226bobo$97bobobo$102bo125bo$
101bo$222bo2$222bobo4$216bobo2$218bo2$212bo2$212bobo4$206bobo2$208bo2$
202bo2$202bobo4$196bobo2$198bo2$192bo2$192bobo4$186bobo2$188bo2$182bo
2$182bobo3$149bo$176bobo$149bobo$178bo2$172bo2$172bobo7$o$2o$11b3o$10b
4o$9b5o$10b3o$11bo!

Please check it out - and report any bugs or questions.

[EvinZL]

Working on classification {
.I'll focus on totalistic
.Notation {
..a.Bx,x,xSx,x,x where {
...a is the neighborhood number;
...Bx,x,x and Sx,x,x are the obvious (neighbor counts for birth and survival) and they are comma separated because there can be two digits
..}
.}
.And then find out which births are needed to escape bounding cube and bounding octahedron
.So we can narrow down the possibilities
.And then exclude explosive rules
.And I also like blah's suggestion of focusing on smaller neighborhoods first
}

[simsim314]

.I'll focus on totalistic
.Notation {

I like the approach due to its simplicity - you're trying to formulate something you can understand as a rule. Notice my approach is way different. I'm choosing random rules, for me those are just bunch of flags stored in a file (there is about 2K such flags - I feel no point in understanding 2000 different numbers). I explore a space by random sampling it. The approach is empirical trying to catch rules in which random soups are evolving in the way I would like to have i.e. producing gliders and other goodies and not behave like a mash of growing dense white noise. In order to find such rules I don't use any notation - I walk through many random rules and find those in which happen something I like. The script of doing this, together with the 3d sparse simulator is posted in my previous post (not sure you got this point).

[EvinZL]

Two ways doubles the chance of success
So I will do analysis
--------------------------------
1. file format:
header:

Code: Select all

x = 10, y = 10, z = 10, rule = ...

purposes are obvious
rle:
line separator: $
layer seperator: &
eof: !
-------------------------------
2. some analysis:
neighborhoods: 2, 3, 5, 7
2. requires B3-; B2 maybe explosive
3. requires B5-; B4 maybe explosive
5. requires B4-; possibly explosive; borderline
6. requires B4-; makes it probably explosive
7. B7-; maybe explosive
Confession: I don't know how to tell explosive rules


_________________________________________________________
Update:
With my crummy 3D rule simulator I determined that neighborhood 2, b# is explosive because Python lagged out and I had to terminate. (UPDATE: maybe not, later experiments make ne not trust that)

_________________________________________________________
(Edited 2/11/2023 for clarity)
Note: "Bn-" seems to mean "B<=n"