ConwayLife.com

EDIT: For note, Real-valued CA is also known as "coupled map lattice(CML)"

Why not?

convolution filter
1 1 1
1 9 1
1 1 1

or

1 1 1
1 1 1
1 1 1

mapping function
m(x)=tanh(x/10).*sin(x)
where x=floor(10*x)/10

(1) rulecurr=@(a) tanh(a/10).*sin(a)
(2) rulecurr=@(a) tanh(a/5).*sin(a)
(3) rulecurr=@(a) sig(a-4.5);
(4) rulecurr=@(a)sin(a/3)

matlab code

So familiar
These plots are lovely tools to explore bifurcations/phase transition.

A somewhat analogue to outer-semi-totalistic rule.

I am quite re-assured that real-valued CA (rvCA) shares many features with discretized CA from the simulations. These including strips, gliders, synchronized patches, bistable states, surface waves, etc...

How could rvCA and dCA share so many features? My speculation is "spontaneous discretization"(SpD), namely the continuous peak spontaneous split into 2 peaks, responding to a change in parameter (similarly to bifurcation in dynamic systems). The fact that the lattice is spatially discrete should aid the process, but probably not an essential for such SpD process (as reflected by M. Rob's study on DE-based Gray-Scott model). How to analytically deduce the manifold where SpD took place, where SpD took a phase-transition nature, would be an open problem.

More importantly, these phenomena exhibit a nice transition on varying some real-valued parameter (px and py), and sometimes a sharp transition. The 1st quadrant gives a particularly nice visualization of such transitions, where you have gliders sandwiched between emptiness and ordered states, and ordered states transiting into more ordered strips. Depending on the parametrization and the distribution of parameters' values, we shall obtain different visualisation with desired advantages.

If we consider a tiny patch of the parametrized phase space, and zoom in on this tiny patch, we can then ignore the variability in the parameters and assume a homogeneous space where every cell follows the same set of recurrence rules (same in the sense of identical set of parameters). In this sense, the derivative direction of any point on the parametrized rvCA manifold can be expanded into a homogeneous rvCA space. This nice property allows fine adjustment of the granularity/scale of the model.

The limitation of such method lies in manual choice of the kernel function. i.e. the function we choose to parametrize. The original outer-semi-totalistic is a fragmented space with a discrete topology. How to project this DCA space is somewhat arbitrary, yet implicitly constrained. How to make sensible choice of the manifold would remain an intriguing open question.

PS: This study is strongly influenced by M. Rob's study on the Gray-Scott model. http://mrob.com/pub/comp/xmorphia/

For future reference, 'M. Rob' --> 'Robert Munafo'.

[min_px, min_py;
max_px, max_py]
=
8.4879 -3.9412
8.4933 -3.9384

return map histogram that shows Spontaneous discretisation accompanying CA

A read-valued representation of B3/S23 and other outer-semi-totalistic rules, where the detection of gliders is equivalent to detection of moving bubbles.


Peak representation


And of B01358/S03

Low-density


High-density

Wow! It's interesting to see your CAs. Too bad I don't know how to use matlab nor can I get it right now...

Scorbie wrote:Wow! It's interesting to see your CAs. Too bad I don't know how to use matlab nor can I get it right now...

Thank you Scorbie. The structure of these CA are inherently simple. The trick is to make sure the updating function has a bounded value-range so that nothing explodes. It's important that you remind me that not all forum users can access matlab which I falsely assumed.

The main hurdles for me to programme (let's say python) elsewhere than matlab is to do efficient updates and to visualise the output. In matlab, using conv2()/convn() to do convolution instead of a for loop significantly speeds up the updating, I am not aware of any equivalent command in python. Visualising output in matlab is straightforward using imagesc() and set(,'CData',). In contrast, I knows nothing about python gui.

A forloop equivalent of conv2 would looks like Having said that, implementation elsewhere than matlab should be straightforward to people with proficient in their programming language .(Matlab is the easiest programming language for me and that's why I stick to it. Another reason for using matlab is that much of this is experimental so writing in matlab allow me to change the structure quickly. (So that I spend all day coding and miss my deadlines ))

PS: As indicated in the pictures I have played with several updateFcn, including cosine() sine() mod() floor() and their scaled composition. The real power lies in the ability to smoothly vary the function by changing the scale parameter, namely px and py.
PPS: As for recent post for outer-totalistic rules, it was born out my attempt to canalising CA pictures by finding the edges. And it seems to work fine so far.

shouldsee wrote:The main hurdles for me to programme (let's say python) elsewhere than matlab is to do efficient updates and to visualise the output. In matlab, using conv2()/convn() to do convolution instead of a for loop significantly speeds up the updating, I am not aware of any equivalent command in python. Visualising output in matlab is straightforward using imagesc() and set(,'CData',). In contrast, I knows nothing about python gui.

The Python library scipy contains functions such as convolve, convolve2d, and fftconvolve. It's built on top of Python's linear algebra package numpy, which uses the same old Fortran libraries (BLAS and LAPACK) used by Matlab under the hood.

Also, the plotting library pyplot (aka matplotlib) gives you Matlab-style plotting capabilities from Python.

I can speak from experience of having used scipy, numpy and matplotlib -- they're really intuitive and complement each other very well. Indeed, Python seems decidedly deficient without these libraries.

calcyman wrote: The Python library scipy contains functions such as convolve, convolve2d, and fftconvolve. It's built on top of Python's linear algebra package numpy, which uses the same old Fortran libraries (BLAS and LAPACK) used by Matlab under the hood.

Also, the plotting library pyplot (aka matplotlib) gives you Matlab-style plotting capabilities from Python.

I can speak from experience of having used scipy, numpy and matplotlib -- they're really intuitive and complement each other very well. Indeed, Python seems decidedly deficient without these libraries.

Thanks for the tips. Will give a try had I any time.

An unexpected continuous CA analogous to Brain's Brain.


With homogeneous parameter, we have:


I also made a guess about the shape of separatrix, with a rescaled sigmoid function, where sig(x)=[1+erf(x)]/2.
ACTUALLY, the separatrix simpifies to px=7*erf(py), possibly connected to the use of mod(Sinput,8) and mod(cells,1). conv filter is:
1 1 1
1 0 1
1 1 1

Bubbles at px=-14.8 py=2.1
mod1=8,mod2=1;
px/py ~= 7 == mod1-mod2

I made an implementation of this system on Ready, which features OpenCL and supports a rich extension of CA.

Remember to initialise the system before running it.

I've also been working on a program in D to run a continuous-valued equivalent of B3/S23, but my results haven't looked anything like yours. Would you mind clarifying how the update rule works for that cvCA?

Here's what I've done,

Radius = 1: Radius = 2:
I'm using the sigmoid functions from this page: https://0fps.net/2012/11/19/conways-gam ... es-part-1/

I've used 5/16 to 7/16 as the birth interval, and
The gifs below were recorded with alpha_n = 1/16, alpha_m = 1/2. I've experimented with others, but none have produced the ring-like patterns you posted.
alpha_n is width of sigmoid for # of neighbors, alpha_m is the width of the sigmoid for cell state

The transition function looks like this: x axis is average of neighbors, y axis is cell state (top = 0 bottom = 1)

CaveBacon wrote:I've also been working on a program in D to run a continuous-valued equivalent of B3/S23, but my results haven't looked anything like yours. Would you mind clarifying how the update rule works for that cvCA?

Hello CaveBacon,

To clarify, I want to list things I have and have not done:

Done:
1. Extend the state values to a continuous set. Correspondingly, use continuous mapping function to update the configuration. This mapping function is in the form of s(x,t+1)=f( s(x,t), mean( s(y,t) for y neighboring x) ).
The map function look like this if heat-colored. (This one involves taking modulus, where f(a,b)=c0*mod(a,m)+c1*mod(b,m) ) 2. Apply Gaussian filter to B3/S23 to identify the edge and make it look better.

Not done:
3. Smoothen the lattice (Which is done in SmoothLife)

Hope these info help.
Kind regards

seesaw 2D replicator in Gary-Scott system
READY implementation

Notice this replicator follow roughly a seesaw growth rate, as opposed to steady growth rate seen in previous GS replicator



compare its dynamics with a 2D replicator in classical CA.

It'd be great if someone can find a glider in this extended logistic rule.

(large bump)



I've been exploring a simple real-valued-state CA rulespace with only 2 (real-valued) parameters using a bad piece of C++ code I've written. Each cell updates like this:
n is the sum of the cell neighborhood (including the cell itself)
new_value = max(0, -(x - a)^2 + b)

The rule is similar to B3/S2 when a=3, b=1. When b=1, the critical a is between 2.92 and 2.93. When b (and a) are lowered, the rules get more blobby. The rule a=0.1, b=0.7 is like Walled Cities (B45678/S2345), but slowly expanding. a=1.5,b=0.5 is similar to 34-Life (B34/S34). There might be a "triple point" for the parameters, below which the rule will transition directly from exploding/class 3 to never-expanding/class 2

Also, I accidentally discovered some (seemingly monochromatic) replicators and spaceships in a=5, b=10.

The colors are weird. a increases to the right and b downwards.
This image shows a "dead zone" between explosive rules and stable ash, caused by instability of the ash. a ranges from 6 to 9 and b from 2.8 to 3.2.
Bigger map. Some weird gaps are visible.