# Smooth Escape Iteration Counts

This web page expands on the mathematical statements and claims made on the page that introduces smooth coloring for Mandelbrot escape sequences. In general, the idea is that for a fairly general sequence of orbits of an iterated function, a regulated and well-behaved series can be defined. While this series will diverge in the limit, the infinity(ies) and the leading finite terms can be extracted. The infinite terms are discarded, and the remaining finite terms can be interpreted as fractional iteration counts. In turn, the fractional iteration count can be used to provide a smooth coloring for Mandelbrot-based artwork. A non-technical presentation of the results can be found here. For further coloring and artistic considerations, see the Fractal FAQ.

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=0
```
The 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 + C
```
Following 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=m
```
The 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=0
```
where
```oo
Sum  exp ((-tx2p) = exp(-tx) + exp(-tx2) + exp(-tx4) + exp(-tx8) + ...
p=0
```
It 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 2
```
Where 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=0
```
which 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)

Created by Linas Vepstas October 1997
linas@linas.org 