Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 Bib Ind
Top of Book Previous Chapter Next Chapter

9 Iterated monodromy groups
9.1 Creators and operations for IMG machines
9.1-1 IMGMachine
9.1-2 IMGRelator
9.1-3 Mating
9.1-4 PolynomialFRMachine
9.1-5 DBRationalIMGGroup
9.1-6 PostCriticalMachine
9.2 Spiders
9.2-1 DelaunayTriangulation
9.2-2 LocateInTriangulation
9.2-3 RationalFunction
9.2-4 FRMachine
9.2-5 FindThurstonObstruction

### 9 Iterated monodromy groups

Iterated monodromy machines are a special class of group FR machines (see Section 3) with attribute `IMGRelator` (9.1-2). This attribute records a cyclic ordering of the generators of the machine whose product is trivial.

The interpretation is the following: the machine encodes a Thurston map, i.e. a post-critically finite topological branched self-covering of the sphere S^2. Generators of the machine correspond to loops in the fundamental group of the sphere (punctured at post-critical points), that circle once counter-clockwise around a post-critical point. For more details on the connection between self-similar groups and Thurston maps, see [Nek05].

IMG elements are a bit different from group FR elements: while we said a group FR element is trivial if and only if its action on sequences is trivial, we say that an IMG element g is trivial if there exists an integer N such that unfolding N times the recursion for g yields only trivial states (as elements of the underlying free group).

#### 9.1 Creators and operations for IMG machines

##### 9.1-1 IMGMachine

`> IMGMachine`( m[, w] ) | ( operation )

Returns: An IMG FR machine.

This function creates a new IMG FR machine, starting from a group FR machine m. If a state `w` is specified, and that state defines the trivial FR element, then it is used as IMG relator; if the state `w` is non-trivial, then a new generator `f` is added to m, equal to the inverse of `w`; and the IMG relator is chosen to be `w*f`. Finally, if no relator is specified, and the product (in some ordering) of the generators is trivial, then that product is used as IMG relator. In other cases, the method returns `fail`.

Note that IMG elements and FR elements are compared differently (see the example below); namely, an FR element is trivial precisely when it acts trivially on sequences. An IMG element is trivial precisely when a finite number of applications of free cancellation, the IMG relator, and the decomposition map, result in trivial elements of the underlying free group.

A standard FR machine can be recovered from an IMG FR machine by `AsGroupFRMachine` (3.3-4), `AsMonoidFRMachine` (3.3-4), and `AsSemigroupFRMachine` (3.3-4).

    gap> m := UnderlyingFRMachine(BasilicaGroup);
    <Mealy machine on alphabet [ 1 .. 2 ] with 3 states>
    gap> g := AsGroupFRMachine(m);
    <FR machine with alphabet [ 1 .. 2 ] on Group( [ f1, f2 ] )>
    gap> IMGMachine(g,Product(GeneratorsOfFRMachine(g)));
    <FR machine with alphabet [ 1 .. 2 ] on Group( [ f1, f2, t ] )/[ f1*f2*t ]>
    gap> Display(last);
     G  |              1         2
    ----+-----------------+---------+
     f1 |          <id>,2      f2,1
     f2 |          <id>,1      f1,2
      t | f2^-1*f1*f2*t,2   f1^-1,1
    ----+-----------------+---------+
    Relator: f1*f2*t
    gap> g := AsGroupFRMachine(GuptaSidkiMachine);
    <FR machine with alphabet [ 1 .. 3 ] on Group( [ f1, f2 ] )>
    gap> m := IMGMachine(g,GeneratorsOfFRMachine(g)[1]);
    <FR machine with alphabet [ 1 .. 3 ] on Group( [ f1, f2, t ] )/[ f1*t ]>
    gap> x := FRElement(g,2)^3; IsOne(x);
    <3|identity ...>
    true
    gap> x := FRElement(m,2)^3; IsOne(x);
    <3#f2^3>
    false

##### 9.1-2 IMGRelator

`> IMGRelator`( m ) | ( attribute )

Returns: The relator of the IMG FR machine.

This attribute stores the product of generators that is trivial. In essence, it records an ordering of the generators whose product is trivial in the punctured sphere's fundamental group.

##### 9.1-3 Mating

`> Mating`( m1, m2[, w1, w2] ) | ( operation )

Returns: An IMG FR machine.

This function mates two IMG FR machines. The arguments w1,w2 are IMG FR elements that represent adding elements; they may be omitted if m1,m2 contain pre-specified adding machines (through the attribute `AddingElement` (10.1-4)). The elements w1 and w2 must satisfy the same recursion.

The mating is defined as follows: one removes a disc around the adding machine in m1 and m2; one applies complex conjugation to m2; and one glues the hollowed spheres along their boundary circle.

    gap> # the Tan-Shishikura examples
    gap> a := ComplexRootsOfUnivariatePolynomial((z-1)*(3*z^2-2*z^3)+1);;
    gap> c := ComplexRootsOfUnivariatePolynomial((z^3+z)^3+z);;
    gap> am := List(a,a->IMGMachine((a-1)*(3*z^2-2*z^3)+1));;
    gap> cm := List(c,c->IMGMachine(z^3+c));;
    gap> m := ListX(am,cm,Mating);;
    gap> # m[!!!] is obstructed
    gap> # m[!!!] is not

##### 9.1-4 PolynomialFRMachine

`> PolynomialFRMachine`( d, per, pre ) | ( operation )

`> PolynomialIMGMachine`( d, per, pre[, formal] ) | ( operation )

`> PolynomialMealyMachine`( d, per, pre ) | ( operation )

Returns: An IMG FR machine.

This function creates a group, IMG or Mealy machine that describes a topological polynomial. The polynomial is described symbolically in the language of external angles. For more details, see [DH84] and [DH85] (in the quadratic case), [BFH92] (in the preperiodic case), and [Poi] (in the general case).

d is the degree of the polynomial. per and pre are lists of angles or preangles. In what follows, angles are rational numbers, considered modulo 1. Each entry in per or pre is either a rational (interpreted as an angle), or a list of angles [a_1,...,a_i] such that da_1=...=da_i.

Note that the last generator if the machine produced is an adding machine, representing a loop going counterclockwise around infinity (in the compactification of C by a disk, this loop goes clockwise around that disk).

Formal!!! !!!! say inverse function is ExternalAngles !!!

    gap> PolynomialIMGMachine(2,[0],[]); # the adding machine
    <FR machine with alphabet [ 1 .. 2 ] on Group( [ f1, f2 ] )/[ f2*f1 ]>
    gap> Display(last);
     G  |     1        2
    ----+--------+--------+
     f1 | <id>,2     f1,1
     f2 |   f2,2   <id>,1
    ----+--------+--------+
    Relator: f2*f1
    gap> Display(PolynomialIMGMachine(2,[1/3],[])); # the Basilica
     G  |      1         2
    ----+---------+---------+
     f1 | f1^-1,2   f2*f1,1
     f2 |    f1,1    <id>,2
     f3 |    f3,2    <id>,1
    ----+---------+---------+
    Relator: f3*f2*f1
    gap> Display(PolynomialIMGMachine(2,[],[1/6])); # z^2+I
     G  |            1         2
    ----+---------------+---------+
     f1 | f1^-1*f2^-1,2   f2*f1,1
     f2 |          f1,1      f3,2
     f3 |          f2,1    <id>,2
     f4 |          f4,2    <id>,1
    ----+---------------+---------+
    Relator: f4*f3*f2*f1
    gap> PolynomialIMGMachine(3,[[0,1/3],[5/9,8/9]],[]);
    <FR machine with alphabet [ 1 .. 3 ] on Group( [ f1, f2, f3 ] )/[ f3*f2*f1 ]>
    gap> PolynomialIMGMachine(3,[[0,1/3]],[[5/9,8/9]]);
    <FR machine with alphabet [ 1 .. 3 ] on Group( [ f1, f2, f3, f4 ] )/[ f4*f3*f2*f1 ]>

The following construct the examples in Poirier's paper:

    PoirierExamples := function(arg)
        if arg=[1] then
            return PolynomialIMGMachine(2,[1/7],[]);
        elif arg=[2] then
            return PolynomialIMGMachine(2,[],[1/2]);
        elif arg=[3,1] then
            return PolynomialIMGMachine(2,[],[5/12]);
        elif arg=[3,2] then
            return PolynomialIMGMachine(2,[],[7/12]);
        elif arg=[4,1] then
            return PolynomialIMGMachine(3,[[3/4,1/12],[1/4,7/12]],[]);
        elif arg=[4,2] then
            return PolynomialIMGMachine(3,[[7/8,5/24],[5/8,7/24]],[]);
        elif arg=[4,3] then
            return PolynomialIMGMachine(3,[[1/8,19/24],[3/8,17/24]],[]);
        elif arg=[5] then
            return PolynomialIMGMachine(3,[[3/4,1/12],[3/8,17/24]],[]);
        elif arg=[6,1] then
            return PolynomialIMGMachine(4,[],[[1/4,3/4],[1/16,13/16],[5/16,9/16]]);
        elif arg=[6,2] then
            return PolynomialIMGMachine(4,[],[[1/4,3/4],[3/16,15/16],[7/16,11/16]]);
        elif arg=[7] then
            return PolynomialIMGMachine(5,[[0,4/5],[1/5,2/5,3/5]],[[1/5,4/5]]);
        elif arg=[9,1] then
            return PolynomialIMGMachine(3,[[0,1/3],[5/9,8/9]],[]);
        elif arg=[9,2] then
            return PolynomialIMGMachine(3,[[0,1/3]],[[5/9,8/9]]);
        fi;
    end;

##### 9.1-5 DBRationalIMGGroup

`> DBRationalIMGGroup`( sequence/map ) | ( function )

Returns: An IMG group from Dau's database.

This function returns the iterated monodromy group from a database of groups associated to quadratic rational maps. This database has been compiled by Dau Truong Tan [Tan02].

When called with no arguments, this command returns the database contents in raw form.

The argments can be a sequence; the first integer is the size of the postcritical set, the second argument is an index for the postcritical graph, and sometimes a third argument distinguishes between maps with same post-critical graph.

If the argument is a rational map, the command returns the IMG group of that map, assuming its canonical quadratic rational form form exists in the database.

    gap> DBRationalIMGGroup(z^2-1);
    IMG((z-1)^2)
    gap> DBRationalIMGGroup(z^2+1); # not post-critically finite
    fail
    gap> DBRationalIMGGroup(4,1,1);
    IMG((z/h+1)^2|2h^3+2h^2+2h+1=0,h~-0.64)

##### 9.1-6 PostCriticalMachine

`> PostCriticalMachine`( f ) | ( function )

Returns: The Mealy machine of f's post-critical orbit.

This function constructs a Mealy machine `P` on the alphabet `[1]`, which describes the post-critical set of f. It is in fact an oriented graph with constant out-degree 1. It is most conveniently passed to `Draw` (5.2-1).

The attribute `Correspondence(P)` is the list of values associated with the stateset of `P`.

    gap> z := Indeterminate(Rationals,"z");;
    gap> m := PostCriticalMachine(z^2);
    <Mealy machine on alphabet [ 1 ] with 2 states>
    gap> Display(m);
       |  1
    ---+-----+
     a | a,1
     b | b,1
    ---+-----+
    gap> Correspondence(m);
    [ 0, infinity ]
    gap> m := PostCriticalMachine(z^2-1);; Display(m); Correspondence(m);
       |  1
    ---+-----+
     a | c,1
     b | b,1
     c | a,1
    ---+-----+
    [ -1, infinity, 0 ]

#### 9.2 Spiders

##### 9.2-1 DelaunayTriangulation

`> DelaunayTriangulation`( points ) | ( operation )

Returns: A Delaunay triangulation of the sphere.

If points is a list of points on the unit sphere, represented by their 3D coordinates, this function creates a triangulation of the sphere with these points as vertices. This triangulation is such that the angles are as equilateral as possible.

This triangulation is a recursive collection of records, one for each vertex, oriented edge or face. Each such object has a `pos` component giving its coordinates; and an `index` component identifying it uniquely. Additionally, vertices and faces have a `n` component which lists their neighbours in CCW order, and edges have `from,to,left,right,reverse` components.

If all points are aligned on a great circle, or if all points are in a hemisphere, some points are added so as to make the triangulation simplicial with all edges of length <pi. These vertices additionally have a `fake` component set to `true`.

A triangulation may be plotted with `Draw`; this requires appletviewer to be installed. The command `Draw(t:detach)` detaches the subprocess after it is started.

This command makes essential use of Renka's package "Algorithm 772" ([Ren97]), which must have been compiled before GAP was run.

    gap> octagon := Concatenation(IdentityMat(3),-IdentityMat(3))*MACFLOAT_1;
    gap> dt := DelaunayTriangulation(octagon);
    <triangulation with 6 vertices, 24 edges and 8 faces>
    gap> dt!.v;
    [ <vertex 1>, <vertex 2>, <vertex 3>, <vertex 4>, <vertex 5>, <vertex 6> ]
    gap> last[1].n;
    [ <edge 17>, <edge 1>, <edge 2>, <edge 11> ]
    gap> last[1].from;
    <vertex 1>

##### 9.2-2 LocateInTriangulation

`> LocateInTriangulation`( t[, seed], point ) | ( operation )

Returns: The face in t containing point.

This command locates the face in t that contains point; or, if point lies on an edge or a vertex, it returns that edge or vertex.

The optional second argument specifies a starting vertex, edge, face, or vertex index from which to start the search. Its only effect is to speed up the algorithm.

    gap> cube := Tuples([-1,1],3)/Sqrt(Float(3));;
    gap> dt := DelaunayTriangulation(cube);
    <triangulation with 8 vertices, 36 edges and 12 faces>
    gap> LocateInTriangulation(dt,dt!.v[1].pos);
    <vertex 1>
    gap> LocateInTriangulation(dt,[3/5,0,4/5]*MACFLOAT_1);
    <face 9>

##### 9.2-3 RationalFunction

`> RationalFunction`( [z, ]m ) | ( operation )

Returns: A rational function.

This command runs a modification of Hubbard and Schleicher's "spider algorithm" [HS94] on the IMG FR machine m. It either returns a rational function `f` whose associated machine is m; or a record describing the Thurston obstruction to realizability of `f`.

This obstruction record `r` contains a list `r.multicurve` of conjugacy classes in `StateSet(m)`, which represent short multicurves; a matrix `r.mat`, and a spider `r.spider` on which the obstruction was discovered.

If a rational function is returned, it has preset attributes `Spider(f)` and `IMGMachine(f)` which is a simplified version of m. This rational function is also normalized so that its post-critical points have barycenter=0 and has two post-critical points at infinity and on the positive real axis. Furthermore, if m is polynomial-like, then the returned map is a polynomial.

    gap> m := PolynomialIMGMachine(2,[1/3],[]);
    <FR machine with alphabet [ 1, 2 ] on Group( [ f1, f2, f3 ] )/[ f3*f2*f1 ]>
    gap> RationalFunction(m);
    0.866025*z^2+(-1)*z+(-0.288675)

##### 9.2-4 FRMachine

`> FRMachine`( f ) | ( operation )

`> IMGMachine`( f ) | ( operation )

Returns: An IMG FR machine.

This function computes a triangulation of the sphere, on the post-critical set of f, and lifts it through the map f. the action of the fundamental group of the punctured sphere is then read into an IMG fr machine `m`, which is returned.

This machine has a preset attribute `Spider(m)`.

An approximation of the Julia set of f can be computed, and plotted on the spider, with the form `IMGMachine(f:julia)` or `IMGMachine(f:julia:=gridsize)`.

    gap> z := Indeterminate(COMPLEX_FIELD);;
    gap> IMGMachine(z^2-1);
    <FR machine with alphabet [ 1, 2 ] on Group( [ f1, f2, f3 ] )/[ f2*f1*f3 ]>
    gap> Display(last);
     G  |            1        2
    ----+---------------+--------+
     f1 |          f2,2   <id>,1
     f2 | f3^-1*f1*f3,1   <id>,2
     f3 |        <id>,2     f3,1
    ----+---------------+--------+
    Relator: f2*f1*f3

##### 9.2-5 FindThurstonObstruction

`> FindThurstonObstruction`( list ) | ( operation )

Returns: A description of the obstruction corresponding to list, or `fail`.

!!!!

Top of Book Previous Chapter Next Chapter
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 Bib Ind

generated by GAPDoc2HTML