For a reasonably-well behaved sequence f_{n},
a regulated (smooth and finite) iteration count can be defined:

oo mu(t) = Sum exp ((-t|f**** Lack of proper math support in HTML sucks! ****_{n}|) n=0

Note that for finite t, this sum converges and is finite for
any sequence where |f_{n}| grows infinitely large at
least logarithmically fast for large n.
This is the case for
sequences f_{n} 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 / |fThe analytical relationship between the two is given by the gamma function, expressed as the integral (s-1)! = G(s)= I_{n}|^{s}n=0

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 f_{n} is provided by the n'th iterate z_{n}
of the classic Mandelbrot iterator:

ZFollowing the usual M-set conventions, define an escape radius R and an escape iteration count m such that_{n+1}= Z_{n}^{2}+ C

R < |fThat is, m is the traditional escape count for the radius R. We can then trivially write_{m}| and R > |f_{m-1}|

m-1 mu(t) = Sum exp ((-t|fThe 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_{n}|) n=0 oo + Sum exp ((-t|f_{n}|) n=m

|f(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_{m+p}| = |f_{m}|^{2p}

oo mu(t) = m + Sum exp ((-t|fwhere_{m}|^{2p}) p=0

oo Sum exp ((-txIt 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^{2p}) = exp(-tx) + exp(-tx^{2}) + exp(-tx^{4}) + exp(-tx^{8}) + ... p=0

log( -log(t) ) log (log (|fWhere O(1) is a term that is independent of |f_{m}|) mu(t) = m + -------------- - --------------- + O(1) log 2 log 2

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 |fwhich 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 (-t_{n}||) n=0

Created by Linas Vepstas October 1997

linas@linas.org

Return to Linas' Art Gallery

Copyright (c) 1997 Linas Vepstas.

Smooth Escape Iteration Counts by Linas Vepstas is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.