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


class TextGraph {

    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());
	return(null);
    }

    public static String text0() {

	String S="ARITHMETIC GRAPH:  In the introduction we defined what we meant by the arithmetic graph for the regular octagon.  For each suitably chosen point, the arithmetic graph is a lattice path in R^8.   As we explained, this path has two nice projections into the plane, G2 and G3, which are the main objects of study here.  In this unit of text we will explain, directly in terms of the polygon exchange map, how the arithmetic graph is defined.";

	return(S);
    }

    public static String text1() {

	String S="At the end, we will explain how you can reconcile the definition given here with the one given in the introduction.  They are completely equivalent.  if you don't know what we mean by 'arithmetic graph', you should re-read the introduction.";

	return(S);
    }




    public static String text2( ) {

	String S="REMINDER:  Let me remind you of the definition of accumulated parity. Let p0,p1,p2... be an h-orbit.  The accumulated parity of (say) p5 is defined to be the number of times one of the points from the list p0,p1,p2,p3,p4 lands in a red region in the domain, mod 2. Likewise for the other numbers..";

    return(S);
    }

    public static String text3( ) {

	String S="RECONSTRUCTION: Suppose we identify R with half of R1. Let q0 be the point in R1 corresponding to p0.   Let q0,q1,q2... be the orbit of q0 under the first return map g: R1-->R1.   Then pN and qN are corresponding points in R and R1 respectively if the accumulated parity of pN is 0.  If the accumulated parity of pN is 1, then qN is in the other half of R1, in the same position as the point that corresponds to pN.  Thus, we can reconstruct a g-orbit from an h-orbit. ";

    return(S);
    }


    public static String text4( ) {

	String S="VECTOR ASSIGNMENT:   As illustrated in the 'vectors' mode of the polygon exchange window, we assign 4 vectors to each polygon in the dissection of the domain.   We call these vectors G2(0), G2(1), G3(0), G3(1).  The vectors G2(0) and G2(1) are used to generate the G2 paths and the vector G3(0) and G3(1) are used to generate the G3 paths.  The G2 vectors have integer coordinates.  The G3 vectors have coordinates in the ring Z[sqrt(2)].";

    return(S);
    }

    public static String text5( ) {

	String S="There are 22 regions and two choices for parity.  For each of the 44 pairs (region,parity) we get a G2 vector and a G3 vector.  \n\nExercise:  Click on the shapes in the domain to see the associated vectors.  Keep the 'which rule' set at 1. For a fixed type (2 or 3) and fixed parity (0 or 1) we have drawn all the vectors in purple.  When you click on a region, the assigned vector turns white.";


    return(S);
    }

    public static String text6( ) {

	String S="MAIN DEFINITIONS:  Consider a periodic orbit p0,p1,p2...  Let s0,s2,s3... be the accumulated parities of these points.  Let r0,r1,r2... be the regions in the domain containing the successive points.   Let v0 be the vector G2(s0) associated to r0.  Let v1 be the vector G2(s1) associated to r1.  And so on.  The vectors v0,v1,v2,... are the edges of the G2 path associated to p0.   We define the G3 paths similarly. ";
    return(S);
    }

    public static String text7( ) {

	String S="By way of example, G3(2) refers to the G3 path associated to the 2th periodic orbit in the orange colored periodic cascade.  More precisely, G3(2) is associated to the octagonal tile that maps to the big upper octagon under 2 iterations of the renormalization map S-->R.";

    return(S);
    }


    public static String text8( ) {

	String S="EXERCISE:  This exercise is supposed to solidify the basic definitions. In the 'arithmetic graph' mode, the left hand side of the polygon exchange window lets you choose an orbit and a point (i.e. iterate) within that orbit.  The right hand side shows the corresponding G2 or G3 path, depending on which you select.   As you press the 'which iterate' arrows, you can trace through the displayed arithmetic graph, one vector at a time.";

	return(S);
    }

    public static String text9( ) {

	String S="EXERCISE:  The point of this exercise is to see that we are really following the rules  when drawing the graphs.  I did this exercise many times when debugging the program.  Start in the 'arith graph' mode. Use the 'which iterate' arrows to choose your favorite octagon in the orbit.  Your favorite octagon should be at the tail end of the white arrow at left.   Note the highlighted vector of G3 that appears on the right.  We want to see where this vector comes from.";

    return(S);
    }

    public static String text10( ) {

	String S="Click on the octagon that is at the tail end of the white arrow.  Now switch back to the 'vectors' option, set the parity correctly, according as to whether your favorite octagon is blue (0) or red (1).   You should see that the vector that appears in the right side in the 'vectors' mode matches (up to scale) the highlighted one on the graph.  Once you have it right, toggle back and forth between 'vectors' and 'arithmetic graph' mode to see the match-up.";

    return(S);
    }



    public static String text11( ) {

	String S="EXERCISE:  The purpose of this exercise is to relate the definition we gave of the arithmetic graph in the introduction with the one we have given here.   Start in the 'outer billiards mode'.  Set 'which half' to 0.  Click some random region of R (to reset things), then click in the top right region, a little blue triangle. Along the bottom, note the vector (-2,0,2,-2,0,0,2,0).  Dot this vector with (1,I,-1,-I,1,I,-1,-I) to get -6+2I.";

	return(S);
    }


    public static String text12( ) {

	String S="Now, in  'vectors' mode, set 'which graph' to 2, 'which rule' to 1, and 'parity' to 0.  You should see the vector (-6,2), which matches.    You can check the other vector assignments for G2 similarly.  You can also check the assignments for G3, dotting the lattice vector in R8 with  (1,Y,Y^2,..,Y^7) where Y=exp(6 Pi I/8).";

	return(S);
    }





    public static String text13( ) {

	String S="EXERCISE:  It is important to see the connection between the arithmetic graph construction we have just described and what is plotted in the two plot windows above.  Reset the program, then turn on the G3 button on the plot control panel.  Make the value of the 'which orbit' arrows in the polygon exchange window coincide with the value of the 'which orbit' arrows that appear in the middle control panel beneath the words 'Arithmetic Graph'.";

	return(S);
    }


    public static String text14( ) {

	String S="Notice that the pictures plotted in the right polygon exchange window coincide with the ones plotted in the two plot windows.  The 'which graph' arrows let you toggle between the two pictures in the polygon exchange window.   Now you know what the arithmetic graph is, and how to call it forth on the plot windows.";

	return(S);
    }













}