######################################################################
## TruncSYT.txt Save this file as Trunc.txt  to use it,              #
# stay in the                                                        #
## same directory, get into Maple (by typing: maple <Enter> )        #
## and then type:  read TruncSYT.txt <Enter>                         #
## Then follow the instructions given there                          #
##                                                                   #
## Written by Doron Zeilberger, Rutgers University ,                 #
##  DoronZeil at gmail dot com                                       #
######################################################################


print(`First Written: May 2025: tested for Maple 2020 `):
print(`Version  : May 2025  `):
print():
print(`This is TruncSYT.txt, A Maple package`):
print(`accompanying  the article `):
print(`" The  Truncated Standard Young Tableaux Calculator " `):
print(` by Ron Adin, Yuval Roichman, and Doron Zeilberger's  `):
print():
print(`The most current version is available on WWW at:`):
print(` http://sites.math.rutgers.edu/~zeilberg/tokhniot/TruncSYT.txt .`):
print(`Please report all bugs to: DoronZeil at gmail dot com .`):
print():
print(`For general help, and a list of the MAIN functions,`):
print(` type "ezra();". For specific help type "ezra(procedure_name);" `):

print(`------------------------------`):

print(`For a list of the supporting functions type: ezra1();`):
print(`  For specific help type "ezra(procedure_name);" `):
print(`------------------------------`):

print(`------------------------------`):

print(`For a list of the STORY functions type: ezraS();`):
print(` For specific help type "ezra(procedure_name);" `):
print(`------------------------------`):


print():






ezraS:=proc()
if args=NULL then

print(`The STORY rocedures are`):
print(` Sefer3, Sefer3r, Sefer4, Sefer4r, Sefer5, Sefer5r, Sefer6, Sefer6r, SeferComps `):

else
ezra(args):

fi:


end:

ezra1:=proc()
if args=NULL then

print(`The SUPPORTING procedures are`):
print(` Comps, Fm, findrec, Hadpes, qfindrec, rf, qfac, qint, qY1, qYF, SolveRec1, Tsyt, YF, `):

else
ezra(args):

fi:


end:

ezra:=proc()
if args=NULL then

print(` TruncSYT.txt: A Maple package for experimenting with Truncated Standard Young Tableaux `):

print(`The MAIN procedures are: AKRseq, CheckAKR, Contest, GuessF, GuessFr, qY, Y, Yg  `):
print(``):


elif nargs=1 and args[1]=AKRseq then
print(`AKRseq(N): The sequence of Adin-King-Roichman, the number of standard Young tableau of truncated shape n^n\(2) for n=2 to n=N. Try:`):
print(`AKRseq(10);`):

elif nargs=1 and args[1]=Comps then
print(`Comps(n,k): the set of compositions of n (including 0) with k parts that add-up to n. Try:`):
print(`Comps(4,2);`):

elif nargs=1 and args[1]=CheckAKR then
print(`CheckAKR(N): checks Conj. 6.1 of Adin-King-Roichman (now Ping Sun's theorem) from n=2 up to n=N. Try:`):
print(`CheckAKR(5);`):

elif nargs=1 and args[1]=Contest then
print(`Contest(r,K,D1): Output the ranked list of compositions of K into r parts, C,  according to the size of the generalized Young tableaux of shape [n$r]+C`):
print(`it also gives the corresponding limiting size compared to the number of YT of [n$r]. D1 is the guessing parameter. Try:`):
print(`Contest(3,2,10);`):

elif nargs=1 and args[1]=findrec then
print(`findrec(f,DEGREE,ORDER,n,N): guesses a recurrence operator annihilating`):
print(`the sequence f of degree DEGREE and order ORDER`):
print(`For example, try: `):
print(` findrec([seq(i,i=1..10)],0,2,n,N);`):
print(` findrec([seq(i!,i=1..10)],1,1,n,N);`):

elif nargs=1 and args[1]=Fm then
print(`Fm(m): prod(i!,i=0..m-1). Try:`):
print(`Fm(6);`):


elif nargs=1 and args[1]=GuessF then
print(`GuessF(A,n,RF,D1): Given a list of non-negative integers A of length r, say, a symbol n, and a symbol RF standing for Raising Factorial, i.e. RF(a,n) means a*(a+1)...*(a+n-1) and a complexity upper bound D1`):
print(`guesses an explicit formula for the number of Adin-King-Roichman style Truncated Young tableaux of shape [n+A[1],....n+A[r]]. For example for`):
print(`3*(n+2) rectanglular shapes where the top row has 2 cells missing on the right, try:`):
print(`GuessF([0,2,2],n,RF,10);`):

elif nargs=1 and args[1]=GuessFr then
print(`GuessFr(L,n,K): Guesses a rational function for the number of tableaux of shape [n$nops(L)]+L divided by the number of tableux of shape [n$nops(L)]. Try:`):
print(`GuessFr([0,2,2,2],n,10);`):

elif nargs=1 and args[1]=Hadpes then
print(`Hadpes(T): prints the tableau T nicely. Try:`):
print(`Hadpes([[1,2,3],[4,5]]);`):

elif nargs=1 and args[1]=qfac then
print(`qfac(i,q): The q-analog of i!. Try:`):
print(`qfac(5,q);`):

elif nargs=1 and args[1]=qfindrec then
print(`qfindrec(f,DEGREE,ORDER,n,N,q): guesses a recurrence operator annihilating`):
print(`the sequence f of expressions in q, of degree DEGREE and order ORDER`):
print(`For example, try: qfindrec([seq(qfac(i,q),i=1..10)],1,1,n,N,1);`):

elif nargs=1 and args[1]=qint then
print(`qint(i,q): qint(i,q): The q-analog of the non-neg. integer i, i.e. 1+q+...+q^(i-1). Try:`):
print(`qint(5,q);`):

elif nargs=1 and args[1]=qY then
print(`qY(L,q): inputs a list of non-neg. integers, and a variable q, outputs the q-analog  (in ths sense of maj-counting) of the number of tableau of shape L where n is at the ith row. `):
print(`When q=1 it is the same as Y(L). Try:`):
print(`qY([2,3,4],q); `):

elif nargs=1 and args[1]=qY1 then
print(`qY1(L,i,q): inputs a list of non-neg. integers, and a row number i,  outputs the q-analog  of the number of tableau of shape L where n is at the ith row. Try:`):
print(`qY1([2,3,4],2,q);`):


elif nargs=1 and args[1]=qYF then
print(`qYF(L,q): The Young-Frobenius formula. Try:`):
print(`qYF([3,2,1],q);`):


elif nargs=1 and args[1]=rf then
print(`rf(a,n): The raising factorial (a)_n i.e. a(a+1)...(a+n-1). Try:`):
print(`rf(a,5);`):

elif nargs=1 and args[1]=Sefer3 then
print(`Sefer3(A,n,RF,D1): inputs a positive integer A, and a variable n, and a symbol RF for rising factorial, outputs an article with conjectured formulas for the number of truncated Young tableaux with`):
print(`3 rows of shape [n,n+a1,n+a2] for all 0<=a1,a2<=A  and a2<a1 with the polynomial part of degree up to D1. Try:`):
print(`Sefer3(5,n,RF,10);`):


elif nargs=1 and args[1]=Sefer3r then
print(`Sefer3r(A,n,D1): inputs a positive integer A, and a variable n,  outputs an article with conjectured formulas for the number of truncated Young tableaux with`):
print(`3 rows of shape [n,n+a1,n+a2] for all 0<=a1,a2<=A  and a2<a1 with the polynomial part of degree up to D1, divided by the number of SYT of shaper [n,n,n], so you get`):
print(`rational functions.  Try:`):
print(`Sefer3r(5,n,10);`):


elif nargs=1 and args[1]=Sefer4 then
print(`Sefer4(A,n,RF,D1): inputs a positive integer A, and a variable n, and a symbol RF for rising factorial, outputs an article with conjectured formulas for the number of truncated Young tableaux with`):
print(`4 rows of shape [n,n+a1,n+a2,n+a3] for all 0<=a1,a2,a3<=A  and a3<a2 with the polynomial part of degree up to D1. Try:`):
print(`Sefer4(5,n,RF,15);`):


elif nargs=1 and args[1]=Sefer4r then
print(`Sefer4r(A,n,D1): inputs a positive integer A, and a variable n,  outputs an article with conjectured formulas for the number of truncated Young tableaux with`):
print(`3 rows of shape [n,n+a1,n+a2,n+a3] for all 0<=a1,a2,a3<=A  and a2<a1 with the polynomial part of degree up to D1, divided by the number of SYT of shaper [n,n,n,n], so you get`):
print(`rational functions.  Try:`):
print(`Sefer4r(5,n,10);`):



elif nargs=1 and args[1]=Sefer5 then
print(`Sefer5(A,n,RF,D1): inputs a positive integer A, and a variable n, and a symbol RF for rising factorial, outputs an article with conjectured formulas for the number of truncated Young tableaux with`):
print(`5 rows of shape [n,n+a1,n+a2,n+a3,n+a4] for all 0<=a1,a2,a3,a4<=A  and a4<a3 with the polynomial part of degree up to D1. Try:`):
print(`Sefer5(3,n,RF,15);`):



elif nargs=1 and args[1]=Sefer5r then
print(`Sefer5r(A,n,D1): inputs a positive integer A, and a variable n, outputs an article with conjectured formulas for the number of truncated Young tableaux with`):
print(`5 rows of shape [n,n+a1,n+a2,n+a3,n+a4], divided by the number of SYT of shape [n,n,n,n,n] for all 0<=a1,a2,a3,a4<=A  and a4<a3 with the polynomial part of degree up to D1. Try:`):
print(`Sefer5r(3,n,15);`):


elif nargs=1 and args[1]=Sefer6 then
print(`Sefer6(A,n,RF,D1): inputs a positive integer A, and a variable n, and a symbol RF for rising factorial, outputs an article with conjectured formulas for the number of truncated Young tableaux with`):
print(`6 rows of shape [n,n+a1,n+a2,n+a3,n+a4,n+a5] for all 0<=a1,a2,a3,a4,a5<=A  and a5 <a4. with the polynomial part of degree up to D1. Try:`):
print(`Sefer6(1,n,RF,15);`):


elif nargs=1 and args[1]=Sefer6r then
print(`Sefer6r(A,n,D1): inputs a positive integer A, and a variable n,  outputs an article with conjectured formulas for the number of truncated Young tableaux with`):
print(`6 rows of shape [n,n+a1,n+a2,n+a3,n+a4,n+a5] for all 0<=a1,a2,a3,a4,a5<=A  and a5 <a4, divided by the number of syt of shape [n$6], with the polynomial part of degree up to D1. Try:`):
print(`Sefer6r(1,n,15);`):


elif nargs=1 and args[1]=SeferComps then
print(`SeferComps(R,K,D1): for number of rows from 3 to R and values K1 from 1 to K it lists`):
print(`the ranked list of compositions of K1 into `):
print(`generalized shapes [n$r]+C where C is a compositon of K1 into r parts`):
print(`according to the number of standard young tableau. It gives the limit of the ratios`):
print(`to the number of SYT of shaper [n$r]. Try:`):
print(`SeferComps(4,2,12);`):

elif nargs=1 and args[1]=SolveRec1 then
print(`SolveRec1(lu,n,RF): Solves the recurrence f(n+1)/f(n)=lu. Try:, RF is the symbol for the rising factorial RF(a,n)=a(a+1)*..*(a+n-1).`):
print(` SolveRec1((n+1)*(n+4)*(n^2+2*n+2)/((n+5)*(n+11)*(n^2+1)),n,RF);`):

elif nargs=1 and args[1]=Tsyt then
print(`Tsyt(L): all the standard young tableaux of shape L. Try:`):
print(`Tsyt([1,2]);`):

elif nargs=1 and args[1]=Y then
print(`Y(L): inputs a list of non-neg. integers L, outputs the number of tableau of shape L. Note that L does not have to be weakly decreasing. If it is not it some kind of truncated tableau. Try:`):
print(`Y([2,3,4]);`):

elif nargs=1 and args[1]=Yg then
print(`Yg(L,b): inputs a list of non-neg. integers, L, and another list of on-neg. intgers b, of the same length, outputs the number of shifted tableau of shape L`):
print(`where row i starts b[i], cells to the right. Yg(L,[0$nops(L)]) is the same as Y(L). Try:`):
print(`Yg([2,3,4],[0,1,2]);`):

elif nargs=1 and args[1]=YF then
print(`YF(L): The Young-Frobenius formula. Try:`):
print(`YF([3,2,1]);`):


else
 print(`There is no such thing as`, args):

fi:


end:




#####From FindRec



Yafe:=proc(ope,N) local i,ope1,coe1,L: 
if ope=0 then
 RETURN(1,0):
fi:
ope1:=expand(ope):
L:=degree(ope1,N):
coe1:=coeff(ope1,N,L):
ope1:=normal(ope1/coe1):
ope1:=normal(ope1):
ope1:=
convert(
[seq(factor(coeff(ope1,N,i))*N^i,i=ldegree(ope1,N)..degree(ope1,N))],`+`):
factor(coe1),ope1:
end:
 
#findrec(f,DEGREE,ORDER,n,N): guesses a recurrence operator annihilating
#the sequence f of degree DEGREE and order ORDER
#For example, try: findrec([seq(i,i=1..10)],0,2,n,N);
findrec:=proc(f,DEGREE,ORDER,n,N)
local ope,var,eq,i,j,n0,kv,var1,eq1,mu,a:
option remember:


if (1+DEGREE)*(1+ORDER)+5+ORDER>nops(f) then
ERROR(`Insufficient data for a recurrence of order`,ORDER, `degree`,DEGREE):
fi:
ope:=0:
var:={}:
 
for i from 0 to ORDER do
 for j from 0 to DEGREE do
  ope:=ope+a[i,j]*n^j*N^i:
  var:=var union {a[i,j]}:
 od:
od:
    
eq:={}:
 
for n0 from 1 to (1+DEGREE)*(1+ORDER)+4 do
  eq1:=0:
 
  for i from 0 to ORDER do
     eq1:=eq1+subs(n=n0,coeff(ope,N,i))*op(n0+i,f):
  od:
 
   eq:= eq union {eq1}:
od:
 
var1:=solve(eq,var):
 
kv:={}:
 
for i from 1 to nops(var1) do
 mu:=op(i,var1):
 
if op(1,mu)=op(2,mu) then
   kv:= kv union {op(1,mu)}:
 fi:
 
od:

ope:=subs(var1,ope):

if ope=0 then
  RETURN(FAIL):
fi:

ope:={seq(coeff(expand(ope),kv[i],1),i=1..nops(kv))} minus {0}:

if nops(ope)>1 then
RETURN(Yafe(ope[1],N)[2]):
elif nops(ope)=1 then
RETURN(Yafe(ope[1],N)[2]):
else
 RETURN(FAIL):
fi:

end:



 
#qfindrec(f,DEGREE,ORDER,n,N,q): guesses a recurrence operator annihilating
#the sequence f of expressions in q, of degree DEGREE and order ORDER
#For example, try: qfindrec([seq(qfac(i,q),i=1..10)],1,1,n,N,1);
qfindrec:=proc(f,DEGREE,ORDER,n,N,q)
local ope,var,eq,i,j,n0,kv,var1,eq1,mu,a:
option remember:


if (1+DEGREE)*(1+ORDER)+5+ORDER>nops(f) then
ERROR(`Insufficient data for a recurrence of order`,ORDER, `degree`,DEGREE):
fi:


if findrec(subs(q=1,f),DEGREE,ORDER,n,N,q)=FAIL then
 RETURN(FAIL):
fi:

ope:=0:
var:={}:
 
for i from 0 to ORDER do
 for j from 0 to DEGREE do
  ope:=ope+a[i,j]*(q^n)^j*N^i:
  var:=var union {a[i,j]}:
 od:
od:
    
eq:={}:
 
for n0 from 1 to (1+DEGREE)*(1+ORDER)+4 do
  eq1:=0:
 
  for i from 0 to ORDER do
     eq1:=eq1+subs(n=n0,coeff(ope,N,i))*op(n0+i,f):
  od:
 
   eq:= eq union {eq1}:
od:


 
var1:=solve(eq,var):
 
kv:={}:
 
for i from 1 to nops(var1) do
 mu:=op(i,var1):
 
if op(1,mu)=op(2,mu) then
   kv:= kv union {op(1,mu)}:
 fi:
 
od:

ope:=subs(var1,ope):

if ope=0 then
  RETURN(FAIL):
fi:

ope:={seq(coeff(expand(ope),kv[i],1),i=1..nops(kv))} minus {0}:

if nops(ope)>1 then
RETURN(Yafe(ope[1],N)[2]):
elif nops(ope)=1 then
RETURN(Yafe(ope[1],N)[2]):
else
 RETURN(FAIL):
fi:

end:

#####End From FindRec

#GP1(L,n,d): Inputs a list of numbers L and a variable n and a non-neg. d outputs the polynomial of degree d
#P(n), such that P(i)=L[i], for all i from 1 to nops(L). OR FAIL
#nops(L)>=d+2
GP1:=proc(L,n,d) local a,i,P,eq,var:
if nops(L)<d+2 then
 ERROR(`List too short`):
 fi:
#P=a[0]+a[1]*n+...+a[d]*n^d
P:=add(a[i]*n^i,i=0..d):
var:={seq(a[i],i=0..d)}:
eq:={seq(L[i]=subs(n=i,P),i=1..d+2)}:
var:=solve(eq,var):
 if var=NULL then
   RETURN(FAIL):
 fi:
P:=subs(var,P):
if {seq(L[i]-subs(n=i,P),i=d+3..nops(L))}<>{0} then
  RETURN(FAIL):
 fi:
P:
end:



#GP(L,n): Inputs a list of numbers L and a variable n and outputs the polynomial of degree <=nops(L)-2
#P(n), such that P(i)=L[i], for all i from 1 to nops(L). OR FAIL
#nops(L)>=d+2
GP:=proc(L,n) local d,P:
for d from 0 to nops(L)-2 do
 P:=GP1(L,n,d):
 if P<>FAIL then
    RETURN(P):
 fi:
od:
FAIL:
end:


#Y(L): inputs a list of non-neg. integers L, outputs the number of tableau of shape L. Try:
#Y([2,3,4]);
Y:=proc(L)  local gu,L1,k,i:
option remember:
k:=nops(L):
if L=[0$k] then
 RETURN(1):
fi:
gu:=0:

for i from 1 to k-1 do

 if L[i]>0 and L[i]>L[i+1] then
  L1:=[op(1..i-1,L),L[i]-1,op(i+1..k,L)]:  
  gu:=gu+Y(L1):
 fi:
od:

 if L[k]>0 then
  L1:=[op(1..k-1,L),L[k]-1]:
  gu:=gu+Y(L1):
 fi:

gu:
end:


#AKRseq(N): The sequence of Adin-King-Roichman, the number of standard Young tableau of truncated shape n^n\(2) for n=2 to n=N. Try:
#AKRseq(10);
AKRseq:=proc(N) local n:
[seq(Y([n-2,n$(n-1)]),n=2..N)]:
end:

#Fm(m): prod(i!,i=0..m-1). Try:
#Fm(6);
Fm:=proc(m) local i: mul(i!,i=0..m-1):end:


#CheckAKR(N): checks Conj. 6.1 of Adin-King-Roichman (now Ping Sun's theorem) from n=2 up to n=N. Try:
#CheckAKR(5);
CheckAKR:=proc(N) local n:
evalb(AKRseq(N)=[seq(Fm(n-2)^2/Fm(2*n-4)*(n^2-2)!*(3*n-4)!^2*6/(6*n-8)!/(2*n-2)!/(n-2)!^2,n=2..N)]):
end:


#AKRseqG(T1,N): The sequence of Adin-King-Roichman, the number of standard Young tableau of truncated shape n^n\T for n=2 to n=N. Try:
AKRseqG:=proc(T1,N) local n,i:
if T1=[] then
[seq(Y([n$(n)]),n=1..N)]:
else
[seq(Y([seq(n-T1[i],i=1..nops(T1)),n$(n-nops(T1))]),n=T1[1]..N)]:
fi:
end:




#rf(a,n): The raising factorial (a)_n i.e. a(a+1)...(a+n-1). Try:
#rf(a,5);
rf:=proc(a,n):
(a+n-1)!/(a-1)!:
end:

#SolveRec1(lu,n,RF): Solves the recurrence f(n+1)/f(n)=lu. Try:, RF is the symbol for the rising factorial.
#SolveRec1((4*n+1)*(6*n+1)/((5*n+1)*(7*n+1))*((n+1)^1+1)/(n^2+1),n):
SolveRec1:=proc(lu,n,RF) local lu1,T1,B1,i,ka1,Ptop,Pbot,mone,mekh,c,ka10,ka11,gu:

lu1:=factor(lu):

mone:=numer(lu1):
mekh:=denom(lu1):


if not (type(mone,`*`) and type(mekh,`*`)) then
 print(`Not yet implemented`):
RETURN(FAIL):
fi:

c:=1:

T1:=[]:
B1:=[]:
Ptop:=1:
Pbot:=1:

for i from 1 to nops(mone) do
 ka1:=op(i,mone):
 
if degree(ka1,n)=0 then
  c:=c*ka1:

elif degree(ka1,n)=1 then
 c:=c*coeff(ka1,n,1):
 T1:=[op(T1),coeff(ka1,n,0)/coeff(ka1,n,1)]:

elif type(ka1,`^`) and degree(op(1,ka1),n)=1 then
  ka10:=op(1,ka1):
  ka11:=op(2,ka1):
 c:=c*coeff(ka10,n,1)^ka11:
 T1:=[op(T1),(coeff(ka10,n,0)/coeff(ka10,n,1))$ka11]:
else

Ptop:=Ptop*ka1:
fi:

od:


for i from 1 to nops(mekh) do
 ka1:=op(i,mekh):
 
if degree(ka1,n)=0 then
  c:=c/ka1:
elif degree(ka1,n)=1 then
 c:=c/coeff(ka1,n,1):
 B1:=[op(B1),coeff(ka1,n,0)/coeff(ka1,n,1)]:

elif type(ka1,`^`) and degree(op(1,ka1),n)=1 then
  ka10:=op(1,ka1):
  ka11:=op(2,ka1):
 c:=c/coeff(ka10,n,1)^ka11:
 B1:=[op(B1),(coeff(ka10,n,0)/coeff(ka10,n,1))$ka11]:
else
Pbot:=Pbot*ka1:
fi:

od:

if expand(subs(n=n+1,Pbot)-Ptop)<>0 then
 RETURN(FAIL):
fi:

gu:=c^n*mul(RF(T1[i],n),i=1..nops(T1))/mul(RF(B1[i],n),i=1..nops(B1))*Pbot:

gu:


end:


#GuessF(A,n,RF,D1): Given a list of non-negative integers A of length r, say, a symbol n, and a symbol RF standing for Raising Factorial, i.e. RF(a,n) means a*(a+1)...*(a+n-1) and a complexity upper bound D1
#guesses an explicit formula for the number of Adin-King-Roichman style Truncated Young tableaux of shape [n+A[1],....n+A[r]]. For example for
#3*(n+2) rectanglular shapes where the top row has 2 cells missing on the right, try:
#GuessF([0,2,2],n,RF,10);

GuessF:=proc(A,n,RF,D1) local gu,i,ope,lu,ku,ku1,N,n1,gu1,c:

gu:=[seq(Y([seq(n1+A[i],i=1..nops(A))]),n1=1..2*D1+8)]:


ope:=findrec(gu,D1,1,n,N):

if ope=FAIL then
 RETURN(FAIL):
fi:

lu:=-coeff(ope,N,0):
ku:=SolveRec1(lu,n,RF):


if ku=FAIL then
 RETURN(FAIL):
fi:



ku1:=SolveRec1(lu,n,rf):


gu1:=simplify([seq(eval(subs(n=i,ku1)),i=1..nops(gu))]):

c:=gu[1]/gu1[1]:

ku:=c*ku:
ku1:=c*ku1:

gu1:=simplify([seq(eval(subs(n=i,ku1)),i=1..nops(gu))]):

if gu<>gu1 then
 print(ku, `did not work out`):

 print(gu,gu1):

 RETURN(FAIL):
fi:

ku:

end:




#Yg(L,b): inputs a list of non-neg. integers, L, and another list of on-neg. intgers b, of the same length, outputs the number of shifted tableau of shape L
#where row i starts b[i], cells to the right. Yg(L,[0$nops(L)]) is the same as Y(L). Try:
#Yg([2,3,4],[0,1,2]);
Yg:=proc(L,b)  local gu,L1,k,i:
option remember:
k:=nops(L):
if L=[0$k] then
 RETURN(1):
fi:

if L[k]=0 then
 RETURN(Yg([op(1..k-1,L)],[op(1..k-1,b)])):
fi:


gu:=0:

for i from 1 to k-1 do

 if L[i]>0 and L[i]+b[i]>L[i+1]+b[i+1] then
  L1:=[op(1..i-1,L),L[i]-1,op(i+1..k,L)]:  
  gu:=gu+Yg(L1,b):
 fi:
od:

 if L[k]>0 then
  L1:=[op(1..k-1,L),L[k]-1]:
  gu:=gu+Yg(L1,b):
 fi:

gu:
end:








#qY1(L,i,q): inputs a list of non-neg. integers, and a row number i,  outputs the q-analog  of the number of tableau of shape L where n is at the ith row. Try:
#qY1([2,3,4],2,q);
qY1:=proc(L,i,q)  local gu,L1,k,j,n:
option remember:
k:=nops(L):

n:=convert(L,`+`):

if k=1 then
if i<>1 then
 RETURN(0):
else
RETURN(1):
fi:
fi:

if L[k]=0 then
if i=k then
 RETURN(0):
else
 RETURN(qY1([op(1..k-1,L)],i,q)):
fi:
fi:

if i<k and not L[i]>L[i+1] then
 RETURN(0):
fi:

L1:=[op(1..i-1,L),L[i]-1,op(i+1..k,L)]:

gu:=0:

for j from 1 to i-1 do
 gu:=expand(gu+q^(n-1)*qY1(L1,j,q)):
od:

for j from i to k do
 gu:=expand(gu+qY1(L1,j,q)):
od:

gu:

end:


#qY(L,q): inputs a list of non-neg. integers, and a variable q, outputs the q-analog  (in ths sense of maj-counting) of the number of tableau of shape L where n is at the ith row. 
#When q=1 it is the same as Y(L). Try:
#qY([2,3,4],q); 
qY:=proc(L,q)  local i:
factor(expand(add(qY1(L,i,q),i=1..nops(L)))):
end:


#YF(L): The Young-Frobenius formula. Try:
#YF([3,2,1]);
YF:=proc(L) local k,i,j:
k:=nops(L):
convert(L,`+`)!/mul((L[i]+k-i)!,i=1..k)*mul(mul(((L[i]+k-i)-(L[j]+k-j)),j=i+1..k),i=1..k):
end:


#qint(i,q): qint(i,q): The q-analog of the non-neg. integer i, i.e. 1+q+...+q^(i-1). Try:
#qint(5,q);
qint:=proc(i,q) :normal((1-q^i)/(1-q)): end:


#qfac(i,q): The q-analog of i!
qfac:=proc(i,q) local j:mul(qint(j,q),j=1..i):end:


#YFq(L): The Young-Frobenius formula. Try:
#YF([3,2,1]);
qYF:=proc(L,q) local k,i,j:
k:=nops(L):
factor(normal((1/q^binomial(k,3))*qfac(convert(L,`+`),q)/mul(qfac(L[i]+k-i,q),i=1..k)*mul(mul((qint(L[i]+k-i,q)-qint(L[j]+k-j,q)),j=i+1..k),i=1..k))):
end:


#Sefer3(A,n,RF,D1): inputs a positive integer A, and a variable n, and a symbol RF for rising factorial, outputs an article with conjectured formulas for the number of truncated Young tableaux with
#3 rows of shape [n,n+a1,n+a2] for all 0<=a1<=a2<=A, with the polynomial part of degree up to D1. Try:
#Sefer3(5,n,RF,10);
Sefer3:=proc(A,n,RF,D1)  local a1,a2,t0,gu:
t0:=time():
print(``):
print(` Conjectured Explicit Formulas Enumerating 3-rowed Truncated Standard Young Tableau of shape [n,n+a1,n+a2] for a from 0<=a1,a2<=`, A, `and a2<a1 `):
print(``):
print(`By Shalosh B. Ekhad `):
print(``):

print(`Let RF(a,n) be the raising factorial: a(a+1)...(a+n-1);`):

for a1 from 0 to A do
for a2 from 0 to a1-1 do
print(``):
gu:=GuessF([0,a1,a2],n,RF,D1):

if gu<>FAIL then
print(`Theorem: The number of 3-rowed Truncated Standard Young Tableaux of shape`, [n,n+a1,n+a2], ` is `):
print(``):
print(gu):
print(``):
print(`and in Maple notation`):
print(``):
lprint(gu):
print(``):
fi:
od:
od:

print(``):
print(`-------------------------`):
print(``):
print(`This ends this article that took`, time()-t0, `seconds to produce. `):
print(``):

end:


#Sefer3r(A,n,D1): inputs a positive integer A, and outputs an article with conjectured formulas for the number of truncated Young tableaux with
#3 rows of shape [n,n+a1,n+a2] for all 0<=a1<=a2<=A, with the polynomial part of degree up to D1 in terms of YF([n$3]. Try:
#Sefer3r(5,n,10);
Sefer3r:=proc(A,n,D1)  local a1,a2,t0,gu:
t0:=time():
print(``):
print(` Conjectured Explicit Formulas Enumerating 3-rowed Truncated Standard Young Tableau of shape [n,n+a1,n+a2] for a from 0<=a1,a2<=`, A, `and a2<a1 `):
print(``):
print(`By Shalosh B. Ekhad `):
print(``):

for a1 from 0 to A do
for a2 from 0 to a1-1 do
print(``):
gu:=GuessFr([0,a1,a2],n,D1):

if gu<>FAIL then
print(`Theorem: The number of 3-rowed Truncated Standard Young Tableaux of shape`, [n,n+a1,n+a2], ` is  the number of SYT of shape`, [n$3], `times `):
print(``):
print(gu):
print(``):
print(`and in Maple notation`):
print(``):
lprint(gu):
print(``):
fi:
od:
od:

print(``):
print(`-------------------------`):
print(``):
print(`This ends this article that took`, time()-t0, `seconds to produce. `):
print(``):

end:

#Sefer4(A,n,RF,D1): inputs a positive integer A, and a variable n, and a symbol RF for rising factorial, outputs an article with conjectured formulas for the number of truncated Young tableaux with
#4 rows of shape [n,n+a1,n+a2,n+a3] for all 0<=a1<=a2<=a3<=A, with the polynomial part of degree up to D1. Try:
#Sefer4(5,n,RF,10);
Sefer4:=proc(A,n,RF,D1)  local a1,a2,a3,t0,gu:
t0:=time():
print(``):
print(` Conjectured Explicit Formulas Enumerating 4-rowed Truncated Standard Young Tableau of shape [n,n+a1,n+a2,n+a3] for a from 0<=a1,a2,a3<=`, A, `and a3<a2 `):
print(``):
print(`By Shalosh B. Ekhad `):
print(``):

print(`Let RF(a,n) be the raising factorial: a(a+1)...(a+n-1);`):

for a1 from 0 to A do
for a2 from 0 to A do
for a3 from 0 to a2-1 do
print(``):

gu:=GuessF([0,a1,a2,a3],n,RF,D1):

if gu<>FAIL then
print(`Theorem: The number of 4-rowed Truncated Standard Young Tableaux of shape`, [n,n+a1,n+a2,n+a3], ` is `):
print(``):
print(gu):
print(``):
print(`and in Maple notation`):
print(``):
lprint(gu):
print(``):
fi:
od:
od:
od:

print(``):
print(`-------------------------`):
print(``):
print(`This ends this article that took`, time()-t0, `seconds to produce. `):
print(``):

end:


#Sefer4r(A,n,D1): inputs a positive integer A, and a variable n, and a symbol RF for rising factorial, outputs an article with conjectured formulas for the number of truncated Young tableaux with
#4 rows of shape [n,n+a1,n+a2,n+a3] for all 0<=a1<=a2<=a3<=A, with the polynomial part of degree up to D1. Try:
#Sefer4r(5,n,10);
Sefer4r:=proc(A,n,D1)  local a1,a2,a3,t0,gu:
t0:=time():
print(``):
print(` Conjectured Explicit Formulas Enumerating 4-rowed Truncated Standard Young Tableau of shape [n,n+a1,n+a2,n+a3] for a from 0<=a1,a2,a3<=`, A, `and a3<a2  divided by the number syt of shape`, [n$4]):
print(``):
print(`By Shalosh B. Ekhad `):
print(``):


for a1 from 0 to A do
for a2 from 0 to A do
for a3 from 0 to a2-1 do
print(``):

gu:=GuessFr([0,a1,a2,a3],n,D1):

if gu<>FAIL then
print(`Theorem: The number of 4-rowed Truncated Standard Young Tableaux of shape`, [n,n+a1,n+a2,n+a3], ` is  the number of syt of [n$4] `):
print(``):
print(gu):
print(``):
print(`and in Maple notation`):
print(``):
lprint(gu):
print(``):
fi:
od:
od:
od:

print(``):
print(`-------------------------`):
print(``):
print(`This ends this article that took`, time()-t0, `seconds to produce. `):
print(``):

end:



#Sefer5(A,n,RF,D1): inputs a positive integer A, and a variable n, and a symbol RF for rising factorial, outputs an article with conjectured formulas for the number of truncated Young tableaux with
#5 rows of shape [n,n+a1,n+a2,n+a3,n+a4] for all 0<=a1,a2,a3,a4<=A, and a4<a3 with the polynomial part of degree up to D1. Try:
#Sefer5(5,n,RF,10);
Sefer5:=proc(A,n,RF,D1)  local a1,a2,a3,a4,t0,gu:
t0:=time():
print(``):
print(` Conjectured Explicit Formulas Enumerating 5-rowed Truncated Standard Young Tableau of shape [n,n+a1,n+a2,n+a3,n+a4] for a from 0<=a1,a2,a3,a4<= `, A, `and a4<a3 `):
print(``):
print(`By Shalosh B. Ekhad `):
print(``):

print(`Let RF(a,n) be the raising factorial: a(a+1)...(a+n-1);`):

for a1 from 0 to A do
for a2 from 0 to A do
for a3 from 0 to A do
for a4 from 0 to a3-1 do
print(``):

gu:=GuessF([0,a1,a2,a3,a4],n,RF,D1):

if gu<>FAIL then
print(`Theorem: The number of 5-rowed Truncated Standard Young Tableaux of shape`, [n,n+a1,n+a2,n+a3,n+a4], ` is `):
print(``):
print(gu):
print(``):
print(`and in Maple notation`):
print(``):
lprint(gu):
print(``):
fi:
od:
od:
od:
od:
print(``):
print(`-------------------------`):
print(``):
print(`This ends this article that took`, time()-t0, `seconds to produce. `):
print(``):

end:


#Sefer5r(A,n,D1): inputs a positive integer A, and a variable n, and a symbol RF for rising factorial, outputs an article with conjectured formulas for the number of truncated Young tableaux with
#5 rows of shape [n,n+a1,n+a2,n+a3,n+a4] for all 0<=a1,a2,a3,a4<=A, and a4<a3 with the polynomial part of degree up to D1. It is divided by SYT([n$5]. Try:
#Sefer5r(5,n,10);
Sefer5r:=proc(A,n,D1)  local a1,a2,a3,a4,t0,gu:
t0:=time():
print(``):
print(` Conjectured Explicit Formulas Enumerating 5-rowed Truncated Standard Young Tableau of shape [n,n+a1,n+a2,n+a3,n+a4] for a from 0<=a1,a2,a3,a4<= `, A, `and a4<a3, divided by the numer of SYT of shape `, [n$5]):
print(``):
print(`By Shalosh B. Ekhad `):
print(``):


for a1 from 0 to A do
for a2 from 0 to A do
for a3 from 0 to A do
for a4 from 0 to a3-1 do
print(``):

gu:=GuessFr([0,a1,a2,a3,a4],n,D1):

if gu<>FAIL then
print(`Theorem: The number of 5-rowed Truncated Standard Young Tableaux of shape`, [n,n+a1,n+a2,n+a3,n+a4], `  divided by the number of SYT of shape [n,n,n,n,n] is `):
print(``):
print(gu):
print(``):
print(`and in Maple notation`):
print(``):
lprint(gu):
print(``):
fi:
od:
od:
od:
od:
print(``):
print(`-------------------------`):
print(``):
print(`This ends this article that took`, time()-t0, `seconds to produce. `):
print(``):

end:




#Sefer6(A,n,RF,D1): inputs a positive integer A, and a variable n, and a symbol RF for rising factorial, outputs an article with conjectured formulas for the number of truncated Young tableaux with
#6 rows of shape [n,n+a1,n+a2,n+a3,n+a4,n+a5] for all 0<=a1<=a2<=a3<=a3<=a4<=A, with the polynomial part of degree up to D1. Try:
#Sefer6(2,n,RF,10);
Sefer6:=proc(A,n,RF,D1)  local a1,a2,a3,a4,a5,t0,gu:
t0:=time():
print(``):
print(` Conjectured Explicit Formulas Enumerating 6-rowed Truncated Standard Young Tableau of shape [n,n+a1,n+a2,n+a3,n+a4,n+a5] for a from 0<=a1,a2,a3,a4,a5<= `, A, `and a5<a4 `):
print(``):
print(`By Shalosh B. Ekhad `):
print(``):

print(`Let RF(a,n) be the raising factorial: a(a+1)...(a+n-1);`):

for a1 from 0 to A do
for a2 from 0 to A do
for a3 from 0 to A do
for a4 from 0 to A do
for a5 from 0 to a4-1 do
print(``):

gu:=GuessF([0,a1,a2,a3,a4,a5],n,RF,D1):

if gu<>FAIL then
print(`Theorem: The number of 6-rowed Truncated Standard Young Tableaux of shape`, [n,n+a1,n+a2,n+a3,n+a4,n+a5], ` is `):
print(``):
print(gu):
print(``):
print(`and in Maple notation`):
print(``):
lprint(gu):
print(``):
fi:
od:
od:
od:
od:
od:
print(``):
print(`-------------------------`):
print(``):
print(`This ends this article that took`, time()-t0, `seconds to produce. `):
print(``):

end:


#Sefer6r(A,n,D1): inputs a positive integer A, and a variable n, and a symbol RF for rising factorial, outputs an article with conjectured formulas for the number of truncated Young tableaux with
#6 rows of shape [n,n+a1,n+a2,n+a3,n+a4,n+a5] for all 0<=a1<=a2<=a3<=a3<=a4<=A, divided by the number of syt of shape [n$6], with the polynomial part of degree up to D1. Try:
#Sefer6(2,n,RF,10);
Sefer6r:=proc(A,n,D1)  local a1,a2,a3,a4,a5,t0,gu:
t0:=time():
print(``):
print(` Conjectured Explicit Formulas Enumerating 6-rowed Truncated Standard Young Tableau of shape [n,n+a1,n+a2,n+a3,n+a4,n+a5] for a from 0<=a1,a2,a3,a4,a5<= `, A, `and a5<a4 divided by `, [n$6] ):
print(``):
print(`By Shalosh B. Ekhad `):
print(``):


for a1 from 0 to A do
for a2 from 0 to A do
for a3 from 0 to A do
for a4 from 0 to A do
for a5 from 0 to a4-1 do
print(``):

gu:=GuessFr([0,a1,a2,a3,a4,a5],n,D1):

if gu<>FAIL then
print(`Theorem: The number of 6-rowed Truncated Standard Young Tableaux of shape`, [n,n+a1,n+a2,n+a3,n+a4,n+a5], ` is `):
print(``):
print(gu):
print(``):
print(`and in Maple notation`):
print(``):
lprint(gu):
print(``):
fi:
od:
od:
od:
od:
od:
print(``):
print(`-------------------------`):
print(``):
print(`This ends this article that took`, time()-t0, `seconds to produce. `):
print(``):

end:


#Comps(n,k): the set of compositions of n (including 0) with k parts that add-up to n. Try:
#Comps(4,2);
Comps:=proc(n,k) local gu,n1,lu,lu1:
option remember:
if k=0 then
 if n=0 then
  RETURN({[]}):
else
 RETURN({}):
fi:
fi:

gu:={}:

for n1 from 0 to n do
 lu:=Comps(n-n1,k-1):
 gu:=gu union {seq([n1,op(lu1)],lu1 in lu)}:
od:
gu:
end:

#Contest(r,K,D1): Output the ranked list of compositions of K into r parts, C,  according to the size of the generalized Young tableaux of shape [n$r]+C
#it also gives the corresponding limiting size compared to the number of YT of [n$r]. D1 is the guessing parameter. Try:
#Contest(3,2,10);
Contest:=proc(r,K,D1) local ru,gu,T,n,V,ku1,gu1,T2,v,i:

V:={}:
ru:=GuessF([0$r],n,rf,D1):
gu:=Comps(K,r):

for gu1 in gu do

ku1:=GuessF(gu1,n,rf,D1):
if ku1=FAIL then
 print(`Make `, D1, `bigger `):
 RETURN(FAIL):
fi:
ku1:=simplify(ku1/ru):
ku1:=lcoeff(numer(ku1),n)/lcoeff(denom(ku1),n):
V:=V union {ku1}:
T[gu1]:=ku1:
od:


for v in V do
 T2[v]:={}:
od:

for gu1 in gu do
 T2[T[gu1]]:=T2[T[gu1]] union {gu1}:
od:
V:=sort(convert(V,list)):

[seq([V[i],T2[V[i]]],i=1..nops(V))], [seq([evalf(V[i]),T2[V[i]]],i=1..nops(V))]:

end:


#SeferComps(R,K,D1): for number of rows from 3 to R and values K1 from 1 to K it lists
#the ranked list of compositions of K1 into 
#generalized shapes [n$r]+C where C is a compositon of K1 into r parts
#according to the number of standard young tableau. It gives the limit of the ratios
#to the number of SYT of shaper [n$r]. Try:
#SeferComps(4,2,12);
SeferComps:=proc(R,K,D1) local r,K1,lu,t0,n:

t0:=time():
print(`Relative Limiting Sizes of the Number of Standard Young Tableaux perturbed by adding at most`, K, `cells to the rectangular shapes up to`, R, `rows `):
print(``):
print(`By Shalosh B. Ekhad `):
print(``):

for r from 3 to R do
 print(`We are doing`, r , `rowed shapes by adding to`, [n$r]):
for K1 from 1 to K do
 lu:=Contest(r,K1,D1):
print(`If you add `, K1, `boxes in all different ways to `, [n$r] ,` the ranked list together with the limit of the ratios of the number of SYT to that of`, [n$r] , ` is `):
print():
lprint(lu[1]):
print():
print(`and in decimals `):
print():
lprint(lu[2]):
print():
od:
od:

print(``):
print(`---------------------------`):
print(``):

print(`This ends this paper that took`, time()-t0, `to produce `):

end:



#Tsyt(L): all the standard young tableaux of shape L. Try:
#Tsyt([1,2]);
Tsyt:=proc(L) local n,gu,k,lu,lu1,i:
n:=convert(L,`+`):
if n=0 then
 RETURN({[]}):
fi:

k:=nops(L):

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

gu:={}:

for i from 1 to k do

 if (i<=k-1 and L[i]>L[i+1]) or (i=k and L[k]>1)  then
  lu:=Tsyt([op(1..i-1,L),L[i]-1,op(i+1..nops(L),L)]):
 gu:=gu union {seq([op(1..i-1,lu1),[op(lu1[i]),n],op(i+1..nops(lu1),lu1)],lu1 in lu)}:
 fi:
od:

if L[k]=1 then
  lu:=Tsyt([op(1..k-1,L)]):
 gu:=gu union {seq([op(lu1),n],lu1 in lu)}:
fi:
gu:
end:



#Hadpes(T): prints the tableau T nicely. Try:
#Hadpes([[1,2,3],[4,5]]);
Hadpes:=proc(T) local i:
for i from 1 to nops(T) do
lprint(op(T[i])):
od:
end:

#GuessFr(L,n,K): Guesses a rational function for the number of tableaux of shape [n$nops(L)]+L divided by the number of tableux of shape [n$nops(L)]. Try:
#GuessFr([0,2,2,2],n,10);
GuessFr:=proc(L,n,K)
factor(simplify( GuessF(L,n,rf,K)/YF([n$nops(L)])));
end: