It's beautiful though.

I still wonder what my own works would eventually actually look like. I need to make an iterative density plot version of it somehow. - In my old mathematica code I just evaluated all the points without ever actually plotting the result mid-calculation to see how it progresses. If anybody has a take on it, that would be nice.

Also, is there a similar, what appears to be a closed form, for this variant of the Metabrot compared to the other?

Just to reiterate, here is the Mathematica code that recursively builds all points in the set given a specific value for c and up to a specific recursion depth n:

z[0, _, _] := 0

z[n_, c_, -1] := {1/2 (1 - Sqrt[1 - 4 z[n - 1, c, -1]]) + c,

1/2 (1 + Sqrt[1 - 4 z[n - 1, c, -1]]) + c}

z[n_, c_, 1] := {1/2 (1 - Sqrt[1 - 4 z[n - 1, c, 1]]) + c,

1/2 (1 + Sqrt[1 - 4 z[n - 1, c, 1]]) + c}

z[n_, c_] := {z[n, c, -1], z[n, c, 1]}

Yesterday I coded up what should be the equivalent function in Python:

import collections

from cmath import sqrt

def flatten(l):

for el in l:

if isinstance(el, collections.Iterable) and not isinstance(el, (str, bytes)):

yield from flatten(el)

else:

yield el

def z(n, c, b=None):

if n == 0:

yield 0

elif b == -1:

for _z in flatten(z(n-1, c, -1)):

yield .5 * (1 - sqrt(1 - 4 * _z)) + c

yield .5 * (1 + sqrt(1 - 4 * _z)) + c

elif b == 1:

for _z in flatten(z(n - 1, c, 1)):

yield .5 * (1 - sqrt(1 - 4 * _z)) + c

yield .5 * (1 + sqrt(1 - 4 * _z)) + c

elif b is None:

yield flatten(z(n, c, -1))

yield flatten(z(n, c, 1))

So what has to be done with this code is to evaluate it with all possible values for c: That would then be the actual Meta-Mandelbrot Set. For any specific value of c, it's the Meta-Julia-set.

To find my potential closed form expression, I simply kept expanding larger and larger meta-iterations of the M-set as given at the start of the other thread, and I observed that the first few polynomial coefficients remained constant; the polynomial family converged to a limit which appears to be the expansion of

which is one of two inverses of

, the other one being

. These two formulae are what the above functions iterate over.

It was relatively easy due to c not being involved in the iteration though. This new take also involves powers of c and thus it will be quite a bit tougher, I assume.

Though perhaps it's just as simple to do. Gotta expand a bunch of terms and see if any pattern emerges.