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


class TextCor{

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

    public static String text0() {

	String S="EXERCISE:    Press the 'survey vectors' button on the 'special configurations' control.  The left plot window shows a magnified copy of G5, corresponding to the 5th periodic orbit.   The big white edge there is the G3 vector associated to the (region,pair) labelled 9.  We call this edge 'type 9'.  The right hand plot window shows the same thing for G2. ";

	return(S);
    }

    public static String text1() {

	String S="EXERCISE:    Press the 'survey vectors' button on the 'special configurations' control.  The left plot window shows a magnified copy of G5, corresponding to the 5th periodic orbit.   The big white edge there is the G3 vector associated to the (region,pair) labelled 9.  We call this edge 'type 9'.  The right hand plot window shows the same thing for G2. ";

	return(S);
    }

    public static String text2() {

	String S="EXERCISE:    Press the 'survey vectors' button on the 'special configurations' control.  The left plot window shows a magnified copy of G5, corresponding to the 5th periodic orbit.   The big white edge there is the G3 vector associated to the (region,pair) labelled 9.  We call this edge 'type 9'.  The right hand plot window shows the same thing for G2. ";

	return(S);
    }

    public static String text3() {

	String S=" Move the mouse over one of these windows and use the key 'w' to advance to the vector having types 10,12,13 (The multiples of 11 do not appear.)  The 'q' key moves in the other direction.   The 'd' and 'e' keys survey all the edges of the same type.  The '1' and '2' keys advance the edge type by 11.   These keyboard shortcuts, which give you many way to survey the edges, are summarized in the red strip at right.";

	return(S);
    }

    public static String text4( ) {

	String S="SUBSTITUTION:  As illustrated in the 'renormalization' mode of the polygon exchange window, the renormalization scheme induces a numerical substitution rule.   Let A be one of 0,...,43.   Let f: S ---> R be the renormalization map.  Let r be the region of R corresponding to A.  Let s be the smaller region of S such that f(s)=r.  Then we get a triple of numbers by considering the regions s0,s1,s2 obtained by applying the 0th, 1st, and 2nd power of the polygon exchange map to s0=s.";

    return(S);
    }

    public static String text5( ) {

	String S=" We compute these numbers keeping track of the accumulated parities.    This gives us three numbers B0,B1,B2.   The convention we use is that s0 has the same accumulated parity as r.  Thus, B0<22 if and only if A<22.  This gives us the substitution rule:  The rule replaces the number A by the triple B0,B1,B2.";

    return(S);
    }


    public static String text6( ) {

	String S="EXERCISE:  In the 'substitution' mode, click on a region, and see the 1st and 2nd  generations of the substitution rule associated to that (region, parity) pair.  Observe the effect of changing the numeric value by multiples of 11.   The 'mod 22' symmetry comes from the global change of accumulated parity and the 'mod 11' symmetry comes from the rotational symmstry of the map. We will explain the number-coloring  later on in this text.";

    return(S);
    }

    public static String text7( ) {

	String S="ITERATION:  To generate the numerical code for our orbits, we start with 0 and iterate.  For instance, the code for the periodic orbit of length 9 is:\n0 --> 9 25 39 -- > 9 26 7 32 34 38 41 2 28.\nWe produce the corresponding G3 curve by assigning the G3 vectors to these numbers.   We do the same thing for the G2 curve.  This gives a more combinatorial description of the arithmetic graphs that we are considering.";

    return(S);
    }


    public static String text8( ) {

	String S="EXERCISE. The control panels labelled V2 and V3 show the curves obtained with the vector substitution method. For k=1,2,3,4,5,6,7 verify that the kth G3 curve matches the kth V3 curve, and likewise for G2 and V2.  The point is that we are plotting these curves in the two different ways, dynamically and combinatorially, and we want to make sure the two methods match.  We debugged the program this way.";

    return(S);
    }




    public static String text9( ) {
 	String S="The 4TH POWER:  We will work with the 4th iteration of the substitution rule, in which one number is replaced by 81 numbers.  In light of the discussion about subsequential limits in the 'ideal limit' text, it makes sense to consider the 4th power of the substitution rather than the simpler but less natural lower powers.  The 4th iteration is the lowest power that preserves both closedness and circulation.   With their natural parametrizations, the curves V(k) and V(k+4) closely follow each other.";
	return(S);
    }

    public static String text10( ) {
 	String S="EXERCISE: Press the 'same circulation' on the 'special configurations' control and use the big arrow keys to trace through V(3) and V(7).  Note the pretty good alignment. Now switch from the 'graph' to the 'ideal' on the 'which rule' control.  Observe the improved alignment: the endpoints of the substitution path match the endpoints of the original.  The 'substitution demo' button summons a close-up view of this.";

	return(S);
    }

    public static String text11() {

	String S="THE IDEAL RULE:  Recall that the V curves are produced by a two step process.  First, the combinatorial substitution rule is iterated some number of times to produce a numeric sequence.  Then, each number is replaced by a vector.  The 'ideal rule' produces new curves by the same two step process.  The first step is the same as what we have already done.  The second step uses a different assignment of vectors. ";

	return(S);
    }

    public static String text12() {

	String S="The new assignment of vectors is a kind of eigenvector for the system:  When we consider the 4th power of the substitution, each segment of length 1 is replaced by a polygonal arc of length 81 that has the same endpoints, up to a suitable scaling factor.  The scaling factors are s2=sqrt(3) and s3=sqrt(2)+1.  In the 'vectors' mode, toggle the 'which rule' switch to see how the two rules differ.";

	return(S);
    }

    public static String text13() {

	String S="ITERATIVE LIMIT:  One can check by hand that the ideal rule really does have the 'same endpoints property', and this constitutes a proof.  Still, you might wonder how we found it.   What we did was iterate the original rule for a while, rescale the picture, and then guess the limit.  This is similar to how one might guess the Perron-Frobenius eigenvector of a positive matrix by applying high powers of the matrix to some initial positive vector.";

	return(S);
    }

    public static String text14() {

	String S="EXERCISE:  First reset the program.   Next, do the following thing for each of the V curves, starting with V(1) and ending with V(9).  Turn on the V curve and toggle between the ideal rule and the graph rule.  Notice, as you progress from 1 to 9, the 'graph curve' and the 'ideal curve' become nearly indistinguishable.   What we mean to illustrate is that the curves produced by the ideal rule have the same limit as the ones produced by the original rule.";

	return(S);
    }

    public static String text15() {

	String S="At the end of this text, we will sketch a proof that both versions have the same limit. So, for the purposes of proving our main result, we can replace the arithmetic graphs by the curves that are produced by the ideal rule.  We still call these curves V2(k) and V3(k), just for economy of notation.";

	return(S);
    }

    public static String text16() {

	String S="THE COLORS:  Now we explain the colors in the 'substitution' display.  For G2, and for any index, the difference between the two vector assignments is either (0,0), or (-1,1) or (1,-1).   For G3, and for any index, the difference between the two vectors assignments is either (0,0) or (0,-2) or (0,2).   Surprisingly, the same option is taken for G2 and for G3 at the same time.   So, for example, the two G2 assignments agree at an index iff the corresponding G3 assignments agree.";
	return(S);
    }


    public static String text17() {

	String S=" We color the numbers in the display according to which option happens.  When the two assignments agree, we use white.  The basic thing to notice is that substitution rule respects the discrepancy.  Thus, for example the number 7 is colored magenta, whereas the subdivision 9,24,6 is colored magenta,cyan.magenta.  The magenta and cyan cancel, leaving a single magenta.";
	return(S);
    }

    public static String text18() {

	String S="DISCREPANCY:   There is a nice consequence of the fact that our subdivision rule respects the discrepancy:  The two versions of any path have the same endpoints.    Both paths start at the origin and, because of the preserved discrepancy, the difference between the other endpoints is invariant under subdivision.  The two versions of V2(1) and V3(1) have matching endpoints, and the general case now follows from induction.";

	return(S);
    }


    public static String text19() {


	String S="CLOSEDNESS PROOF:  Let's prove that the original G3 curves are closed.  With the ideal rule, we know that the G3 curves are closed.  This is true for the first one, and then the next one contains the vertices of the previous one. So, the result follows from induction.   Since the two versions of the G3 curves have the same endpoints, the original G3 curves are all closed. The same argument shows that both versions of G2(k) are closed if and only if k is odd. ";
	return(S);
    }


    public static String text20() {
	String S=" SAME LIMIT.  Let V stand for either V2 or V3.  Now we prove that both versions of the V curves have the same limit. Let U(n) stand for the unscaled version V(n).   Say that a special strand of U(n) is a polygonal arc that comes from iteratively applying the substitution rule to a single edge.  Such strands have length which is a power of 3.  For instance both versions of U(3), paths with 27 edges, have 3 special strands of combinatorial length 9.";
	return(S);
    }

    public static String text21() {
	String S="ALIGNMENT: The same argument  as in the closedness proof (i.e. substitution respects descrepancy)  shows that corresponding special strands of the two versions of U(n) can be lined up so that their tails coincide and their heads differ by at most 2 units.  The argument goes by induction on n. Put another way, if the tails of corresponding special strands are d units away, then the heads are at most d+2 units away.";
	return(S);
    }


    public static String text22() {
	String S="LOG DIVERGENCE:  Let U(n,k) be the portion of U connecting vertex 0 to vertex k.   Using the base 3 expansion of k, we can break both versions of U(n,k) into at most 2log(n) special strands. Here log is taken base 3.   Hence, by the alignment result, the endpoints of U(n,k) on both versions are at most 4log(n) units apart.  But k is arbitrary. Hence every pair of corresponding vertices on the two versions of U(n) are at most 4log(n) apart.";
	return(S);
    }

    public static String text23() {
	String S="END OF PROOF:  But V(n) is obtained from U(n) by scaling.  The scale factor is exponentially small in n.  Hence, the distance between any corresponding pair of vertices of the two versions of V(n) tends to 0 (exponentially fast) with n.  This finishes the proof that the two versions of V(n) have the same limit as n tends to infinity.  It remains to match up the ideal versions of V2 and V3 with the ideal fractals.";
	return(S);
    }


}