HOME:
BACK:	Maple Packages

non-symmetric and vanishing Jack & Macdonald polynomials

> # Vanishing_J_M Polynomes de Jack et Macdonald s'annulant
# repris le 30 juillet
# remplace Sahi_t1t2
# AJOUTER cas homogene
# Convention sur ValProp pour avoir positivite quand q1=q, q2=-1
#
#
lprint(`Macdonald et Jack fonctions propres ou s'annulant\
: Macd(v,Q=J,Jn,M,Mn,ff)`);
#
### standardisation a partir des plus hautes valeurs
# [0,0,0] -> [0,1,2] , [0,4,4] -> [2, 0,1]
poids := proc(k,v) local i,res; res:=0;
for i from 1 to k-1 do
if v[i] >=v[k] then res:=res+1;
fi;
od;
for i from k+1 to nops(v) do
if v[i] >v[k] then res:=res+1;
fi;
od;
res;
end:
### u= 1/alpha
# Prendre la meme Val Prop pour 'M' et 'Mn'
ValProp:= proc(v,Q) local i;
if (Q='M' or 'Q'=Mn ) then
[seq( q^v[i]*(q1)^(nops(v)-1 -poids(i,v))*(-q2)^poids(i,v),i=1..nops(v))]
# elif Q='Mn' then
# [seq( q^(-v[i])*(q2)^(nops(v)-1 -poids(i,v))*(-q1)^poids(i,v),i=1..nops(v))]
elif Q='J' then
[seq(-poids(i,v)+v[i]*a,i=1..nops(v))]
elif Q='Jn' then
[seq(-poids(i,v)*u +v[i]*b,i=1..nops(v))]
fi
end:

Phi:=proc(n,pol,Q) local i;
if (Q='J') then
x.n*SgaOnPol(A[n,$(1..n-1)],pol)
elif (Q='Jn') then
(x.n+ u*(n-1))*subs({seq(x.i=x.(i-1),i=2..n),x1=x.n-b},pol)
elif (Q='M') then
(x.n)* subs( { seq(x.(i+1)=x.i,i=1..n-1),x.1=x.n/q},pol)
elif(Q='Mn') then
(x.n- (-q2)^(n-1))* subs( { seq(x.(i+1)=x.i,i=1..n-1),x.1=x.n/q},pol)
fi
end:
#
`Macd/elem`:= proc(k,v,pol,Q) local cv;
cv:=ValProp(v,Q);
if (Q='M' or Q='Mn') then
HekaOnPol( A[$1..k-1,k+1,k] + (q1+q2)/(cv[k+1]/cv[k]-1), pol)
elif (Q='J') then
SgaOnPol( A[$1..k-1,k+1,k]+ 1/(cv[k+1]-cv[k]), pol)
elif (Q='Jn') then
simplify(SgaOnPol( A[$1..k-1,k+1,k]+ u/(cv[k+1]-cv[k]), pol)
+ u*NcaOnPol( A[$1..k-1,k+1,k],pol) )
fi
end:

Macd:=proc(v,Q) local i, j, n, nv;
option remember;
n:=nops(v);
if (subs(0=NULL,v)=[]) then
1
elif (v[n]<>0) then
Phi(n, Macd([ v[n]-1,seq(v[i],i=1..n-1) ],Q), Q)
else
for j from n-1 by -1 to 1 while (v[j]=0) do od;
nv:=subsop(j=v[j+1], j+1=v[j], v);
`Macd/elem`(j, nv, Macd(nv,Q), Q);
fi
end:
#
##### Verification des Annulations ################
# tous les vecteurs dans N^n de poids <= pds
ToutCode := proc(pds,n) local m,i,j,pa,lp,res;
res:=[0$(n)];
for m from 1 to pds do
lp:=ListPart(m,'maxlg'=n);
for i from nops(lp) by -1 to 1 do pa:=lp[i];
res:= res,op(ListPerm(
[0$(n-nops(pa)), seq(pa[nops(pa)-j],j=0..nops(pa)-1)])) ;
od;
od;
res:=[res];
end:
#
Vec2Spec:=proc(v,pol,Q) local i,cv;
cv:=ValProp(v,Q);
subs(seq(x.i=op(i,cv),i=1..nops(v)),pol)
end:
#
# for v in ll do lprint(v, simplify(Vec2Spec(v,aa, M))) od:

ACE>

Cherdnik's Algebra

> ##########################################################
# ########### ALGEBRE DE CHEREDNIK #################
##########################################################
# Options J=Jack homogene , M= Macd homogene Q=ff Hecke avec fonction
# ## Pas defini pour Q='Jn'
## les Macd( v, Mn) ne sont pas vecteurs propres
lprint(` Operateurs de Cherednik: Ksi(i,card,pol,M ou J), KsiInv(..,Mn ou Jn`);
Ksi:=proc(k,n,pol,Q) local i,j,res,fact;
if Q='J' then
convert( [
seq( normal( (pol*x.j-
subs({x.j=x.k,x.k=x.j},pol)*x.k)/(x.k-x.j)),j=1..k-1),
seq( normal( (pol- subs({x.j=x.k, x.k=x.j},pol))*x.j/(x.k-x.j)), j=k+1..n)
],`+`) + a*x.k*diff(pol,x.k)
else
if Q='M' then fact:=1
elif Q='Mn' then fact:= x.n/( x.n- (-q2)^(n-1))
elif Q='ff' then fact:= x.n/ff(x.n)
fi;
res:=pol;
for i from k to n-1 do
res:= HekaOnPol( A[$1..i-1,i+1,i] , res);
od;
res:= res*fact;
res:=subs( { seq(x.i=x.(i+1),i=1..n-1),x.n=q*x.1},res);
for i from 1 to k-1 do
res:= HekaOnPol( A[$1..i-1,i+1,i] -q1-q2 , res);
od;
res;
fi
end:
# Verification
# aa:=Macd([2,0,1],M): seq( simplify(Ksi(i,3,aa,M)/aa), i=1..3);
# bb:=Macd([2,0,1],J): seq( simplify(Ksi(i,3,bb,J)/bb), i=1..3);
#
# inverse a la puissance (-q1q2)^(n-1) pres
# Z!!! Jack n'est pas fonction propre pour Q='J'
KsiInv:=proc(k,n,pol,Q) local i,j,res,fact;
res:=pol;
if Q='Jn' then
for i from k-1 by -1 to 1 do
res:= SgaOnPol(A[$1..i-1,i+1,i],res) +u*NcaOnPol(A[$1..i-1,i+1,i],res);
od;
res:=Phi(n,res,Q);
for i from n-1 by -1 to k do
res:=SgaOnPol(A[$1..i-1,i+1,i],res) +u*NcaOnPol(A[$1..i-1,i+1,i],res) ;
od;
simplify(x.k*pol - res)
else
if Q='M' then fact:=1
elif Q='Mn' then fact:= 1- (-q2)^(n-1)/x.n
elif Q='ff' then fact:= ff(x.n)/x.n
fi;
for i from k-1 by -1 to 1 do
res:= HekaOnPol( A[$1..i-1,i+1,i], res);
od;
res:=subs( { seq(x.i=x.(i-1),i=2..n),x.1=x.n/q},res);
res:= res*fact;
for i from n-1 by -1 to k do
res:= HekaOnPol( A[$1..i-1,i+1,i] -q1-q2 , res);
od;
if Q='Mn' then
simplify( res+ (-q1*q2)^(n-1)*pol/x.k)
else res;
fi;
fi
end:
#
# Verification
# aa:=Macd([2,0,1],M): seq( simplify(KsiInv(i,3,aa,M)/aa), i=1..3);
# aa:=Macd([2,0,1],Mn): seq( simplify(KsiInv(i,3,aa,Mn)/aa), i=1..3);
# bb:=Macd([2,0,1],Jn): seq( simplify(KsiInv(i,3,bb,Jn)/bb), i=1..3);

# ##### Pour les pol de Macdonald homogenes
CoKsiOnPol:=proc(k,n,pol) local i,j, res;
res:=pol;
for i from k to n-1 do
res:= HekaOnPol( A[$1..i-1,i+1,i]-q1-q2 , res);
od;
res:=subs( { seq(x.i=x.(i+1),i=1..n-1),x.n=q*x.1},res);
for i from 1 to k-1 do
res:= HekaOnPol( A[$1..i-1,i+1,i] , res);
od;
res
end:

 Operateurs de Cherednik:  Ksi(i,card,pol,M ou J), KsiInv(..,Mn ou Jn

Symmeterization operations

> ##########################################################
########### SYMETRISATION ##############################
########################################################
Symetrise:=proc(n,pol,Q) local i,j,eul;
if Q='M'or Q='Mn' then
eul:= convert([seq(seq(q1*x.i+q2*x.j, j=i+1..n),i=1..n-1)],`*`);
elif Q='Jn' then
eul:= convert([seq(seq(u+x.i-x.j, j=i+1..n),i=1..n-1)],`*`);
elif Q='J' then
eul:= convert([seq(seq(x.i-x.j, j=i+1..n),i=1..n-1)],`*`);
fi;
NcaOnPol(A[seq(n-i,i=0..n-1)], pol*eul)
end:
#
# IL FAUDRAIT DIVISER PAR LES MULTIPLICITES DES COMPOSANTES DE v
MacSym:=proc(v,Q)
Symetrise(nops(v), Macd(v,Q), Q)
end:
#### Action de la somme des Ksi ou KsiInv suivant le choix de 'Q'
SommeKsi:= proc(n,pol,Q) local i;
if Q=M or Q=J then
simplify( convert([
seq(Ksi(i,n,pol,Q),i=1..n)],`+`))
else
simplify( convert([
seq(KsiInv(i,n,pol,Q),i=1..n)],`+`))
fi;
end:
#
TestSommeKsi:=proc(v,Q) local pol;
pol:=Macd(v,Q);
simplify(SommeKsi(nops(v),pol,Q)/pol)
end:
#
# Symetrise(2,Macd([0,1] ,J),J);
# map(factor,Tos(Tos_n(x2m_n(expand(numer(")))),collect))
#
# Les symetrisations verifient les annulations en degre < |v|
# aa:=Symetrise(3, Macd([0,3,1],Jn), Jn):
# for v in ToutCode(3,3) do lprint(v, simplify(Vec2Spec(v,aa,Jn)) ) od:
#
# Verifie que MacSym(v,J) coincide a un facteur pres, avec
# Part2Jack_m() de Jack_Jenn Parametre u= a
VerifieDeuxJack:=proc(pa,card)
CLG_n(card);
simplify(Tox_n(Part2Jack_m(pa)) /
MacSym([0$(card-nops(pa)),op(sort(pa))], J) )
end:

# Les polynomes de Jack symetriques s'annulant sont pour v=[0..0 1..1]
# des specialisation de polynomes de Schubert YY[0..0 1..1],
# y.i-> i-1, x.j -> x.j +n-1
# de meme que pour tout v, et u specialise en 1
StirlingSpec:=proc(cod) local i;
SpSpecialize(
subs(seq(x.i=x.i+u*(nops(cod)-1),i=1..nops(cod)),Tox(YY[op(cod)])),
'y',i->(i-1)*u)
end:

# simplify( MacSym([0,0,1,1], Jn)/4 / StirlingSpec([0,0,1,1]));

#simplify( subs(u=1,b=1,MacSym([0,1,2], Jn)) /subs(u=1,StirlingSpec([0,1,2])));
#simplify( subs(u=1,b=1,MacSym([2,0,1], Jn)) /subs(u=1,StirlingSpec([0,1,2])));
# simplify( subs(u=1,MacSym([2,0,1], Jn)) /StirlingSpec([0,1,2]));
# ATTENTION : facteur de proportionalite
#

>

>

Examples

> with(ACE):

Macdonald non-symmetric polynomials indexed by a weight vector

ACE> Macd([0,2,1],M);

Macdonald non-symmtric with vanishing properties

ACE> Macd([0,2,1],Mn);

Jack non-symmetric with vanishing properties

ACE> Macd([0,0,1],Jn);

Jack non-symmetric

ACE> Macd([0,0,1],J);

ACE> factor(Macd([0,2,1],Jn));

ACE> factor(Macd([0,2,1],J));

ACE> simplify(subs(u=0,%%));

ACE> Macd([0,0,1],M);

ACE> factor(Symetrise(3,x3,M));

ACE> x2X(%);

ACE> X2Y(%);

ACE> ToY(%%);

ACE>