#######################################################################
## PPar: Save this file as PPar. To use it, stay in the               #
## same directory, get into Maple (by typing: maple <Enter> )         #
## and then type:  read PPar : <Enter>                                #
## Then follow the instructions given there                           #
##                                                                    #
## Written by Doron Zeilberger, Temple University ,                   #
##  zeilberg@math.temple.edu.                                         # 
#######################################################################
#This accompanies Doron Zeilberger's series of articles:
#The Umbral Transfer-Matrix Method. Most specifically, part II
#
#Created: Sept. 29, 2000
#This version: Sept. 29, 2000
#PPar: A Maple package to handle Umbral Schemes
#Please report bugs to zeilberg@math.temple.edu
read(ROTA):
print(`Created:  Sept. 29, 2000.`):
print(`This version: Sept. 29,  2000`):
lprint(``):
print(`Written by Doron Zeilberger, zeilberg@math.temple.edu`):
lprint(``):
print(`Please report bugs to zeilberg@math.temple.edu`):
lprint(``):
 print(`The most current version of this  package and paper`):
 print(` are  available from`):
 print(`http://www.math.temple.edu/~zeilberg/`):
 print(`For a list of the MAIN procedures type Ezra();, for help with`):
 print(`a specific procedure, type Ezra(procedure_name)`):
 
Ezra:=proc()
if args=NULL then
 print(` The  procedures are: `):
 print(` An,  Bk, CheckPercy, GFMT, GFPP, GFPPx, MT, PzAB, PzB, PreUmbraMT`):
 print(` PreUmbraMTTerm ,PreUmbraPP, PreUmbraPPTerm `):
 print(`UmbraMT, UmbralScPP `):
 print(`For help with a procedure type: Ezra(Procedure_Name) ; `):
fi:
 
 
if nops([args])=1 and op(1,[args])=An  then
print(`An(n): all sequences of weakly increasing`):
print(`positive integers [a[1], ..., a[n]] of length r`):
print(`such that a[i]<=i and a[1]<=a[2]<= ... <=a[n]=n`):
print(`For example, try: An(5); `):
fi:
 
if nops([args])=1 and op(1,[args])=Bk then
print(`Bk(k): all subsets of {1,2, ..., k}`):
print(`(interfaces for Monotone Triangles)`):
print(`For example, try: Bk(5); `):
fi:
 
if nops([args])=1 and op(1,[args])=CheckPercy then
print(`CheckPercy(n,r,q): Using the Umbral Scheme`):
print(`for n-rowed plane-partitions, finds`):
print(`the generating function of those`):
print(`with r columns`):
print(`For example, try: CheckPercy(3,2,q); `):
fi:
 
if nops([args])=1 and op(1,[args])=GFMT then
print(`GFMT(x,k): the generating function in x[1],..., x[k] of`):
print(`all monotone triangles with k rows`):
print(`For example, try: GFMT(x,3); `):
fi:
 
if nops([args])=1 and op(1,[args])=GFPP then
print(`GFPP(n,r,q): Using the Umbral Scheme`):
print(`for n-rowed plane-partitions, finds`):
print(`the generating function of those`):
print(`with r columns according to the weight`):
print(`q^(sum of entires)*t^(#of columns)*`):
print(`For example, try: GFPP(3,2,q); `):
fi:
 
if nops([args])=1 and op(1,[args])=GFPPx then
print(`GFPPx(n,x,r,q): Using the Umbral Scheme`):
print(`for n-rowed plane-partitions, finds`):
print(`the generating function of those`):
print(`with r columns according to the weight`):
print(`q^(sum of entires)*t^(#of columns)*`):
print(`x[1]^a[1]*...x[k]^a[k], where a[1], ..., a[k]`):
print(`are the entries of the first column`):
print(`For example, try: GFPPx(3,x,2,q); `):
fi:
 
if nops([args])=1 and op(1,[args])=MT then
print(`MT(resh): the number of Monotone triangles whose bottom is `):
print(`list resh. For example MT([1,2,3,4,5]); should give 429`):
fi:
 
if nops([args])=1 and op(1,[args])=PreUmbraMTTerm then
print(`PreUmbraMTTerm(x,b,k,kvu) : Given a symbol x (denoting an `):
print(`indexed contiuous variable, and a symbol b (denoting an `):
print(`indexed discrete variable, and an interface subset`):
print(`of {1,...,k}, kvu `):
print(`finds how the operator corresponding to the inteface`):
print(`coded by kvu acts on the generic monomial`): 
print(`x[1]^b[1]* ... *x[k]^b[k] to generate all`):
print(`continuation to the (k+1)^th row of a Monotone Triangle`):
print(`whose k^th row is b[1]....b[k] and such that`):
print(`the members of kvu are those i for which a[i+1]=b[i]`):
print(`For example try:`):
print(`PreUmbraMTTerm(x,b,3,{1,2}); `):
 
fi:
 
if nops([args])=1 and op(1,[args])=PreUmbraMT then
print(`PreUmbraMT(x,b,k) : Given a symbol x (denoting an `):
print(`indexed contiuous variable, `):
print(` and a symbol b (denoting an `):
print(` indexed discrete variable, finds the pre-umbra `):
print(` connecting the legal k-th row to those that `):
print(` can be continued to the (k+1)-th row in a monotone triangle `):
print(` In other words, it is the sum of all`):
print(` x[1]^a[1]*x[2]^a[2]*... x[k+1]^a[k+1] `):
print(` summed over all a[1] ... a[k+1] `):
print(` where a[1]<=b[1]<=a[2]<=b[2]<=a[3]<=..b[k]<=a[k+1] `):
print(` and 1<=a[1]<a[2]<... <a[k+1] `):
fi:
 
if nops([args])=1 and op(1,[args])=PreUmbraPP then
print(`PreUmbraPP(x,q,t,b,n): Given a symbol x (denoting an `):
print(`indexed contiuous variable, and a symbol b (denoting an `):
print(`indexed discrete variable, `):
print(` and a symbol q, denoting a (single) continuous variable`):
print(`that is the counter of the sum of elements of the plane partition`):
print(`finds the pre-umbra`):
print(`corresponding to n-rowed plane-partitions`):
print(`of integers, `):
fi:
 
if nops([args])=1 and op(1,[args])=PzAB  then
print(`PzAB(z,A,B): inputs a list of variables z, (of size r,say)`):
print(`and outputs the sum of z[1]^a1*...*a[r]^ar`):
print(`over A>=a1>=a2>=...>=ar>=B`):
print(`For example, type: PzAB(x,B,C); `):
fi:
 
if nops([args])=1 and op(1,[args])=PzB  then
print(`PzB(z,B): inputs a list of variables z, (of size r,say)`):
print(`and outputs the sum of z[1]^a1*...*a[r]^ar`):
print(`over infinity>a1>=a2>=...>=ar>=B`):
print(` For example, type: PzB(y,A); `):
fi:
 
 
if nops([args])=1 and op(1,[args])= PreUmbraPPTerm then
print(`PreUmbraPPTerm(x,b,vec): Given a symbol x (denoting an `):
print(`indexed contiuous variable, and a symbol b (denoting an `):
print(`indexed discrete variable, and an interface vector`):
print(`of integers, vec`):
print(`finds how the operator corresponding to the inteface`):
print(`coded by vec (let k:=nops(vec)) acts on the generic monomial`):
print(`x[1]^b[1]* ... *x[k]^b[k]`):
fi:
 
if nops([args])=1 and op(1,[args])=UmbraMT then
print(`UmbraMT(x,k): The Umbra connecting the k-th`):
print(`row of a monotone triangle to that of the (k+1)-th row`):
print(`For example, type: UmbraMT(x,4); `):
fi:
 
if nops([args])=1 and op(1,[args])=UmbralScPP then
print(`UmbralScPP(x,q,t,n): An Umbral Scheme for n-rowed`):
print(`plane-partitions`):
print(`For example, type UmbralScPP(x,q,t,3); `):
fi:
 
end:
 
#An(n): all sequences of weakly increasing
##such that a[i]<=i and a[1]<=a[2]<= ... <=a[n]=n
An:=proc(n) local gu,r:
gu:={}:
for r from 1 to n do
gu:=gu union Anr(n,r):
od:
gu:
end:
 
 
#Anr(n,r): all sequences of weakly increasing
#positive integers [a[1], ..., a[n]] of length n
#such that a[i]<=i and a[1]<=a[2]<= ... <=a[n]=r
Anr:=proc(n,r)
local gu,m,mu,i:
option remember:
if n=1  then
if r=1 then
RETURN({[1]}):
else
 RETURN({}):
fi:
fi:
 
if r>n then
RETURN({}):
fi:
 
gu:={}:
 
for m from 1 to r do
mu:=Anr(n-1,m):
 
for i from 1 to nops(mu) do
 gu:=gu union {[op(mu[i]),r]}:
od:
 
od:
 
gu:
 
end:
 
 
#PzAB(z,A,B): inputs a list of variables z, (of size r,say)
#and outputs the sum of z[1]^a1*...*a[r]^ar
#over A>=a1>=a2>=...>=ar>=B
PzAB:=proc(z,A,B) local a1,z1:
if nops(z)=0 then RETURN(1): fi:
z1:=[op(2..nops(z),z)]:
normal(sum(PzAB(z1,a1,B)*z[1]^a1,a1=B..A)):
end:
 
#PzB(z,B): inputs a list of variables z, (of size r,say)
#and outputs the sum of z[1]^a1*...*a[r]^ar
#over infinity>a1>=a2>=...>=ar>=B
PzB:=proc(z,B) local i,z1,mu:
if nops(z)=0 then RETURN(1): fi:
z1:=[op(1..nops(z)-1,z)]:
mu:=1:
 
for i from 1 to nops(z) do
mu:=mu*z[i]:
od:
 
z[nops(z)]^B*PzB(z1,B)/(1-mu):
end:
 
 
#ConsStretch(resh,i): given a list, resh, and a place i
#finds the largest j such that resh[i]=...resh[j]
#and also returns resh[i]
ConsStretch:=proc(resh,i)
local j:
for j from i to nops(resh) while resh[j]=resh[i] do
od:
j-1,resh[i]:
end:
 
 
#PreUmbraPPTerm(x,b,vec): Given a symbol x (denoting an 
#indexed contiuous variable, and a symbol b (denoting an 
#indexed discrete variable, and an interface vector
#of integers, vec
#finds how the operator corresponding to the inteface
#coded by vec (let k:=nops(vec)) acts on the generic monomial
#x[1]^b[1]* ... *x[k]^b[k]
PreUmbraPPTerm:=proc(x,b,vec)
local gu,j,n,mu,wi,guj,j1,i:
n:=nops(vec):
gu:=1:
 
j:=ConsStretch(vec,1)[1]:
mu:=[seq(x[j1],j1=1..j)]:
gu:=PzB(mu,b[1]):
 
while j<n do
i:=j+1:
guj:=ConsStretch(vec,i):
wi:=guj[2]:
j:=guj[1]:
mu:=[seq(x[j1],j1=i..j)]:
gu:=gu*PzAB(mu,b[wi-1]-1,b[wi]):
od:
 
gu:
end:
 
 
#PreUmbraPP(x,q,t,b,n): Given a symbol x (denoting an 
#indexed contiuous variable, 
#and symbols q (for the sum of the parts) and
#a symbol t (for the number of columns)
#and a symbol b (denoting an 
#indexed discrete variable, finds the pre-umbra
#
#corresponding to n-rowed plane-partitions
#of integers, 
#finds the weight-enumerator of all extensions of
#a generic extension to [b[1], ..., b[n]]
# 
PreUmbraPP:=proc(x,q,t,b,n)
local mu, gu,i:
mu:=An(n):
 
gu:=0:
 
for i from 1 to nops(mu) do
gu:=gu+PreUmbraPPTerm(x,b,mu[i]):
od:
 
gu:
 
for i from 1 to n do
 gu:=subs(x[i]=q*x[i],gu):
od:
t*gu:
end:
 
#UmbralScPP(x,q,t,n): An Umbral Scheme for n-rowed
#plane-partitions
UmbralScPP:=proc(x,q,t,n)
local b,lu,i,mu,ku:
lu:=PreUmbraPP(x,q,t,b,n):
lu:=ToUmbra(lu,[seq(x[i],i=1..n)],[seq(b[i],i=1..n)]):
lu:=SimplifyUmbra(lu):
[{1},[[lu]],[1],[[seq(x[i],i=1..n)]] ]:
end:
 
qfac:=proc(q,r)
local gu,i:
gu:=1:
for i from 1 to r do
gu:=gu*(1-q^i):
od:
gu:
end:
 
#CheckPercy(n,r,q): Using the Umbral Scheme
#for n-rowed plane-partitions, finds
#the generating function of those
#with r columns
CheckPercy:=proc(n,r,q)
local lu,x,i,mu,t:
lu:=UmbralScPP(x,q,t,n):
lu:=ApplyUmSc(lu,t,r,[seq(x[i],i=1..n)])[2][r]:
mu:=1:
 
for i from 0 to n-1 do
mu:=mu*qfac(q,i)/qfac(q,r+i):
od:
 
evalb(normal(lu/mu)=1):
 
end:
 
 
#Bk(k): all subsets of {1,2, ..., k}
#(interfaces for Monotone Triangles)
Bk:=proc(k) local gu,mu,i:
if k=0 then
RETURN({{}}):
fi:
mu:=Bk(k-1):
gu:=mu:
 
for i from 1 to nops(mu) do
gu:=gu union {mu[i] union {k}}:
od:
gu:
 
end:
 
 
 
#PreUmbraMTTerm(x,b,k,kvu): Given a symbol x (denoting an 
#indexed contiuous variable, and a symbol b (denoting an 
#indexed discrete variable, and an interface subset
#of {1,...,k}, kvu 
#finds how the operator corresponding to the inteface
#coded by kvu acts on the generic monomial
#x[1]^b[1]* ... *x[k]^b[k] to generate all
#continuation to the (k+1)^th row of a Monotone Triangle
#whose k^th row is b[1]....b[k] and such that
#the members of kvu are those i for which a[i+1]=b[i]
PreUmbraMTTerm:=proc(x,b,k,kvu)
local i,gu:
 
if not kvu minus {seq(i,i=1..k)}={} then
ERROR(kvu, `should have been a subset of`, {seq(i,i=1..k)}):
fi:
 
if member(1,kvu) then
gu:=(x[1]-x[1]^b[1])/(1-x[1]):
else
gu:=x[1]*(1-x[1]^b[1])/(1-x[1]):
fi:
 
for i from 2 to k do
if member(i-1,kvu) then
gu:=gu*x[i]^b[i-1]:
else
 if member(i,kvu) then
   gu:=gu*(x[i]^b[i]-x[i]^(b[i-1]+1))/(x[i]-1) :
 else
   gu:=gu*(x[i]^(b[i]+1)-x[i]^(b[i-1]+1))/(x[i]-1) :
 fi:
fi:
od:
 
if member(k,kvu) then
  gu:=gu*x[k+1]^b[k]:
 else
  gu:=gu*x[k+1]^(b[k]+1)/(1-x[k+1]):
fi:
 
gu:
end:
 
 
#PreUmbraMT(x,b,k): Given a symbol x (denoting an 
#indexed contiuous variable, 
#and a symbol b (denoting an 
#indexed discrete variable, finds the pre-umbra
#connecting the legal k-th row to those that
#can be continued to the (k+1)-th row in a monotone triangle
#In other words, it is the sum of all
#x[1]^a[1]*x[2]^a[2]*... x[k+1]^a[k+1]
#summed over all a[1] ... a[k+1]
#where a[1]<=b[1]<=a[2]<=b[2]<=a[3]<=..b[k]<=a[k+1]
#and 1<=a[1]<a[2]<... <a[k+1]
PreUmbraMT:=proc(x,b,k)
local mu, gu,i:
mu:=Bk(k):
 
gu:=0:
 
for i from 1 to nops(mu) do
gu:=gu+PreUmbraMTTerm(x,b,k,mu[i]):
od:
 
normal(gu):
 
end:
 
 
#UmbraMT(x,k): The Umbra connecting the k-th
#row of a monotone triangle to that of the (k+1)-th row
UmbraMT:=proc(x,k)
local lu,b,i:
lu:=PreUmbraMT(x,b,k):
lu:=ToUmbra(lu,[seq(x[i],i=1..k+1)],[seq(b[i],i=1..k)]):
SimplifyUmbra(lu):
end:
 
#GFMT(x,k): the generating function in x[1],..., x[k] of
#all monotone triangles with k rows
GFMT:=proc(x,k)
local lu,mu,i:
option remember:
if k<1 then
ERROR(`k>=1`):
fi:
 
if k=1 then
 RETURN(x[1]/(1-x[1])):
fi:
 
mu:=GFMT(x,k-1):
 
lu:=UmbraMT(x,k-1):
 
normal(ApplyUmbra(lu,mu,[seq(x[i],i=1..k-1)])):
 
end:
 
#MT(resh): the number of Monotone triangles whose bottom is
#resh
MT:=proc(resh)
local x,lu,i,k:
k:=nops(resh):
lu:=GFMT(x,k):
 
for i from 1 to k do
lu:=taylor(lu,x[i]=0,resh[i]+1):
lu:=coeff(lu,x[i],resh[i]):
od:
lu:
end:
 
#GFPPx(n,x,r,q): Using the Umbral Scheme
#for n-rowed plane-partitions, finds
#the generating function of those
#with r columns according to the weight
#q^(sum of entires)*t^(#of columns)*
#x[1]^a[1]*...x[k]^a[k], where a[1], ..., a[k]
#are the entries of the first column
GFPPx:=proc(n,x,r,q)
local lu,t:
lu:=UmbralScPP(x,q,t,n):
lu:=ApplyUmSc(lu,t,r,[])[2][r]:
normal(lu):
end:
 
#GFPP(n,r,q): Using the Umbral Scheme
#for n-rowed plane-partitions, finds
#the generating function of those
#with r columns according to the weight
#q^(sum of entires)*t^(#of columns)
#are the entries of the first column
GFPP:=proc(n,r,q)
local lu,t,i,x:
lu:=UmbralScPP(x,q,t,n):
lu:=ApplyUmSc(lu,t,r,[seq(x[i],i=1..n)])[2][r]:
normal(lu):
end: