after not working on this stuff for quite a while, i then also started a complete rewrite of my mandelbrot program. i haven't quite gotten to the point of acceleration techniques yet, but i am getting close so i started thinking about how i want to approach it, implement the original SA+perturbation technique or just jump right in to what you guys are discussing here. i went back and read through this whole thread, and i at least have a better idea of what you are even describing than when i first saw this discussion.

after reading through all this again, i have a few thoughts. i am not a math scientist like some of you, so please forgive my ignorance if my thoughts or questions are stupid or wrong.

my first observation is that it seems like we came up with a number of different ideas, and proceeded to suffer from the pitfall of "lets implement all the new ideas all at once, and hope it all works out." then when things go wrong, we aren't sure what exactly went wrong, why, or how to fix it. this business of utilizing a "super series" to do "super iterations" sounds awesome of course, but it is more of an additional trick that could perhaps be added on to a general purpose algorithm after first nailing down an implementation of that underlying algorithm.

the algorithm for the general case seems to be "identify the series of roots that leads to this location, then using these roots as references, calculate the location by successively handing off to the next reference." in theory then, the absolute simplest implementation of this algorithm could be by simple perturbation alone. it seems this should likely also eliminate the phenomenon of perturbation "glitches."

in practice, i suppose you would at least want to start with applying series approximation to this algorithm. in theory at least, it seems to me that you should be able to simply recycle the techniques we've already developed for SA: perform the SA with the current reference, using whatever stopping condition youve already decided works well, hand off to the next reference, repeat. once youve worked your way out to the top, you should be pretty close and hopefully be able to finish with normal iterations.

if one was to then add super iterations on to this algorithm, it seems to me the situation you would find yourself in is doing some multiple of period iterations, then being left with some number < period iterations to bridge the gap to the next reference. you would then bridge this gap with normal SA (and/or non-SA iterations if necessary, but hopefully SA always gets you there). if the period of the current reference is an exact multiple of the next reference, then perhaps you could do a direct handoff between super series?

indeed after reading through this thread again, this seems to be the primary point of confusion, debate, and implementation failure, is the handoff between super series. it seems to my mind that gerrit must have been right when he was first insisting that you cant just hand straight off between super series unless perhaps the period is an exact multiple of the other. knighty repeatedly insisted that you should be able to just immediately hand off to the next reference at any point along the way, because you are still "inside its escape radius." unless i am missing something, that sounds obviously backwards to me. you are trying to

*escape* the current reference's influence

*into* the next, not simply stay within the escape radius of the next. if the criterion was in fact just staying inside the escape radius of an outer mini, then that criterion is always satisfied and you could zoom to some infinite depth and simply use the outermost mini as reference, and this is obviously backward. bearing in mind also that if we had a nickel for every time knighty said "i did a mistake", we would all be rich.

on the matter of identifying a proper stopping condition for a super series, this business of attempting to divine a magic "escape radius" sounds suspect in general. instead of "did we get there yet," shouldn't it be a "has this failed yet" sort of condition like what is already used with regular SA? an error condition seems more intuitively correct and attainable versus some ill-conceived success condition that relies on voodoo and hand-tuned magic numbers and the like. i suspect you will not achieve a truly reliable implementation with the latter.

anyway, it seems that a more proper place to start with all this is to first establish a correct implementation of this algorithm with regular SA. this would eliminate some obvious complexities and points of failure, like finding periods, sizes, shapes, etc of roots. can any of that even be reasonably done with near 100% reliability? once a proper algorithm is identified and implemented for reliably handing off between references using SA (and possibly also non-SA iterations?), adding super iterations on to the algorithm should be much easier to correctly implement and debug.