Welcome to Fractal Forums

The Mandelbrot set is defined as the set of points that do not escape under a certain repeated transformation. There seems to be no way of extending this transformation to the third dimension. I propose that we don't try to extend it into higher dimension. Instead, we can keep working in the complex plane, and represent multiple points in the plane as different dimensions. Here, let me try to explain this visually:

The mandelbrot set formula transforms the point z0 to z1:
(http://lh3.ggpht.com/_fNiQGJP16I0/TIVPK2XaAiI/AAAAAAAAABQ/3pRazqzPZ2g/s800/complexplanewithpoints.png)

But, we can also represent that as this:
(http://lh5.ggpht.com/_fNiQGJP16I0/TIVPKqmJ_KI/AAAAAAAAABQ/GwHa2RA3L64/s800/complexplanewithlinesegments.png)
We can say that the formula transforms the line segments L0 to L1. One end point, at the origin, always stays fixed, but what if we changed that. What if we vary the point on the x-axis and represent that as the third dimension.

For example, the 3d point (8,4,6) is represented as line segment L0 and is transformed by some unknown formula to L1:
(http://lh5.ggpht.com/_fNiQGJP16I0/TIVV3hOBONI/AAAAAAAAABY/XGdTljijHpM/s800/complexplanelinetransformation.png)

The unknown formula is the hard part, we need a transformation that keeps a line segment with endpoint zero fixed, but chaotic enough to allow the endpoints to interact enough to produce chaotic results.

Further ideas coming. Tell me what you think.

parametric line segment:
(x1,y1)*t+(x2,y2)*(1-t)

so what you search for should be something like:
z(t)=>(z1*t+z2*(1-t))²+c1*t+c2*(1-t) =
((x1+y1*i)*t+(x2+y2*i)*(1-t))²+(a1+b1*i)*t+(a2+b2*i)*(1-t) =>

x(t)=>(t (x1-x2+y1-y2)+x2+y2) (t (x1-x2-y1+y2)+x2-y2)+a2-t (a2-a1)
y(t)=>2 (t (x1-x2)+x2) (t (y1-y2)+y2)+b2-t (b2-b1)

However, that ultimately just expands to a transformation of all the points described on that line at once...
It leads to the very same shape...
But then, you'd have to put in a t to make it realistically computable, which results in just iterating points once again. - points on any given straight line segment between any given two points, but still points.

Also, the line wont stay straight during the iterations. It might be interesting to basically look at 1D-cuts through the 2- or 4D set and see what kinds of orbits it includes, but for the whole set, that's just additional work for the very same thing.

Hello kram, thanks for replying  :)

There are many possible transformations that could be used, but we need one that keeps line segments straight, and make line segments that are connected to the origin behave like the standard mandelbrot iterations.

For example, I just thought of this transformation.

Imagine the line segment to be stretchable(not rigid).
Let d(z) be the distance between z and the origin.
Let a(z) be the argument(angle) of z.
Let r be the length of the line segment.
First, double the a(z) for each of the end points.  Then square d(z) for them. We just did the regular z^2, but with two points. Now here comes the interaction between the two points. Take the line segment, and contract it until its length is the equal to r^2.

You will see that this transformation preserves the origin endpoint property, keeps the line segment straight, and also has the points interact.

There are many other transformations that we could come up with, the challenge is to find the right one.
I need to try this transformation. I'll tell you what I find.  ;D

But wait, how can you add line segments? Need to figure that out for the essential +c.

interesting approach, what about not twiggling with a fixed y axis, instead , why not use just a line segment, consisting of the 2 (complex) points A,B, and iterate those ...  ;)
if the seed value would also be 4 dimensional ( 2 complex numbers) both points could diverge very good, and produce interesting results :D

in my eyes that approach would satisfy the 2d mandelbrot which would be contained, and the rotated 2d mandelbrot ( along x/y axis ) for 3rd dimension

but i think this is the hypecomplex approach as implemented in fractint earlier

Hi Trifox,

Yes, using two complex numbers for end points is ideal, but we must limit it to 3 dimensions somehow, so it's best to have the point vary on the x-axis, and represent that as the third dimension. Although the end point is not limited to the x-axis, it is free to move around once we iterate.  :dink:

And of course we could go above and beyond and iterate triangles(3 points, 6 dimension) and quadrilaterals(4 points, 8d), but I'm only concerned now with just lines, and what transformations produce interesting results.

By the way, no thoughts on adding line segments? Haven't had time to think about it.
Oh wait, add the end points, but in what order? No, must find better way.

Oh I see, I forgot to say how you get a new x1, y1, x2 and y2 from what I did:

x(t)=>(t (x1-x2+y1-y2)+x2+y2) (t (x1-x2-y1+y2)+x2-y2)+a2-t (a2-a1)
y(t)=>2 (t (x1-x2)+x2) (t (y1-y2)+y2)+b2-t (b2-b1)

for x1 and y1, simply set t to 0, for x2 and y2 to 1

In theory, you could force the lines to stay straight by just evaluating the endpoints and redraw the line in between. That might create some funky spirals, somewhat related to those fly-through-tunnel games, where the borders of the world are zillions of squares in a curved array :)

So, all you need is iterate through two complex numbers / points and connect them by a straight line. Very straight forward.
However, I don't see how 3D comes in for any of the transforms until now...

Hi kram,

I think I should have explained how the third dimension comes into this better.

Here is a visual:
(http://lh4.ggpht.com/_fNiQGJP16I0/TIbZM2729oI/AAAAAAAAABw/u2HeSuI_2zI/s800/lineiteratedexplanation.png)

The line L represents a 4 dimensional point, the first values (x,y) is one point, and the second (z,w) is the other. When we actually render this 4d object, we will take a 3d slice of it by setting w=0. The points are free to move around in the plane after we start iterating, and its best if they do because that means we are getting maximum interaction between the points.

And for your parametric equations, now I understand. But, by plugging in 0 and 1, we just accomplish squaring the two complex numbers, the don't interact at all. And if we didn't put in a t and left it as is, it would get horribly more complex each iteration until we ran out of memory to remember all the points or the equation.  :)