Help:=proc():

if args=NULL then
 print(`The main procedures are:  rPar, rPar1, Children, FPP,FPP1, Bn, Bnk, PBn,Bn2,Bnk2,Rec,Rec2`):
 print(` `):

elif nops([args])=1 and op(1,[args])=rPar then
print(`rPar(M,K,r2): the set of resticted r2-partitions of length M (where 0 is NOT allowed) with the first part equal to K.`):
print(`Try: `):
print(`rPar(3,2,-1);`):


elif nops([args])=1 and op(1,[args])=rPar1 then
print(`rPar1(M,K,r2): the set of resticted r2-partitions of length M (where 0 is NOT allowed) with parts <= K.`):
print(`Try: `):
print(`rPar1(3,2,-1)`):

elif nops([args])=1 and op(1,[args])=Children then
print(`Children(p1,r1,r2): outputs all members p2 of rPar(M,K,r2) (M:=nops(p1),K:=p1[1]) such that p1 p2 are legal first two columns of an (r1,r2)-plane partition.`):
print(`Try: `):
print(`Children([1,2],0,-1)`):

elif nops([args])=1 and op(1,[args])=FPP then
print(`FPP(M,N,K,r1,r2,q): outputs the generating function of (r1,r2)-plane partition whose base in an M by N rectangle and whose first entry is equal to K (with weight q^(sum of parts)/product of parts).`):
print(`Try: `):
print(`FPP(3,1,2,0,0,q);`):

elif nops([args])=1 and op(1,[args])=FPP1 then
print(`FPP1(p1,N,r1,r2,q): outputs the generating function of (r1,r2)-plane partition whose base in an M (M:=nops(p1)) by N rectangle and whose frist row is the partition p1 (with weight q^(sum of parts)/product of parts).`):
print(`Try: `):
print(`FPP1([2,2],2,0,0,q)`):

elif nops([args])=1 and op(1,[args])=Bn then
print(`Bn(n): the fractional count of the set of partitions of n`):
print(`Try: `):
print(`Bn(3)`):

elif nops([args])=1 and op(1,[args])=Bnk then
print(`Bnk(n,k): the fractional count of the set of partitions of n whose largest part is k.`):
print(`Try: `):
print(`Bnk(5,2)`):

elif nops([args])=1 and op(1,[args])=PBn then
print(`PBn(n): the fractional count of the set of plane partions of n`):
print(`Try: `):
print(`PBn(3)`):

elif nops([args])=1 and op(1,[args])=Bn2 then
print(`Bn2(n): the fractional count of the set of plane partitions of n with two rows`):
print(`Try: `):
print(`Bn2(5)`):

elif nops([args])=1 and op(1,[args])=Bnk2 then
print(`Bnk2(n,k1,k2): the fractional count of the set of plane partions of n with two rows whose first column is [k1,k2].`):
print(`Try: `):
print(`Bnk2(5,2,1)`):


elif nops([args])=1 and op(1,[args])=Rec then
print(`Rec(n,k,b): the right hand side of the reccurence relation of k*b(n,k)`):
print(`Try: `):
print(`Rec(10,4,b)`):

elif nops([args])=1 and op(1,[args])=Rec2 then
print(`Rec2(n,k1,k2,b2): the right hand side of the reccurence relation of k1*k2*b2(n,k1,k2)`):
print(`Try: `):
print(`Rec2(9,4,2,b2)`):

else
print(`There is no Help for`,args):
fi:
end:



#rPar(M,K,r2): the set of resticted r-partitions of length M (where 0 is NOT allowed) with the first part equal to K.

rPar:=proc(M,K,r2) local M1,K1,p,S:
option remember:

S:={}:

if M=1 then
RETURN({[K]}):
fi:

for K1 from 1 to K-r2 do

S:=S union {seq([K,op(p)], p in rPar(M-1,K1,r2))}:

od:

S:
end:


#rPar1(M,K,r2): the set of resticted r-partitions of length M (where 0 is NOT allowed) with the first part equal to K and all other parts no greater than K.

rPar1:=proc(M,K,r2) local M1,K1,p,S:
option remember:

S:={}:

if M=1 then
RETURN({[K]}):
fi:

for K1 from 1 to K-r2 do

if K1<=K then

S:=S union {seq([K,op(p)], p in rPar1(M-1,K1,r2))}:
fi:
od:

S:
end:


Children:=proc(p1,r1,r2) local p,s,K1,ch,i,S,S1,K,M:

option remember:

K:=p1[1]:
M:=nops(p1):
if M=1 then
RETURN({seq([i],i=1..K-r1)}):
fi:

S:={}:
p:=p1[2..nops(p1)]:
S1:=Children(p,r1,r2):

for K1 from 1 to K-r1 do
for ch in S1 do
if K1-ch[1]>=r2 then
S:=S union {[K1,op(ch)]}:
fi:
od:
od:

S:

end:




#inputs non-negative integers M, N, K, an integer (pos., neg. or zero) r and a variable (or number) q, 
#and outputs the generating function (with weight q^(Sum of parts)/the product of the parts).

FPP:=proc(M,N,K,r1,r2,q) local gen,p1:
option remember:
gen:=0:

for p1 in rPar(M,K,r2) do

gen:=gen+FPP1(p1,N,r1,r2,q):

od:

gen:
end:




FPP1:=proc(p1,N,r1,r2,q) local S,gen,p2:
option remember:

gen:=0:
if N=1 then
RETURN(q^(convert(p1,`+`))/convert(p1,`*`)):
fi:

S:=Children(p1,r1,r2):

for p2 in S do
gen:=gen+q^(convert(p1,`+`))/convert(p1,`*`)*FPP1(p2,N-1,r1,r2,q):
od:



expand(gen):


end:




Bnk:=proc(n,k) option remember:

if k=1 then 
RETURN(1):
fi:
if k>n then
RETURN(0):
fi:

Bnk(n-1,k-1)*(k-1)/k+Bnk(n-k,k)/k:

end:


#The fractional counting of the partitions of n 
Bn:=proc(n) local k: option remember:

add(Bnk(n,k),k=1..n):

end:





#The fractional counting of plane partions of n

PBn:=proc(n) option remember:

coeff(add(add(add(FPP(M,N,K,0,0,q),M=1..n-K+1),N=1..n-K+1),K=1..n),q,n):

end:


Bnk2:=proc(n,k1,k2) local k11, k21: 
option remember:

if k1<k2 then 
RETURN(0):
fi:

if k1+k2>n then 
RETURN(0):
fi:

if k1+k2=n then
RETURN(1/(k1*k2)):
fi:

if k1<=0 or k2<=0 then
RETURN(FAIL):
fi:


1/(k1*k2)*add(add(Bnk2(n-k1-k2,k11,k21),k11=1..min(k1,n-k1-k2)),k21=1..min(k2,n-k1-k2)):

end:



Bn2:=proc(n) local k1, k2, S:
option remember:

S:=0:

for k1 from 1 to n do
for k2 from 1 to n-k1 do

S:=S+Bnk2(n,k1,k2):

od:
od:

S:
end:



Rec:=proc(n,k,b) local k1:

sum(b(n-k,k1),k1=1..k):

end:

RecD:=proc(n,k,b):
Rec(n,k,b)-Rec(n-1,k-1,b):
end:


Rec2:=proc(n,k1,k2,b2) local k11,k21:

sum(sum(b2(n-k1-k2,k11,k21),k11=1..k1),k21=1..k2):

end:


Rec2D:=proc(n,k1,k2,b):
Rec2(n,k1,k2,b)-Rec2(n-1,k1-1,k2,b)-Rec2(n-1,k1,k2-1,b)+Rec2(n-2,k1-1,k2-1,b):
end:


F2:=proc(k1,k2,q):


q^(k1+k2)*sum(sum(F2(k11,k21,q),k11=1..k1),k21=1..k2):

end:

F2D:=proc(k1,k2,q):

if k2=1 then 
RETURN(q/(1-q)*1/product(1-q^i/i,i=1..30)):
fi:

if k1=1 then
RETURN(add(q^(2*i),i=1..20)):
fi:

(q*F2D(k1-1,k2,q)*(k1-1)*k2+q*F2D(k1,k2-1,q)*(k2-1)*k1-q^2*F2D(k1-1,k2-1,q)*(k1-1)*(k2-1))/(k1*k2-q^(k1+k2)):



#F2(k1,k2,q)-q*F2(k1-1,k2,q)-q*F2(k1,k2-1,q)+q^2*F2(k1-1,k2-1,q):

end: