### This file contains the functions needed for Harashita's injectivity criterion ### Felix Grelak 04-2014 ### Following functions are contained: ### ### SchubertIntersectionEmpty(v,w) ### DeltaLambda(lambda,w) ### FindMinimalSetJ(w,q) ### IsAffineHin(lambda,J,w) ### AreNotAffineByHin(A,q) ### AreNotAffineByHinSlow(A,q) ################################################################################### SchubertIntersectionEmpty := function (v,w) ### Function computes, whether the intersection of the two Schubert cells v^{-1}C(w)v ### and C(w) is empty or not ### ### @Input: Two (reduced) Coxeter words (or Coxeter elements) in W ### ### @Output: 'true' or 'false' ### ### Required global variables: ### W a Coxeter group, such that the Frobenius acts trivially on W local L, Lnew, i, j; if w in Elements(W) then w := CoxeterWord(W,w); else w:=ReducedCoxeterWord(W,w); fi; if v in Elements(W) then v := CoxeterWord(W,v); else v:=ReducedCoxeterWord(W,v); fi; L:=[w]; v:=Reversed(v); ### Main part computes the set L by Bruhat order ### v^{-1}C(w)v = \bigcup C(v'), v'\in L (disjoint union) ### 1st: Multiplication from the right: C(w)v for i in [1..Length(v)] do Lnew:=[]; for j in [1..Length(L)] do if CoxeterLength(W,EltWord(W,L[j])*EltWord(W,[v[i]])) > CoxeterLength(W,EltWord(W,L[j])) then Lnew:=Concatenation(Lnew,[CoxeterWord(W,EltWord(W,L[j])*EltWord(W,[v[i]]) )]); else Lnew:=Concatenation(Lnew,[CoxeterWord(W,EltWord(W,L[j])*EltWord(W,[v[i]]))],[L[j]]); fi; od; L:=Copy(Lnew); od; ### 2nd: Multiplication from the left: v^{-1}C(w) for i in [1..Length(v)] do Lnew:=[]; for j in [1..Length(L)] do if CoxeterLength(W,EltWord(W,[v[i]])*EltWord(W,L[j])) > CoxeterLength(W,EltWord(W,L[j])) then Lnew:=Concatenation(Lnew,[CoxeterWord(W,EltWord(W,[v[i]])*EltWord(W,L[j]))]); else Lnew:=Concatenation(Lnew,[CoxeterWord(W,EltWord(W,[v[i]])*EltWord(W,L[j]))],[L[j]]); fi; od; L:=Copy(Lnew); od; return not(w in L); end;; #################################################################################### DeltaLambda := function (lambda,w) ### This function computes a set Deltalambda such that ### X^{\lambda}_M(w) = \cup X_M(v); v\ in Deltalambda ### ### @Input: lambda a tuple of indices denoting lambda as in [Ha13]. In our application ### to Deligne-Lusztig varieties the set I is assumed to be empty. ### w a Coxeter word given in W ### ### @Output: Set \Delta^lambda(w), consisting of certain (reduced) Coxeter words v <= w ### ### Required global variables: ### W a Coxeter group, w in W local i ,j, k, dlambda, omega, BSw, BSwReduced, BS, Delta, Deltalambda; if w in Elements(W) then w := CoxeterWord(W,w); fi; w := ReducedCoxeterWord(W,w); ### Generate dlambda = \partial^lambda_M, see [Ha13] dlambda:=[]; omega := Reversed(w); for i in [1..Length(omega)] do if not i in lambda then Add(dlambda, Reversed( Concatenation(omega{[1..i-1]},omega{[i+1 .. Length(omega)]} ) ) ); fi; od; ### Generate list of all v <= w, given in reduced expression BSw:=BruhatSmaller(W,EltWord(W,w)); BSwReduced:=[]; for i in [1..Length(BSw)] do for j in [1..Length(BSw[i])] do Add(BSwReduced,CoxeterWord(W,BSw[i][j])); od; od; ### Delta = List of all v in W with v <= v_i for some v_i in d_lambda Delta:=[]; for i in [1..Length(dlambda)] do BS:=BruhatSmaller(W,EltWord(W,dlambda[i])); for j in [1..Length(BS)] do for k in [1..Length(BS[j])] do Add(Delta,CoxeterWord(W,BS[j][k])); od; od; od; ### Generate list of all v <= w that are not in Delta, given in reduced expression Deltalambda:=[]; for i in [1..Length(BSwReduced)] do if not BSwReduced[i] in Delta then Add(Deltalambda,BSwReduced[i]); fi; od; return Deltalambda; end;; ################################################################################### FindMinimalSetJ := function (w,q) ### Computes a set J\subset \Delta, i.e. a subset of simple roots, of minimal length ### and some lambda \in D(w), such that the generalized DL-conditions hold for ### J and lambda, see [Ha13]. ### ### @Input: Coxeter word w, integer q, denoting the size of the ground field ### ### @Output: subset J of [1..W.rank] indicating the simple reflections ### subset lambda of [1..Length(w)] indicating the roots with = 0 ### ### Required global variables: (boolean LOPsolvable), W a Coxeter group local LOP_size, A, h, c, list_possible_J, list_possible_lambda, k, l, J, lambda, restrictionJ, restrictionlambda; LOP_size := 0; if type = "A" then LOP_size := W.rank + 1; fi; if not w in W then w:=EltWord(W,w); fi; A := BuildMatrix(w,q); h:=NullMat(1, W.rank + CoxeterLength(W,w) + LOP_size); for k in [1..(W.rank )] do h[1][k]:=-1; od; if type = "A" then c:=NullMat(1, W.rank+1); else c:=NullMat(1, W.rank); fi; c[1][1]:=1; ### Iterate over all J, beginning with J of size 1 ### and test with python, if the LOP is solvable. list_possible_J:=Combinations([1..W.rank]); Sort(list_possible_J, function(v,w) return Length(v)