For some simplification in the formulas, I will index  the vertices () of a representative of half of a 2D polytope (in the affine or hyperbolic case) by the following set of surreal numbers: with the following conventions:

• ,
• for ,
• where is a simple root and as in the previous post,
• ,
• , and
• , and
• for , is an imaginary root or zero.

Note that for a sequence comprised of imaginary roots and zeros the equivalence defined in the last post will always freely shift the zeroes around,  so we may take a number of conventions regarding its support (which must be finite).  I will leave it to the future to determine whether it is more convenient in different contexts to have, e.g,. or or , etc.

With this notation I define:

where is the Cartan matrix and matrix multiplication and are understood with the convention that is the th basis element.

If let be the smallest to achieve this maximum.  Then we set , for , and for , then inductively consider the smaller polytope.

In a fashion similar to that described by Tingley for 2D affine polytopes we may handle the cases when but at this point I think I may need to delay particulars to a third installment.

The real parts of the polytopes are exactly as in the affine case – similar to the finite case but enumerated by a rather than .  Describing the imaginary side is a bit trickier and there may be a number of ways to do it accurately, but I believe the following method will have some advantages over others.

Definition: For sequences of positive imaginary roots of length , , and an integer ,  I denote (resp. , ) if:

• for or ,
• ,
• , and
• and
  (resp.   and ,
  and )

Where and means the determinant of the linear transformation that maps .

More Definitions:

• For , as above we say if either or ,
• by we denote the transitive extension of all these relations,
• we say if either or , and
• we say if for some representatives , , and some .

The imaginary part of polytopes are enumerated by .  This completely generalizes the affine case where never happens and comprises all permutations of .

data for

These calculations were done using universal enveloping algebras.  These are the numbers my polytope calculus needs to match if it is accurate.  There was an issue with computer round-off when calculating high energy levels which I think I have corrected. Just in case anything above level 3 should be considered tentative.

The core function Eval() (I realize now its very badly named) should takes as input a word in the universal enveloping algebra (represented as a sequence of signed integers) which is assumed to have weight zero, and two parameters h and K. Its output is how that word acts on the generator of a Verma module where and act by those parameters.

The main body of the program generates a list of words (and their anti-words) that have a particular weight (anti-weight). It then populates a matrix with the outputs of Eval() under fixed h and K and takes the rank.

Based on my current debugging statistics generating the list of words and taking the rank of the matrix happens rather quickly – the bottle neck is the Eval(). So maybe some extra eyes will help me to optimize it.

Essentially the rules break down as this:

• Eval(A+[n],h,K)=0 if .
• Eval(A+[0],h,K)=h*Eval(A,h,K).
• Eval(A+[n,m]+C,h,K)=Eval(A+[m,n]+C,h,K)+X*Eval(A+[m+n]+C,h,K)+Y*K*Eval(A+C,h,K) where X and Y depend only on m and n and can be calculated in constant time.

My algorithm for Eval() uses a recursive algorithm:

1. Choose an integer in the list which is non-positive.
2. Repeatedly apply rule 3 to move it all the way to the right.
3. Each application of rule 3 spawns (up to) 2 new calls to Eval()
   • one with a word of length n-1,
   • one with a word of length n-2.

Here’s the code:

def Eval (X,h,K):
    #First we see if X or an equivalent input has already been calculated
    #EvalDict is a hash where we store previously calculated values
    Y=[-x for x in X]
    Y.reverse()
    if str(X) in EvalDict:
        return EvalDict[str(X)]
    elif str(Y) in EvalDict:
        return EvalDict[str(Y)]
    elif len(X)==0:
        return 1
    else:#word has not been previously Evaluated
        o=0 #initialize output value
        Y=min(X) #"1. choose a non-positive element" This is probably not the most efficient choice.
        if Y>0:
            return 0 #something is wrong! should throw.
        else:
            A=X[:X.index(Y)]
            C=X[X.index(Y)+1:]
            for i in range(len(C)): #"2. Repeatedly apply rule 3"
                (Z,n,m)=Brack([Y,C[i]]) #Operates in constant time
                D=C[:i]
                E=C[i+1:]
                if n!=0:
                    o+=n*Eval(A+D+[Z]+E,h,K)
                if m*K!=0:
                    o+=m*K*Eval(A+D+E,h,K)
            if Y==0 and h!=0:
                o+=h*Eval(A+C,h,K)
            EvalDict[str(X)]=o #Store result for latter recovery
            return o

Adding EvalDict dramatically sped up the calculation time. But I estimate it increases in size exponentially with the size of the words being stored.

I’m trying to figure out the best way to post the whole code.  I was going to use Launchpad (since I used quickly to write the program) but I’ve been having some trouble with that.  So I might end up just uploading the *.py to either my umich or math.northwestern accounts.

First I define an object called a “polytope half” that uses three lists of integers to represents a single path through the polytope.  (In the two dimensional case each polytope only has two paths so one constitutes a polytope half). There are several methods implemented (or partially implemented) for this object including “__add__” which gives the convex hull of to paths. The “FIX ME” is because I haven’t yet implemented the merger of the side partitions. (It shouldn’t be too difficult, I simply haven’t gotten around to it.)

class Polytopehalf:
    """Only 'half' if the polytope is 2 dimensionsl.  Really an i-lusztig datum
    though we don't specify i.  For sl3 this should be 3 non-negative integers.
    for Lsl2 this should be 2 sequences (each of arbitrary finite length) of
    non-negative integers and a multiset of positive integers.

    This program only implements for Lsl2.

    """
    def __init__(self,bottom=[],top=[],side=[]):
        self.bottom = bottom
        self.top = top
        self.side = side

    def weight(self):
        """returns the projecton of the weight to the sl2 component
        assumes the polytope half is the right hand side"""
        return sum(self.bottom)-sum(self.top)

    def increment(self):
        """advancing in the crystal structure - relative to the chosen i-Lustig path"""
        self.top=[0]+self.top
        self.top[-1]+=1

    def flip(self):
        """tells how this i-Lustig path effects other paths during iteration
        this process may insert a negative number!"""
        self.top=[0]+self.top
        self.bottom.append(-2*self.weight()-self.top.pop())

    def __add__(self,other):
        """takes the convex hull of the two halfs -- currently expects the paths align at top and bottom
        this needs to be fixed because this is *not* typical """
        Out=Polytopehalf()

        #Pad to be the same length.
        diff=len(self.top)-len(other.top)
        if diff>0:
            other.top=[0]*(diff+1)+other.top
            self.top=[0]+self.top
        else:
            self.top=[0]*(1-diff)+self.top
            other.top=[0]+other.top

        #calculate displacements this is necessary as the tops of the polytopes do not align
        d1=0
        d2=0
        for i in range(len(self.bottom)):
            d1-=self.bottom[-i-1]*i
            d2-=self.bottom[-i-1]
        for i in range(len(self.top)):
            d1-=self.top[-i-1]*(i+1)
            d2+=self.top[-i-1]
        for i in range(len(other.bottom)):
            d1+=other.bottom[-i-1]*i
            d2+=other.bottom[-i-1]
        for i in range(len(other.top)):
            d1+=other.top[-i-1]*(i+1)
            d2-=other.top[-i-1]
        for i in range(len(self.side)):
            d1-=self.side[-i-1]*(i+1)
        for i in range(len(other.side)):
            d1+=other.side[-i-1]*(i+1)
        Disp1=[0,0]
        Disp2=[d1,d1+d2]
        for i in range(len(self.top)):
            Disp1.append(2*Disp1[-1]+self.top[-i-1]-Disp1[-2])
            Disp2.append(2*Disp2[-1]+other.top[-i-1]-Disp2[-2])
        D1=Disp1[-1]-Disp1[-2]
        D2=Disp2[-1]-Disp2[-2]
        while (Disp1[-1]-Disp2[-1])*(D1-D2)<=0 and (D1-D2)0:
            Disp1.append(Disp1[-1]+D1)
            Disp2.append(Disp2[-1]+D2)
        Disp=map(max,Disp1,Disp2)

        for i in range(1,len(Disp)-1):
            Out.top=[Disp[i-1]+Disp[i+1]-2*Disp[i]]+Out.top

        #Pad to the same length
        diff=len(self.bottom)-len(other.bottom)
        if diff>0:
            other.bottom=[0]*(diff+1)+other.bottom
            self.bottom=[0]+self.bottom
        else:
            self.bottom=[0]*(1-diff)+self.bottom
            other.bottom=[0]+other.bottom

        Disp1=[0,0]
        Disp2=[0,0]
        for i in range(len(self.bottom)):
            Disp1.append(2*Disp1[-1]+self.bottom[-i-1]-Disp1[-2])
            Disp2.append(2*Disp2[-1]+other.bottom[-i-1]-Disp2[-2])
        D1=Disp1[-1]-Disp1[-2]
        D2=Disp2[-1]-Disp2[-2]
        while (Disp1[-1]-Disp2[-1])*(D1-D2)<=0 and (D1-D2)0:
            Disp1.append(Disp1[-1]+D1)
            Disp2.append(Disp2[-1]+D2)
        Disp=map(max,Disp1,Disp2)

        for i in range(1,len(Disp)-1):
            Out.bottom=[Disp[i-1]+Disp[i+1]-2*Disp[i]]+Out.bottom

        if sum(self.bottom)>sum(other.bottom):
            Out.side=self.side
        elif sum(self.bottom)<sum(other.bottom):
            Out.side=other.side
        elif sum(self.bottom)==sum(other.bottom):
            b1=0
            b2=0
            p1=0
            p2=0
            for i in range(len(self.bottom)):
                b1+=self.bottom[-i-1]*i
                b2+=other.bottom[-i-1]*i
            for i in range(len(self.side)):
                p1+=self.side[-i-1]*(i+1)
            for i in range(len(other.side)):
                p2+=other.side[-i-1]*(i+1)
            p=max(b1+p1,b2+p2)-min(b1,b2)
            Out.side=[p] #FIXME

        #Trim unnecessary zeros
        Out.top.reverse()
        while len(Out.top) and Out.top[-1]==0:
            Out.top.pop()
        Out.top.reverse()
        Out.bottom.reverse()
        while len(Out.bottom) and Out.bottom[-1]==0:
            Out.bottom.pop()
        Out.bottom.reverse()

        return Out

I also create a full “polytope” class that contains two polytope halves (“Left” and “Right”) and a method for retrieving all the “points” of a polytope by going round the perimeter. An unfortunate side effect of doing things this way is that python stores lists as pointers so copying a polytope (and not merely creating another name that points to the same data) is a bit of a pain.

Inside my main instance I have two functions “itereate left” and “iterate right” linked to buttons on the GUI:

def iterate_right(self,button):
    #increment
    self.Polytope.Left.increment()
    temp=copy.deepcopy(self.Polytope.Left)

    #reflect
    temp.flip()

    #convex hull
    self.Polytope.Right+=temp

    self.builder.get_object("drawingarea1").queue_resize()

This method of incrementing, reflecting and taking convex hull is proven to work for and conjectured to work for . The current polytope being diplayed in window is “self.Polytope”. Since iterating changes the polytope I get the drawing area to refresh by sending it a “queue_resize” signal.

• LiE software package the page also has a link for doing calculations on the web! Including Littlewood Richardson numbers.
• http://www.gap-system.org/

I just found them in a 2000 abstract by Charles Cochet.

Of course I would find this *after* spending all weekend writing my own program to do such calculations. (Of course my own program is specifically for the affine case .)

Speaking of which I should post the polytope calculator I wrote as proof of concept for my thesis. The thing is I used Ubuntu’s quickly to create it and I’m not sure which scripts are strictly necessary to make it run (though, theoretically I should be able to publish a .deb quickly).

Begin with any positive integer then define for let where .  If ever then In fact, it would seem that, no matter which number you start with this will always happen.

For example if you begin with it takes 397 steps to stabalize at . On the other hand if you begin with then so etc. In otherwords, sometimes it may happen soon, sometimes it may take rather a long time.

Only recently I realized that the possibility that this always stabilizes should not be very surprising. Suppose that prior to stability the value behaved randomly. If then there would be a chance that . Since grows by no more than n, at some point we must have and so . At that point, if we haven’t already stabilized the probability that we eventually stabilize is . Noting that the partial sums of this series are we deduce that the limit is equal to 1. In otherwords the probability of never stabilizing is zero.

If my level-rank duality calculations are correct (very similar to those from last post) the dimension vectors will be .

As before we have and by the “limit” condition. Thus we can again deduce that and by the condition. The limit condition additionally tells us that each of these compositions, and the composition , must be nilpotent. This might be sufficient to satisfy the limit condition — technically we should require that any loop involving at least one bar must be nilpotent.

So the only thing left to answer is the “stability” condition. I’m still working on this but I believe there are two basic ways the stability could be satisfied:(1) there is a path beginning with and ending at such that the partial paths give a basis for the whole space (see below for an example) or (2) there are two paths from to who together span the whole space.

Example: one way to satisfy the stability condition is if ,, and form a basis for V and if . In that case I have used the sage notebook (sagenb.org) to apply the composition and nilpotency conditions to get four subcases:

Subcase 1:

,
,

Subcase 2:

,
,

Subcase 3:

,
,

Subcase 4:

,
,

Where the basis for writing the matrices is chosen to be the basis mentioned above.

On the other hand if we consider modules for which the path generates a basis we only get two subcases:

Subcase 1:

,
,

Subcase 2:

,
,

(Notice that this subcase and subcase 2 above intersect when .)

But for the path there will be only one case:

,
,

I was on going to do all possible paths — but I begin to realize this isn’t a good way to approach things. For starters I don’t have a good idea when these subcases lie on the same component of the quiver variety.

My goal is to find the cycles corresponding to the first two triangles in my list of polytopes so I use:



Some of the notation is very confusing, I understand. I’m sorry, I don’t know what to do with it: at the end of the day the dimension vectors we are concerned about are and

We want to replace the arrows in this diagram with maps (in order of appearance top to bottom left to right) in such a way that it satisfies three conditions which I abbreviate as the “” (this is not the same … sorry), “stability” and “limit” conditions.

The “” condition in our case (for and for other choices of but still r=l=2) implies:

The “Stability” condition has two halves. First that every vector v in the top half has “Origins” i.e. where live in the bottom half and are chosen from appropriate paths in the quiver. And second that every non-zero v in the top half has “Futures” i.e. for some path g terminating in the bottom half.

The “Limit” condition requires that the action of t (not the same as either previous t… sorry) given on page 30 can be “controled” as by action of described on page 5 (just before eq. 2.1 )

Something to notice right away because it will be useful in future calculations: taking the two halves of “Stability” together gives paths on which has no control! The “Limit” condition requires that the image of such a composition must lie in . (Superscript refers to the decomposition into 1-dimensional subspaces given by — use of the is short hand for the corresponding filtration.)

In our case we have . For example if the image of is non-zero the "Futures" condition says it must escape but, according to the "Limit" condition, in doing so it can only afford to accumulate orders of t and every possible exiting accumulates at least . The argument for is quite similar replacing "image" with "kernel", "Futures" with "Origins" etc..

Furthermore we get:
,
and
.
(Moding out by the action in this case we can assume

The two components, then, correspond to diagrams:

and

Where the solid line indicates the map is non-zero and dashed line indicates the map may be zero.

I should have been posting while I was at the conference. But anyway I’ll try to post as much as I can remember, before I forget it.

Geometric Satake gives a correspondence from representation theory to subvarieties of an affine Grassmanian. MV-cycles help give a better handle on them but are still rather abstract. MV-polytopes , introduced by Jared Anderson, are more “hands on” in terms of being able to do direct computations. But you need to know what they are first, and their original definition as moment map images of MV-cycles doesn’t really help. At least if you know they are a convex hill of the torus fixed-points appear in the *closure* of an MV-cycle then you’re done — but this still requires more-or-less calculating the MV-cycles and taking their closure.

Kamnitzer’s thesis provided a few ways to get direct handle on MV-polytopes avoiding MV-cycles entirely.

• Implicit description via Plucker relations
• Inductive description (for later extended to types B and C by **FIXME**)
• Reduction to dim-2: higher dimensional MV-polytopes are all polytopes whose 2-faces are MV-polytopes.
• Construction from primitives: MV-polytopes are Minkowski sums of “primitives” and sums of primitives from the same “cluster” are MV-polytopes
• In dimension 2, clusters can be described by networks of non-overlapping cords each parallel to a sides of the Weyl polytope