Skip to content
Browse files

new doc

  • Loading branch information...
1 parent 611813a commit 4ab6f137033b75031647bfab1f68845c0e2b4421 @laurentbartholdi committed Nov 19, 2012
Showing with 2,971 additions and 26 deletions.
  1. +1 −1 .gitignore
  2. +7 −6 PackageInfo.g
  3. +2 −1 README
  4. +5 −8 cnf/Makefile.in
  5. +212 −0 doc/chap0.html
  6. +43 −0 doc/chap1.html
  7. +262 −0 doc/chap2.html
  8. +1,274 −0 doc/chap3.html
  9. +55 −0 doc/chap4.html
  10. +68 −0 doc/chap5.html
  11. +399 −0 doc/chap6.html
  12. +224 −0 doc/chapBib.html
  13. +141 −0 doc/chapInd.html
  14. +11 −10 doc/img.xml
  15. BIN doc/manual.pdf
  16. +267 −0 doc/manual.six
View
2 .gitignore
@@ -9,7 +9,7 @@ bin/*
imgbib.xml.bib
autom4te.cache
.DS_Store
-doc/chap*
+doc/chap*txt
doc/manual.*
doc/*.aux
doc/*.pnr
View
13 PackageInfo.g
@@ -6,10 +6,11 @@ SetPackageInfo( rec(
PackageName := "IMG",
Subtitle := "Computations with iterated monodromy groups",
Version := "0.0.0",
+Date := "19/11/2012",
## <#GAPDoc Label="Version">
-## <!ENTITY0.0.0
+## <!ENTITY Version "0.0.0">
+## <!ENTITY Date "19/11/2012">
## <#/GAPDoc>
-Date := "19/11/2012",
ArchiveURL := Concatenation("https://github.com/laurentbartholdi/img/archive/",~.Version),
ArchiveFormats := ".tar.gz",
Persons := [
@@ -34,11 +35,11 @@ Status := "deposited",
CommunicatedBy := "Götz Pfeiffer (NUI Galway)",
AcceptDate := "",
-README_URL := "http://www.uni-math.gwdg.de/laurent/IMG/README.img",
-PackageInfoURL := "http://www.uni-math.gwdg.de/laurent/IMG/PackageInfo.g",
+README_URL := "http://laurentbartholdi.github.com/img/README.img",
+PackageInfoURL := "http://laurentbartholdi.github.com/img/PackageInfo.g",
AbstractHTML := "The <span class=\"pkgname\">IMG</span> package allows \
GAP to manipulate iterated monodromy groups",
-PackageWWWHome := "http://www.uni-math.gwdg.de/laurent/IMG/",
+PackageWWWHome := "http://laurentbartholdi.github.com/img/",
PackageDoc := rec(
BookName := "IMG",
@@ -57,7 +58,7 @@ Dependencies := rec(
SuggestedOtherPackages := [["Float",">=0.4"]],
# for compilation of the external module, one needs:
- # gcc, gfortran, libcblas, libgsl, javac, appletviewer.
+ # gcc, libcblas, javac, appletviewer.
ExternalConditions := []
),
View
3 README
@@ -37,7 +37,8 @@ in the subdirectory `extern'. If your system has them, their location can
be specified using the arguments `--with-levmar' and `--with-libdogleg' to
the `./configure' script. The options `--with-gaproot', `--with-gaparch' and
`CONFIGNAME' tell IMG where to look for the GAP installation; by default,
-IMG searches for it in ../.. and /usr/local/src/gap.
+IMG searches for it in ../.. and /usr/local/src/gap. The library `cholmod'
+is also required (often part of suitesparse), but is not provided.
In all cases, then run
View
13 cnf/Makefile.in
@@ -15,6 +15,7 @@
PWDU:=$(shell dirname $(PWD))
PWDUU:=$(shell dirname $(PWDU))
+VERSION:=$(shell grep '^Version :=' PackageInfo.g | cut -f2 -d'"')
LOCALBIN=bin/@GAPARCH@
EXTERN=$(CURDIR)/bin/@GAPARCH@/extern
@@ -64,33 +65,29 @@ java/javaview.jar:
rm -f javaview.zip
clean:
- rm -rf .version config.log $(LOCALBIN) `find doc -type l`
+ rm -rf config.log $(LOCALBIN) `find doc -type l`
mrproper: clean
rm Makefile config.h
configure: cnf/Makefile.in cnf/configure.ac
(cd cnf; aclocal -Im4; autoconf; mv -f configure ..)
-.version: PackageInfo.g
- grep '^Version :=' $< | cut -f2 -d'"' | tr -d '\n' > $@
-
doc: doc/chap0.html
doc/chap0.html: doc/img.xml doc/imgbib.xml gap/helpers.gd gap/complex.gd
echo 'LoadPackage("img"); DOC@IMG();' | @GAP_EXEC@ -r -q -T -l ";$(PWDUU)"
- (cd doc; git add *.html manual.pdf manual.css; git commit -m 'New html files'; git push github master:gh-pages --force)
checkblocks:
grep '<#GAPDoc' PackageInfo.g gap/*d | awk -F'"' '{print $$2}' | sort > @@-blocks
grep '<#Include' doc/img.xml | awk -F'"' '{print $$2}' | sort > @@-in
comm -3 @@-blocks @@-in
@rm @@-blocks @@-in
-tarballs: .version doc
+tarballs: doc
mkdir -p zips
- tar -c -f zips/img-`cat .version`.tar.gz -z --exclude '*~' --exclude '.[a-z]*' --exclude 'config.[ls]*' --exclude 'img/Makefile*' --exclude autom4te.cache --exclude sandbox --exclude zips --exclude bin --exclude extern -C .. img
- ln -sf img-`cat .version`.tar.gz zips/img.tar.gz
+ tar -c -f zips/img-$(VERSION).tar.gz -z --exclude '*~' --exclude '.[a-z]*' --exclude 'config.[ls]*' --exclude 'img/Makefile*' --exclude autom4te.cache --exclude sandbox --exclude zips --exclude bin --exclude extern -C .. img
+ ln -sf img-$(VERSION).tar.gz zips/img.tar.gz
wwwdir: doc/chap0.html tarballs
cp PackageInfo.g doc/
View
212 doc/chap0.html
@@ -0,0 +1,212 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+<head>
+<title>GAP (IMG) - Contents</title>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
+<meta name="generator" content="GAPDoc2HTML" />
+<link rel="stylesheet" type="text/css" href="manual.css" />
+<script src="manual.js" type="text/javascript"></script>
+<script type="text/javascript">overwriteStyle();</script>
+</head>
+<body class="chap0" onload="jscontent()">
+
+
+<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
+
+<div class="chlinkprevnexttop">&nbsp;<a href="chap0.html">[Top of Book]</a>&nbsp; <a href="chap0.html#contents">[Contents]</a>&nbsp; &nbsp;<a href="chap1.html">[Next Chapter]</a>&nbsp; </div>
+
+<p><a id="X7D2C85EC87DD46E5" name="X7D2C85EC87DD46E5"></a></p>
+<div class="pcenter">
+
+<h1>Iterated monodromy groups</h1>
+
+<p>Version 0.0.0</p>
+
+<p>19/11/2012</p>
+
+</div>
+<p>
+ Groups and dynamical systems
+ </p>
+<p><b>Laurent Bartholdi
+
+
+ </b>
+<br />Email: <span class="URL"><a href="mailto:laurent dot bartholdi at gmail dot com ">laurent dot bartholdi at gmail dot com </a></span>
+<br />Homepage: <span class="URL"><a href="http://www.uni-math.gwdg.de/laurent/">http://www.uni-math.gwdg.de/laurent/</a></span>
+</p>
+
+<p><b>Address:</b><br />
+Mathematisches Institut<br /> Bunsenstraße 3-5<br /> D-37073 Göttingen<br /> Germany</p>
+<p><a id="X7AA6C5737B711C89" name="X7AA6C5737B711C89"></a></p>
+<h3>Abstract</h3>
+<p>This document describes the package <strong class="pkg">IMG</strong>, which implements in <strong class="pkg">GAP</strong> the iterated monodromy groups of Nekrashevych. It depends on the package <strong class="pkg">FR</strong>.</p>
+
+<p>The computer algebra system <strong class="pkg">GAP</strong> is available at <span class="URL"><a href="http://gap-system.org">http://gap-system.org</a></span>.</p>
+
+<p>This documentation for <strong class="pkg">IMG</strong> is available at <span class="URL"><a href="http://laurentbartholdi.github.com/img/doc/manual.pdf">http://laurentbartholdi.github.com/img/doc/manual.pdf</a></span> in PDF format, and may be accessed online at <span class="URL"><a href="http://laurentbartholdi.github.com/img/">http://laurentbartholdi.github.com/img/</a></span>.</p>
+
+<p>The latest release of the package may be downloaded as <span class="URL"><a href="https://github.com/laurentbartholdi/img/archive/0.0.0.tar.gz">https://github.com/laurentbartholdi/img/archive/0.0.0.tar.gz</a></span> (tar, gzipped) and <span class="URL"><a href="https://github.com/laurentbartholdi/img/archive/0.0.0.zip">https://github.com/laurentbartholdi/img/archive/0.0.0.zip</a></span> (zip). The latest repository version (possibly unstable) may be downloaded as <span class="URL"><a href="https://github.com/laurentbartholdi/img/tarball/master">https://github.com/laurentbartholdi/img/tarball/master</a></span> (tar, gzipped), <span class="URL"><a href="https://github.com/laurentbartholdi/img.git">https://github.com/laurentbartholdi/img.git</a></span> (git repository), or explored at <span class="URL"><a href="https://github.com/laurentbartholdi/img/tree/master/">https://github.com/laurentbartholdi/img/tree/master/</a></span>.</p>
+
+<p>For comments or questions on <strong class="pkg">IMG</strong> please contact the author; this package is still under development.</p>
+
+<p><a id="X81488B807F2A1CF1" name="X81488B807F2A1CF1"></a></p>
+<h3>Copyright</h3>
+<p>© 2006-2012 by Laurent Bartholdi</p>
+
+<p><a id="X82A988D47DFAFCFA" name="X82A988D47DFAFCFA"></a></p>
+<h3>Acknowledgements</h3>
+<p>Part of this work is/was supported by the "German Science Foundation".</p>
+
+<p><a id="X7982162280BC7A61" name="X7982162280BC7A61"></a></p>
+<h3>Colophon</h3>
+<p>This project started in the mid-1990s, when, as a PhD student I did many calculations with groups generated by automata, and realized the similarities between all calculations; it quickly became clear that these calculations could be done much better by a computer than by a human.</p>
+
+<p>The first routines I wrote constructed finite representations of the groups considered, so as to get insight from fast calculations within <strong class="pkg">GAP</strong>. The results then had to be proved correct within the infinite group under consideration, and this often involved guessing appropriate words in the infinite group with a given image in the finite quotient.</p>
+
+<p>Around 2000, I had developed quite a few routines, which I assembled in a <strong class="pkg">GAP</strong> package, that dealt directly with infinite groups. This package was primitive at its core, but was extended with various routines as they became useful.</p>
+
+<p>I decided in late 2005 to start a new package from scratch, that would encorporate as much functionality as possible in a uniform manner; that would handle semigroups as well as groups; that could be easily extended; and with a complete, understandable documentation. I hope I am not too far from these objectives.</p>
+
+<p><a id="X8537FEB07AF2BEC8" name="X8537FEB07AF2BEC8"></a></p>
+
+<div class="contents">
+<h3>Contents<a id="contents" name="contents"></a></h3>
+
+<div class="ContChap"><a href="chap1.html#X86DB23CC834ABD71">1 <span class="Heading">Licensing</span></a>
+</div>
+<div class="ContChap"><a href="chap2.html#X83058F397E03A3A8">2 <span class="Heading">IMG package</span></a>
+<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap2.html#X80C332C686212786">2.1 <span class="Heading">A brief mathematical introduction</span></a>
+</span>
+</div>
+<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap2.html#X78DF4DE18260BD80">2.2 <span class="Heading">An example session</span></a>
+</span>
+</div>
+</div>
+<div class="ContChap"><a href="chap3.html#X798DE1297EC58F59">3 <span class="Heading">Iterated monodromy groups</span></a>
+<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap3.html#X8287B3D98071EBB7">3.1 <span class="Heading">Creators and operations for IMG machines</span></a>
+</span>
+<div class="ContSSBlock">
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X851C12AA87B92799">3.1-1 IsIMGMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X78D75CDE792449A6">3.1-2 IMGMachineNC</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X857CD5C587549F1A">3.1-3 AsIMGMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7BCE03F2827DAA0A">3.1-4 IMGRelator</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X8706C13B7D6A1225">3.1-5 CleanedIMGMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7D4A6996874A3DF3">3.1-6 NewSemigroupFRMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X80388DDE7F9B41FD">3.1-7 AsIMGElement</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X84C2881D87C1FB74">3.1-8 IsKneadingMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X8203D69280D4B64C">3.1-9 AsPolynomialFRMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7F67843E83A288AF">3.1-10 AddingElement</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7D71EBDA7D7C3474">3.1-11 PolynomialFRMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X814E27317A6213D3">3.1-12 SupportingRays</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X78130FC97C58AFC4">3.1-13 AsGroupFRMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7F1FAAF37B54772F">3.1-14 NormalizedPolynomialFRMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X85AECB5A7A962200">3.1-15 SimplifiedIMGMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7AB029AE8590964E">3.1-16 Mating</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X8410869F8358A1AF">3.1-17 AutomorphismVirtualEndomorphism</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X82F0B23486F2E3AC">3.1-18 DBRationalIMGGroup</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X8365719F7E03B7C3">3.1-19 PostCriticalMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7E858BE07A7C55B4">3.1-20 Mandel</a></span>
+</div></div>
+<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap3.html#X7C73C74D87428A33">3.2 <span class="Heading">Spiders</span></a>
+</span>
+<div class="ContSSBlock">
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X80C530E87B7FA7C4">3.2-1 DelaunayTriangulation</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X82CA08BD85AA4F4E">3.2-2 LocateInTriangulation</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X81727B8B7A599605">3.2-3 IsSphereTriangulation</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7CC0BBAD807D1A45">3.2-4 RationalFunction</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X8563CADF7AA37AA4">3.2-5 Draw</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X86BD8FD97D3AFA45">3.2-6 FRMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X86377DEA7B83E596">3.2-7 FindThurstonObstruction</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7E169BC681F9A1DA">3.2-8 HurwitzMap</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X84FC673C7B104194">3.2-9 DessinByPermutations</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X86C9E1938159FEE1">3.2-10 KneadingSequence</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X857FCD7678B12A0C">3.2-11 AllInternalAddresses</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X86C250907E09F399">3.2-12 ExternalAnglesRelation</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X84F962AF7D553DDA">3.2-13 ExternalAngle</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X814F53B97C3F43F5">3.2-14 ChangeFRMachineBasis</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7BE001A0811CD599">3.2-15 ComplexConjugate</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7F56E5F184700C5C">3.2-16 BraidTwists</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7E941D2185A1DF3B">3.2-17 RotatedSpider</a></span>
+</div></div>
+</div>
+<div class="ContChap"><a href="chap4.html#X7A489A5D79DA9E5C">4 <span class="Heading">Examples</span></a>
+<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap4.html#X7AF5DEF08531AFA5">4.1 <span class="Heading">Examples of groups</span></a>
+</span>
+<div class="ContSSBlock">
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap4.html#X8700DB2886B0A7E4">4.1-1 PoirierExamples</a></span>
+</div></div>
+</div>
+<div class="ContChap"><a href="chap5.html#X830C0CE882611F8E">5 <span class="Heading">IMG implementation details</span></a>
+<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap5.html#X7F8F64548143DF99">5.1 <span class="Heading">Marked spheres</span></a>
+</span>
+</div>
+</div>
+<div class="ContChap"><a href="chap6.html#X785C6C0B80936CC8">6 <span class="Heading">Miscellanea</span></a>
+<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap6.html#X7E09F9097DA0FB63">6.1 <span class="Heading">Complex numbers</span></a>
+</span>
+<div class="ContSSBlock">
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X87EFAAE97B81054E">6.1-1 IsPMComplex</a></span>
+</div></div>
+<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap6.html#X82A013F78010EC06">6.2 <span class="Heading">P1 points</span></a>
+</span>
+<div class="ContSSBlock">
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X84AD618C7906AC92">6.2-1 IsP1Point</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X80B00F0685209993">6.2-2 CleanedP1Point</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X87AC40C579500473">6.2-3 P1infinity</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X80DB7A677E1EF1F6">6.2-4 P1Antipode</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X7E220B497FF24C98">6.2-5 P1Barycentre</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X83BD8B5C856DF570">6.2-6 P1Circumcentre</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X7A3A339181EF9D24">6.2-7 P1Distance</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X86D3189D83BA09F8">6.2-8 P1Midpoint</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X7FC042FA8032C1A5">6.2-9 P1Sphere</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X83072FCB86850BDA">6.2-10 SphereP1</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X87B815958442BA68">6.2-11 SphereP1Y</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X7C50C284794F35A8">6.2-12 P1XRatio</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X7E5D08E07C9994F8">6.2-13 IsP1Map</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X83D5E52A7FFB797D">6.2-14 MoebiusMap</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X7B5CBC0585889AC9">6.2-15 P1z</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X87A94D82784C718C">6.2-16 CleanedP1Map</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X8016D67A7E896C06">6.2-17 CompositionP1Map</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X7BDFCBC5811CE899">6.2-18 InverseP1Map</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X7C68BED87D1EC1AD">6.2-19 ConjugatedP1Map</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X7AFFF43383BF5001">6.2-20 CoefficientsOfP1Map</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X7DE9419F7E0FADE9">6.2-21 P1MapByCoefficients</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X78DBA65C7990FE8A">6.2-22 P1Path</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X78DB4F257D1E2E8B">6.2-23 DegreeOfP1Map</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X78BB00397DBDE5F5">6.2-24 P1Image</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X8523E70785E32A8F">6.2-25 P1PreImages</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X78B3055980B23917">6.2-26 P1MapCriticalPoints</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X8362CB5B79247851">6.2-27 P1MapRational</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X84BEAA60839AADAA">6.2-28 RationalP1Map</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X83410A948102C845">6.2-29 P1MapSL2</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X840A9CD185F5519C">6.2-30 SL2P1Map</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X874D59BD87D136D0">6.2-31 SetP1Points</a></span>
+</div></div>
+<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap6.html#X785C6C0B80936CC8">6.3 <span class="Heading">Miscellanea</span></a>
+</span>
+</div>
+<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap6.html#X7ADFF37084706CEC">6.4 <span class="Heading">User settings</span></a>
+</span>
+<div class="ContSSBlock">
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap6.html#X7B685E7E825B7403">6.4-1 InfoIMG</a></span>
+</div></div>
+</div>
+<div class="ContChap"><a href="chapBib.html"><span class="Heading">References</span></a></div>
+<div class="ContChap"><a href="chapInd.html"><span class="Heading">Index</span></a></div>
+<br />
+</div>
+
+<div class="chlinkprevnextbot">&nbsp;<a href="chap0.html">[Top of Book]</a>&nbsp; <a href="chap0.html#contents">[Contents]</a>&nbsp; &nbsp;<a href="chap1.html">[Next Chapter]</a>&nbsp; </div>
+
+
+<div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
+
+<hr />
+<p class="foot">generated by <a href="http://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
+</body>
+</html>
View
43 doc/chap1.html
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+<head>
+<title>GAP (IMG) - Chapter 1: Licensing</title>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
+<meta name="generator" content="GAPDoc2HTML" />
+<link rel="stylesheet" type="text/css" href="manual.css" />
+<script src="manual.js" type="text/javascript"></script>
+<script type="text/javascript">overwriteStyle();</script>
+</head>
+<body class="chap1" onload="jscontent()">
+
+
+<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
+
+<div class="chlinkprevnexttop">&nbsp;<a href="chap0.html">[Top of Book]</a>&nbsp; <a href="chap0.html#contents">[Contents]</a>&nbsp; &nbsp;<a href="chap0.html">[Previous Chapter]</a>&nbsp; &nbsp;<a href="chap2.html">[Next Chapter]</a>&nbsp; </div>
+
+<p><a id="X86DB23CC834ABD71" name="X86DB23CC834ABD71"></a></p>
+<div class="ChapSects"><a href="chap1.html#X86DB23CC834ABD71">1 <span class="Heading">Licensing</span></a>
+</div>
+
+<h3>1 <span class="Heading">Licensing</span></h3>
+
+<p>This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or any later version.</p>
+
+<p>This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.</p>
+
+<p>You should have received a copy of the GNU General Public License along with this program, in the file COPYING. If not, see <span class="URL"><a href="http://www.gnu.org/licenses/">http://www.gnu.org/licenses/</a></span>.</p>
+
+
+<div class="chlinkprevnextbot">&nbsp;<a href="chap0.html">[Top of Book]</a>&nbsp; <a href="chap0.html#contents">[Contents]</a>&nbsp; &nbsp;<a href="chap0.html">[Previous Chapter]</a>&nbsp; &nbsp;<a href="chap2.html">[Next Chapter]</a>&nbsp; </div>
+
+
+<div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
+
+<hr />
+<p class="foot">generated by <a href="http://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
+</body>
+</html>
View
262 doc/chap2.html
@@ -0,0 +1,262 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+<head>
+<title>GAP (IMG) - Chapter 2: IMG package</title>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
+<meta name="generator" content="GAPDoc2HTML" />
+<link rel="stylesheet" type="text/css" href="manual.css" />
+<script src="manual.js" type="text/javascript"></script>
+<script type="text/javascript">overwriteStyle();</script>
+</head>
+<body class="chap2" onload="jscontent()">
+
+
+<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
+
+<div class="chlinkprevnexttop">&nbsp;<a href="chap0.html">[Top of Book]</a>&nbsp; <a href="chap0.html#contents">[Contents]</a>&nbsp; &nbsp;<a href="chap1.html">[Previous Chapter]</a>&nbsp; &nbsp;<a href="chap3.html">[Next Chapter]</a>&nbsp; </div>
+
+<p><a id="X83058F397E03A3A8" name="X83058F397E03A3A8"></a></p>
+<div class="ChapSects"><a href="chap2.html#X83058F397E03A3A8">2 <span class="Heading">IMG package</span></a>
+<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap2.html#X80C332C686212786">2.1 <span class="Heading">A brief mathematical introduction</span></a>
+</span>
+</div>
+<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap2.html#X78DF4DE18260BD80">2.2 <span class="Heading">An example session</span></a>
+</span>
+</div>
+</div>
+
+<h3>2 <span class="Heading">IMG package</span></h3>
+
+<p><a id="X80C332C686212786" name="X80C332C686212786"></a></p>
+
+<h4>2.1 <span class="Heading">A brief mathematical introduction</span></h4>
+
+<p>This chapter assumes that you have no familiarity with groups generated by automata. If you do, and wish to see their usage within <strong class="pkg">GAP</strong> through a sample session, please skip to Section <a href="chap2.html#X78DF4DE18260BD80"><span class="RefLink">2.2</span></a>. For a more thourough introduction on self-similar groups see <a href="chapBib.html#biBMR2091700">[BGN03]</a> or <a href="chapBib.html#biBMR2035113">[BGŠ03]</a>.</p>
+
+<p>We shall here be interested in groups <span class="SimpleMath">G</span> defined by their action on a regular rooted tree. Let <span class="SimpleMath">X</span> be a finite set; and let <span class="SimpleMath">X^*</span> denote the set of words (free monoid) over <span class="SimpleMath">X</span>. Then <span class="SimpleMath">X^*</span> naturally has the structure of a regular rooted tree: the root is the empty word, and vertex <span class="SimpleMath">v ∈ X^*</span> is connected to vertex <span class="SimpleMath">vx</span> for all choices of <span class="SimpleMath">x ∈ X</span>. Each vertex except the root therefore has <span class="SimpleMath">#X+1</span> neighbours.</p>
+
+<p>Let <span class="SimpleMath">W</span> denote the automorphism group of the graph <span class="SimpleMath">X^*</span>. Given <span class="SimpleMath">a ∈ W</span>, we may restrict its action to <span class="SimpleMath">X ⊂ X^*</span>, and obtain a permutation <span class="SimpleMath">π_a</span> on <span class="SimpleMath">X</span>, called the <em>activity</em> of <span class="SimpleMath">a</span>. We may also obtain, for all <span class="SimpleMath">x∈ X</span>, a tree automorphism <span class="SimpleMath">a_x ∈ W</span>, called the <em>state of <span class="SimpleMath">a</span> at <span class="SimpleMath">x</span></em>, by the formula</p>
+
+<p class="pcenter">(v){a_x} = w \quad\textrm{if}\quad (xv)a = x^{\pi_a}w.</p>
+
+<p>The data <span class="SimpleMath">(a_x,π_a)</span> determine uniquely the automorphism <span class="SimpleMath">a</span>, and any choice of <span class="SimpleMath">a_x</span> and <span class="SimpleMath">π_a</span> defines a tree isometry. We therefore have a group isomorphism</p>
+
+<p class="pcenter">\phi: W \to W\wr \mathop{Sym}(X),</p>
+
+<p>called the <em>Wreath recursion</em>. The image of <span class="SimpleMath">ϕ</span> is the permutational wreath product <span class="SimpleMath">W^X ⋊ Sym(X)</span>.</p>
+
+<p>The state <span class="SimpleMath">a_x</span> should be interpreted as the restriction of the action of <span class="SimpleMath">a</span> on the subtree <span class="SimpleMath">xX^*</span>; the automorphism <span class="SimpleMath">a</span> is defined by acting first on each of the subtrees of the form <span class="SimpleMath">xX^*</span> by its respective state, and then permuting these subtrees according to <span class="SimpleMath">π_a</span>. The wreath recursion can be iterated on the states of <span class="SimpleMath">a</span>, to define states <span class="SimpleMath">a_v</span> for any <span class="SimpleMath">v ∈ X^*</span>.</p>
+
+<p>The automorphism <span class="SimpleMath">a ∈ W</span> may be represented by a graph, as follows. There is one vertex for each state <span class="SimpleMath">a_v</span> of <span class="SimpleMath">a</span>, labeled <span class="SimpleMath">π_a_v</span>; and for each <span class="SimpleMath">x ∈ X</span> there is one edge from state <span class="SimpleMath">a_v</span> to state <span class="SimpleMath">a_vx</span>, labeled <span class="SimpleMath">x</span>. This graph is nothing but a quotient of the regular rooted tree <span class="SimpleMath">X^*</span>, where vertices <span class="SimpleMath">v</span> and <span class="SimpleMath">w</span> are identified if <span class="SimpleMath">a_v=a_w</span>. Again, this graph, with a choice of initial vertex, determines uniquely the automorphism <span class="SimpleMath">a</span>.</p>
+
+<p>This graph may be conveniently encoded in what is called a <em>Moore machine</em>: it consists of a set <span class="SimpleMath">Q</span>, the vertex set of the graph; an alphabet, <span class="SimpleMath">X</span>; a `transition' function <span class="SimpleMath">ϕ:Q× X-&gt; Q</span>, where <span class="SimpleMath">ϕ(q,x)</span> is the endpoint of the edge starting at <span class="SimpleMath">q</span> and labeled <span class="SimpleMath">x</span>; and a labeling <span class="SimpleMath">π</span> of <span class="SimpleMath">X</span> by the symmetric group on <span class="SimpleMath">X</span>. We will use the equivalent <em>Mealy machines</em>, given by a `transition' function <span class="SimpleMath">ϕ:Q× X-&gt; X× Q</span>, encoding both <span class="SimpleMath">ϕ</span> and <span class="SimpleMath">π</span> together.</p>
+
+<p>Of particular interest are <em>finite-state automorphisms</em>: these are automorphisms whose Mealy machine has finitely many states. The product and inverse of finite-state automorphisms is again finite-state.</p>
+
+<p>A subgroup <span class="SimpleMath">G le W</span> is <em>self-similar</em> if <span class="SimpleMath">G^ϕ ⊂ G≀Sym(X)</span>. This is equivalent to asking, for every <span class="SimpleMath">a ∈ G</span>, that all of its states <span class="SimpleMath">a_x</span> also belong to <span class="SimpleMath">G</span>.</p>
+
+<p>The following important properties have also been considered. A subgroup <span class="SimpleMath">G le W</span> is <em>level-transitive</em> if its action is transitive on all the <span class="SimpleMath">G</span>-subsets <span class="SimpleMath">X^n</span>. It is <em>weakly branched</em> if it is level-transitive, and for every <span class="SimpleMath">v∈ X^*</span> there is a non-trivial <span class="SimpleMath">a_v∈ G</span> that fixes <span class="SimpleMath">X^* ∖ vX^*</span>. It is <em>branched</em> if furthermore for each <span class="SimpleMath">n ∈ N</span> the group generated by all such <span class="SimpleMath">a_v</span> for all <span class="SimpleMath">v</span> of length <span class="SimpleMath">n</span> has finite index in <span class="SimpleMath">G</span>.</p>
+
+<p>A self-similar finitely generated group <span class="SimpleMath">G le W</span> is <em>contracting</em> if there are constants <span class="SimpleMath">K,n ∈ N</span> and <span class="SimpleMath">λ&lt;1</span> such that <span class="SimpleMath">|a_v|leλ|a|+K</span> for all <span class="SimpleMath">a∈ G</span> and <span class="SimpleMath">v∈ X^n</span>; here <span class="SimpleMath">|a|</span> denotes the minimal number of generators needed to express <span class="SimpleMath">a</span>. It then follows that there exists a finite set <span class="SimpleMath">N⊂ G</span> such that for all <span class="SimpleMath">a∈ G</span>, all but finitely many of the states of <span class="SimpleMath">a</span> belong to <span class="SimpleMath">N</span>. The minimal such <span class="SimpleMath">N</span> is called the <em>nucleus</em> of <span class="SimpleMath">G</span>. Since the states of elements of the nucleus are again in the nucleus, we see that the nucleus is naturally a Mealy machine. By considering all elements of <span class="SimpleMath">W</span> obtained from this Mealy machine by choosing all possible initial states, we obtain a generating set for <span class="SimpleMath">G</span> made of all states of a single machine; this is the <em>group generated</em> by the machine.</p>
+
+<p>In this package, we are mainly interested in self-similar groups of finite-state automorphisms. The reason is historical: Aleshin <a href="chapBib.html#biBMR713968">[Ale83]</a>, and later Grigorchuk <a href="chapBib.html#biBMR565099">[Gri80]</a> and Gupta and Sidki <a href="chapBib.html#biBMR696534">[GS83]</a> constructed peculiar examples of groups using self-similar finite-state automorphisms. All these groups can be defined by drawing a small machine (at most five vertices) and considering the group that they generate.</p>
+
+<p>We assumed for simplicity that the elements <span class="SimpleMath">a</span> were invertible. Actually, in the definition of Mealy machines it makes sense to accept arbitrary maps, and not necessarily bijections of <span class="SimpleMath">X</span> as a label at each vertex. One may in this way define peculiar semigroups.</p>
+
+<p><a id="X78DF4DE18260BD80" name="X78DF4DE18260BD80"></a></p>
+
+<h4>2.2 <span class="Heading">An example session</span></h4>
+
+<p>This is a brief introduction describing some of the simpler features of the <strong class="pkg">FR</strong> package. It assumes you have some familiarity with the theory of groups defined by automata; if not, a brief mathematical introduction may be found in Section <a href="chap2.html#X80C332C686212786"><span class="RefLink">2.1</span></a>. We show here and comment a typical use of the package.</p>
+
+<p>The package is installed by unpacking the archive in the <code class="file">pkg/</code> directory of your <strong class="pkg">GAP</strong> installation. It can also be placed in a local directory, which must be added to the load-path by invoking <code class="code">gap</code> with the <code class="code">-l</code> option.</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">LoadPackage("fr");</span>
+----------------------------------------------------------------
+Loading FR 0.857142p5 (Functionally recursive and automata groups)
+by Laurent Bartholdi (http://www.uni-math.gwdg.de/laurent)
+----------------------------------------------------------------
+true
+</pre></div>
+
+<p>Many FR groups are predefined by <strong class="pkg">FR</strong>, see Chapter <span class="RefLink">???</span>. We consider here the <em>Basilica group</em>, considered in <a href="chapBib.html#biBMR1902367">[GŻ02a]</a> and <a href="chapBib.html#biBMR2176547">[BV05]</a>.</p>
+
+<p>We may start by defining a group: it has two generators <span class="SimpleMath">a</span> and <span class="SimpleMath">b</span>, satisfying the specified recursions.</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">B := FRGroup("a=&lt;1,b&gt;(1,2)","b=&lt;1,a&gt;",IsFRMealyElement);</span>
+&lt;self-similar group over [ 1 .. 2 ] with 2 generators&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">AssignGeneratorVariables(B);</span>
+#I Assigned the global variables [ a, b ]
+</pre></div>
+
+<p>We have just created the group <span class="SimpleMath">B=⟨ a,b⟩</span>.</p>
+
+<p>Note that this group is predefined as <code class="code">BasilicaGroup</code>. We now compute the decompositions of the generators:</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">DecompositionOfFRElement(a); DecompositionOfFRElement(b);</span>
+[ [ &lt;2|identity ...&gt;, &lt;2|b&gt; ], [ 2, 1 ] ]
+[ [ &lt;2|identity ...&gt;, &lt;2|a&gt; ], [ 1, 2 ] ]
+</pre></div>
+
+<p>Elements are described as words in the generators; they are printed as <code class="code">&lt;2|a&gt;</code>, where the <span class="SimpleMath">2</span> reminds of the degree of the tree on which <span class="SimpleMath">a</span> acts.</p>
+
+<p>The optional argument <code class="func">IsFRElement</code> (<span class="RefLink">???</span>) tells <strong class="pkg">FR</strong> to store elements in this way. This representation is always possible, but it is usually inefficient for calculations. The argument <code class="func">IsMealyElement</code> (<span class="RefLink">???</span>) forces <strong class="pkg">FR</strong> to use a more efficient representation, which in some cases may take an infinite time to set up. With no extra argument, <strong class="pkg">FR</strong> does what it thinks is best. The advantages of both representations are sometimes obtained by the argument <code class="func">IsFRMealyElement</code> (<span class="RefLink">???</span>), which stores both representations.</p>
+
+<p>Elements act on sequences over <span class="SimpleMath">{1,2}</span>. The action is computed in the standard manner:</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">1^a; [1]^a; [1,1]^a;</span>
+2
+[ 2 ]
+[ 2, 1 ]
+</pre></div>
+
+<p>Periodic sequences are also implemented in <strong class="pkg">FR</strong>; they are constructed by giving the period and preperiod. The period is printed by preceding it with a "/":</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">v := PeriodicList([1],[2]);</span>
+[ 1, / 2 ]
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">v^a; v^(a^2);</span>
+[/ 2 ]
+[/ 1, 2 ]
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">last{[1..10]};</span>
+[ 1, 2, 1, 2, 1, 2, 1, 2, 1, 2 ]
+</pre></div>
+
+<p>Most computations are much more efficient if <span class="SimpleMath">B</span>'s elements are converted to <em>Mealy representation</em>,</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Bm := Image(IsomorphismMealyGroup(B));</span>
+&lt;recursive group over [ 1 .. 2 ] with 2 generators&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">a := Bm.1; b := Bm.2;</span>
+&lt;Mealy element on alphabet [ 1, 2 ] with 3 states&gt;
+&lt;Mealy element on alphabet [ 1, 2 ] with 3 states&gt;
+</pre></div>
+
+<p>This could have been done automatically by specifying <code class="code">IsMealyElement</code> as last argument in the call to <code class="code">FRGroup</code>.</p>
+
+<p>The group <span class="SimpleMath">B</span> is torsion-free, and its elements are bounded automata. Although torsion-freeness is difficult to check for <strong class="pkg">FR</strong>, it can be checked on individual elements:</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">IsBoundedFRSemigroup(Bm);</span>
+true
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Order(a); Order(b);</span>
+infinity
+infinity
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">g := PseudoRandom(B);; Length(InitialState(g));</span>
+4679
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Order(g); time;</span>
+infinity
+2599
+</pre></div>
+
+<p>The group <span class="SimpleMath">B</span> is weakly branched; more precisely, the derived subgroup <span class="SimpleMath">B'</span> contains <span class="SimpleMath">B' × B'</span>. To prove that, it suffices to check <span class="SimpleMath">[a,b] × 1∈ B'</span> and <span class="SimpleMath">1 × [a,b]∈ B'</span>. These elements are constructed using <code class="func">VertexElement</code> (<span class="RefLink">???</span>):</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">c := Comm(a,b);</span>
+&lt;Mealy element on alphabet [ 1, 2 ] with 9 states&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">K := NormalClosure(Bm,Group(c));</span>
+&lt;self-similar group over [ 1 .. 2 ] with 3 generators&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">VertexElement(1,c) in K; VertexElement(1,c) in K;</span>
+true
+true
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">DecompositionOfFRElement(VertexElement(1,c))=[[c,One(Bm)],[1,2]];</span>
+true
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">VertexElement(2,c)=Comm(b,a^2);</span>
+true
+</pre></div>
+
+<p>Note that we had to guess the form of the element <code class="code">VertexElement(2,c)</code> above. This could have been found out by <strong class="pkg">GAP</strong> using <code class="func">ShortGroupWordInSet</code> (<span class="RefLink">???</span>).</p>
+
+<p>We may also check the relations <span class="SimpleMath">[b^p,(b^p)^a^p]=1</span> and <span class="SimpleMath">[a^2p,(a^2p)^b^p]</span> for <span class="SimpleMath">p</span> any power of <span class="SimpleMath">2</span>:</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">ForAll([0..10],i-&gt;IsOne(Comm(b^(2^i),(b^(2^i))^((a^(2^i)))))); time;</span>
+true
+1361
+</pre></div>
+
+<p>Since the group <span class="SimpleMath">B</span> is bounded, it is contracting. We compute its nucleus:</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">NucleusOfFRSemigroup(B);</span>
+[ &lt;2|identity ...&gt;, &lt;2|b&gt;, &lt;2|b^-1&gt;, &lt;2|a&gt;, &lt;2|a^-1&gt;, &lt;2|b^-1*a&gt;, &lt;2|a^-1*b&gt; ]
+</pre></div>
+
+<p>We then compute the Mealy machine with stateset this nucleus, and draw it graphically (this requires the external programs <strong class="pkg">graphviz</strong> and <strong class="pkg">imagemagick</strong>):</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">N := NucleusMachine(B);</span>
+&lt;Mealy machine on alphabet [ 1, 2 ] with 7 states&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Draw(N);</span>
+</pre></div>
+
+<p>We may also draw powers of the dual automaton: these are approximations to the Schreier graph of <span class="SimpleMath">B</span>. However, we also construct a smaller Mealy machine with states only <span class="SimpleMath">a</span> and <span class="SimpleMath">b</span>, which give better images:</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Draw(DualMachine(N)^3);</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">M := AsMealyMachine(FRMachine(a))[1];</span>
+&lt;Mealy machine on alphabet [ 1, 2 ] with 3 states&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Draw(DualMachine(M)^4);</span>
+</pre></div>
+
+<p>These Schreier graphs are orbits of the group; they can be displayed as follows:</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">WordGrowth(B:point:=[1,1,1,1],draw);</span>
+</pre></div>
+
+<p>More properties of <span class="SimpleMath">B</span> can be checked, or experimented with, on its finite quotients obtained by truncating the tree on which <span class="SimpleMath">B</span> acts at a given length. <code class="code">PermGroup(B,n)</code> constructs a permutation group which is the natural quotient of <span class="SimpleMath">B</span> acting on <span class="SimpleMath">2^n</span> points:</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G := PermGroup(B,7);</span>
+&lt;permutation group with 2 generators&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Size(G); LogInt(last,2);</span>
+309485009821345068724781056
+88
+</pre></div>
+
+<p>We may "guess" the structure of the Lie algebra of <span class="SimpleMath">B</span> by examining the ranks of the successive quotients along its Jennings series:</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">J := JenningsLieAlgebra(G); time;</span>
+&lt;Lie algebra of dimension 88 over GF(2)&gt;
+18035
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">List([1..15],i-&gt;Dimension(Grading(J).hom_components(i)));</span>
+[ 2, 3, 1, 4, 1, 2, 1, 4, 1, 2, 1, 3, 1, 2, 1 ]
+</pre></div>
+
+<p>The "<span class="SimpleMath">4</span>" in position <span class="SimpleMath">8</span> of that list should really be a "<span class="SimpleMath">5</span>"; computations on finite quotients of <span class="SimpleMath">B</span> usually give lower bounds for invariants of <span class="SimpleMath">B</span>. In that case, we guess that the ranks behave like a "ruler" function, i.e. that the rank of the homogeneous component of degree <span class="SimpleMath">i</span> is <span class="SimpleMath">2+ν_2(i)</span> if <span class="SimpleMath">i</span> is a power of <span class="SimpleMath">2</span> and is <span class="SimpleMath">1+ν_2(i)</span> otherwise; here <span class="SimpleMath">ν_2(i)</span> is the number of times <span class="SimpleMath">2</span> divides <span class="SimpleMath">i</span>.</p>
+
+
+<div class="chlinkprevnextbot">&nbsp;<a href="chap0.html">[Top of Book]</a>&nbsp; <a href="chap0.html#contents">[Contents]</a>&nbsp; &nbsp;<a href="chap1.html">[Previous Chapter]</a>&nbsp; &nbsp;<a href="chap3.html">[Next Chapter]</a>&nbsp; </div>
+
+
+<div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
+
+<hr />
+<p class="foot">generated by <a href="http://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
+</body>
+</html>
View
1,274 doc/chap3.html
@@ -0,0 +1,1274 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+<head>
+<title>GAP (IMG) - Chapter 3: Iterated monodromy groups</title>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
+<meta name="generator" content="GAPDoc2HTML" />
+<link rel="stylesheet" type="text/css" href="manual.css" />
+<script src="manual.js" type="text/javascript"></script>
+<script type="text/javascript">overwriteStyle();</script>
+</head>
+<body class="chap3" onload="jscontent()">
+
+
+<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
+
+<div class="chlinkprevnexttop">&nbsp;<a href="chap0.html">[Top of Book]</a>&nbsp; <a href="chap0.html#contents">[Contents]</a>&nbsp; &nbsp;<a href="chap2.html">[Previous Chapter]</a>&nbsp; &nbsp;<a href="chap4.html">[Next Chapter]</a>&nbsp; </div>
+
+<p><a id="X798DE1297EC58F59" name="X798DE1297EC58F59"></a></p>
+<div class="ChapSects"><a href="chap3.html#X798DE1297EC58F59">3 <span class="Heading">Iterated monodromy groups</span></a>
+<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap3.html#X8287B3D98071EBB7">3.1 <span class="Heading">Creators and operations for IMG machines</span></a>
+</span>
+<div class="ContSSBlock">
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X851C12AA87B92799">3.1-1 IsIMGMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X78D75CDE792449A6">3.1-2 IMGMachineNC</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X857CD5C587549F1A">3.1-3 AsIMGMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7BCE03F2827DAA0A">3.1-4 IMGRelator</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X8706C13B7D6A1225">3.1-5 CleanedIMGMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7D4A6996874A3DF3">3.1-6 NewSemigroupFRMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X80388DDE7F9B41FD">3.1-7 AsIMGElement</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X84C2881D87C1FB74">3.1-8 IsKneadingMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X8203D69280D4B64C">3.1-9 AsPolynomialFRMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7F67843E83A288AF">3.1-10 AddingElement</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7D71EBDA7D7C3474">3.1-11 PolynomialFRMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X814E27317A6213D3">3.1-12 SupportingRays</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X78130FC97C58AFC4">3.1-13 AsGroupFRMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7F1FAAF37B54772F">3.1-14 NormalizedPolynomialFRMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X85AECB5A7A962200">3.1-15 SimplifiedIMGMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7AB029AE8590964E">3.1-16 Mating</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X8410869F8358A1AF">3.1-17 AutomorphismVirtualEndomorphism</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X82F0B23486F2E3AC">3.1-18 DBRationalIMGGroup</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X8365719F7E03B7C3">3.1-19 PostCriticalMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7E858BE07A7C55B4">3.1-20 Mandel</a></span>
+</div></div>
+<div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap3.html#X7C73C74D87428A33">3.2 <span class="Heading">Spiders</span></a>
+</span>
+<div class="ContSSBlock">
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X80C530E87B7FA7C4">3.2-1 DelaunayTriangulation</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X82CA08BD85AA4F4E">3.2-2 LocateInTriangulation</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X81727B8B7A599605">3.2-3 IsSphereTriangulation</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7CC0BBAD807D1A45">3.2-4 RationalFunction</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X8563CADF7AA37AA4">3.2-5 Draw</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X86BD8FD97D3AFA45">3.2-6 FRMachine</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X86377DEA7B83E596">3.2-7 FindThurstonObstruction</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7E169BC681F9A1DA">3.2-8 HurwitzMap</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X84FC673C7B104194">3.2-9 DessinByPermutations</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X86C9E1938159FEE1">3.2-10 KneadingSequence</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X857FCD7678B12A0C">3.2-11 AllInternalAddresses</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X86C250907E09F399">3.2-12 ExternalAnglesRelation</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X84F962AF7D553DDA">3.2-13 ExternalAngle</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X814F53B97C3F43F5">3.2-14 ChangeFRMachineBasis</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7BE001A0811CD599">3.2-15 ComplexConjugate</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7F56E5F184700C5C">3.2-16 BraidTwists</a></span>
+<span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap3.html#X7E941D2185A1DF3B">3.2-17 RotatedSpider</a></span>
+</div></div>
+</div>
+
+<h3>3 <span class="Heading">Iterated monodromy groups</span></h3>
+
+<p>Iterated monodromy machines are a special class of group FR machines (see Section <span class="RefLink">???</span>) with attribute <code class="func">IMGRelator</code> (<a href="chap3.html#X7BCE03F2827DAA0A"><span class="RefLink">3.1-4</span></a>). This attribute records a cyclic ordering of the generators of the machine whose product is trivial.</p>
+
+<p>The interpretation is the following: the machine encodes a <em>Thurston map</em>, i.e. a post-critically finite topological branched self-covering of the sphere <span class="SimpleMath">S^2</span>. 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 <a href="chapBib.html#biBMR2162164">[Nek05]</a>.</p>
+
+<p>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 <span class="SimpleMath">g</span> is trivial if there exists an integer <span class="SimpleMath">N</span> such that unfolding <span class="SimpleMath">N</span> times the recursion for <span class="SimpleMath">g</span> yields only trivial states (as elements of the underlying free group).</p>
+
+<p><a id="X8287B3D98071EBB7" name="X8287B3D98071EBB7"></a></p>
+
+<h4>3.1 <span class="Heading">Creators and operations for IMG machines</span></h4>
+
+<p><a id="X851C12AA87B92799" name="X851C12AA87B92799"></a></p>
+
+<h5>3.1-1 IsIMGMachine</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsIMGMachine</code>( <var class="Arg">m</var> )</td><td class="tdright">( filter )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsPolynomialFRMachine</code>( <var class="Arg">m</var> )</td><td class="tdright">( filter )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsPolynomialIMGMachine</code>( <var class="Arg">m</var> )</td><td class="tdright">( filter )</td></tr></table></div>
+<p>The categories of <em>IMG</em> and <em>polynomial</em> machines. IMG machines are group FR machines with an additional element, their attribute <code class="func">IMGRelator</code> (<a href="chap3.html#X7BCE03F2827DAA0A"><span class="RefLink">3.1-4</span></a>); see <code class="func">AsIMGMachine</code> (<a href="chap3.html#X857CD5C587549F1A"><span class="RefLink">3.1-3</span></a>).</p>
+
+<p>A polynomial machine is a group FR machine with a distinguished state (which must be a generator of the stateset), stored as the attribute <code class="func">AddingElement</code> (<span class="RefLink">???</span>); see <code class="func">AsPolynomialFRMachine</code> (<a href="chap3.html#X8203D69280D4B64C"><span class="RefLink">3.1-9</span></a>). If it is normalized, in the sense that the wreath recursion of the adding element <code class="code">a</code> is <code class="code">[[a,1,...,1],[d,1,...,d-1]]</code>, then the basepoint is assumed to be at <span class="SimpleMath">+∞</span>; the element <code class="code">a</code> describes a clockwise loop around infinity; the <span class="SimpleMath">k</span>th preimage of the basepoint is at <span class="SimpleMath">exp(2iπ(k-1)/d)∞</span>, for <span class="SimpleMath">k=1,dots,d</span>; and there is a direct connection from basepoint <span class="SimpleMath">k</span> to <span class="SimpleMath">k+1</span> for all <span class="SimpleMath">k=1,dots,d-1</span>.</p>
+
+<p>The last category is the intersection of the first two.</p>
+
+<p><a id="X78D75CDE792449A6" name="X78D75CDE792449A6"></a></p>
+
+<h5>3.1-2 IMGMachineNC</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IMGMachineNC</code>( <var class="Arg">fam</var>, <var class="Arg">group</var>, <var class="Arg">trans</var>, <var class="Arg">out</var>, <var class="Arg">rel</var> )</td><td class="tdright">( operation )</td></tr></table></div>
+<p>Returns: An IMG FR machine.</p>
+
+<p>This function creates, without checking its arguments, a new IMG machine in family <var class="Arg">fam</var>, stateset <var class="Arg">group</var>, with transitions and output <var class="Arg">trans,out</var>, and IMG relator <var class="Arg">rel</var>.</p>
+
+<p><a id="X857CD5C587549F1A" name="X857CD5C587549F1A"></a></p>
+
+<h5>3.1-3 AsIMGMachine</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AsIMGMachine</code>( <var class="Arg">m</var>[, <var class="Arg">w</var>] )</td><td class="tdright">( operation )</td></tr></table></div>
+<p>Returns: An IMG FR machine.</p>
+
+<p>This function creates a new IMG FR machine, starting from a group FR machine <var class="Arg">m</var>. If a state <code class="code">w</code> is specified, and that state defines the trivial FR element, then it is used as <code class="func">IMGRelator</code> (<a href="chap3.html#X7BCE03F2827DAA0A"><span class="RefLink">3.1-4</span></a>); if the state <code class="code">w</code> is non-trivial, then a new generator <code class="code">f</code> is added to <var class="Arg">m</var>, equal to the inverse of <code class="code">w</code>; and the IMG relator is chosen to be <code class="code">w*f</code>. 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 <code class="keyw">fail</code>.</p>
+
+<p>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.</p>
+
+<p>A standard FR machine can be recovered from an IMG FR machine by <code class="func">AsGroupFRMachine</code> (<span class="RefLink">???</span>), <code class="func">AsMonoidFRMachine</code> (<span class="RefLink">???</span>), and <code class="func">AsSemigroupFRMachine</code> (<span class="RefLink">???</span>).</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">m := UnderlyingFRMachine(BasilicaGroup);</span>
+&lt;Mealy machine on alphabet [ 1 .. 2 ] with 3 states&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">g := AsGroupFRMachine(m);</span>
+&lt;FR machine with alphabet [ 1 .. 2 ] on Group( [ f1, f2 ] )&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">AsIMGMachine(g,Product(GeneratorsOfFRMachine(g)));</span>
+&lt;FR machine with alphabet [ 1 .. 2 ] on Group( [ f1, f2, t ] )/[ f1*f2*t ]&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Display(last);</span>
+ G | 1 2
+----+-----------------+---------+
+ f1 | &lt;id&gt;,2 f2,1
+ f2 | &lt;id&gt;,1 f1,2
+ t | f2^-1*f1*f2*t,2 f1^-1,1
+----+-----------------+---------+
+Relator: f1*f2*t
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">g := AsGroupFRMachine(GuptaSidkiMachine);</span>
+&lt;FR machine with alphabet [ 1 .. 3 ] on Group( [ f1, f2 ] )&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">m := AsIMGMachine(g,GeneratorsOfFRMachine(g)[1]);</span>
+&lt;FR machine with alphabet [ 1 .. 3 ] on Group( [ f1, f2, t ] )/[ f1*t ]&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">x := FRElement(g,2)^3; IsOne(x);</span>
+&lt;3|identity ...&gt;
+true
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">x := FRElement(m,2)^3; IsOne(x);</span>
+&lt;3#f2^3&gt;
+false
+</pre></div>
+
+<p><a id="X7BCE03F2827DAA0A" name="X7BCE03F2827DAA0A"></a></p>
+
+<h5>3.1-4 IMGRelator</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IMGRelator</code>( <var class="Arg">m</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<p>Returns: The relator of the IMG FR machine.</p>
+
+<p>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.</p>
+
+<p><a id="X8706C13B7D6A1225" name="X8706C13B7D6A1225"></a></p>
+
+<h5>3.1-5 CleanedIMGMachine</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; CleanedIMGMachine</code>( <var class="Arg">m</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<p>Returns: A cleaned-up version of <var class="Arg">m</var>.</p>
+
+<p>This command attempts to shorten the length of the transitions in <var class="Arg">m</var>, and ensure (if possible) that the product along every cycle of the states of a generator is a conjugate of a generator. It returns the new machine.</p>
+
+<p><a id="X7D4A6996874A3DF3" name="X7D4A6996874A3DF3"></a></p>
+
+<h5>3.1-6 NewSemigroupFRMachine</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; NewSemigroupFRMachine</code>( <var class="Arg">...</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; NewMonoidFRMachine</code>( <var class="Arg">...</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; NewGroupFRMachine</code>( <var class="Arg">...</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; NewIMGMachine</code>( <var class="Arg">...</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<p>Returns: A new FR machine, based on string descriptions.</p>
+
+<p>This command constructs a new FR or IMG machine, in a format similar to <code class="func">FRGroup</code> (<span class="RefLink">???</span>); namely, the arguments are strings of the form "gen=&lt;word-1,...,word-d&gt;perm"; each <code class="code">word-i</code> is a word in the generators; and <code class="code">perm</code> is a transformation, either written in disjoint cycle or in images notation.</p>
+
+<p>Except in the semigroup case, <code class="code">word-i</code> is allowed to be the empty string; and the "&lt;...&gt;" may be skipped altogether. In the group or IMG case, each <code class="code">word-i</code> may also contain inverses.</p>
+
+<p>In the IMG case, an extra final argument is allowed, which is a word in the generators, and describes the IMG relation. If absent, <strong class="pkg">FR</strong> will attempt to find such a relation.</p>
+
+<p>The following examples construct realizable foldings of the polynomial <span class="SimpleMath">z^3+i</span>, following Cui's arguments.</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fold1 := NewIMGMachine("a=&lt;,,b,,,B&gt;(1,2,3)(4,5,6)","b=&lt;,,b*a/b,,,B*A/B&gt;",</span>
+ "A=&lt;,,b*a,,,B*A&gt;(3,6)","B=(1,6,5,4,3,2)");
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">&lt;FR machine with alphabet [ 1, 2, 3, 4, 5, 6 ] on Group( [ a, b, A, B ] )/[ a*B*A*b ]&gt; </span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">fold2 := NewIMGMachine("a=&lt;,,b,,,B&gt;(1,2,3)(4,5,6)","b=&lt;,,b*a/b,,,B*A/B&gt;",</span>
+ "A=(1,6)(2,5)(3,4)","B=&lt;B*A,,,b*a,,&gt;(1,4)(2,6)(3,5)");;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">RationalFunction(fold1); RationalFunction(fold2);</span>
+...
+</pre></div>
+
+<p><a id="X80388DDE7F9B41FD" name="X80388DDE7F9B41FD"></a></p>
+
+<h5>3.1-7 AsIMGElement</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AsIMGElement</code>( <var class="Arg">e</var> )</td><td class="tdright">( operation )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsIMGElement</code>( <var class="Arg">e</var> )</td><td class="tdright">( filter )</td></tr></table></div>
+<p>The category of <em>IMG elements</em>, namely FR elements of an IMG machine. See <code class="func">AsIMGMachine</code> (<a href="chap3.html#X857CD5C587549F1A"><span class="RefLink">3.1-3</span></a>) for details.</p>
+
+<p><a id="X84C2881D87C1FB74" name="X84C2881D87C1FB74"></a></p>
+
+<h5>3.1-8 IsKneadingMachine</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsKneadingMachine</code>( <var class="Arg">m</var> )</td><td class="tdright">( property )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsPlanarKneadingMachine</code>( <var class="Arg">m</var> )</td><td class="tdright">( property )</td></tr></table></div>
+<p>Returns: Whether <var class="Arg">m</var> is a (planar) kneading machine.</p>
+
+<p>A <em>kneading machine</em> is a special kind of Mealy machine, used to describe postcritically finite complex polynomials. It is a machine such that its set of permutations is "treelike" (see <a href="chapBib.html#biBMR2162164">[Nek05, §6.7]</a>) and such that each non-trivial state occurs exactly once among the outputs.</p>
+
+<p>Furthermore, this set of permutations is <em>treelike</em> if there exists an ordering of the states that their product in that order <span class="SimpleMath">t</span> is an adding machine; i.e. such that <span class="SimpleMath">t</span>'s activity is a full cycle, and the product of its states along that cycle is conjugate to <span class="SimpleMath">t</span>. This element <span class="SimpleMath">t</span> represents the Carathéodory loop around infinity.</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">M := BinaryKneadingMachine("0");</span>
+BinaryKneadingMachine("0*")
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Display(M);</span>
+ | 1 2
+---+-----+-----+
+ a | c,2 b,1
+ b | a,1 c,2
+ c | c,1 c,2
+---+-----+-----+
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">IsPlanarKneadingMachine(M);</span>
+true
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">IsPlanarKneadingMachine(GrigorchukMachine);</span>
+false
+</pre></div>
+
+<p><a id="X8203D69280D4B64C" name="X8203D69280D4B64C"></a></p>
+
+<h5>3.1-9 AsPolynomialFRMachine</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AsPolynomialFRMachine</code>( <var class="Arg">m</var>[, <var class="Arg">adder</var>] )</td><td class="tdright">( operation )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AsPolynomialIMGMachine</code>( <var class="Arg">m</var>[, <var class="Arg">adder</var>[, <var class="Arg">relator</var>]] )</td><td class="tdright">( operation )</td></tr></table></div>
+<p>Returns: A polynomial FR machine.</p>
+
+<p>The first function creates a new polynomial FR machine, starting from a group or Mealy machine. A <em>polynomial</em> machine is one that has a distinguished adding element, <code class="func">AddingElement</code> (<span class="RefLink">???</span>).</p>
+
+<p>If the argument is a Mealy machine, it must be planar (see <code class="func">IsPlanarKneadingMachine</code> (<a href="chap3.html#X84C2881D87C1FB74"><span class="RefLink">3.1-8</span></a>)). If the argument is a group machine, its permutations must be treelike, and its outputs must be such that, up to conjugation, each non-trivial state appears exactly once as the product along all cycles of all states.</p>
+
+<p>If a second argument <var class="Arg">adder</var> is supplied, it is checked to represent an adding element, and is used as such.</p>
+
+<p>The second function creates a new polynomial IMG machine, i.e. a polynomial FR machine with an extra relation among the generators. the optional second argument may be an adder (if <var class="Arg">m</var> is an IMG machine) or a relator (if <var class="Arg">m</var> is a polynomial FR machine). Finally, if <var class="Arg">m</var> is a group FR machine, two arguments, an adder and a relator, may be specified.</p>
+
+<p>A machine without the extra polynomial / IMG information may be recovered using <code class="func">AsGroupFRMachine</code> (<span class="RefLink">???</span>).</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">M := PolynomialIMGMachine(2,[1/7],[]);; SetName(StateSet(M),"F"); M;</span>
+&lt;FR machine with alphabet [ 1, 2 ] and adder f4 on F/[ f4*f3*f2*f1 ]&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Mi := AsIMGMachine(M);</span>
+&lt;FR machine with alphabet [ 1, 2 ] on F/[ f4*f3*f2*f1 ]&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Mp := AsPolynomialFRMachine(M);</span>
+&lt;FR machine with alphabet [ 1, 2 ] and adder f4 on F&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Mg := AsGroupFRMachine(M);</span>
+&lt;FR machine with alphabet [ 1, 2 ] on F&gt;
+gap&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">AsPolynomialIMGMachine(Mg);</span>
+&lt;FR machine with alphabet [ 1, 2 ] and adder f4 on F/[ f4*f3*f2*f1 ]&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">AsPolynomialIMGMachine(Mi);</span>
+&lt;FR machine with alphabet [ 1, 2 ] and adder f4 on F/[ f4*f3*f2*f1 ]&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">AsPolynomialIMGMachine(Mp);</span>
+&lt;FR machine with alphabet [ 1, 2 ] and adder f4 on F/[ f4*f3*f2*f1 ]&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">AsIMGMachine(Mg);</span>
+&lt;FR machine with alphabet [ 1, 2 ] on F4/[ f1*f4*f3*f2 ]&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">AsPolynomialFRMachine(Mg);</span>
+&lt;FR machine with alphabet [ 1, 2 ] and adder f4 on F4&gt;
+</pre></div>
+
+<p><a id="X7F67843E83A288AF" name="X7F67843E83A288AF"></a></p>
+
+<h5>3.1-10 AddingElement</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AddingElement</code>( <var class="Arg">m</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<p>Returns: The relator of the IMG FR machine.</p>
+
+<p>This attribute stores the product of generators that is an adding machine. In essence, it records an ordering of the generators whose product corresponds to the Carathéodory loop around infinity.</p>
+
+<p>The following example illustrates Wittner's shared mating of the airplane and the rabbit. In the machine <code class="code">m</code>, an airplane is represented by <code class="code">Group(a,b,c)</code> and a rabbit is represented by <code class="code">Group(x,y,z)</code>; in the machine <code class="code">newm</code>, it is the other way round. The effect of <code class="code">CleanedIMGMachine</code> was to remove unnecessary instances of the IMG relator from <code class="code">newm</code>'s recursion.</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f := FreeGroup("a","b","c","x","y","z");;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">AssignGeneratorVariables(f);</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">m := AsIMGMachine(FRMachine(f,[[a^-1,b*a],[One(f),c],[a,One(f)],[z*y*x,</span>
+ x^-1*y^-1],[One(f),x],[One(f),y]],[(1,2),(),(),(1,2),(),()]));;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Display(m);</span>
+ G | 1 2
+---+---------+-------------+
+ a | a^-1,2 b*a,1
+ b | &lt;id&gt;,1 c,2
+ c | a,1 &lt;id&gt;,2
+ x | z*y*x,2 x^-1*y^-1,1
+ y | &lt;id&gt;,1 x,2
+ z | &lt;id&gt;,1 y,2
+---+---------+-------------+
+Relator: z*y*x*c*b*a
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">iso := GroupHomomorphismByImages(f,f,[a,b^(y^-1),c^(x^-1*y^-1*a^-1),x^(b*a*z*a^-1),y,z^(a^-1)],[a,b,c,x,y,z]);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">newm := CleanedIMGMachine(ChangeFRMachineBasis(m^iso,[a^-1*y^-1,y^-1*a^-1*c^-1]));;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Display(newm);</span>
+ G | 1 2
+---+-------------+---------+
+ a | a^-1*c^-1,2 c*a*b,1
+ b | &lt;id&gt;,1 c,2
+ c | a,1 &lt;id&gt;,2
+ x | z*x,2 x^-1,1
+ y | &lt;id&gt;,1 x,2
+ z | y,1 &lt;id&gt;,2
+---+-------------+---------+
+Relator: c*a*b*y*z*x
+</pre></div>
+
+<p><a id="X7D71EBDA7D7C3474" name="X7D71EBDA7D7C3474"></a></p>
+
+<h5>3.1-11 PolynomialFRMachine</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PolynomialFRMachine</code>( <var class="Arg">d</var>, <var class="Arg">per</var>[, <var class="Arg">pre</var>] )</td><td class="tdright">( operation )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PolynomialIMGMachine</code>( <var class="Arg">d</var>, <var class="Arg">per</var>[, <var class="Arg">pre</var>[, <var class="Arg">formal</var>]] )</td><td class="tdright">( operation )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PolynomialMealyMachine</code>( <var class="Arg">d</var>, <var class="Arg">per</var>[, <var class="Arg">pre</var>] )</td><td class="tdright">( operation )</td></tr></table></div>
+<p>Returns: An IMG FR machine.</p>
+
+<p>This function creates a group, IMG or Mealy machine that describes a topological polynomial. The polynomial is described symbolically in the language of <em>external angles</em>. For more details, see <a href="chapBib.html#biBMR762431">[DH84]</a> and <a href="chapBib.html#biBMR812271">[DH85]</a> (in the quadratic case), <a href="chapBib.html#biBMR1149891">[BFH92]</a> (in the preperiodic case), and <a href="chapBib.html#biBmath.DS/9305207">[Poi]</a> (in the general case).</p>
+
+<p><var class="Arg">d</var> is the degree of the polynomial. <var class="Arg">per</var> and <var class="Arg">pre</var> are lists of angles or preangles. In what follows, angles are rational numbers, considered modulo 1. Each entry in <var class="Arg">per</var> or <var class="Arg">pre</var> is either a rational (interpreted as an angle), or a list of angles <span class="SimpleMath">[a_1,...,a_i]</span> such that <span class="SimpleMath">da_1=...=da_i</span>. The angles in <var class="Arg">per</var> are angles landing at the root of a Fatou component, and the angles in <var class="Arg">pre</var> land on the Julia set.</p>
+
+<p>Note that, for IMG machines, the last generator of the machine produced is an adding machine, representing a loop going counterclockwise around infinity (in the compactification of <span class="SimpleMath">C</span> by a disk, this loop goes <em>clockwise</em> around that disk).</p>
+
+<p>In constructing a polynomial IMG machine, one may specify a boolean flag <var class="Arg">formal</var>, which defaults to <code class="keyw">true</code>. In a <em>formal</em> recursion, distinct angles give distinct generators; while in a non-formal recursion, distinct angles, which land at the same point in the Julia set, give a single generator. The simplest example where this occurs is angle <span class="SimpleMath">5/12</span> in the quadratic family, in which angles <span class="SimpleMath">1/3</span> and <span class="SimpleMath">2/3</span> land at the same point -- see the example below.</p>
+
+<p>The attribute <code class="code">Correspondence(m)</code> records the angles landing on the generators: <code class="code">Correspondence(m)[i]</code> is a list <code class="code">[a,s]</code> where <span class="SimpleMath">a</span> is an angle landing on generator <code class="code">i</code> and <span class="SimpleMath">s</span> is <code class="keyw">"Julia"</code> or <code class="keyw">"Fatou"</code>.</p>
+
+<p>If only one list of angles is supplied, then <strong class="pkg">FR</strong> guesses that all angles with denominator coprime to <var class="Arg">n</var> are Fatou, and all the others are Julia.</p>
+
+<p>The inverse operation, reconstructing the angles from the IMG machine, is <code class="func">SupportingRays</code> (<a href="chap3.html#X814E27317A6213D3"><span class="RefLink">3.1-12</span></a>).</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PolynomialIMGMachine(2,[0],[]); # the adding machine</span>
+&lt;FR machine with alphabet [ 1 .. 2 ] on Group( [ f1, f2 ] )/[ f2*f1 ]&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Display(last);</span>
+ G | 1 2
+----+--------+--------+
+ f1 | &lt;id&gt;,2 f1,1
+ f2 | f2,2 &lt;id&gt;,1
+----+--------+--------+
+Relator: f2*f1
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Display(PolynomialIMGMachine(2,[1/3],[])); # the Basilica</span>
+ G | 1 2
+----+---------+---------+
+ f1 | f1^-1,2 f2*f1,1
+ f2 | f1,1 &lt;id&gt;,2
+ f3 | f3,2 &lt;id&gt;,1
+----+---------+---------+
+Relator: f3*f2*f1
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Display(PolynomialIMGMachine(2,[],[1/6])); # z^2+I</span>
+ G | 1 2
+----+---------------+---------+
+ f1 | f1^-1*f2^-1,2 f2*f1,1
+ f2 | f1,1 f3,2
+ f3 | f2,1 &lt;id&gt;,2
+ f4 | f4,2 &lt;id&gt;,1
+----+---------------+---------+
+Relator: f4*f3*f2*f1
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PolynomialIMGMachine(2,[],[5/12]);</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PolynomialIMGMachine(2,[],[5/12]);</span>
+&lt;FR machine with alphabet [ 1, 2 ] and adder f5 on Group( [ f1, f2, f3, f4, f5 ] )/[ f5*f4*f3*f2*f1 ]&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Correspondence(last);</span>
+[ [ 1/3, "Julia" ], [ 5/12, "Julia" ], [ 2/3, "Julia" ], [ 5/6, "Julia" ] ]
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PolynomialIMGMachine(2,[],[5/12],false);</span>
+&lt;FR machine with alphabet [ 1, 2 ] and adder f4 on Group( [ f1, f2, f3, f4 ] )/[ f4*f3*f2*f1 ]&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Correspondence(last);</span>
+[ [ [ 1/3, 2/3 ], "Julia" ], [ [ 5/12 ], "Julia" ], [ [ 5/6 ], "Julia" ] ]
+</pre></div>
+
+<p>The following construct the examples in Poirier's paper:</p>
+
+
+<div class="example"><pre>
+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]]);
+ else
+ Error("Unknown Poirier example ",arg);
+ fi;
+end;
+</pre></div>
+
+<p><a id="X814E27317A6213D3" name="X814E27317A6213D3"></a></p>
+
+<h5>3.1-12 SupportingRays</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; SupportingRays</code>( <var class="Arg">m</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<p>Returns: A <code class="code">[degree,fatou,julia]</code> description of <var class="Arg">m</var>.</p>
+
+<p>This operation is the inverse of <code class="func">PolynomialIMGMachine</code> (<a href="chap3.html#X7D71EBDA7D7C3474"><span class="RefLink">3.1-11</span></a>): it computes a choice of angles, describing landing rays on Fatou/Julia critical points.</p>
+
+<p>If there does not exist a complex realization, namely if the machine is obstructed, then this command returns an obstruction, as a record. The field <code class="keyw">minimal</code> is set to false, and a proper sub-machine is set as the field <code class="keyw">submachine</code>. The field <code class="keyw">homomorphism</code> gives an embedding of the stateset of <code class="keyw">submachine</code> into the original machine, and <code class="keyw">relation</code> is the equivalence relation on the set of generators of <var class="Arg">m</var> that describes the pinching.</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">r := PolynomialIMGMachine(2,[1/7],[]);</span>
+&lt;FR machine with alphabet [ 1, 2 ] and adder f4 on Group( [ f1, f2, f3, f4 ] )/[ f4*f3*f2*f1 ]&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := StateSet(r);; SetName(F,"F");</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">SupportingRays(r);</span>
+[ 2, [ [ 1/7, 9/14 ] ], [ ] ] # actually returns the angle 2/7
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># now CallFuncList(PolynomialIMGMachine,last) would return the machine r</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">twist := GroupHomomorphismByImages(F,F,GeneratorsOfGroup(F),[F.1^(F.2*F.1),F.2^F.1,F.3,F.4])^-1;</span>
+[ f1, f2, f3, f4 ] -&gt; [ f1*f2*f1^-1, f2*f1*f2*f1^-1*f2^-1, f3, f4 ]
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">List([-5..5],i-&gt;2*SupportingRays(r*twist^i)[2][1][1]);</span>
+[ 4/7, 5/7, 4/7, 4/7, 5/7, 2/7, 4/7, 4/7, 2/7, 4/7, 4/7 ]
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">r := PolynomialIMGMachine(2,[],[1/6]);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := StateSet(r);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">twist := GroupHomomorphismByImages(F,F,GeneratorsOfGroup(F),[F.1,F.2^(F.3*F.2),F.3^F.2,F.4]);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">SupportingRays(r);</span>
+[ 2, [ ], [ [ 1/12, 7/12 ] ] ]
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">SupportingRays(r*twist);</span>
+[ 2, [ ], [ [ 5/12, 11/12 ] ] ]
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">SupportingRays(r*twist^2);</span>
+rec(
+ transformation := [ [ f1, f2^-1*f3^-1*f2^-1*f3^-1*f2*f3*f2*f3*f2, f2^-1*f3^-1*f2^-1*f3*f2*f3*f2,
+ f4 ] -&gt; [ f1, f2, f3, f4 ],
+ [ f1^-1*f2^-1*f1^-1*f2^-1*f1*f2*f1*f2*f1, f1^-1*f2^-1*f1^-1*f2*f1*f2*f1, f3, f4 ] -&gt;
+ [ f1, f2, f3, f4 ],
+ [ f1^-1*f2^-1*f3^-1*f2*f1*f2^-1*f3*f2*f1, f2, f2*f1^-1*f2^-1*f3*f2*f1*f2^-1, f4 ] -&gt;
+ [ f1, f2, f3, f4 ], [ f1, f3*f2*f3^-1, f3, f4 ] -&gt; [ f1, f2, f3, f4 ],
+ [ f1, f2, f2*f3*f2^-1, f4 ] -&gt; [ f1, f2, f3, f4 ],
+ [ f1, f3*f2*f3^-1, f3, f4 ] -&gt; [ f1, f2, f3, f4 ],
+ [ f1, f2, f2*f3*f2^-1, f4 ] -&gt; [ f1, f2, f3, f4 ],
+ [ f1, f3*f2*f3^-1, f3, f4 ] -&gt; [ f1, f2, f3, f4 ] ], machine := &lt;FR machine with alphabet
+ [ 1, 2 ] and adder f4 on Group( [ f1, f2, f3, f4 ] )/[ f4*f3*f2*f1 ]&gt;, minimal := false,
+ submachine := &lt;FR machine with alphabet [ 1, 2 ] and adder f3 on Group( [ f1, f2, f3 ] )&gt;,
+ homomorphism := [ f1, f2, f3 ] -&gt; [ f1, f2*f3, f4 ],
+ relation := &lt;equivalence relation on &lt;object&gt; &gt;, niter := 8 )
+</pre></div>
+
+<p><a id="X78130FC97C58AFC4" name="X78130FC97C58AFC4"></a></p>
+
+<h5>3.1-13 AsGroupFRMachine</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AsGroupFRMachine</code>( <var class="Arg">f</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AsMonoidFRMachine</code>( <var class="Arg">f</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AsSemigroupFRMachine</code>( <var class="Arg">f</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<p>Returns: An FR machine.</p>
+
+<p>This function creates an FR machine on a 1-letter alphabet, that represents the endomorphism <var class="Arg">f</var>. It is specially useful when combined with products of machines; indeed the usual product of machines corresponds to composition of endomorphisms.</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f := FreeGroup(2);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">h := GroupHomomorphismByImages(f,f,[f.1,f.2],[f.2,f.1*f.2]);</span>
+[ f1, f2 ] -&gt; [ f2, f1*f2 ]
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">m := AsGroupFRMachine(h);</span>
+&lt;FR machine with alphabet [ 1 ] on Group( [ f1, f2 ] )&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">mm := TensorProduct(m,m);</span>
+&lt;FR machine with alphabet [ 1 ] on Group( [ f1, f2 ] )&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Display(mm);</span>
+ G | 1
+----+------------+
+ f1 | f1*f2,1
+ f2 | f2*f1*f2,1
+----+------------+
+</pre></div>
+
+<p><a id="X7F1FAAF37B54772F" name="X7F1FAAF37B54772F"></a></p>
+
+<h5>3.1-14 NormalizedPolynomialFRMachine</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; NormalizedPolynomialFRMachine</code>( <var class="Arg">m</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; NormalizedPolynomialIMGMachine</code>( <var class="Arg">m</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<p>Returns: A polynomial FR machine.</p>
+
+<p>This function returns a new FR machine, in which the adding element has been put into a standard form <span class="SimpleMath">t=[t,1,dots,1]s</span>, where <span class="SimpleMath">s</span> is the long cycle <span class="SimpleMath">i↦ i-1</span>.</p>
+
+<p>For the first command, the machine returned is an FR machine; for the second, it is an IMG machine.</p>
+
+<p><a id="X85AECB5A7A962200" name="X85AECB5A7A962200"></a></p>
+
+<h5>3.1-15 SimplifiedIMGMachine</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; SimplifiedIMGMachine</code>( <var class="Arg">m</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<p>Returns: A simpler IMG machine.</p>
+
+<p>This function returns a new IMG machine, with hopefully simpler transitions. The simplified machine is obtained by applying automorphisms to the stateset. The sequence of automorphisms (in increasing order) is stored as a correspondence; namely, if <code class="code">n=SimplifiedIMGMachine(m)</code>, then <code class="code">m^Product(Correspondence(n))=n</code>.</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">r := PolynomialIMGMachine(2,[1/7],[]);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := StateSet(r);; SetName(F,"F");</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">twist := GroupHomomorphismByImages(F,F,GeneratorsOfGroup(F),[F.1^(F.2*F.1),F.2^F.1,F.3,F.4]);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">m := r*twist;; Display(m);</span>
+ G | 1 2
+----+------------------------+------------+
+ f1 | f1^-1*f2^-1,2 f3*f2*f1,1
+ f2 | f1^-1*f2^-1*f1*f2*f1,1 &lt;id&gt;,2
+ f3 | f1^-1*f2*f1,1 &lt;id&gt;,2
+ f4 | f4,2 &lt;id&gt;,1
+----+------------------------+------------+
+Adding element: f4
+Relator: f4*f3*f2*f1
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">n := SimplifiedIMGMachine(m);</span>
+&lt;FR machine with alphabet [ 1, 2 ] and adder f4 on F&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Display(n);</span>
+ G | 1 2
+----+---------------+------------+
+ f1 | f2^-1*f1^-1,2 f1*f2*f3,1
+ f2 | &lt;id&gt;,1 f1,2
+ f3 | &lt;id&gt;,1 f2,2
+ f4 | f4,2 &lt;id&gt;,1
+----+---------------+------------+
+Adding element: f4
+Relator: f4*f1*f2*f3
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">n = m^Product(Correspondence(n));</span>
+true
+</pre></div>
+
+<p><a id="X7AB029AE8590964E" name="X7AB029AE8590964E"></a></p>
+
+<h5>3.1-16 Mating</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Mating</code>( <var class="Arg">m1</var>, <var class="Arg">m2</var>[, <var class="Arg">formal</var>] )</td><td class="tdright">( operation )</td></tr></table></div>
+<p>Returns: An IMG FR machine.</p>
+
+<p>This function "mates" two polynomial IMG machines.</p>
+
+<p>The mating is defined as follows: one removes a disc around the adding machine in <var class="Arg">m1</var> and <var class="Arg">m2</var>; one applies complex conjugation to <var class="Arg">m2</var>; and one glues the hollowed spheres along their boundary circle.</p>
+
+<p>The optional argument <var class="Arg">formal</var>, which defaults to <code class="keyw">true</code>, specifies whether a <em>formal</em> mating should be done; in a non-formal mating, generators of <var class="Arg">m1</var> and <var class="Arg">m2</var> which have identical angle should be treated as a single generator. A non-formal mating is of course possible only if the machines are realizable -- see <code class="func">SupportingRays</code> (<a href="chap3.html#X814E27317A6213D3"><span class="RefLink">3.1-12</span></a>).</p>
+
+<p>The attribute <code class="code">Correspondence</code> is a pair of homomorphisms, from the statesets of <var class="Arg">m1,m2</var> respectively to the stateset of the mating.</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># the Tan-Shishikura examples</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">z := Indeterminate(MPC_PSEUDOFIELD);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">a := RootsFloat((z-1)*(3*z^2-2*z^3)+1);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">c := RootsFloat((z^3+z)^3+z);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">am := List(a,a-&gt;IMGMachine((a-1)*(3*z^2-2*z^3)+1));;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">cm := List(c,c-&gt;IMGMachine(z^3+c));;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">m := ListX(am,cm,Mating);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># m[2] is realizable</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">RationalFunction(m[2]);</span>
+((1.66408+I*0.668485)*z^3+(-2.59772+I*0.627498)*z^2+(-1.80694-I*0.833718)*z
+ +(1.14397-I*1.38991))/((-1.52357-I*1.27895)*z^3+(2.95502+I*0.234926)*z^2
+ +(1.61715+I*1.50244)*z+1)
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># m[6] is obstructed</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">RationalFunction(m[6]);</span>
+rec( matrix := [ [ 1/2, 1 ], [ 1/2, 0 ] ], machine := &lt;FR machine with alphabet
+ [ 1, 2, 3 ] on Group( [ f1, f2, f3, g1, g2, g3 ] )/[ f2*f3*f1*g1*g3*g2 ]&gt;,
+ obstruction := [ f1^-1*f3^-1*f2^-1*f1*f2*f3*f1*g2^-1*g3^-1*f1^-1*f3^-1*f2^-1,
+ f2*f3*f1*f2*f3*f1*g2*f1^-1*f3^-1*f2^-1*f1^-1*f3^-1 ],
+ spider := &lt;spider on &lt;triangulation with 8 vertices, 36 edges and
+ 12 faces&gt; marked by GroupHomomorphismByImages( Group( [ f1, f2, f3, g1, g2, g3
+ ] ), Group( [ f1, f2, f3, f4, f5 ] ), [ f1, f2, f3, g1, g2, g3 ],
+ [ f1*f4*f2^-1*f1*f4^-1*f1^-1, f1*f4*f2^-1*f1*f4*f5^-1*f1^-1*f2*f4^-1*f1^-1,
+ f1*f4*f2^-1*f1*f5*f1^-1*f2*f4^-1*f1^-1, f2*f4^-1*f1^-1*f2*f1*f4*f2^-1,
+ f2*f4^-1*f3*f2^-1, f2*f4^-1*f1^-1*f3^-1*f4*f2^-1 ] )&gt; )
+</pre></div>
+
+<p><a id="X8410869F8358A1AF" name="X8410869F8358A1AF"></a></p>
+
+<h5>3.1-17 AutomorphismVirtualEndomorphism</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AutomorphismVirtualEndomorphism</code>( <var class="Arg">v</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; AutomorphismIMGMachine</code>( <var class="Arg">m</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<p>Returns: A description of the pullback map on Teichmüller space.</p>
+
+<p>Let <var class="Arg">m</var> be an IMG machine, thought of as a biset for the fundamental group <span class="SimpleMath">G</span> of a punctured sphere. Let <span class="SimpleMath">M</span> denote the automorphism of the surface, seen as a group of outer automorphisms of <span class="SimpleMath">G</span> that fixes the conjugacy classes of punctures.</p>
+
+<p>Choose an alphabet letter <var class="Arg">a</var>, and consider the virtual endomorphism <span class="SimpleMath">v:G_a-&gt; G</span>. Let <span class="SimpleMath">H</span> denote the subgroup of <span class="SimpleMath">M</span> that fixes all conjugacy classes of <span class="SimpleMath">G_a</span>. then there is an induced virtual endomorphism <span class="SimpleMath">α:H-&gt; M</span>, defined by <span class="SimpleMath">t^α=v^-1tv</span>. This is the homomorphism computed by the first command. Its source and range are in fact groups of automorphisms of range of <var class="Arg">v</var>.</p>
+
+<p>The second command constructs an FR machine associated with <var class="Arg">\alpha</var>. Its stateset is a free group generated by elementary Dehn twists of the generators of <var class="Arg">G</var>.</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">z := Indeterminate(COMPLEX_FIELD);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># a Sierpinski carpet map without multicurves</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">m := IMGMachine((z^2-z^-2)/2/COMPLEX_I);</span>
+&lt;FR machine with alphabet [ 1, 2, 3, 4 ] on Group( [ f1, f2, f3, f4 ] )/[ f3*f2*f1*f4 ]&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">AutomorphismIMGMachine(i);</span>
+&lt;FR machine with alphabet [ 1, 2 ] on Group( [ x1, x2, x3, x4, x5, x6 ] )&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Display(last);</span>
+ G | 1 2
+----+--------+--------+
+ x1 | &lt;id&gt;,2 &lt;id&gt;,1
+ x2 | &lt;id&gt;,1 &lt;id&gt;,2
+ x3 | &lt;id&gt;,2 &lt;id&gt;,1
+ x4 | &lt;id&gt;,2 &lt;id&gt;,1
+ x5 | &lt;id&gt;,1 &lt;id&gt;,2
+ x6 | &lt;id&gt;,2 &lt;id&gt;,1
+----+--------+--------+
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># the original rabbit problem</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">m := PolynomialIMGMachine(2,[1/7],[]);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">v := VirtualEndomorphism(m,1);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">a := AutomorphismVirtualEndomorphism(v);</span>
+MappingByFunction( &lt;group with 20 generators&gt;, &lt;group with 6 generators&gt;, function( a ) ... end )
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Source(a).1;</span>
+[ f1, f2, f3, f4 ] -&gt; [ f3*f2*f1*f2^-1*f3^-1, f2, f3, f3*f2*f1^-1*f2^-1*f3^-1*f2^-1*f3^-1 ]
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Image(a,last);</span>
+[ f1, f2, f3, f4 ] -&gt; [ f1, f2, f2*f1*f3*f1^-1*f2^-1, f3^-1*f1^-1*f2^-1 ]
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># so last2*m is equivalent to m*last</span>
+</pre></div>
+
+<p><a id="X82F0B23486F2E3AC" name="X82F0B23486F2E3AC"></a></p>
+
+<h5>3.1-18 DBRationalIMGGroup</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; DBRationalIMGGroup</code>( <var class="Arg">sequence/map</var> )</td><td class="tdright">( function )</td></tr></table></div>
+<p>Returns: An IMG group from Dau's database.</p>
+
+<p>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 <a href="chapBib.html#biBtan:database">[Tan02]</a>.</p>
+
+<p>When called with no arguments, this command returns the database contents in raw form.</p>
+
+<p>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.</p>
+
+<p>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.</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">DBRationalIMGGroup(z^2-1);</span>
+IMG((z-1)^2)
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">DBRationalIMGGroup(z^2+1); # not post-critically finite</span>
+fail
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">DBRationalIMGGroup(4,1,1);</span>
+IMG((z/h+1)^2|2h^3+2h^2+2h+1=0,h~-0.64)
+</pre></div>
+
+<p><a id="X8365719F7E03B7C3" name="X8365719F7E03B7C3"></a></p>
+
+<h5>3.1-19 PostCriticalMachine</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PostCriticalMachine</code>( <var class="Arg">f</var> )</td><td class="tdright">( function )</td></tr></table></div>
+<p>Returns: The Mealy machine of <var class="Arg">f</var>'s post-critical orbit.</p>
+
+<p>This function constructs a Mealy machine <code class="code">P</code> on the alphabet <code class="code">[1]</code>, which describes the post-critical set of <var class="Arg">f</var>. It is in fact an oriented graph with constant out-degree 1. It is most conveniently passed to <code class="func">Draw</code> (<span class="RefLink">???</span>).</p>
+
+<p>The attribute <code class="code">Correspondence(P)</code> is the list of values associated with the stateset of <code class="code">P</code>.</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">z := Indeterminate(Rationals,"z");;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">m := PostCriticalMachine(z^2);</span>
+&lt;Mealy machine on alphabet [ 1 ] with 2 states&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Display(m);</span>
+ | 1
+---+-----+
+ a | a,1
+ b | b,1
+---+-----+
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Correspondence(m);</span>
+[ 0, infinity ]
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">m := PostCriticalMachine(z^2-1);; Display(m); Correspondence(m);</span>
+ | 1
+---+-----+
+ a | c,1
+ b | b,1
+ c | a,1
+---+-----+
+[ -1, infinity, 0 ]
+</pre></div>
+
+<p><a id="X7E858BE07A7C55B4" name="X7E858BE07A7C55B4"></a></p>
+
+<h5>3.1-20 Mandel</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Mandel</code>( [<var class="Arg">map</var>] )</td><td class="tdright">( function )</td></tr></table></div>
+<p>Returns: Calls the external program <code class="file">mandel</code>.</p>
+
+<p>This function starts the external program <code class="file">mandel</code>, by Wolf Jung. The program is searched for along the standard PATH; alternatively, its location can be set in the string variable EXEC@FR.mandel.</p>
+
+<p>When called with no arguments, this command returns starts <code class="file">mandel</code> in its default mode. With a rational map as argument, it starts <code class="file">mandel</code> pointing at that rational map.</p>
+
+<p>More information on <code class="file">mandel</code> can be found at <span class="URL"><a href="http://www.mndynamics.com">http://www.mndynamics.com</a></span>.</p>
+
+<p><a id="X7C73C74D87428A33" name="X7C73C74D87428A33"></a></p>
+
+<h4>3.2 <span class="Heading">Spiders</span></h4>
+
+<p><strong class="pkg">FR</strong> contains an implementation of the Thurston-Hubbard-Schleicher "spider algorithm" <a href="chapBib.html#biBMR1315537">[HS94]</a> that constructs a rational map from an IMG recursion. This implementation does not give rigourous results, but relies of floating-point approximation. In particular, various floating-point parameters control the proper functioning of the algorithm. They are stored in a record, <code class="code">EPS@fr</code>. Their meaning and default values are:</p>
+
+
+<dl>
+<dt><strong class="Mark"><code class="code">EPS@fr.mesh := 10^-1</code></strong></dt>
+<dd><p>If points on the unit sphere are that close, the triangulation mesh should be refined.</p>
+
+</dd>
+<dt><strong class="Mark"><code class="code">EPS@fr.prec := 10^-6</code></strong></dt>
+<dd><p>If points on the unit sphere are that close, they are considered equal.</p>
+
+</dd>
+<dt><strong class="Mark"><code class="code">EPS@fr.obst := 10^-1</code></strong></dt>
+<dd><p>If points on the unit sphere are that close, they are suspected to form a Thurston obstruction.</p>
+
+</dd>
+<dt><strong class="Mark"><code class="code">EPS@fr.juliaiter := 10^3</code></strong></dt>
+<dd><p>In computing images of the Julia set, never recur deeper than that.</p>
+
+</dd>
+<dt><strong class="Mark"><code class="code">EPS@fr.fast := 10^-1</code></strong></dt>
+<dd><p>If the spider moved less than that amount in the last iteration, try speeding up by only wiggling the spider's legs, without recomputing it.</p>
+
+</dd>
+<dt><strong class="Mark"><code class="code">EPS@fr.ratprec := 10^-10</code></strong></dt>
+<dd><p>The desired precision on the coefficients of the rational function.</p>
+
+</dd>
+</dl>
+<p><a id="X80C530E87B7FA7C4" name="X80C530E87B7FA7C4"></a></p>
+
+<h5>3.2-1 DelaunayTriangulation</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; DelaunayTriangulation</code>( <var class="Arg">points</var>[, <var class="Arg">quality</var>] )</td><td class="tdright">( operation )</td></tr></table></div>
+<p>Returns: A Delaunay triangulation of the sphere.</p>
+
+<p>If <var class="Arg">points</var> 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.</p>
+
+<p>This triangulation is a recursive collection of records, one for each vertex, oriented edge or face. Each such object has a <code class="code">pos</code> component giving its coordinates; and an <code class="code">index</code> component identifying it uniquely. Additionally, vertices and faces have a <code class="code">n</code> component which lists their neighbours in CCW order, and edges have <code class="code">from,to,left,right,reverse</code> components.</p>
+
+<p>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 <span class="SimpleMath">&lt;π</span>. These vertices additionally have a <code class="code">fake</code> component set to <code class="keyw">true</code>.</p>
+
+<p>A triangulation may be plotted with <code class="code">Draw</code>; this requires <strong class="pkg">appletviewer</strong> to be installed. The command <code class="code">Draw(t:detach)</code> detaches the subprocess after it is started. The extra arguments <code class="code">Draw(t:lower)</code> or <code class="code">Draw(t:upper)</code> stretch the triangulation to the lower, respectively upper, hemisphere.</p>
+
+<p>If the second argument <var class="Arg">quality</var>, which must be a floatean, is present, then all triangles in the resulting triangulation are guaranteed to have circumcircle ratio / minimal edge length at most <var class="Arg">quality</var>. Of course, additional vertices may need to be added to ensure that.</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">octagon := Concatenation(IdentityMat(3),-IdentityMat(3))*1.0;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">dt := DelaunayTriangulation(octagon);</span>
+&lt;triangulation with 6 vertices, 24 edges and 8 faces&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">dt!.v;</span>
+[ &lt;vertex 1&gt;, &lt;vertex 2&gt;, &lt;vertex 3&gt;, &lt;vertex 4&gt;, &lt;vertex 5&gt;, &lt;vertex 6&gt; ]
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">last[1].n;</span>
+[ &lt;edge 17&gt;, &lt;edge 1&gt;, &lt;edge 2&gt;, &lt;edge 11&gt; ]
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">last[1].from;</span>
+&lt;vertex 1&gt;
+</pre></div>
+
+<p><a id="X82CA08BD85AA4F4E" name="X82CA08BD85AA4F4E"></a></p>
+
+<h5>3.2-2 LocateInTriangulation</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; LocateInTriangulation</code>( <var class="Arg">t</var>[, <var class="Arg">seed</var>], <var class="Arg">point</var> )</td><td class="tdright">( operation )</td></tr></table></div>
+<p>Returns: The face in <var class="Arg">t</var> containing <var class="Arg">point</var>.</p>
+
+<p>This command locates the face in <var class="Arg">t</var> that contains <var class="Arg">point</var>; or, if <var class="Arg">point</var> lies on an edge or a vertex, it returns that edge or vertex.</p>
+
+<p>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.</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">cube := Tuples([-1,1],3)/Sqrt(3.0);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">dt := DelaunayTriangulation(cube);</span>
+&lt;triangulation with 8 vertices, 36 edges and 12 faces&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">LocateInTriangulation(dt,dt!.v[1].pos);</span>
+&lt;vertex 1&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">LocateInTriangulation(dt,[3/5,0,4/5]*1.0);</span>
+&lt;face 9&gt;
+</pre></div>
+
+<p><a id="X81727B8B7A599605" name="X81727B8B7A599605"></a></p>
+
+<h5>3.2-3 IsSphereTriangulation</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsSphereTriangulation</code></td><td class="tdright">( filter )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsMarkedSphere</code></td><td class="tdright">( filter )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Spider</code>( <var class="Arg">ratmap</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Spider</code>( <var class="Arg">machine</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
+<p>The category of triangulated spheres (points in Moduli space), or of marked, triangulated spheres (points in Teichmüller space).</p>
+
+<p>Various commands have an attribudte <code class="code">Spider</code>, which records this point in Teichmüller space.</p>
+
+<p><a id="X7CC0BBAD807D1A45" name="X7CC0BBAD807D1A45"></a></p>
+
+<h5>3.2-4 RationalFunction</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; RationalFunction</code>( [<var class="Arg">z</var>, ]<var class="Arg">m</var> )</td><td class="tdright">( operation )</td></tr></table></div>
+<p>Returns: A rational function.</p>
+
+<p>This command runs a modification of Hubbard and Schleicher's "spider algorithm" <a href="chapBib.html#biBMR1315537">[HS94]</a> on the IMG FR machine <var class="Arg">m</var>. It either returns a rational function <code class="code">f</code> whose associated machine is <var class="Arg">m</var>; or a record describing the Thurston obstruction to realizability of <code class="code">f</code>.</p>
+
+<p>This obstruction record <code class="code">r</code> contains a list <code class="code">r.multicurve</code> of conjugacy classes in <code class="code">StateSet(m)</code>, which represent short multicurves; a matrix <code class="code">r.mat</code>, and a spider <code class="code">r.spider</code> on which the obstruction was discovered.</p>
+
+<p>If a rational function is returned, it has preset attributes <code class="code">Spider(f)</code> and <code class="code">IMGMachine(f)</code> which is a simplified version of <var class="Arg">m</var>. 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 <var class="Arg">m</var> is polynomial-like, then the returned map is a polynomial.</p>
+
+<p>The command accepts the following options, to return a map in a given normalization:</p>
+
+
+<dl>
+<dt><strong class="Mark"><code class="code">RationalFunction(m:param:=IsPolynomial)</code></strong></dt>
+<dd><p>returns <span class="SimpleMath">f=z^d+A_d-2z^d-2+⋯+A_0</span>;</p>
+
+</dd>
+<dt><strong class="Mark"><code class="code">RationalFunction(m:param:=IsBicritical)</code></strong></dt>
+<dd><p>returns <span class="SimpleMath">f=((pz+q)/(rz+s)^d</span>, with <span class="SimpleMath">1</span>postcritical;</p>
+
+</dd>
+<dt><strong class="Mark"><code class="code">RationalFunction(m:param:=n)</code></strong></dt>
+<dd><p>returns <span class="SimpleMath">f=1+a/z+b/z^2</span> or <span class="SimpleMath">f=a/(z^2+2z)</span> if <code class="code">n=2</code>.</p>
+
+</dd>
+</dl>
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">m := PolynomialIMGMachine(2,[1/3],[]);</span>
+&lt;FR machine with alphabet [ 1, 2 ] on Group( [ f1, f2, f3 ] )/[ f3*f2*f1 ]&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">RationalFunction(m);</span>
+0.866025*z^2+(-1)*z+(-0.288675)
+</pre></div>
+
+<p><a id="X8563CADF7AA37AA4" name="X8563CADF7AA37AA4"></a></p>
+
+<h5>3.2-5 Draw</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Draw</code>( <var class="Arg">s</var> )</td><td class="tdright">( operation )</td></tr></table></div>
+<p>This command plots the spider <var class="Arg">s</var> in a separate X window. It displays the complex sphere, big dots at the post-critical set (feet of the spider), and the arcs and dual arcs of the triangulation connecting the feet.</p>
+
+<p>If the option <code class="keyw">julia:=&lt;gridsize&gt;</code> (if no grid size is specified, it is 500 by default), then the Julia set of the map associated with the spider is also displayed. Points attracted to attracting cycles are coloured in pastel tones, and unattracted points are coloured black.</p>
+
+<p>If the option <code class="keyw">noarcs</code> is specified, the printing of the arcs and dual arcs is disabled.</p>
+
+<p>The options <code class="keyw">upper</code>, <code class="keyw">lower</code> and <code class="keyw">detach</code> also apply.</p>
+
+<p><a id="X86BD8FD97D3AFA45" name="X86BD8FD97D3AFA45"></a></p>
+
+<h5>3.2-6 FRMachine</h5>
+
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; FRMachine</code>( <var class="Arg">f</var> )</td><td class="tdright">( operation )</td></tr></table></div>
+<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IMGMachine</code>( <var class="Arg">f</var> )</td><td class="tdright">( operation )</td></tr></table></div>
+<p>Returns: An IMG FR machine.</p>
+
+<p>This function computes a triangulation of the sphere, on the post-critical set of <var class="Arg">f</var>, and lifts it through the map <var class="Arg">f</var>. the action of the fundamental group of the punctured sphere is then read into an IMG fr machine <code class="code">m</code>, which is returned.</p>
+
+<p>This machine has a preset attribute <code class="code">Spider(m)</code>.</p>
+
+<p>An approximation of the Julia set of <var class="Arg">f</var> can be computed, and plotted on the spider, with the form <code class="code">IMGMachine(f:julia)</code> or <code class="code">IMGMachine(f:julia:=gridsize)</code>.</p>
+
+
+<div class="example"><pre>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">z := Indeterminate(COMPLEX_FIELD);;</span>
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">IMGMachine(z^2-1);</span>
+&lt;FR machine with alphabet [ 1, 2 ] on Group( [ f1, f2, f3 ] )/[ f2*f1*f3 ]&gt;
+<span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Display(last);</span>
+ G | 1 2
+----+---------------+--------+
+ f1 | f2,2 &lt;id&gt;,1
+ f2 | f3^-1*f1*f3,1 &lt;id&gt;,2
+ f3 | &lt;id&gt;,2 f3,1
+----+---------------+--------+