# Follow the rabbit

The rabbit polynomial, or Douady's rabbit, is the quadratic polynomial
f(z) = z^{2} + c,
where c ≈ -0.122561 + 0.744862 i
is a zero of the cubic polynomial
c^{3} + 2c^{2} + c + 1.
The critical points are 0
and ∞.
The postcritial set is {0, c, c^{2}+c, ∞}.
Since there are four postcritical points and the critical points are simple,
f is a NET map.

The Julia set for f is shown in the figure below. The filled Julia set
is also called Douady's rabbit.

Since f is a NET map, f is
given by a NET map presentation. This is described in detail
in the paper *Origami, affine maps, and complex dynamics*.
A NET map presentation diagram for f is shown below.

This figure encodes the information of the NET map presentation. Except
for the circle around the vertex (2,1), this information is also
given in the file
rabbit.input,
which is the input file for the program NETmap for this example.
The parallelogram has vertices (0,0),
2 λ_{1},
λ_{2}, and
2 λ_{1} + λ_{2},
where λ_{1} = (0,-1) and
λ_{2} = (2,1).
In addition there are green line segments joining
(0,0) to (1,0),
λ_{1} to (1,-1),
λ_{2} to itself, and
λ_{1} + λ_{2}
to itself. The circle around the vertex λ_{2}
indicates that it is the translation vector b. (The translation
vector is either (0,0), λ_{1},
λ_{2}, or
λ_{1} + λ_{2}.)
This isn't part of the input to NETmap because NETmap considers
all four possible input vectors where that matters to the output.

When you run the program NETmap, it asks for inputs of the root of the file
name of the input file, a bound N for the absolute values of the
numerators and denominators of slopes p/q for which
it will compute the slopes of the preimages, and the minimum and maximum
x-coordinates, xmin and xmax,
for the figure showing the half spaces. Here are the output
files, with input N=50, xmin=-2, and
xmax=1.
The program creates the graphics files as postscript files,
but here we have converted them to pdf files.
For detailed explanations of
the output files, see the program documentation in the menu on the left.

- rabbit.input
- rabbit_Main.output
- rabbit_MOD.output
- rabbit_Table.output
- rabbitMod2Corre.pdf
- rabbitDynPortrait.pdf
- rabbitGraphMu.pdf
- rabbitGraphMuLines.pdf
- rabbitGraphMuTorus.pdf
- rabbitHalfSpace.pdf
- rabbitPrenDgm.pdf
- rabbitSigma.pdf
- rabbitTreeEMOD.pdf
- rabbitTreeMOD.pdf
- rabbitTreePMOD.pdf

The file rabbitDynPortrait.pdf (shown above) gives the dynamic portraits for the NET map presentations coming from this input file with the four possible choices of a translation vector. In this case two of the spaces are blank because the corresponding maps have fewer than four postcritical points and hence are not NET maps.

The file rabbitHalfSpace.pdf (shown above) shows that the map f is combinatorially equivalent to a rational map. If p/q ∈ ℚ ∪ {∞} is a slope that is not fixed by the slope map, then by the Half Space Theorem there is a half space containing the boundary point -q/p which does not contain the negative reciprocal of a Thurston obstruction. In this example, the union of four of the half spaces covers the boundary, so there are no Thurston obstructions and so f is equivalent to a rational map.

The file rabbitGraphMu.pdf shows part of the graph of the slope function μ

_{f}. It plots (p/q,μ

_{f}(p/q)) if both are in the interval [-5,5] and |p|,|q| ≤ 25. The entire graph (without the restriction on |p|,|q|) is dense in the plane.

The file rabbitGraphMuTorus.pdf is also a plot of part of the graph of the slope function. This time it is on a torus which is viewed as the product of the compactified real line with itself.

The program found no fixed points of the slope map, and the only cycle it found was a 3-cycle 1/0 → 0/1 → 1/1 → 1/0. The file rabbitGraphMuLines.pdf shows images of vectors (p,q) (corresponding to slope p/q) by the third iterate μ

_{f}

^{3}of the slope map. Lots of points have image one of the points (0,1), (1,1) or (1,0), so lots of line segments end at one of these points.

The file rabbit_MOD.output is about which elements of the modular groups lift. There are three modular groups to consider here:

- Mod(S
^{2},P), the group of isotopy classes of orientation-preserving homeomorphisms

φ:(S^{2},P) → (S^{2},P) (this is the modular group) - PMod(S
^{2},P), the group of isotopy classes of orientation-preserving homeomorphisms

φ:(S^{2},P) → (S^{2},P) which fix P pointwise (this is the pure modular group) - EMod(S
^{2},P), the group of isotopy classes of homeomorphisms φ:(S^{2},P) → (S^{2},P) (this is the extended modular group)

^{2},P) and SL(2,ℤ). Mod(S

^{2},P) is isomorphic to a semidirect product of PSL(2,ℤ) and the Klein 4-group, PMod(S

^{2},P) is isomorphic to a subgroup of PSL(2,ℤ), and EMod(S

^{2},P) is isomorphic to a semidirect product of PGL(2,ℤ) and the Klein 4-group.

An isotopy class of a homeomorphism φ:(S

^{2},P) → (S

^{2},P) in one of these groups G is liftable (relative to G) if there is a homeomorphism μ:(S

^{2},P) → (S

^{2},P) with isotopy class in G such that f ∘ μ = φ ∘ f. For each of the three modular groups, the set of liftable elements is a subgroup of finite index.

The files rabbitTreeEMOD.pdf, rabbitTreeMOD.pdf, and rabbitTreePMOD.pdf, which are shown below, give fundamental domains for the actions of the liftables in these groups on the Stern-Brocot tree. The Stern-Brocot tree is an infinite tree with vertices of valence two and of valence three. The complementary regions are labeled by extended rational numbers a/b, and there is an edge between the complementary regions labeled a/b and c/d if and only if the 2-by-2 matrix with rows [a c] and [b d] has determinant ± 1. The edges of the tree correspond to the elements of PSL(2,ℤ). Combinatorially, the Stern-Brocot tree is the subgraph of edges of finite hyperbolic length in the standard PGL(2,ℤ) tesselation of the hyperbolic plane.

The file rabbit_Main.output gives a wreath recursion presentation suitable for input into Laurent Bartholdi's GAP package IMG. Here are the text output and a screenshot of the graphics output.

gap> testex:=NewSphereMachine(

> "a=<1,d>

> "b=<a^-1,a*b>(1,2)",

> "c=<1,a>(1,2)",

> "d=<1,c>",

> "a*b*c*d");

<sphere machine with alphabet [ 1 .. 2 ] on Group( [ a, b, c, d ] ) / [ a*b*c*d ]>

gap> r:=ThurstonAlgorithm(testex);

rec( machine :=

_z)*z+(0.29888075536381736+0.58525893410403051i_z))/ ((1.7013938751035842-1.1014023152440142i_z)*z^2\

+(-0.15124585816302033-0.90258252704038189i_z)*z+1._z)>,

markedsphere := <marked sphere on