Can Boids Be Turned into a Cellular Automaton?

[MortezaRahmani]

The 9 to 0 Golly Challenge
Can It Be Done Without Python, Lua, Ada, or Any Programming Language?

I would like to propose a small challenge for the Golly and cellular automata community.
The goal is to create a pattern in Golly that visually performs the following countdown:

9 → 8 → 7 → 6 → 5 → 4 → 3 → 2 → 1 → 0

The important point is that I am not simply looking for a pattern that produces or displays the digits 0 through 9.
The intended effect is a visual countdown in which the current digit fades out or disappears through the evolution of the pattern, and the next digit appears as part of that same evolution.
For example:

9 fades out → 8 appears → 8 fades out → 7 appears → ... → 1 fades out → 0 appears

The GIF attached to this post illustrates the intended visual effect.

The Rules
The challenge is deliberately restricted:

• No Python
• No Lua
• No Ada
• No JavaScript, C, C++, or any other programming language
• No external program controlling Golly
• No script telling Golly which digit to display

The solution should be achieved through Golly itself and its native pattern, rule, and encoding capabilities.
In other words, the interesting question is:

Can the pattern itself perform the visual countdown?

Respecting Previous Work
I am aware that cellular automata and Conway's Game of Life already have sophisticated counters, digital clocks, and other computational constructions.
I have great respect for those previous achievements, and this challenge is not intended to dismiss or replace them.
What I am looking for is a more specific construction matching the visual behavior shown here: a self-evolving 9 to 0 countdown in which the previous digit disappears and the next digit emerges through the evolution of the pattern itself.
So this is not simply about making the digits 0 through 9 appear, or about counting upward from 0 until another number appears.
The desired behavior is specifically:

9 → fade out → 8 → fade out → 7 → ... → 1 → fade out → 0

And to be completely transparent...
I have not solved this myself.
I am proposing this as a genuine challenge because I am also trying to find out whether it can be done under these restrictions.
A solution does not necessarily have to be minimal or elegant. Even an experimental, partial, or unconventional construction would be interesting.
So, the question is:

Can we make Golly itself perform a visual 9 to 0 countdown, using only the cellular automaton and Golly's native capabilities, with no programming language involved?

I'm looking for the solution too.
Let the challenge begin!

Nine2ZeroCountdown.gif (26.49 KiB) Viewed 466 times

[LuveelVoom]

Alright, someone bring out a circuitry rule or the ruletable searcher...

[Gustone]

Patterns/HashLife/Metacell/hexadecimal.mc.gz is close

[NNlk05]

Alright, someone bring out a circuitry rule or the ruletable searcher...

We don't need all that

Code: Select all

x = 44, y = 9, rule = B3/S23Super
6.3X.3X.3X.3X.3X.X.X.3X.3X2.X.3X$6.X.X.X.X3.X.X3.X3.X.X3.X3.X2.X.X.X$
6.3X.3X3.X.3X.3X.3X.3X.3X2.X.X.X$8.X.X.X3.X.X.X3.X3.X3.X.X4.X.X.X$6.3X
.3X3.X.3X.3X3.X.3X.3X2.X.3X$A2.A$4.A$A3.A$.4A!

[CasperWen8805181]

What do you mean by no python, lua, ada, and other languages? as in they cannot be used to identify patterns, so we would need to manually search? also, is this challenge limited to life or also to OCA? And also, with all due respect, why this specifically?

If OCA is allowed, I'll assume LtL is also allowed, so there's probably some very niche mapped rule that is very very hard to find but can accomplish the goal.

And if OCA is allowed, are coded rules (Like the one in the post below) allowed? since they still categorize as OCA.

[unname4798]

Code: Select all

x = 15, y = 22, rule = countdown
ABCDEABCDEABCDE$J.HGFJ.HG.JIHGF4$AB.DE5.ABC$J3.F5.JIHGF4$AB.DEAB.DEAB
CDE$J.HGF2.HGFJIHGF4$.B.D6.ABCDE$J.H7.JI.GF4$AB.DEAB.DEABCDE$J.HG.J.H
G.JIHGF!
[[ GPS 1 AUTOSTART ]]
@RULE countdown
@TABLE
n_states:11
neighborhood:oneDimensional
symmetries:permute
var a={0,1,2,3,4,5,6,7,8,9,10}
var b=a
1,a,b,0
2,a,b,1
3,a,b,2
4,a,b,3
5,a,b,4
6,a,b,5
7,a,b,6
8,a,b,7
9,a,b,8
10,a,b,9
@COLORS
0 0 0 0
1 255 255 255
2 0 0 0
3 0 0 0
4 0 0 0
5 0 0 0
6 0 0 0
7 0 0 0
8 0 0 0
9 0 0 0
10 0 0 0

[MortezaRahmani]

Using Golly's "Create Gradient" for Toranj
I know that multi-color cellular automata in Golly are nothing new, and that Golly can assign different colors to different states.
What I'm wondering about is something slightly different.
For my Toranj (ICM: Iranian Carpet Medallion) pattern, I would like to get a color distribution like this:
deep blue → blue/cyan → green → yellow → orange → red
with the colors gradually changing from the inner part of the pattern toward its outer edges.
I noticed that Golly has:

Code: Select all

Set Layer Color → Create Gradient

So my question is:

Can Golly's built-in gradient functionality be used to color an existing CA pattern according to its position on the screen, so that the inner part of Toranj is one end of the gradient and the outer edges are the other end?

I'd prefer to do this entirely within Golly, without any programming.
However, if this is not possible using Golly's built-in features, I'm also open to using a script or other programming-based solution.
The result I'm looking for is essentially this:

ColoredToranj.png (1.05 MiB) Viewed 379 times

Maybe there is already a built-in way to do this that I'm overlooking.
Thanks!

[MortezaRahmani]

A Golly challenge: can an apparently non-cellular phenomenon emerge from cellular rules?
I've been thinking about a question that goes a little beyond the usual Cellular Automata framework.
There are many phenomena that are normally modeled using agents, particles, vectors, velocities, forces, or continuous coordinates rather than cellular automata.
But some of these systems are still based on local interactions.
Boids is a particularly interesting example.
The familiar flocking behavior can be described using three basic rules:
Separation
Avoid getting too close to nearby Boids.
Alignment
Adjust the direction of movement toward the direction of nearby Boids.
Cohesion
Move toward the local center of nearby Boids.

These three relatively simple interactions can produce surprisingly complex collective behavior.
At first glance, however, Boids seems quite different from a Cellular Automaton.
A CA normally has cells arranged on a discrete grid, a finite set of states, a neighborhood, and a local transition rule.
A Boid normally has a position and a velocity, and its movement is calculated using continuous or vector-based quantities.
So this raises an interesting question:
Can the essential behavior of Boids be converted into a genuine Cellular Automaton?
Not simply running a Boids simulation next to a CA.
Not simply using a Python script to draw Boids in Golly.
I mean encoding the essential interactions themselves into cellular states and local rules, so that flocking behavior emerges from the CA.
For example, direction could potentially be represented by different states:

Code: Select all

Empty
North
Northeast
East
Southeast
South
Southwest
West
Northwest

Then perhaps local cellular interactions could somehow reproduce:
Separation + Alignment + Cohesion
The interesting part for me is not necessarily reproducing the original Boids equations exactly.
The question is whether the same kind of emergent flocking behavior can arise from a discrete cellular system.
The first challenge: no programming
My first question is whether anybody has found a clever way to get close to this using Golly itself, without writing Python, Lua, or any other programming language.
Perhaps there is some combination of:
multistate rules, neighborhoods, rule-table construction, directional states, pattern manipulation, or other Golly features
that can be used to create something Boids-like.
If somebody has already attempted this, I'd be very interested to see the result.
The second challenge: if programming is necessary
If this cannot realistically be achieved without programming, then the challenge becomes more open:
Use whatever tools are available in Golly and try to create the closest possible cellular version of Boids.
Python, Lua, or other programming approaches would then be acceptable.
The main objective is to explore the boundary between an agent-based system and a Cellular Automaton.
Boids seems like a good test case because its fundamental ingredients are already based on local interactions:
Separation · Alignment · Cohesion
So perhaps the distinction between "agent-based" and "cellular" is not always as clear-cut as it first appears.
Has anyone tried to implement Boids, or something sufficiently close to Boids, as a Cellular Automaton in Golly?
And more importantly:
Has anyone managed to get close to it without programming?

BOIDS.gif (3.19 MiB) Viewed 435 times

[J5L]

Probably, with a ruletable(at a set speed since ruletables cannot change their neighborhood).

[ThePlayzr]

A Golly challenge: can an apparently non-cellular phenomenon emerge from cellular rules?
I've been thinking about a question that goes a little beyond the usual Cellular Automata framework.
There are many phenomena that are normally modeled using agents, particles, vectors, velocities, forces, or continuous coordinates rather than cellular automata.
But some of these systems are still based on local interactions.
Boids is a particularly interesting example.
The familiar flocking behavior can be described using three basic rules:
Separation
Avoid getting too close to nearby Boids.
Alignment
Adjust the direction of movement toward the direction of nearby Boids.
Cohesion
Move toward the local center of nearby Boids.

Here is a very inefficient, horribly slow and laggy, buggy, but just barely working moore rule with 6 states, that has the 'Boids' move towards each other if they are the closest but not too close. I only made sure simple reactions work, so if you find any that don't quote/PM me and I will fix them.

Code: Select all

x = 0, y = 0, rule = Boidstest
A!
@RULE Boidstest
@TABLE
n_states:6
neighborhood:Moore
symmetries:permute
var a={2,3}
var b={0,2,3}
var n={0,5}
var o={0,1,2,3,4}
var x={0,1,2,3,4,5}
var aa=a
var ab=a
var ac=a
var ba=b
var bb=b
var bc=b
var bd=b
var oa=o
var ob=o
var oc=o
var od=o
var oe=o
var xa=x
1,4,o,o,oa,ob,oc,od,oe,0
4,1,o,o,oa,ob,oc,od,oe,5
0,1,b,ba,0,0,0,0,0,2
0,2,2,a,b,0,0,0,0,2
2,a,a,ab,ac,o,oa,ob,oc,3
0,3,3,3,3,3,3,3,b,4
a,4,o,o,oa,ob,oc,od,oe,4
4,x,xa,o,o,oa,ob,oc,od,0
0,3,3,3,3,3,3,b,ba,4
0,3,4,4,4,4,5,5,5,5
0,1,3,3,b,b,ba,bb,bc,3
0,1,1,b,b,bb,bb,bc,bd,5
0,3,4,4,5,5,5,5,5,5
5,0,0,0,4,4,4,4,5,1
5,0,0,0,0,4,5,5,5,1
5,5,5,5,5,n,0,0,0,0
3,3,3,3,3,3,0,0,0,2
2,0,0,0,1,2,2,2,5,5
0,1,1,1,3,3,3,5,5,5
5,o,o,oa,oa,ob,oc,od,oe,1
1,5,x,xa,o,o,oa,ob,oc,0
5,5,x,x,o,oa,ob,oc,od,0
@COLORS
0 0 0 0
1 0 255 255
2 0 60 60
3 0 100 100
4 0 150 150

Works best with random 2-state soups with 1% density.
I like it!
EDIT: fixed a reaction
EDIT 2: fixed another reaction
EDIT 3: actually fixed the second reaction
EDIT 4: fixed yet another reaction
EDIT 5: fixed a big blinker made of state 5 existing
EDIT 6: fixed yet again another reaction
EDIT 7: I'm not labelling them anymore
EDIT 8
EDIT 9
EDIT 10

[LuveelVoom]

I’d recommend putting all these challenges in one forum thread so as to avoid cluttering the topic list

[TheWayOfTheCon]

I’d recommend putting all these challenges in one forum thread so as to avoid cluttering the topic list

"OCA Challenges" would be a pretty good thread.

[MortezaRahmani]

Yeah, "OCA Challenges" sounds like a good name.
Do I need a moderator to merge the existing challenge threads into it, or is there a way I can do that myself

[TheWayOfTheCon]

Yeah, "OCA Challenges" sounds like a good name.
Do I need a moderator to merge the existing challenge threads into it, or is there a way I can do that myself

You can make a thread yourself, but for merging threads you do in fact need a moderator to do that.

[unname4798]

4 boids make this:

Code: Select all

x = 2, y = 2, rule = Boidstest
2A$2A!
@RULE Boidstest
@TABLE
n_states:9
neighborhood:Moore
symmetries:permute
var a={2,3}
var b={0,2,3}
var n={0,5}
var o={0,1,2,3,4}
var x={0,1,2,3,4,5}
var aa=a
var ab=a
var ac=a
var ba=b
var bb=b
var bc=b
var bd=b
var oa=o
var ob=o
var oc=o
var od=o
var oe=o
var xa=x
1,4,o,o,oa,ob,oc,od,oe,0
4,1,o,o,oa,ob,oc,od,oe,5
0,1,b,ba,0,0,0,0,0,2
0,2,2,a,b,0,0,0,0,2
2,a,a,ab,ac,o,oa,ob,oc,3
0,3,3,3,3,3,3,3,b,4
a,4,o,o,oa,ob,oc,od,oe,4
4,x,xa,o,o,oa,ob,oc,od,0
0,3,3,3,3,3,3,b,ba,4
0,3,4,4,4,4,5,5,5,5
0,1,3,3,b,b,ba,bb,bc,3
0,1,1,b,b,bb,bb,bc,bd,5
0,3,4,4,5,5,5,5,5,5
5,0,0,0,4,4,4,4,5,1
5,0,0,0,0,4,5,5,5,1
5,5,5,5,5,n,0,0,0,0
3,3,3,3,3,3,0,0,0,2
2,0,0,0,1,2,2,2,5,5
0,1,1,1,3,3,3,5,5,5
5,o,o,oa,oa,ob,oc,od,oe,1
1,5,x,xa,o,o,oa,ob,oc,0
5,5,x,x,o,oa,ob,oc,od,0
@COLORS
0 0 0 0
1 0 255 255
2 0 60 60
3 0 100 100
4 0 150 150

Another configuration makes a p2 oscillator:

Code: Select all

x = 3, y = 3, rule = Boidstest
A.A2$A.A!
@RULE Boidstest
@TABLE
n_states:9
neighborhood:Moore
symmetries:permute
var a={2,3}
var b={0,2,3}
var n={0,5}
var o={0,1,2,3,4}
var x={0,1,2,3,4,5}
var aa=a
var ab=a
var ac=a
var ba=b
var bb=b
var bc=b
var bd=b
var oa=o
var ob=o
var oc=o
var od=o
var oe=o
var xa=x
1,4,o,o,oa,ob,oc,od,oe,0
4,1,o,o,oa,ob,oc,od,oe,5
0,1,b,ba,0,0,0,0,0,2
0,2,2,a,b,0,0,0,0,2
2,a,a,ab,ac,o,oa,ob,oc,3
0,3,3,3,3,3,3,3,b,4
a,4,o,o,oa,ob,oc,od,oe,4
4,x,xa,o,o,oa,ob,oc,od,0
0,3,3,3,3,3,3,b,ba,4
0,3,4,4,4,4,5,5,5,5
0,1,3,3,b,b,ba,bb,bc,3
0,1,1,b,b,bb,bb,bc,bd,5
0,3,4,4,5,5,5,5,5,5
5,0,0,0,4,4,4,4,5,1
5,0,0,0,0,4,5,5,5,1
5,5,5,5,5,n,0,0,0,0
3,3,3,3,3,3,0,0,0,2
2,0,0,0,1,2,2,2,5,5
0,1,1,1,3,3,3,5,5,5
5,o,o,oa,oa,ob,oc,od,oe,1
1,5,x,xa,o,o,oa,ob,oc,0
5,5,x,x,o,oa,ob,oc,od,0
@COLORS
0 0 0 0
1 0 255 255
2 0 60 60
3 0 100 100
4 0 150 150

[MortezaRahmani]

Hi Moderators,
Following LuveelVoom’s suggestion, I’d like to consolidate my recent OCA challenges into a single thread called:

OCA Challenges

Could you please merge these three existing threads into that new thread?

1. [Can Boids Be Turned into a Cellular Automaton?]
https://conwaylife.com/forums/viewtopic ... 71#p234871

2. [Gradient for Toranj]
https://conwaylife.com/forums/viewtopic ... 61#p234761

3. [The 9 to 0 Golly Challenge: Can It Be Done Without Python, Lua, Ada or Any Programming Language?]
https://conwaylife.com/forums/viewtopic ... 75#p234675

I’d like the complete existing discussions to be preserved, including all replies from other members, with the original posts and discussion history intact.

The intention is to continue posting future OCA challenges in this same thread, as LuveelVoom suggested, so that the topic list doesn’t become unnecessarily cluttered.

Thank you!

[TheWayOfTheCon]

4 boids make this:

Code: Select all

x = 2, y = 2, rule = Boidstest
2A$2A!

Another configuration makes a p2 oscillator:

Code: Select all

x = 3, y = 3, rule = Boidstest
A.A2$A.A!

A couple of still lifes:

Code: Select all

x = 11, y = 4, rule = Boidstest
2E5.2E$E6.E$2.E7.E$.2E6.2E!
@RULE Boidstest
@TABLE
n_states:9
neighborhood:Moore
symmetries:permute
var a={2,3}
var b={0,2,3}
var n={0,5}
var o={0,1,2,3,4}
var x={0,1,2,3,4,5}
var aa=a
var ab=a
var ac=a
var ba=b
var bb=b
var bc=b
var bd=b
var oa=o
var ob=o
var oc=o
var od=o
var oe=o
var xa=x
1,4,o,o,oa,ob,oc,od,oe,0
4,1,o,o,oa,ob,oc,od,oe,5
0,1,b,ba,0,0,0,0,0,2
0,2,2,a,b,0,0,0,0,2
2,a,a,ab,ac,o,oa,ob,oc,3
0,3,3,3,3,3,3,3,b,4
a,4,o,o,oa,ob,oc,od,oe,4
4,x,xa,o,o,oa,ob,oc,od,0
0,3,3,3,3,3,3,b,ba,4
0,3,4,4,4,4,5,5,5,5
0,1,3,3,b,b,ba,bb,bc,3
0,1,1,b,b,bb,bb,bc,bd,5
0,3,4,4,5,5,5,5,5,5
5,0,0,0,4,4,4,4,5,1
5,0,0,0,0,4,5,5,5,1
5,5,5,5,5,n,0,0,0,0
3,3,3,3,3,3,0,0,0,2
2,0,0,0,1,2,2,2,5,5
0,1,1,1,3,3,3,5,5,5
5,o,o,oa,oa,ob,oc,od,oe,1
1,5,x,xa,o,o,oa,ob,oc,0
5,5,x,x,o,oa,ob,oc,od,0
@COLORS
0 0 0 0
1 0 255 255
2 0 60 60
3 0 100 100
4 0 150 150

The rule lags easily even with small soups, thanks to the state 3 wickstretchers.

Code: Select all

x = 16, y = 16, rule = Boidstest
A3.A.A2.2A2.A.A$.A.A2.A.2A.A.A.A$A3.2A2.2A.5A$2.2A2.3A.5A$2.A3.2A3.A2.
2A$.3A.2A2.A3.A$2.4A.A.3A$A.A.A4.2A.2A$A.2A.2A.A2.A2.2A$A4.2A5.A.2A$2.
A.5A5.A$A2.5A2.A2.A.A$2.A3.2A.2A3.A$A4.A.3A$.2A3.A5.2A.A$3A.2A.4A.A2.
A!
@RULE Boidstest
@TABLE
n_states:9
neighborhood:Moore
symmetries:permute
var a={2,3}
var b={0,2,3}
var n={0,5}
var o={0,1,2,3,4}
var x={0,1,2,3,4,5}
var aa=a
var ab=a
var ac=a
var ba=b
var bb=b
var bc=b
var bd=b
var oa=o
var ob=o
var oc=o
var od=o
var oe=o
var xa=x
1,4,o,o,oa,ob,oc,od,oe,0
4,1,o,o,oa,ob,oc,od,oe,5
0,1,b,ba,0,0,0,0,0,2
0,2,2,a,b,0,0,0,0,2
2,a,a,ab,ac,o,oa,ob,oc,3
0,3,3,3,3,3,3,3,b,4
a,4,o,o,oa,ob,oc,od,oe,4
4,x,xa,o,o,oa,ob,oc,od,0
0,3,3,3,3,3,3,b,ba,4
0,3,4,4,4,4,5,5,5,5
0,1,3,3,b,b,ba,bb,bc,3
0,1,1,b,b,bb,bb,bc,bd,5
0,3,4,4,5,5,5,5,5,5
5,0,0,0,4,4,4,4,5,1
5,0,0,0,0,4,5,5,5,1
5,5,5,5,5,n,0,0,0,0
3,3,3,3,3,3,0,0,0,2
2,0,0,0,1,2,2,2,5,5
0,1,1,1,3,3,3,5,5,5
5,o,o,oa,oa,ob,oc,od,oe,1
1,5,x,xa,o,o,oa,ob,oc,0
5,5,x,x,o,oa,ob,oc,od,0
@COLORS
0 0 0 0
1 0 255 255
2 0 60 60
3 0 100 100
4 0 150 150

[MortezaRahmani]

What do you mean by no python, lua, ada, and other languages? as in they cannot be used to identify patterns, so we would need to manually search? also, is this challenge limited to life or also to OCA? And also, with all due respect, why this specifically?

If OCA is allowed, I'll assume LtL is also allowed, so there's probably some very niche mapped rule that is very very hard to find but can accomplish the goal.

And if OCA is allowed, are coded rules (Like the one in the post below) allowed? since they still categorize as OCA.

Thanks for the questions. To clarify:
By "no programming languages", I mean no external programming to search for, generate, transform, or control the solution. Manually searching existing rules or patterns is fine.
I'm happy to allow OCA, including LtL and other rule families. Coded OCA rules such as RuleTables are also allowed, as long as they are used directly through Golly's native capabilities.
As for "why this specifically?", I'm not claiming the countdown itself is new. The interesting part for me is the specific visual effect shown in the example: the current digit fades/disappears while the next digit emerges, producing a genuine 9-to-0 countdown.
I haven't solved it myself. I'm asking whether this particular effect can be achieved using Golly's native capabilities without external programming.

[unname4798]

A preblock can be a still life:

Code: Select all

x = 2, y = 2, rule = Boidstest
2E$E!
@RULE Boidstest
@TABLE
n_states:9
neighborhood:Moore
symmetries:permute
var a={2,3}
var b={0,2,3}
var n={0,5}
var o={0,1,2,3,4}
var x={0,1,2,3,4,5}
var aa=a
var ab=a
var ac=a
var ba=b
var bb=b
var bc=b
var bd=b
var oa=o
var ob=o
var oc=o
var od=o
var oe=o
var xa=x
1,4,o,o,oa,ob,oc,od,oe,0
4,1,o,o,oa,ob,oc,od,oe,5
0,1,b,ba,0,0,0,0,0,2
0,2,2,a,b,0,0,0,0,2
2,a,a,ab,ac,o,oa,ob,oc,3
0,3,3,3,3,3,3,3,b,4
a,4,o,o,oa,ob,oc,od,oe,4
4,x,xa,o,o,oa,ob,oc,od,0
0,3,3,3,3,3,3,b,ba,4
0,3,4,4,4,4,5,5,5,5
0,1,3,3,b,b,ba,bb,bc,3
0,1,1,b,b,bb,bb,bc,bd,5
0,3,4,4,5,5,5,5,5,5
5,0,0,0,4,4,4,4,5,1
5,0,0,0,0,4,5,5,5,1
5,5,5,5,5,n,0,0,0,0
3,3,3,3,3,3,0,0,0,2
2,0,0,0,1,2,2,2,5,5
0,1,1,1,3,3,3,5,5,5
5,o,o,oa,oa,ob,oc,od,oe,1
1,5,x,xa,o,o,oa,ob,oc,0
5,5,x,x,o,oa,ob,oc,od,0
@COLORS
0 0 0 0
1 0 255 255
2 0 60 60
3 0 100 100
4 0 150 150

The most hilarious way to write 2:

Code: Select all

x = 8, y = 14, rule = Boidstest
2A.2A.2A$2A.2A.2A2$6.2A$6.2A2$2A.2A.2A$2A.2A.2A2$2A$2A2$2A.2A.2A$2A.2A
.2A!
@RULE Boidstest
@TABLE
n_states:9
neighborhood:Moore
symmetries:permute
var a={2,3}
var b={0,2,3}
var n={0,5}
var o={0,1,2,3,4}
var x={0,1,2,3,4,5}
var aa=a
var ab=a
var ac=a
var ba=b
var bb=b
var bc=b
var bd=b
var oa=o
var ob=o
var oc=o
var od=o
var oe=o
var xa=x
1,4,o,o,oa,ob,oc,od,oe,0
4,1,o,o,oa,ob,oc,od,oe,5
0,1,b,ba,0,0,0,0,0,2
0,2,2,a,b,0,0,0,0,2
2,a,a,ab,ac,o,oa,ob,oc,3
0,3,3,3,3,3,3,3,b,4
a,4,o,o,oa,ob,oc,od,oe,4
4,x,xa,o,o,oa,ob,oc,od,0
0,3,3,3,3,3,3,b,ba,4
0,3,4,4,4,4,5,5,5,5
0,1,3,3,b,b,ba,bb,bc,3
0,1,1,b,b,bb,bb,bc,bd,5
0,3,4,4,5,5,5,5,5,5
5,0,0,0,4,4,4,4,5,1
5,0,0,0,0,4,5,5,5,1
5,5,5,5,5,n,0,0,0,0
3,3,3,3,3,3,0,0,0,2
2,0,0,0,1,2,2,2,5,5
0,1,1,1,3,3,3,5,5,5
5,o,o,oa,oa,ob,oc,od,oe,1
1,5,x,xa,o,o,oa,ob,oc,0
5,5,x,x,o,oa,ob,oc,od,0
@COLORS
0 0 0 0
1 0 255 255
2 0 60 60
3 0 100 100
4 0 150 150

[CasperWen8805181]

By "no programming languages", I mean no external programming to search for, generate, transform, or control the solution. Manually searching existing rules or patterns is fine.

So why not? Manually searching for a specific methuselah (or diehard) in THIS specific configuration will be extremely difficult and time consuming, even programs. One possible method, is the previously mentioned engineered counters. TL;DR: Why are programs not allowed? This problem is already complex enough without programs.

[MortezaRahmani]

By "no programming languages", I mean no external programming to search for, generate, transform, or control the solution. Manually searching existing rules or patterns is fine.

So why not? Manually searching for a specific methuselah (or diehard) in THIS specific configuration will be extremely difficult and time consuming, even programs. One possible method, is the previously mentioned engineered counters. TL;DR: Why are programs not allowed? This problem is already complex enough without programs.

That's a fair point. The main reason is that I wanted this to be a Golly challenge rather than a programming challenge.
I realize that finding the required configuration manually can be extremely difficult, and that programs could make the search much more practical. I know it's very difficult. But what if it works? What if someone actually finds a way? We might then open up a new horizon, a new direction, and perhaps a new way of looking at what Golly can do. And that could lead to ideas and approaches that may prove useful far beyond this particular challenge.
I'm not against using programs in general, and I agree that engineered counters could be a more practical approach. I simply wanted to see whether this particular effect can be achieved without external programming.
If that turns out to make the challenge impractically difficult, I'm open to reconsidering the restriction.

[MortezaRahmani]

We have already explored whether Golly can reproduce phenomena that do not initially look like cellular automata.
So, here is the next challenge:
Can a Julia set be reproduced in Golly using its native capabilities, preferably without programming?
The goal is not simply to display an image of a Julia set, but to find a genuine cellular-automaton approach that can generate this kind of structure.
Can it be done?

JSet.png (398.74 KiB) Viewed 181 times

[unname4798]

Already done. This is a Julia Set of a point (∞,∞):

Code: Select all

!

[MortezaRahmani]

Already done. This is a Julia Set of a point (∞,∞):

Code: Select all

!

Haha, nice one! But I was thinking of something a little more interesting than the Julia Set of (∞,∞).

[TheWayOfTheCon]

Haha, nice one! But I was thinking of something a little more interesting than the Julia Set of (∞,∞).

I've never seen something like that be generated with normal cellular automata before. This might require a custom neighborhood to pull off, maybe a third state as well.