######################################################################
## 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: March 2023: tested for Maple 2020 `):
print(`Version  : March2023:  `):
print():
print(`This is TruncSYT.txt, A Maple package`):
print(`accompanying  the article `):
print(`"Experimenting with Truncated Standard Young Tableaux " `):
print(` by Ron Adin, Arvind Ayyer, 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, Sefer4, Sefer5, Sefer6`):

else
ezra(args):

fi:


end:

ezra1:=proc()
if args=NULL then

print(`The SUPPORTING procedures are`):
print(` Fm, findrec, qfindrec, rf, qfac, qint, qY1, qYF, SolveRec1, 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, GuessF, 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]=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]=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]=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  with the polynomial part of degree up to D1. Try:`):
print(`Sefer3(5,n,RF,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  with the polynomial part of degree up to D1. Try:`):
print(`Sefer4(5,n,RF,15);`):


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  with the polynomial part of degree up to D1. Try:`):
print(`Sefer5(3,n,RF,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  with the polynomial part of degree up to D1. Try:`):
print(`Sefer6(1,n,RF,15);`):

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]=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):
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 a1 to A 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:


#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):
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 a1 to A do
for a3 from a2 to A 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:



#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<=a3<=A, 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):
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 a1 to A do
for a3 from a2 to A do
for a4 from a3 to A 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:




#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):
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 a1 to A do
for a3 from a2 to A do
for a4 from a3 to A do
for a5 from a4 to A 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: