# Algorithm

• paper by John H. Hubbard and Dierk Schleicher
• original paper by Yuval Fisher

# Program

Original program Spider by Yuval Fisher:

• written in c
• XView library - widget toolkit from Sun Microsystems 

Version by Claude Heiland-Allen

The program :

• computes the value of C at a rational external angle of M using a variant of Thurston's algorithm. In other words : computes a postcritically finite polynomials from the angles of the external rays landing at the critical point. For example, enter 1/6 and get out c = i, for the quadratic case ( notice that the dynamics of 1/6 under multiplication by 2 modulo 1 has some relationship with the orbit of i under z2+i).
• draws parameter (Mandelbrot set) and dynamical space (Julia sets) pictures using the Koebe 1/4 theorem as in The Science of Fractal Images. This part of the code was largely written by Marc Parmet,
• draws external angles on Julia sets.

"If you want to understand the relationship between the Mandelbrot set and the dynamics of Julia sets, this program is for you."

```This directory includes souces and exectutable for a program
which implements a version of what some people call Thurston's algorithm.
The program also contains an implementation (using code written
largely by Marc Parmet) of the 1/4 theorem
method of drawing parameter and dynamical space images, as
in The Science of Fractal Images, appendix D.
It also includes a version of a paper on the subject, based
on my thesis.

The program is fully interactive, allowing specification of
angle(s), iteration of the algorithm until it converges (to a
polynomial), plotting of the Julia set for the polynomial, and
plotting of the spiders (and/or external rays of the Julia
sets) which are the data set used in the algorithm. There is on
line help (if your keyboard has a HELP button). There is a
brief step by step on line tutorial, also.
The program uses the XView toolkit, under X.

The program takes as input an angle (or set of angles) and
gives as output a polynomial whose dynamics in the complex plane
is determined by the dynamics of multiplication of the angle
by the degree of the desired polynomial modulo 1. For example,
suppose we choose 1/6 as an angle and wish to find a quadratic
polynomial (d = 2), then
1/6 -> d*1/6 = 2*1/6 = 1/3 -> 2*2*1/6 = 2/3 -> 2*2*2*1/6
= 4/3 (modulo 1) = 1/3. It is periodic of period 2 after
1 step.

Pressing the New 2 button, entering 1/6 as a fraction, and pressing
the Set Repeating Expansion Button, will set up the algorithm. Pressing
LIFT or Many Lifts will iterate the algorithm; The Goings On window will
show the C value of the polynomial z^d + C, which will converge to
C = i = sqrt(-1). The main window will show some lines, which also
converge to something... p(z) = z^2 + i has the property that
the critical value i has the same dynamics as 1/6,
i -> p(i)  = 1-i -> p(i-1) = -i -> p(-i) = 1-i. That is, it is perdiodic
of period two after one step.

Yuval Fisher

November 17, 1992

```

## How to run it ?

One way is to use a compiled binary version for i386 by Claude Heiland-Allen

```git clone http://code.mathr.co.uk/spider.git
```

One need 32-bit version of XView :

```# ubuntu
sudo apt-get update
sudo apt-get install xviewg:i386
```

then create a s.sh file :

``` #!/bin/bash
export LD_LIBRARY_PATH=/usr/lib32:/usr/lib64:\$LD_LIBRARY_PATH
./s.bin  -fn fixed \$*
```

and run it :

```./s.sh
```

Or one can compile program and run on Virtual Machine