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


class TextDiscuss {

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


    public static String text0( ) {
	String S="PROOF SKETCH:  Let me at least give a hint about how the proof goes. Press the 'theorem' button.  For convenience we'll think of the various maps as acting directly on the tiles.  The vector that translates the first (red) tile to the last (blue) tile is the vector that does the square outer billiards map.  This vector is the sum of the vectors that translate each of the other tiles to the next one.  Speaking colorfully, we might say that 'red - blue' = 'red - yellow' + 'yellow - green' + ...  We have a telescoping sum of vectors.";

    return(S);
    }

    public static String text1( ) {
	String S="To establish the result, we just have to see that the remaining vectors really do implement the pinwheel map on the relevant points.  This amounts to checking that each of the colored tiles lies to the correct side of the correspondingly colored strip.  You can see this in action either using the animation feature or manually using the 'which strip' arrow keys.  In case there are gaps, we also have to check that the intervening grey strips contain the relevant tiles.";

    return(S);
    }

    public static String text2( ) {
	String S="By convexity, it suffices to check what we want just on the vertices of the tiles.  That is, we have to check that various points lie on various sides of various strips.  For any given polygon of interest, one can do this with a finite computation -- e.g., by inspecting this program.  In general, we give a giant induction argument which essentially reduces the whole problem to a tautology.  My paper has the details of this argument.";

    return(S);
    }

    public static String text3() {

	String S="ACCELERATION: One immediate consequence of our result is that a point in the plane has an unbounded forward outer billiards orbit if and only its lift has an unbounded pinwheel orbit.   The significance of this result is that it gives a very efficient way to compute those outer billiards orbits that wander far from the shape.  We now explain this in detail.";

	return(S);
    }

    public static String text4() {

	String S="Recall that a strip map based on a pair (S,V) takes a point p and replaces it either by p itself, or p+V, or p-V, depending on which move maps p closer to S.   An accelerated version of the strip map works like this.  We replace p with p+kV, where k is the integer chosen so that p+kV lies in S.  This map is defined on almost every point of the plane, and we ignore the points where it is not defined.";

	return(S);
    }

    public static String text5() {

	String S="We define the accelerated pinwheel map just like the pinwheel map.  The difference is that we use the accelerated strip maps in place of the ordinary ones.  With this definition, any accelerated pinwheel orbit is contained in the corresponding pinwheel orbit.  The accelerated pinwheel orbit essentially captures all the information.  Between consecutive points in the accelerated orbit, the original orbit just moves along a straight line.  In particular, the accelerated pinwheel orbit is unbounded if and only if the outer billiards orbit is unbounded.";

	return(S);
    }

     public static String text6( ) {

	 String S="The important point is that, far from the polygon P, the accelerated orbit progresses much faster than the ordinary orbit.  For points about N units from P, the accelerated orbit takes 1 step for roughly N steps of the outer billiards orbit.  This is a great computational savings.  One can explore much more of the outer billiards dynamics using the accelerated pinwheel orbit.";

	 return(S);
     }


    public static String text7( ) {

	String S="LIMITATIONS:   One limitation of our result is that we only proved it for polygons that have no parallel sides.  Mainly, we make this restriction for the sake of convenience.  For instance, this assumption leads to the result that no two strips have the same slope, and that any two strips intersect in a compact set.    I think that the result is true without these restrictions, but some care has to be taken in making the basic definitions.  My paper 'Outer billiards, Arithmetic Graphs, and the Octagon' gives a general definition of the pinwheel map.";

    return(S);
    }

    public static String text8( ) {

	String S="My device of allowing you to select random polygons is designed to prevent you from picking polygons that have parallel sides.  You can defeat this restriction with careful use of key-v, as explained in the 'how to use' text, but you would have to work at it.";

    return(S);
    }

}