🚀 go-pugleaf

In article <1993Aug27.120648.11566@mnemosyne.cs.du.edu>, lmitchel@nyx.cs.du.edu (lloyd mitchell) writes:
|> It seems to me that most of the points on the spike are periodic, but the
|> windows are very small and the periods are very high.  I say this based on
|> a hunch from looking at the spike; we've all seen periodic windows but I
|> don't know of any chaotic windows.  

The trouble is the chaotic windows are dirty, with periodic specs in them.

|> The M-points (M stands for a mathematician's name that I can't remember), 
[ Misiurewicz ? ]
|> where the orbit is periodic after a few iterations (-2, -1.543689..., 
|> etc.) are (I think) countable, and are isolated.  

There is an infinite number, they are 'everywhere'.

|> It would seem that truly chaotic points may be, also.

I see the periodic zones as ever decreasing in density as I zoom in.
Consider the interval near -1.75 where little Mandelbroties all line up
to 'enter' the cusp.  There is a sequence of 'self-similar' cardioid
patterns, each with a period 3 greater. In each pattern, there seems to
be a bisecting pattern.  Here is the data:
period     center        approx size
  5  -1.6254137251233038  0.0020294
  8  -1.7110794700131522  0.0000864
 11  -1.7320062728696561  0.0000109
 14  -1.7397176014514633  0.0000026
 17  -1.7433378329345028  0.0000009
 20  -1.7453196244460596  0.00000038
 23  -1.7465233432992069  0.00000020
 26  -1.7473107209745575  0.00000012
 29  -1.7478549581283644  0.00000007
 32  -1.7482474524728249  0.00000005

In between are smaller ones with about ??% of the length.  Notice
the length goes down as the square of the distance to -1.75.  The 
periodic zones are getting less per centage of the length.  (Is this
conclusion correct?)

Take a look with fractint at these little Mandelbroties, especially at
the 'tree' above them (in the +i direction).  I was surprised to find
a pattern that we like to make with iterated function systems fractals.
The pattern is

                                                        


                  _|    |          \_
                    \___|   |   ___/ 
                    /    \  |  /   \_
                  _/      \ | /    | 
                   |       \|/  
                            | 
                            |
                            | 
                            | 


|> 
|> Related question:  the Feigenbaum point is at the very tip of the 
|> cascade of 1-period, 2-period, 4-, 8-, 16-, etc., components.  Does 
|> this mean that chaotic points are only found at the tips of such 
|> doubling cascades?
|> 
|> Kerry Mitchell

There has to be a problem with this, we would have to have each 
Feigenbaum point butt up to a cusp of the next.  Now each  little 
Mandelbrotie has at least a 26 degree angle from its spike (equavelent 
to -2) to the structure at its top (equavelent to near +i) [greater angle
if we count from the Feigenbaum point (equavelent to -1.401155)] and if you 
count the tree like structure I mention above - There is not room to 
jam it into the cusp, which approaches zero width.  I'd think there
would be a continuous chaotic window.  But no matter where you examine
it, there are always small periodic zones.  Most interesting.

--Jay 'Not tonight honey, I'm caught on a chaotic filement' Hill

{ hilljr@jupiter.saic.com } begin writeln(3*ln(640320)/sqrt(163):17:15) end.
void main(){double sqrt(), y=1/sqrt(2.), a=.5, m=1,z; int n=0;
for(;m*=2,z=sqrt(1-y*y),y=(1-z)/(1+z),a=a*(1+y)*(1+y)-m*y,n<4;n++);
printf("%17.15lf\n",1/a);}

In article <1993Aug28.013942.18928@ast.saic.com>, 
  hilljr@jupiter.saic.com (Jay R. Hill) writes:
> In article <1993Aug27.120648.11566@mnemosyne.cs.du.edu>, 
  lmitchel@nyx.cs.du.edu (lloyd mitchell) writes:
>> It seems to me that most of the points on the spike are periodic, but the
>> windows are very small and the periods are very high.  I say this based on
>> a hunch from looking at the spike; we've all seen periodic windows but I
>> don't know of any chaotic windows.  
> 
> The trouble is the chaotic windows are dirty, with periodic specs in them.
> 
 
             The Mandelbrot Set Chaosometer

Those of you who have followed my posts about the area of the M-Set
and related computations will have noticed the recurant theme: How 
to aviod long computations by early identification of three classes
of orbits for the z <- z^2 + c iteration.  These are the escapers,
periodics and chaotics.  The sci.fractals.FAQ states the Lyapunov 
exponent can identify chaos.  If the Lyapunov exponent, lambda, is 
positive, then the iteration is chaotic.  The exponent is defined as

>  lambda = limit as N->infinity of 1/N times sum from n=1 to N of 
>    log2(abs(dx sub n+1 over dx sub n))

Now for the Mandelbrot Set this is

lambda = lim (1/N) sum{ log2 | 2*z[n] | }                   (1)

since z[n+1] = z[n]*z[n] + c.  It is not clever to do lots of logs, 
so I have reworked the formula and use

  J = product{ 2*abs(z[n]) },   n=1,...,N                   (2)

Then lambda = (ln J)/(N*ln 2), but you need only compare J to 1.  
If J>1 you have chaos.  If you are iterating c in the center of a 
component, J will be equal to or very close to zero.  Evaluating the
logarithm to get lambda gets an error.  Using formula (2) saves
evaluating the logs in formula (1) and gets the same results.  The 
factor of 2 in (2) tends to keep J of reasonable size during the 
iteration.  

Now, how well does equation (1) or (2) work as a detector of chaos
in Mandelbrot calculations?  I have mixed results.  Along the real 
line (See the Re: 1-D M-set thread) J remains 'undecided' until n is 
greater than some value, call it k.  In or near a periodic component, 
I find k is at least equal to the period.  For example, in the 
period 4096 component centered at -1.4011551704444 (in the Feigenbaum
sequence approaching -1.401155189092) J-1 remains positive most of 
the time, dropping briefly below zero at n=1024 and 2048.  Only after 
n>4096 does J become very small. But even then it jumps to above 1
a few more times, depending on how close c is to -1.4011551704444.
I have traced the Feigenbaum component sequence to that with period 
262144.  Now if I were to have used the Chaosometer to cut off 
computations for chaotic points early, I'd have missed these small 
high period components.  

On the otherhand, chaotic points on the real line (with lambda=0.25,
for example) drive J quickly to very large values (>1e200).  These 
can certainly be abandonded as chaotic saving us the trounble of 
following the iterations to some MAXITER since the iteration will 
not ever diverge (-2 > c > -1.401155...).  For these points the 
test is useful.

The next example I tried is c = complex points on the boundary of 
the main cardioid.  As I posted earlier, these are either periodic 
(tangent to a touching bud) or chaotic.  I posted a list of chaotic 
c, some of which I tested here.  The formula does not work as well as 
I would like, since 'limit N->inf' is computationally vague.  Let's
start with a definitely periodic point: c=(0.25+0.5i).  After more
than a million iterations, lambda approaches zero but only mostly
from the minus side, but not completely.  It occasionally jumps into
posative for one or two iterations.  A chaotic point near 0.25+0.5i
is c=(0.2850441472+0.4607492096i).  Again, lambda approached zero,
but now mostly from positive side and even after more than a million 
iterations, it still drops to negative (hinting at periodic).

It would appear that lambda for c on the edge of a component will
approach zero in a jerky manner and the test is not very useful.
The test will work well for points on filements, points far away 
from component edges.  

I recommend it for use in Mandelbrot calculations along with period
detection and other tests and devices.  Since the only filement we 
know well is the real line, the test should at least be used when
imag(c)==0.

Warmly,
--Jay 'Not tonight honey, I'm calibrating my Chaosometer' Hill

{ hilljr@jupiter.saic.com } begin writeln(3*ln(640320)/sqrt(163):17:15) end.
void main(){double sqrt(), y=1/sqrt(2.), a=.5, m=1,z; int n=0;
for(;m*=2,z=sqrt(1-y*y),y=(1-z)/(1+z),a=a*(1+y)*(1+y)-m*y,n<4;n++);
printf("%17.15lf\n",1/a);}