Welcome to Fractal Forums

(http://u5789.direct.atpic.com/25268/0/1247800/1024.jpg) (http://pic.atpic.com/1247800/1024)

At first, this looks like a tear in space, opening onto a strange new world.

There is a strange new world, alright: the world of Matchmaker, a two-parameter family of rational maps capable of generating arbitrary pairs of quadratic Julia sets, intertwined.

A technical explanation follows.

Freely redistributable and usable subject to the Creative Commons Attribution license, version 3.0.

Detailed statistics:

Name: Portal II
Date: February 8, 2009
Fractal: Matchmaker Mandelbrot set
Location: b-plane, a = 0.53256 + 0.31163i
Depth: Very Shallow
Min Iterations: 1
Max Iterations: 1,000,000
Layers: 4
Anti-aliasing: 3x3, threshold 0.10, depth 1
Preparation time: 1 hour
Calculation time: 2 days (2GHz dual-core Athlon XP)

There is a strange new world, alright: the world of Matchmaker, a two-parameter family of rational maps capable of generating arbitrary pairs of quadratic Julia sets, intertwined. Technically, it has two critical points, and so depending on the parameters there may be zero, one, or two finite attractors. Moreover, the finite attractors bifurcate independently, so any two connected quadratic Julia sets can be forced to tile the entire Riemann sphere together.

I constructed Matchmaker by starting from the map , which Mandelbrot himself studied and which also has two critical points. The critical points of f(z) have complementary fates, which leads to three possible behaviors: no finite attractors; two finite attractors that are rotated images of one another; or one finite attractor that is invariant under a 180 degree rotation and that captures both critical points. The latter divides into two cases, the attractor is the fixed point zero and the attractor is an even-length cycle.

It is important to note that infinity is not a critical point or an attractor here. It is a preimage of zero, and since it is repelling for . (In Matchmaker, this becomes a more irregular shape and the fixed point moves off of the origin.) For these points, the Julia set contains both infinity and zero. Since f(z) is an odd function, it is rotationally symmetrical as well, and has two copies of the same quadratic Julia basin entwined, typically spiraling about zero and infinity, for parameter values that yield attractors. Its Mandelbrot set is a circle containing internal Mandelbrot buds, along with a "foam" of minibrots amid points for which there are no attractors. The Julia sets are interesting; the Mandelbrot set is difficult to visualize and is fairly boring (no seahorses, etc. can be seen with any of the visualization tricks I know).

I decided it would be interesting if instead of entwining two copies of the same quadratic Julia set, I could entwine two arbitrary quadratic Julia sets. So I tried perturbing f(z). My first attempt, , did exactly that, and Matchmaker was born.

The original f(z) is a subfamily of Matchmaker obtained when a = 0, and its Mandelbrot occurs as the b-plane through the origin of the Matchmaker parameter space. The Mandelbrot images produced from other slices, even parallel ones, can be very interesting, as shown here.

In this image and in the first Portal, both critical points are studied. In Portal (http://www.fractalforums.com/images-showcase-(rate-my-fractal)/portal/), black points have no attractors (the Julia set is the whole Riemann sphere). Grey/blue points have one attractor. Pink points have two. The gradients in the latter two areas map smoothed iterations, calculated for both critical points and then averaged (unless one critical point failed to converge to anything; then only the other's smoothed iterations value gets used).

In Portal II, there are two more layers. One colors the points with no finite attractors; the critical points are iterated in tandem and their separations after each iteration are recorded and averaged. They can get quite far apart, since the numerator degree doesn't exceed the denominator degree and so infinity is not a special point on the Riemann sphere for this map.

The other additional layer brings out the filament structures visible in the one-attractor regions. These filament structures can include all the familiar Mandelbrot bestiary: seahorses, elephants, and so forth.

This filament structure results when the critical point that doesn't "own" the attractor wanders through the dynamic plane and sometimes hits the Julia set, and so has Misiurewicz points and other structures. Where this occurs, the difference between the two smoothed iteration values jumps as it's much higher for the critical point that's near the Julia set than it is for the one that's in the immediate basin of the attractor. So this difference is used to enhance the filament structure using a solid-white layer with an alpha channel that goes from transparent to opaque as the difference rises.

Near the filaments, typically one converges slowly (the one associated with the filaments and with a nearby other bud) and one converges quickly (the one associated with the bud we're in).

The filaments can also be made to contrast more, without an added layer, by weighting the average of the two critical points' smoothed iteration values; weighting 99% in favor of the one with more iterations, at each point, tends to do an okay job. Here, though, the difference-layer method is used.

Now some details about the structure of this Mandelbrot.

The outer grey "void" is actually the period-1 component. The Julia sets here are dusts, with nearly every point going to the sole attractor (which is not generally zero; in Matchmaker, zero goes to and therefore is not a fixed point for ).

The large circular bud is period-2. In this and all higher-period components where there is just one attractor, the Julia set is connected: if the period is n, consider the rational map made by composing Matchmaker with itself n times, and note that the period-n attractor of the original map must be n attracting fixed points of this map, and their basin boundaries must coincide with one another and with the Julia set, which must be the Julia set of the original map. Hence that Julia set is connected and the attracting basin tiles the Riemann sphere with connected chunks of itself. The result is to take a quadratic Julia set and "extend" it and fold it in on itself to densely cover the entire Riemann sphere.

But the really interesting stuff happens where two attractors coexist. At these parameter values, one gets arbitrary pairs of connected quadratic Julia sets that each have to fill the space outside the other, so they become fractally entwined in extravagantly complex and beautiful ways.

The downside is that long calculation times are inevitable with Matchmaker images. The Julia sets frequently require aggressive antialiasing to render decently, whereas the Mandelbrot images are plagued by large expanses of space within which there are no attractors in the dynamics, every point in which therefore has to be iterated to the max. And the max needs to be set high, at least a million, to get a decent component interior gradient. To add insult to injury, for the Mandelbrot images the calculation time gets a final doubling from iterating both critical points.

Numerous Mandelbrot and (especially) Julia images are forthcoming.

Eventually.

Very interesting, although I did not understand everything  :hmh: :D


What about a 3D render of these slices ?


Waiting for the pictures ! If you do it in Ultrafractal, would you mind sharing the file ?

By the way, you seem to have good knowledge of the relationship between maths and nice images, so I have a quick question:

Tell me if I'm wrong. In the M-Set, my understanding is that, graphically, Misiurewicz points are the intersection of branches, or at the center of spirals, or any point that seems to be at the center of something. This is also where almost perfect self-similarity occurs when you keep on zooming. These Misiurewizc points can be found almost everywhere near the border, and I also think that you can find an M-point as close as you want to another given M-point. So everywhere near the border, there are kind of M-Point "clouds", infinitely dense at there center.

I noticed that a technique to find nice images in the M-set is to zoom a lot near M-points, then zoom into one of the branches and find a minibrot, find another M-Point in this minibrot, and deep zoom again into the spiral, etc...It works great by zooming in the successive minibrots alternatively into elephant and seahorse valley, and the main antenna. Zooming deep to find a minibrot is not very important, you can choose a big one, it's better to use the zooming power near the M-points.

So, how can you explain in simple mathematical terms, that most (all ?) interesting images produced by deep zoom into the M-set are near M-points ? And does my question make sense ?  :D

I'm working on a formula for UF that will allow detection/colouring of periodic attractors in a similar way to how Paul is doing it - but in UF it's not straightforward because detecting and colouring a periodic attractor requires the main fractal formula and colouring formula to work together in a way that's not really possible using the standard UF format.
However the new UF5 classes give a way to do this such that any main class formula and any class colouring could be used with a bailout based on detecting periodicity, the trick is to have the selected fractal formula (UFM) set to a "pixel" formula that bails out immediately and have all the iterations done in a controlling class colouring (to be used 'Outside') that allows you to select a class main formula and a class colouring and all the iterations are performed from the controlling colouring - this way you can link together the data from a main formula and a colouring in almost any way you like. Actually I'll write the controlling colouring so that you can select two different class colourings, one for 'inside' and one for 'outside'.
Hopefully I'll be ready to upload something to the UF formula database at the weekend....

Thanks.


Sorry, don't currently have the means. Maybe someday.


I've already posted some. Search for "matchmaker" in this forum.


Branch tips, and so forth, yes. Actually, they are dense in the boundary of M, as are parabolic points, Siegel-disk points, and types of points that are none of the above. (The accumulation point at the tip of all the buds on the x-axis is one such point.)

To see this, consider that if you have any piece of the M-set with buds visible in a zoom, you can zoom near one of the buds to find filaments, and if you have any piece of a filament in a zoom, you can zoom into it and find a minibrot, or zoom into it and find a branch point.

More technically, you can study the mathematics used to prove the set connected. A side-effect of the proof's construction is to assign every point on the boundary of M an "external angle" between zero and one, with zero at the cardioid cusp increasing clockwise around the set's boundary to 1 back in the cusp, with 0.5 at the tip of the spike at "utter west". It turns out that:

• Bud attachment points, called parabolic points, have two rational external angles with odd denominators when expressed as a fraction in lowest terms; the main cardioid cusp can be thought of as having 0/1 and 1/1 as its two fractions.
• Misiurewicz points have one or more rational external angles with even denominators when expressed as a fraction in lowest terms. The spike tip with 1/2 is one example. The ones with a power of two tend to be branch tips; branch forks have more than one external angle like 1/12, 5/12, and 7/12 or similarly in lowest terms, sharing a common denominator. Seahorse "eyes" and the fork in the "far north" are examples.
• These are necessarily dense in the interval 0...1 but at the same time are a countably-infinite drop in the uncountably infinite bucket of all points in that interval. By far the vast majority of the external angles are irrational. A subset of these are the points whose Julia sets are Siegel disks, on the boundaries of buds and cardioids but not the attachment point of any bud or cusp of any cardioid. This subset is dense by the argument given above, that in any zoomed image containing part of the boundary of M you can zoom further and find a minibrot, and on that a point with a Siegel disk. Indeed, even points with internal angle the golden mean in their component are dense in the boundary of M, since you can find a minibrot and then find the point on its cardioid with that internal angle.
• Not all the irrational points are Siegel disk points; the accumulation points of buds of buds of buds... are also irrational points (since they are not Misiurewicz points nor are they parabolic points, which exhaust the rational points, they must be) and are not Siegel disk points, and these alone also form a dense subset of the boundary since again you can zoom any image containing boundary to find a minibrot and then zoom the accumulation point of the axis buds of this minibrot.

For more information, I refer you to The Beauty of Fractals, by Heinz-Otto Peitgen and Peter H. Richter. (It's hard to find and expensive; you might try finding it via file-sharing network or see if you can eventually get at most of it with carefully crafted Google Book Search queries. I'm fortunate enough to have a physical copy, which sometimes comes in handy.)

Have got a formula for UF that has periodic bailouts and works pretty accurately, it's not that fast as it's a generic version of the algorithm i.e. it can detect any period for any pixel - you can specify a range of periods to test for or up to 10 specific periods. The problem with this sort of bailout detection is that bailing out say for an attractor of period 6 will often produce bailout in areas of period 2 or 3 as well - extra iterations are necessary to avoid this problem.
It's not quite finished yet - I'm going to add some dedicated colouring for it.
Also I'm going to do another formula that will make use of UF's switch facility to specify a pixel (or pixels by repeated switching) that should be iterated to the full in the global section in order to find the attractors very accurately - the attractors thus found can then be used in the main fractal iterations to find the same attractors for other pixels much faster and more accurately than the generic formula - this just won't work too well on Mandelbrots, it's specifically for Julias and other escape-time fractals where large areas converge to specific attractors i.e. for when viewing specific attractor basins rather than basins of many different attractors of the same period.

I have been using a more general method.

For Mandelbrot images, in particular, I iterate the point in tandem with itself: on odd iterations, I step only one of them, and on even iterations, I step both. After that I compare them for being close to each other. Of course, on the first iteration, both start out as z₀, one gets stepped forward, and then they get compared, so it doesn't trap right at the start on every pixel.

When a cycle is detected, I determine its period by saving z, iterating some more until it goes close again, and counting those iterations. If I want to do something different depending on its period, the number I have is the actual period rather than possibly a larger multiple of it.


This might be handy to optimize Julias for multivariable maps, like Henon/Phoenix. For single-complex-variable maps there is a wonderful shortcut: you only have to iterate the critical values of the map, for which there are analytic formulae, and see where they go. While finding the periods of all attractors you can also detect if two went to the same one.

Furthermore, you can do this even with Mandelbrot maps, coloring differently depending on what all of the critical points did. Sometimes this gives you a more complete picture of the map's behavior, though it can wind up giving you a more cluttered picture in many cases.

With Julia maps, though, you can do this once at the start of the image, record the attractors, and then check just against them in the main loop.


Not as a speedup no. As noted above, it can produce interestingly informative images if done for every pixel, but at a cost of actually slowing things down (by iterating every pixel multiple times; with four critical values of interest the workload is quadrupled, for instance).

A Mandelbrot speedup that might work though is to check each pixel just for the period found for the previous pixel. If it trips, go once around the attractor to see if the period has actually halved or otherwise reduced by a factor; if it does not and hits an iteration limit, iterate some more using the generic cycle-detection method, and if you find an attractor that way record its period; now you know the period of this pixel. This might lead to quite fast iteration of lines of pixels crossing buds, as it knows the bud's period for most of them and can just iterate period times, compare to saved z value, if not close save over it with current z value, iterate period times...

This does very little extra work per iteration, compared with the generic-periodicity-detection which adds 50% to the work done.

I think I follow your method, but if you colour the standard Mandelbrot and set your algorithm to bailout only on divergence or on a period of 2 does it colour correctly (with the rest as 'inside') or do you get some of the period 1 main cardoid bailing out as having a period of 2 ?

Since I'm writing the algorithm to work for any generic main formula it's not really possible to find and iterate the critical values - for that you'd need individual algorithms for every main formula.

It's not only a period of 2 though. Since one iteration proceeds with half the speed of the other, it catches cycles of any length. With a cycle of period 1, for instance, eventually the slower iteration will settle near the attractor and the faster one will already be there -- trapped. With a cycle of period 2, eventually the slower iteration is jumping between the attractor points, but it won't stay out of phase with the faster iteration; half the time they should be in phase (slow on point 1, fast on 1, slow on 1 fast on 2, slow on 2 fast on 1, slow on 2 fast on 2, so in fact it gets two chances to catch that there's a 2-cycle, then two iterations where it can't discover this, then two more chances, until they're all close enough for the trap to be sprung). With period 3, again there will be some times when the difference between the number of iterations of the slower one and the number of iterations of the faster one is a multiple of three, and then they're in phase. Something like *...*...* repeating with * indicating in-phase, so a chance to detect the cycle, so the cycle can be detected on one third of the iterations over time. This pattern continues; if the cycle has period 79, only every 79th iteration on average there's a chance to catch the cycle, though it will be 80, 80, 80, ..., 1, 80, 80 instead of a steady series of 79s.

This method of cycle detection is not original to me, though; it is known as Floyd's algorithm. See http://en.wikipedia.org/wiki/Cycle_detection (http://en.wikipedia.org/wiki/Cycle_detection).

This does not discover the actual period though. It just discovers the fact of periodicity. Discovering the actual period is done by saving the current iterate, then iterating and counting these iterations until the saved value is approached again. For a cycle of period 79, for example, this entails an additional 79 iterations.

Furthermore, the iteration numbers at this point are not the best choice to color with. Re-iterating the point from scratch until it hits a trap around the discovered attractor gives better results.

All of the above can be optimized by saving the orbit, having the slower iteration just step through the saved orbit instead of repeat the calculations, and using the saved orbit to get the final iterations-until-trap-hit value as well, but at a potentially colossal cost in memory. The saved orbit is likely to be gigs if you are into the hundreds of millions of iterations, or even just the millions with big enough bignums.

Hence the two further optimizations:

• For Julia sets, discover the attractors, e.g. by sampling critical values first, then test against the known attractors. If the critical value method can't work, an alternative is to have a growing set of discovered attractors; points iterate until a known attractor is hit or the iteration maximum is hit. If the latter, rerun with cycle detection to discover the attractor, and add it to the set, then recalculate the point again to get the proper coloring. This should happen only once per attractor, unless an exact hit on a point belonging to the Julia set itself occurs.
• For Mandelbrots, the attractors move from point to point so instead, remember the period of the last point and see if the point escapes (hits an always-there attractor) or has that period first (iterate p times, compare to saved value, overwrite saved value, iterate p times...; also catches divisors of that period, useful if you move into a bud's parent bud or cardioid). If it does not (iteration limit hit), rerun with generic cycle detection, determine actual period, remember that. If it does, see if the real period is a proper divisor, both to save the correct period for the next point to test for and to use the correct period in coloring. This time, again, the full general period detection only gets done infrequently: whenever the rendering moves into a bud or cardioid from either a lower-period one or the outside. However, it is generally necessary to iterate periodic points twice for best results, once to discover their fates and once more to discover the exact number of iterations to hit a trap around the attractor.

One possible further optimization is to save part of the orbit, say the most recent N values (using a ring buffer) for some N chosen to limit memory consumption. If the number of iterations when a cycle is detected is less than N, you have the whole orbit to play with. Even if it's more, the first point to land within the trap radius of the attractor may be in those last N iterates, and the iteration number can then be computed without recalculating the point. If a point hits maximum iterations while looking for a particular period, you can look in the saved part of the orbit for other cycle lengths, or simply save the current iterate (as it's probably already converged to a cycle) and iterate it some more until it lands near the saved value; if it does so in a short enough time, you've both discovered that it converges and discovered the actual period. Then that saved orbit can be examined to see if the first point to land in the appropriate trap disk is in there, though it probably isn't.

However, a more sophisticated technique might be possible: given a point that's converged much closer to the target than "just landed in the trap disk" you can iterate through one more cycle, see how much closer it got, and estimate the number of "extra" iterations you had: trap radius times shrinkage-factor-to-the-x equals point's distance from attractor, solve for x. This obviously involves a logarithm. The floor of x is the number in question, and the remainder can in theory be used to get the fractional part of the smoothed iteration value as well. How well this would work in practise I don't know as I haven't tried it yet.


Ah. I've been using separate algorithms for every main formula; I plan at some point to generalize this, by having get-critical-values hooks in the main formula. I doubt this would be possible for you using Ultra Fractal though; it needs writing custom software, a next-generation fractal app.

With respect to the using loads of memory, actualy that's the method I'm using as it allows the possibility of pre-calculating the iterations and storing the z values in an array then passing a possibly modified orbit on to the colouring algorithms - this is necessary for say standard generic convergent smoothing to work on a periodic orbit - e.g. for an attractor of period 6 then the values from iterations 0,6,12,18.... are the ones passed on to the colouring as the values for iterations 0,1,2,3.....
My algorithm now only tests for a given period of "n" on every nth iteration, this seems much the best option, but even using this methods requires extra iterations beyond the intitial period detection to avoid the miscategorisation of some periods.


That's a good point. Actually it's perfectly possible to do that in Ultra Fractal 5 using the classes and plug-ins, I just hadn't thought that far ahead with respect to periodic trapping :)
For UF classes see:
http://formulas.ultrafractal.com/reference/

My convergent smoothed-iteration colorings only need the last two or three of those.