import java.applet.Applet;
import java.awt.event.*;
import java.awt.*;
import java.awt.geom.*;


class TextIntro {

    /**This is a documentation file.  It is read by the file reader.**/

    public TextIntro() {}

    public String getText(int k) {
	if(k==0) return(text0());
	if(k==1) return(text1());
	if(k==2) return(text2());
	if(k==3) return(text3());
	if(k==4) return(text4());
	if(k==5) return(text5());
	if(k==6) return(text6());
	if(k==7) return(text7());
	if(k==8) return(text8());
	if(k==9) return(text9());
	if(k==10) return(text10());
	if(k==11) return(text11());
	if(k==12) return(text12());
	if(k==13) return(text13());
	if(k==14) return(text14());
	if(k==15) return(text15());
	if(k==16) return(text16());
	if(k==17) return(text17());
	if(k==18) return(text18());
	if(k==19) return(text19());
	if(k==20) return(text20());
	if(k==21) return(text21());
	return(null);
    }

    public static String text0() {

	String S="WELCOME: The purpose of this program is to re-present the mathematics in my paper  'Outer Billiards, Arithmetic Graphs, and the Octagon'.   This program is self-contained.  You can learn it without reading my paper.  The explanatory text comes in 7 units, of which this is the first.  The buttons on the 'explanation' window select different text units.  You should probably read the text in order.   The arrow keys in the top right corner of this window advance the text.";
	return(S);
    }

    public static String text1() {
    String S="This program is an elaboration of an earlier program I wrote, called OctoMap 1.  OctoMap 1 illustrates a small portion of my paper, namely Chapter 4.  You can use this program without knowing OctoMap 1, though there is one component of this program that OctoMap 1 does in more detail, namely the presentation of the two fractals discussed in the 'ideal limit' text unit.";
	return(S);
    }





    public static String text2() {

	String S="ACKNOWLEDGEMENT:  This work is supported by NSF grant DMS-0072607.";
	return(S);
    }


    public static String text3() {

	String S="EXERCISES:   As you read along this text, I'll give you little exercises to do.  Their purpose is to familiarize you with the workings of the program and/or to make certain mathematical points.  You will gain a greater appreciation of the program if you actually do the exercises.";

	return(S);
    }

    public static String text4() {

	String S="FIRST EXERCISE:   As preparation for subsequent pages in this introduction, toggle back and forth a few times between the 'basic map' button and the 'outer billiards' button on the 'polygon exchange' window.   We are going to use the 'outer billiards' window to explain the 'basic map' window (and other stuff).   Finally settle on the 'outer billiards' window.    Next, play around with the '# of iterates' arrows to see how they change the picture.";
	return(S);
    }




    public static String text5() {

	String S="OUTER BILLIARDS:   Outer billiards is a dynamical system based on a convex shape P in the plane.  In our case, P is the yellow regular octagon shown at bottom right. Let p0 be a point not in P.  We define p1 so that the line segment joining p0 to p1 is tangent to P at its midpoint, and a person walking from p0 to p1 sees P on the right.    The map p0-->p1 is the outer billiards map.  It is defined except when p0 lies in a line extending an edge of P.";

	return(S);
    }


    public static String text6() {

	String S="The initial point p0 lies in the green region, and the  black segments join successive points in the orbit of p0.  The thick white segments join every other point.  We are mainly interested in the square of the outer billiards map, which we call f.  We have f(p0)=p2.  So, the thick white lines join successive iterates of f.";
	return(S);
    }


    public static String text7() {

	String S="POINT SELECTION:  You select the initial point p0 for the outer billiards map by clicking on the big shape R, which is an enlarged copy of either half of the green shape R1.  The 'which half' button selects whether we identify R with the top half of R1 or the bottom.  R is partitioned into 22 regions and correspondingly R1 is partitioned into 44 regions. (The partition of R1 is not shown.) The number at bottom left indicates the region of R1 you have selected.";

	return(S);
    }
    public static String text8() {

	String S="If you click in the highlighted shape, you do not change the number of iterates shown.   However, if you click on a different shape, the number of iterates is set to a special value that we explain next.\n\nExercise: Play around with the point selection feature and the arrow keys until you see how they work.";

	return(S);
    }



    public static String text9() {

	String S="FIRST RETURN:  The 'necklaces' of  purple octagons at far right are invariant sets for the outer billiards map, and so is the region between the necklaces.  These necklaces serve as guides for defining the green  region R1. If p0 is a point in R1 with a well-defined orbit then some f-iterate of p0 again lies in R1.  We let g(p0) be the first such iterate.  We call the map g: R1-->R1 the first return map.";

	return(S);
    }


    public static String text10() {

	String S="When you click on a new region in R, the number of iterates is set to be such that the return map is done exactly  The number is either 5, 6, or 7, depending on the region.\n\nExercise: Click on the various regions in R and observe g. Can you figure out our coloring scheme for R?  Switch back and forth between 'outer billiards' window and  'basic map'.  Note the correlation between the position of the points in R1 and the highlighted regions in 'basic map'.";

	return(S);
    }




    public static String text11() {

	String S="PARITY:  The special coloring of R is designed to capture information about both halves of R1 at the same time.  We color a region blue if the first return map comes back to the same half of R1 and we color a region red if the first return map comes back to the other half.    The coloring turns out to be independent of whether we identify R to the top of R1 or to the bottom of R1.";

	return(S);
    }



    public static String text12() {

	String S="EXERCISE:  After clicking on a region of R, toggle the 'which half' button and observe the effect this has on the return map.  Essentially, the two halves just 'swap'.";

	return(S);
    }





    public static String text13() {

	String S="POLYGON EXCHANGE MAP:  The 2 halves of R1 are translation equivalent.  The first return map to R1 commutes with this translation, as you can see by clicking the 'which half arrows' and watching carefully what happens to the first return map.  For this reason, we can identify both halves and consider a simpler map h: R-->R. This map h is our basic object of study.  The 'basic map' feature of the 'polygon exchange' window shows h in action.";
	return(S);
    }



    public static String text14() {

	String S="The 'basic map' feature of the 'polygon exchange' window shows h in action. We call h the polygon exchange map, and  the 'poly exchange' text describes this map in detail.     We can reconstruct the map g: R1-->R1 from the 'compressed' map h: R-->R by keeping track of the coloring.   Pages 3-4 of the 'arithmetic graph' unit of text explains how this reconstruction is done.";
	return(S);
    }

    public static String text15() {

	String S="SYMBOLIC ENCODING:  In 'outer billiards' mode, the numbers that run across the top of the right window record the sequence of vertices encountered by the outer billiards orbit.  For instance, select the top right region of R.  The list you see is 74...   What this means is that the vertex 7 bisects p0-->p1 and vertex 4 bisects p1-->p2, and so forth.   The vertices of the yellow octagon are the 8th roots of unity, and vertex k is the kth such root.";
	return(S);
    }

    public static String text16() {

	String S="The polygonal decomposition of R is such that points in the same polygon give rise to the same numerical code.\n\nExercise: set the number of iterates to 1 in order to see a clearer picture of how the numerical code at the top corresponds to the outer billiards map.";
	return(S);
    }


    public static String text17() {

	String S="ASSOCIATED VECTOR:   The 8 numbers at the bottom of the right window are a geometric version of the symbolic encoding.  We think of these 8 numbers as the coordinates of a point in R^8.  We convert from the symbolic encoding at the top to the vector at the bottom as follows:  The kth coordinate at the bottom is 2E(k)-2O(k).  Here E(k) is the number of times the digit k appears in an even position at the top.  O(k) is the number of times the digit k appears in an odd position at the top.";

	return(S);
    }


    public static String text18() {

	String S="ARITHMETIC GRAPH:   Suppose now we start with p0 in R1 and consider the orbit of the first return map. We produce points p1,p2,p3... all in R1.  Associated to these points we have vectors V0,V1,V2,...  in R^8.  We make a polygonal path whose edges are these vectors.   We call this path the arithmetic graph associated to the orbit.   We emphasize that this path is associated to the first return orbit, and not to the outer billiards orbit. ";

	return(S);
    }

    public static String text19() {

	String S=" The arithmetic graph construction gives a high dimensional  geometric encoding of the dynamics of the first return map.  The specific path we get of course depends on the orbit under study.  We are interested in the structure of the arithmetic graph, for periodic orbits, as the period tends to infinity.";

	return(S);
    }

    public static String text20() {

	String S="PROJECTIONS:   We can't visualize a polygonal path in 8-dimensions, so we choose some canonical projections into the plane.  Let w=exp(2 Pi i/8) be the usual primitive 8th root of unity.  Given some integer k, we let Y=w^k and we consider the projection T_k(a0,...,a7)=a0Y^0+...+a7Y^7.  When k=1 we basically recover the original orbit in R1.  When k=2 and k=3 we get a beautiful surprise.";

	return(S);
    }

    public static String text21() {

	String S="The 'ideal fractal' button summons two fractals that are, respectively, the rescaled asymptotic limits of the k=3 and k=2 projections of arithmetic graphs associated to periodic orbits, as the period tends to infinity.  The purpose of the paper, and this program, is to explain what this statement means and to prove it. ";

	return(S);
    }







}