Basic Idea: Click on a point in the Mandelbrot set (technically the white areas below). To see why your point is in (or not in!) the set, click on "Run" to start the Mandelbrot iterations. If the resulting "orbit" does not go to infinity your starting point is in the Mandelbrot set, otherwise it is not (and the color assigned to it on the background image indicates in some sense how "far away" it is from the set).

The different regions of the fractal correspond to different kinds of stable, closed orbits. Neat!!

The largest white region is a 1-cycle (fixed point) orbit, the big circle to the left of it is the 2-cycle orbit region. Can you find the three different 3-cycle regions? The six different 4-cycle regions? Can you predict the cycle length and orbit shape of a region beforehand? As an orbit settles into its pattern, what does the shape of the dying off transient say about nearby regions? It's a fun puzzle!

The following is from the Mandelstep Tcl/Tk application (not applet) online help. The general info applies, but some features may be missing in the applet.

```mandelstep v0.4 Copyright (c) 1997 Karl J. Runge

========================
How to use "mandelstep":
========================

"mandelstep" IS NOT a fractal generator or zoomer.

Excellent programs for doing generation can be found. For example:

Fractint:       http://spanky.triumf.ca/www/fractint/FRACTINT.HTML
Xmandel:        http://chem.leeds.ac.uk/ICAMS/people/zsolt/xmandel.html
XaoS:           http://www.paru.cas.cz/~hubicka/XaoS/

and there are others.

Fractal generation programs want to do as many pixel calculations
as fast as possible, "mandelstep", on the other hand, wants to do as
few pixel calculations as slowly as possible!!!!

===============
Huh? Why Slow??
===============

Fractals are beautiful and mysterious things to look at, but if you want
to at least start to try understand a little bit about them, the fractal
generation programs (out of necessity) hide too much information.  They
basically give the bottom line: is a point in the fractal set or not,
and if not, color it to show how in a crude sense how "far away" it is
from the set.

Since there can easily be half a million pixels, each requiring 100-200,
or more, iterations each, it is very useful that the fractal generation
programs do not show all the information contained in the iteration
"trajectories".

The idea behind "mandelstep" is that by letting a person select starting
positions and looking at a handful of iteration "trajectories" or
"orbits" the person can begin to understand more about the different
regions of the Mandelbrot set. I.e., not just whether a point is inside
the set, but what sort of "dance" it does to be a member. It is not
long before one is using one's intuition about what sort of "dance"
a point will do before one runs the actual iteration. It's a puzzle.
It's fun!

=========
Mappings:
=========

For many fractals, the X-Y plane describes a control parameter of an
iterated mapping function.  If, for a fixed value of the control
parameter, repeated iteration leads to the coordinates diverging towards
infinity that point is said to not be in the fractal set.  How fast it
diverges to infinity is usually used to determine what color is assigned
to it. This gives beautiful images!

A point that does not lead to divergence toward infinity is said to be
in the fractal set (in practice, if it has not diverged after some pre-
defined "large enough" value, i.e.  N_MAX = 128, then for practical
purposes it is said that the point is in fractal set, although who knows
exactly what will happen in the next N_MAX iterations!).  Typically a point
declared to be in the set would be colored black or white. They are white
for "mandelstep".

For the classical Mandelbrot set the iterated mapping function is:

x' = x^2 - y^2 + Q_x
y' = 2xy       + Q_y

or in complex numbers notation, (z = x + iy):

z' = z^2 + Q

The prime, e.g. x', means the updated value after one iteration.
Perhaps x <==  x^2 - y^2 + Q_x, y <== 2xy + Q_y is a better notation.

Q = (Q_x, Q_y) is the control parameter of the iterated mapping
function.  A Q value is in the Mandelbrot set if (starting the first
iteration at z = (0,0)) after infinitely many iterations the z variable
has not diverged to infinity.

It is not hard to show that if |z| > 2 then z will quickly diverge to infinity.

========
Running:
========

When "mandelstep" starts up (it even does that slowly!) it will show you
the complex Q plane with the classical Mandelbrot fractal (derived via
XaoS mentioned above) superimposed on the background. A little black
dot denotes Q = (0,0). white regions denote the points inside the set (i.e.
iteration does not diverge for those points).

OK, here are the steps to actually run something:

Click the mouse somewhere to select a point Q.

To do a single iteration step from starting a z = Q, click the
"Step" button.

Or to run a whole bunch, say 30, in succession, click on "Run".

That is basically it.

For a Q-point to be in the Mandelbrot set it seems (to me) that it must
converge to a stable n-cycle orbit.  That is to say, an orbit that
repeats after n iterations.  The biggest round white region (the one
containing 0,0) is where the iteration evolves to a 1-cycle.  Try it and
see!  The next largish section that is a circle to the left of the 1-
cycle region is where 2-cycles are stable.  Crossing over a boundary
inside the Mandelbrot set usually means an n-cycle region has become
unstable and an m-cycle has become stable.

It's fun predicting (at least I find it fun!) what the cycle lengths will
be for a given region.  Also, the shape of the orbit will sometimes be
surprising. Run in the 1-cycle region close to another region and see
how the shape of slowest dying transient (as the orbit collapses to a point)
lets you predict the cycle length and orbit shape of the nearby region without
even running in it!

"mandelstep" does not (yet) let you get into the fascinating "super deep
zooms" regions that give the beautiful images.  But many things can be
learned from looking at the global iteration picture.  Can your
intuition learned at the global level be applied way down in the deep
zoom regions?  It is, afterall, a self similar fractal!

-----------------------------------------------------------------------------
Now to touch upon all the features, buttons, etc.

=================
=================

Step:
-----

On the main menubar the "Step" button will perform one iteration of
the mapping function.

Run:
----

The next button over "Run", will do a number (default 30) of iterations
in succession. The starting point is blue, the latest point is red, and
the rest are green. Follow the red dot for the orbit.

Stop:
-----

As the name implies, this button will stop the current "Run". Hit
"Run" again to resume, or switch to a new set of run parameters if
you like.

Clear:
------

This will remove all trajectories/orbits from the display.
(See "Clear Last Orbit" below)

Help:
-----

Shows the current help text.

X: and Y:
---------

As the mouse is moving around the fractal background, the Q_x and Q_y
of the mouse position are shown in these entry boxes.

If you click the mouse button the Q-value at point of the click will be
"frozen" in the display boxes.  You can then, say, move the mouse over
to the "Run" button.

You can also type values directly into the X: and Y: entry boxes. Hit
in either one to "freeze/set" the values, then go over to
"Step" or "Run" to start iterating the mapping function for this Q.

========
Actions:
========

More things one can do.

Long Run:
---------

Do a run 5 times the normal length.

X-Y Trace:
------------

Pops up a text window with the history of x and y values for the latest run.

Clear Last Orbit:
----------

Remove the latest trajectory/orbit from the display.

Exit:
-----

I forget what this one does :-)

======================
Options:
======================

Set the parameters.

Connect Points:
---------------

Checkbox to set mode to draw lines between the iteration points or not.

Set N iterations:
-----------------

Set the number of iterations in one "Run" click. An entry box will appear
on the Menu Bar. Type the value in the entry box and then hit  to
set it.

Delay:
------

Set the time delay between iterations in the "Run" action.  Not that
"mandelstep" is blazingly fast or anything, but you may want to slow it down
a bit to watch some complicated orbit.  Enter the delay time in
milliseconds.  There are 1000 of them in 1 second.  As in the previous
paragraph, the entry box appears on the Menu Bar, Hit  to set
the value to what you typed in.

=============================================================================

Well, that's all for now except for some misc. notes below.

The main thing on the TODO list is:
Let user drag out a region of the plane with the mouse,
a second canvas appears where the region is zoomed
(maybe call xaos or something in "filter" mode, or just scale?)
Then the user can click on the expanded view to select the
starting point with higher resolution. Iterations should
be shown on both the main and zoomed canvases.

mandelstep v0.4 Copyright (c) 1997 Karl J. Runge

=============================================================================

Misc. Notes:
------------

One can solve for the two main regions of the classical Mandelbrot set
by solving using some simple math:

If you denote the mapping by f(z) = z^2 + Q, then look for
fixed point solutions  z = f(z), this will give a quadratic equation
for the 1-cycle orbit z's. By examining the derivative df/dz at the
fixed point one finds it is a stable orbit when |df/dz| < 1 (hint expand
about the solution z + dz and look for the condition that |dz| shrinks).
The formula |df/dz| < 1 gives exactly the big cardioid shape that encloses
the point (0,0). Seriously cool!

What about the stable 2-cycle region? Look at fixed points z = f(f(z))
this will give you a quartic equation in z, but you can factor out
the 1-cycle solutions found above (since a 1-cycle is clearly also a
2-cycle), this leaves another quadratic equation to solve for the "real"
2-cycles. The condition that is it stable ( |d(f(f(z))/dz| < 1) gives the
equation for the circle (centered at (-1,0)) immediately to left of
the 1-cycle cardioid. The circle's radius is 1/4.

Well, the math starts getting hard at z = f(f(f(z))), (3-cycles) and above,
but you can let "mandelstep" do all the work for you! Start a run inside a
given region and what what sort of n-cycle it settles into.

In my non-rigorous view of these things, all of the infinitely many
sections of the mandelbrot fractal can be thought as some sort of stable
n-cycle.  As n goes up the region of stability gets smaller and smaller
giving rise to smaller still regions with longer period orbits.  And
this continues downward to smaller scales without limit.  Amazing!

Another way to proceed is to look for Super Stable orbits. These
are ones obeying the stability criterion: d(f(...(f(z))...)/dz = 0.
It turns out this requires one of the points on the orbit be z = 0.
The control parameters corresponding to these super stable orbits
tend to be near the center of its region, i.e. farthest from the
region boundary (where |df(...)/dz| = 1). Anyway, it is not too hard to
get a symbolic manipulator work out f(f(...f(0)...)) = Q, then solve
numerically for the roots Q of this polynomial (it is all Q, no z for
this approach). Sure enough, the roots are right near the centers of the
corresponding n-cycle regions of the set.

```