For a reasonably-well behaved sequence fn, a regulated (smooth and finite) iteration count can be defined:
oo mu(t) = Sum exp ((-t|fn|) n=0**** Lack of proper math support in HTML sucks! ****
Note that for finite t, this sum converges and is finite for any sequence where |fn| grows infinitely large at least logarithmically fast for large n. This is the case for sequences fn that describe the escaping orbit of a fractal iterate. Note that in the limit of t going to zero, this sum diverges.
[Side note: this function is analytically related to the Reimann Zeta-like regulator
oo zeta(s) = Sum 1 / |fn|s n=0The analytical relationship between the two is given by the gamma function, expressed as the integral (s-1)! = G(s)= I0oo tse-tdt. The integrals are not hard, and it turns out that poles in the s-plane correspond to powers of t in the taylor expansion of mu(t). For most 'plain-old ordinary' sequences, the poles seem to occur at integers. An interesting math question might be, 'what sort of sequences result in poles not lying on integers'? End of side note.]
The claim made here is that by analyzing the above expression in terms of powers of t, the divergent parts will appear as poles of some form or another. The claim made here is also that the finite part that remains after the removal of the divergent parts is a candidate for the smooth, fractional iteration escape count of an iterated function.
For the remainder of this discussion, it is useful to imagine that fn is provided by the n'th iterate zn of the classic Mandelbrot iterator:
Zn+1 = Zn2 + CFollowing the usual M-set conventions, define an escape radius R and an escape iteration count m such that
R < |fm| and R > |fm-1|That is, m is the traditional escape count for the radius R. We can then trivially write
m-1 mu(t) = Sum exp ((-t|fn|) n=0 oo + Sum exp ((-t|fn|) n=mThe first term, in the limit t->0 clearly will equal the integer escape count m. The second term contains the infinities. Note that for n>m, for the Mandelbrot equation, one can approximate
|fm+p| = |fm|2p(the above equation is not #$%^& properly displayed by Netscape. It should read f_sub_m to the power (2 power of p)). So, we have the approximation
oo mu(t) = m + Sum exp ((-t|fm|2p) p=0where
oo Sum exp ((-tx2p) = exp(-tx) + exp(-tx2) + exp(-tx4) + exp(-tx8) + ... p=0It can be clearly seen that for any x>1, this sum converges very rapidly. The author is not aware of any closed-form expression for this sum, although it is beguilingly simple. With a little bit of thought, it can be seen that this expression diverges as log(-log(t)) for small t. Although it is a little harder to see, this expression becomes a stair-step function for very small t, with the steps occurring near the integer values of log(-log(t)). The finite x-dependent part of this sum is also easy to extract, although the finite non-z-dependent part cannot be because of the stair-stepping in t. Thus, we can present the result:
log( -log(t) ) log (log (|fm|) mu(t) = m + -------------- - --------------- + O(1) log 2 log 2Where O(1) is a term that is independent of |fm|. By dropping the divergent term, we get exactly the result obtained through different means, as described on the escape web page.
A different, but ultimately identical derivation can be made by realizing the rapid escape of the orbits, and working instead with the regulated sum
oo nu(t) = Sum exp (-t log | log |fn||) n=0which exhibits a simple pole at t=0 and whose finite term yields the same results as above. For those new to this method of regulating infinite series, it should be noted that there are many possible regulators, and that most of these regulators can be converted into one-another through analytic techniques. In such transformations, one soon finds that poles of various strengths get mapped to other poles of various strengths and locations or even cuts. However, the finite terms do NOT change in magnitude, and thus, one will always find the same finite term, independent of the method of regulation. Note alsot that the mu(t) type of regulators are far more numerically tractable (for numeric summations) than the zeta-style regulators. Even more strongly convergent, and still analytically tractable, are regulators of the form exp (-t2|fn|2)