FTMF.sagews

def ParabolicRoots(P): #this should find the root subspaces that Lie(P_1) contains
    Proots=copy(positiveroots)
    for g in P:
        for sr in S:
            if g*vector(sr) not in Proots:
                Proots.append(g*vector(sr))
    return Proots
def WconjugateRoots(w,roots): #moves the roots by w
    wroots=copy([])
    for r in roots:
        wroots.append(w*vector(r))
    return wroots
def StabilizerRoots(P,Q,w): #computes the roots in the stabilizer (P\cap wQw^{-1})
    Sroots=copy([])
    Proots=ParabolicRoots(P)
    wQroots=WconjugateRoots(w,ParabolicRoots(Q))
    for r in Proots:
        if r in wQroots:
            Sroots.append(r)
    return Sroots
def StabilizerDimension(P,Q,w): #returns the dimension of the stabilizer (P\cap wQw^{-1})
    dim=len(StabilizerRoots(P,Q,w))+rank
    return dim
def OrbitRoots(P,Q,w): #returns the root spaces of the orbit (the ones that don't get absorbed in Q after going through w)
    remainingroots=copy([])
    Proots=(ParabolicRoots(P))
    for r in Proots:
        if (w.inverse())*vector(r) not in ParabolicRoots(Q):
            remainingroots.append(r)
    return remainingroots
def OrbitStabilizerRoots(P,Q,R,w,v): #separates the roots in the orbit into a set of roots who appear in the stabilizer and a set of roots who don't
    remainingroots=copy([])
    discardedroots=copy([])
    orbitroots=OrbitRoots(P,R,v)
    stabilizerroots=StabilizerRoots(P,Q,w)
    for r in orbitroots:
        if r not in stabilizerroots:
            remainingroots.append(r)
        else:
            discardedroots.append(r)
    return [remainingroots,discardedroots]
def MNroots(P,Q,w,gamma): #separates the roots into the roots for M and N #This function gets us the Levi part using gamma
    mroots=copy([])
    nroots=copy([])
    for r in StabilizerRoots(P,Q,w):
        if  gamma*r==0:
            mroots.append(r)
        else:
            nroots.append(r)
    return[mroots,nroots]
def Level0Roots(Mroots): #This function gets us the Levi part without using gamma
    pmroots=copy([])
    for r in Mroots:
        if ((-1)*r in Mroots):
            pmroots.append(r)
    return(pmroots)
def xMwMvroots(P,Q,R,w,v,x): #Computes the intersection of Mv and (x^-1 Mw x) #This function is now obsolete (and incorrect)
    Mwroots=WconjugateRoots(x.inverse(),Level0Roots(StabilizerRoots(P,Q,w)))
    Mvroots=Level0Roots(StabilizerRoots(P,R,v))
    roots=copy([])
    for r in Mwroots:
        if r in Mvroots:
            roots.append(r)
    return roots
def SplitRoots(Mroots): #groups the roots into two groups, the ones which appear with +- and the ones which don't #This function also gets us half of the Levi part without gamma
    pmroots=copy([])
    otherroots=copy([])
    for r in Mroots:
        if ((-1)*r in Mroots) and (r in positiveroots):
            pmroots.append(r)
        else:
            if (r not in otherroots) and ((-1)*r not in pmroots):
                otherroots.append(r)
    return([pmroots,otherroots])
def FindLevels(gamma,roots): #Finds the levels of roots with respect to gamma
    levels=copy([])
    for r in roots:
        if r*gamma not in levels:
            levels.append(r*gamma)
    return levels
def RootsWithLevels(gamma,roots): #Separates the roots according to the levels with respect to gamma
    rootswithlevels=copy([])
    for r in roots:
        rootswithlevels.append([r,r*gamma])
    return rootswithlevels
def PrintRootsWithLevels(gamma,roots): #Prints the roots along with the levels with respect to gamma
    levels=FindLevels(gamma,roots)
    roots=RootsWithLevels(gamma,roots)
    levels.sort()
    for l in levels:
        print "\n","level ",l,"\n"
        for r in roots:
            if r[1]==l:
                print r[0]
def NilpotentAction(coords,nilroots): #throws out the roots that appear in both lists
     rcoords=copy([])
     usednilroots=copy([])
     rnilroots=copy([])
     for r in coords:
         if r not in nilroots:
             rcoords.append(r)
         else:
             usednilroots.append(r)
     for r in nilroots:
         if r not in usednilroots:#This finds the w's
             rnilroots.append(r)
     return (rcoords,rnilroots)
def FindSums(coords,redroots): #outputs a list of all sums of roots \alpha+\beta
    sums=copy([])
    for alpha in coords:
        for beta in redroots:
            if alpha+beta not in sums:
                sums.append(alpha+beta)
    return sums
def LowestLevel(roots):
    levels=FindLevels(gamma,roots)
    roots=RootsWithLevels(gamma,roots)
    levels.sort()
    lowest=copy([])
    for r in roots:
        if r[1]==levels[0]:
            lowest.append(r[0])
    return lowest
def StepOne(roots,nilroots):
    levels=FindLevels(gamma,roots)
    levels.sort()
    coords=LowestLevel(roots)
    result=NilpotentAction(coords,nilroots)
    return ([levels[0],result[0],result[1]])
def StepTwo(coords,redroots):
    lowestcoords=copy([])
    sums=FindSums(coords,redroots)
    for r in coords:
        if r not in sums:
            lowestcoords.append(r)
    return lowestcoordsw in W
def Nvperp(gamma,P,Q,v): #Finds the roots in N_v^perp, these are the coordinates for the orbit O(v) that are not at level 0 #Correct but obsolete now
    remainingroots=copy([])
    Proots=(ParabolicRoots(P))
    for r in Proots:
        if (r not in WconjugateRoots(v,ParabolicRoots(Q)) and (gamma*vector(r)!=0)):
            remainingroots.append(r)
    return remainingroots
def SetDifference(A,B):#Returns (A-B,A intersection B)
    remainingroots=copy([])
    discardedroots=copy([])
    for r in A:
        if r not in B:
            remainingroots.append(r)
        else:
            discardedroots.append(r)
    return [remainingroots,discardedroots]
#####
# Acual input starts here:
#####
type='F'
rank=4
S=RootSystem([type,rank]).ambient_space().simple_roots()
R=RootSystem([type,rank]).ambient_space().roots()
identitysize=RootSystem([type,rank]).ambient_space().dimension()
e=identity_matrix(identitysize)
temp=RootSystem([type,rank]).ambient_space().positive_roots()
positiveroots=copy([])
for proot in temp:
    positiveroots.append(vector(proot))
W=RootSystem([type,rank]).ambient_space().weyl_group()
s=copy([[]])
for i in [1..rank]:
    s.append(W.simple_reflections()[i])
print "Simple roots:\n",list(RootSystem([type,rank]).ambient_space().simple_roots()),"\n"
print "Fundamental weights:\n",list(RootSystem([type,rank]).ambient_space().fundamental_weights()),"\n"
rho=0
for pr in list(RootSystem([type,rank]).ambient_space().fundamental_weights()):
    rho=rho+pr
print "Rho=",rho

#-------------------------

#This computes the minimal length coset representatives w for the action of P1 on G/P2
W=WeylGroup(['F',4],prefix="s")
minlengthcosetreps=copy([])
for w in W:
    m=w.coset_representative([1,2,3], side='left').coset_representative([1,2,3], side='right')#Choose the appropriate simple roots here for the left and right component
    if m not in minlengthcosetreps:
        minlengthcosetreps.append(m)
minlengthcosetreps.sort()
for r in minlengthcosetreps:
    print r,"\n\n",r.matrix(),"\n"

#------------------------------------------
#This computes the minimal length coset representatives v for the action of P1 on G/P3.
WP=WeylGroup(['F',4],prefix="s")
Pminlengthcosetreps=copy([])
for w in WP:
    m=w.coset_representative([1,2,3], side='left').coset_representative([1,2,4], side='right')#Choose the appropriate simple roots here for the left and right component
    if m not in Pminlengthcosetreps:
        Pminlengthcosetreps.append(m)
Pminlengthcosetreps.sort()
for r in Pminlengthcosetreps:
    print r,"\n\n",r.matrix(),"\n"

#----------------------------------------

#Finds what parabolic subgroups of M, M_w and M_v are
gens_1=[s[1],s[2],s[3]]#Choose the appropriate generators here
gens_2=[s[1],s[2],s[3]]#Choose the appropriate generators here
gens_3=[s[1],s[2],s[4]]#Choose the appropriate generators here
P_1=MatrixGroup(gens_1)
P_2=MatrixGroup(gens_2)
P_3=MatrixGroup(gens_3)
w=minlengthcosetreps[0]
v=Pminlengthcosetreps[0]
print "\n Roots of M_w:\n"
for i in SetDifference(StabilizerRoots(P_1,P_2,w),Level0Roots(ParabolicRoots(P_1)))[1]:
    print i
print "\n Roots of M_v:\n"
for i in SetDifference(StabilizerRoots(P_1,P_3,v),Level0Roots(ParabolicRoots(P_1)))[1]:
    print i
print "\nSimple roots, for reference:\n",list(RootSystem([type,rank]).ambient_space().simple_roots()),"\n"

#-----------------------------------

#The first two roots of F4 are the long roots and the third and fourth roots are the short roots.
#This computes the minimal length coset representatives x
Wx=WeylGroup(['B',3],prefix="s")
xminlengthcosetreps=copy([])
for wx in Wx:
    m=wx.coset_representative([1,2], side='left').coset_representative([1,2,3], side='right')#Choose the appropriate simple roots here for the left and right component
    if m not in xminlengthcosetreps:
        xminlengthcosetreps.append(m)
xminlengthcosetreps.sort()
print "List of x's:\n"
for r in xminlengthcosetreps:
    print r,"\n\n",r.matrix(),"\n"

#--------------------------------------------------

#generators should be specified by simple reflections (s[i]'s), in case of B, use e or use W.one()
x=e #x is a product of simple reflections according to the root system of F4 (not P_1)
print "\n roots in ( x^-1 M_w x ) intersect M_v: \n"
for i in SetDifference(WconjugateRoots(x.inverse(),SetDifference(StabilizerRoots(P_1,P_2,w),Level0Roots(ParabolicRoots(P_1)))[1]),SetDifference(StabilizerRoots(P_1,P_3,v),Level0Roots(ParabolicRoots(P_1)))[1])[1]:
    print i
print "\nSimple roots, for reference:\n",list(RootSystem([type,rank]).ambient_space().simple_roots()),"\n"
print "Fundamental weights:\n",list(RootSystem([type,rank]).ambient_space().fundamental_weights()),"\n"

#---------------------------------------------------------

#gamma is the vector against which we are measuring the levels
#Choose gamma as the sum of Weights corresponding to Simple roots not in (x^-1Mwx intersect Mv)
gamma=vector([1,0,0,0])
print "\n Roots in (N_v^perp) not in ( x^-1 N_w x ):"
PrintRootsWithLevels(gamma,SetDifference(SetDifference(SetDifference(ParabolicRoots(P_1),Level0Roots(ParabolicRoots(P_1)))[0],SetDifference(StabilizerRoots(P_1,P_3,v),SetDifference(ParabolicRoots(P_1),Level0Roots(ParabolicRoots(P_1)))[0])[1])[0],WconjugateRoots(x.inverse(),SetDifference(StabilizerRoots(P_1,P_2,w),SetDifference(ParabolicRoots(P_1),Level0Roots(ParabolicRoots(P_1)))[0])[1]))[0])

#=--------------------------------------------------

#Un-comment and run this code to find Nroots, Nv^Perp, (x^-1 Nw x) explicitly
#print "\n Nroots in the stabilizer"
#PrintRootsWithLevels(gamma,MNroots(P_1,P_2,w,gamma)[1])
#print "\n Mroots in the stabilizer\n"
#for i in SplitRoots(StabilizerRoots(P_1,P_2,w))[0]:
#    print "+-",i
#print "\n x=\n",x,"\n"
#print "\n Roots forming coordinates for the orbit (N_v^perp):"
#PrintRootsWithLevels(gamma,Nvperp(gamma,P_1,P_3,v))
#print "\n roots in ( x^-1 N_w x ): \n"
#PrintRootsWithLevels(gamma,WconjugateRoots(x.inverse(),SplitRoots(StabilizerRoots(P_1,P_2,w))[1]))

Simple roots: [(0, 1, -1, 0), (0, 0, 1, -1), (0, 0, 0, 1), (1/2, -1/2, -1/2, -1/2)] Fundamental weights: [(1, 1, 0, 0), (2, 1, 1, 0), (3/2, 1/2, 1/2, 1/2), (1, 0, 0, 0)] Rho= (11/2, 5/2, 3/2, 1/2) s4*s3*s2*s3*s1*s2*s3*s4*s3*s2*s3*s1*s2*s3*s4 [-1 0 0 0] [ 0 1 0 0] [ 0 0 1 0] [ 0 0 0 1] s4*s3*s2*s3*s1*s2*s3*s4 [-1/2 1/2 1/2 1/2] [ 1/2 1/2 1/2 -1/2] [ 1/2 1/2 -1/2 1/2] [ 1/2 -1/2 1/2 1/2] s4*s3*s2*s3*s4 [0 1 0 0] [1 0 0 0] [0 0 1 0] [0 0 0 1] s4 [ 1/2 1/2 1/2 1/2] [ 1/2 1/2 -1/2 -1/2] [ 1/2 -1/2 1/2 -1/2] [ 1/2 -1/2 -1/2 1/2] 1 [1 0 0 0] [0 1 0 0] [0 0 1 0] [0 0 0 1] s4*s3*s2*s3*s1*s2*s3*s4*s3*s2*s3*s1*s2*s3 [-1/2 -1/2 -1/2 -1/2] [ 1/2 1/2 -1/2 -1/2] [ 1/2 -1/2 1/2 -1/2] [ 1/2 -1/2 -1/2 1/2] s4*s3*s2*s3*s1*s2*s3*s4*s3*s2*s3 [-1/2 1/2 -1/2 -1/2] [ 1/2 1/2 1/2 -1/2] [ 1/2 1/2 -1/2 1/2] [ 1/2 -1/2 -1/2 -1/2] s4*s3*s2*s3*s4*s1*s2*s3 [ 0 0 0 -1] [ 1 0 0 0] [ 0 1 0 0] [ 0 0 1 0] s4*s3*s2*s3*s1*s2*s3 [ 1/2 -1/2 -1/2 -1/2] [ 1/2 1/2 1/2 -1/2] [ 1/2 1/2 -1/2 1/2] [ 1/2 -1/2 1/2 1/2] s4*s3*s2*s3 [ 1/2 1/2 -1/2 -1/2] [ 1/2 1/2 1/2 1/2] [ 1/2 -1/2 1/2 -1/2] [ 1/2 -1/2 -1/2 1/2] s4*s3 [ 1/2 1/2 1/2 -1/2] [ 1/2 1/2 -1/2 1/2] [ 1/2 -1/2 1/2 1/2] [ 1/2 -1/2 -1/2 -1/2] 1 [1 0 0 0] [0 1 0 0] [0 0 1 0] [0 0 0 1] Roots of M_w: (0, 1, 0, 0) (0, 0, 1, 0) (0, 0, 0, 1) (0, 1, 1, 0) (0, 1, 0, 1) (0, 0, 1, 1) (0, 1, -1, 0) (0, 1, 0, -1) (0, 0, 1, -1) (0, 0, 0, -1) (0, 0, -1, -1) (0, -1, 0, -1) (0, 0, -1, 0) (0, -1, -1, 0) (0, -1, 0, 0) (0, 0, -1, 1) (0, -1, 0, 1) (0, -1, 1, 0) Roots of M_v: (0, 1, 0, 0) (0, 0, 1, 0) (0, 0, 0, 1) (0, 1, 1, 0) (0, 1, 0, 1) (0, 0, 1, 1) (0, 1, -1, 0) (0, 1, 0, -1) (0, 0, 1, -1) (0, 0, -1, 1) (0, -1, 0, 1) (0, -1, 1, 0) Simple roots, for reference: [(0, 1, -1, 0), (0, 0, 1, -1), (0, 0, 0, 1), (1/2, -1/2, -1/2, -1/2)] List of x's: 1 [1 0 0] [0 1 0] [0 0 1] roots in ( x^-1 M_w x ) intersect M_v: (0, 1, 0, 0) (0, 0, 1, 0) (0, 0, 0, 1) (0, 1, 1, 0) (0, 1, 0, 1) (0, 0, 1, 1) (0, 1, -1, 0) (0, 1, 0, -1) (0, 0, 1, -1) (0, 0, -1, 1) (0, -1, 0, 1) (0, -1, 1, 0) Simple roots, for reference: [(0, 1, -1, 0), (0, 0, 1, -1), (0, 0, 0, 1), (1/2, -1/2, -1/2, -1/2)] Fundamental weights: [(1, 1, 0, 0), (2, 1, 1, 0), (3/2, 1/2, 1/2, 1/2), (1, 0, 0, 0)] Roots in (N_v^perp) not in ( x^-1 N_w x ): level 1/2 (1/2, 1/2, 1/2, -1/2) (1/2, 1/2, -1/2, 1/2) (1/2, 1/2, -1/2, -1/2) (1/2, -1/2, 1/2, 1/2) (1/2, -1/2, 1/2, -1/2) (1/2, -1/2, -1/2, 1/2) (1/2, -1/2, -1/2, -1/2) level 1 (1, 0, 0, 0) (1, 1, 0, 0) (1, 0, 1, 0) (1, 0, 0, 1) (1, -1, 0, 0) (1, 0, -1, 0) (1, 0, 0, -1)

x.inverse()

[1 0 0 0] [0 1 0 0] [0 0 1 0] [0 0 0 1]

SetDifference(StabilizerRoots(P_1,P_2,w),Level0Roots(ParabolicRoots(P_1)))[1]

[(0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1), (0, 1, 1, 0), (0, 1, 0, 1), (0, 0, 1, 1), (0, 1, -1, 0), (0, 1, 0, -1), (0, 0, 1, -1), (0, 0, 0, -1), (0, 0, -1, -1), (0, -1, 0, -1), (0, 0, -1, 0), (0, -1, -1, 0), (0, -1, 0, 0), (0, 0, -1, 1), (0, -1, 0, 1), (0, -1, 1, 0)]