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


print(`First Written :March 2021: tested for Maple 2018 `):
print(`Version  : March 2021:  `):
print():
print(`This is Solomon.xt, A Maple package`):
print(`accompanying AJ Bu's  article: `):
print(`The Groebner basis for the Ideal Generated by the Elementary Symmetric Polynomials `):

print():
print(`The most current version is available on WWW at:`):
print(` http://sites.math.rutgers.edu/~zeilberg/tokhniot/Solomon.txt .`):
print(`Please report all bugs to: DoronZeil at gmail dot com .`):
print(``):

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

print():
print(`For general help, and a list of the MAIN functions,`):
print(` type "ezra();". For specific help type "ezra(procedure_name);" `):
print():
 print(`----------------------------------------------------`):


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

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


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

print():
print(`For  a list of the  COUNTING dimenions functions,`):
print(` type "ezraC();". For specific help type "ezra(procedure_name);" `):
print(`For a list of the supporting functions type: ezra();`):
print():
 print(`----------------------------------------------------`):




ezraC:=proc()
if args=NULL then

print(`The COUNTING dimenions procedures are:`):
print(` DimKernSeq, DimKernSeqG, HilGF, HilSer, HilSerG `):


else
ezra(args):

fi:


end:

ezra1:=proc()
if args=NULL then

print(`The SUPPORTING procedures are`):
print(`AJ3, CheckProp1, CheckProp2, Conjab,eknS, hknS, G13n, Gn, GnC,  GuessGF, GuessPol1, ISn, In`):

else
ezra(args):

fi:


end:

ezra:=proc()
if args=NULL then

print(` Solomon.txt: A Maple package for proving Solomn's theorem  `):

print(`The MAIN procedures are`):
print(``):

print(`ekn, hkn, Ikn, Gkn, GSn,GknC, LeaSn `):
print(`AJk,AJab,AJ123,AJabc`):

elif nargs=1 and args[1]=AJab then
print(`AJab(a,b,n,x): the conjectured form for GSn({a, b},n, x`):

elif nargs=1 and args[1]=AJabc then
print(`AJabc(a,b,c,n,x): the conjectured form for GSn({a, b,c},n, x`):

elif nargs=1 and args[1]=AJ123 then
print(`AJ123(a,n,x): the conjectured form for GSn({a-2,a-1,a},n, x`):

elif nargs=1 and args[1]=AJk then
print(`AJk(k,n,x): the conjectured form for GSn({n,n-1,...,n-k+1},n, x`):

elif nargs=1 and args[1]=AJ3 then
print(`AJ3(n,x): The conjectured form for GSn({n,n-1,n-2},n,x)`):
print(`Try: `):
print(`AJ3(5,x);`):


elif nargs=1 and args[1]=CheckAJ3 then
print(`CheckAJ3(N): Checks that AJ3(n,x)=GSn({n,n-1,n-2},n,x) for n from 3 to N`):
print(`Try: `):
print(`CheckAJ3(7);`):


elif nargs=1 and args[1]=AJ4 then
print(`AJ4(n,x): The conjectured form for GSn({n,n-1,n-2,n-3},n,x)`):
print(`Try: `):
print(`AJ4(5,x);`):


elif nargs=1 and args[1]=CheckAJ4 then
print(`CheckAJ4(N): Checks that AJ4(n,x)=GSn({n,n-1,n-2,n-3},n,x) for n from 4 to N`):
print(`Try: `):
print(`CheckAJ4(7);`):


elif nargs=1 and args[1]=CheckProp1 then
print(`CheclProp1(x,n,k): checks Proposition 1 in the paper. Try:`):
print(`CheckProp1(x,5,3);`):


elif nargs=1 and args[1]=CheckProp2 then
print(`CheclProp2(x,n,k): checks Proposition 2 in the paper. Try:`):
print(`CheckProp2(x,5,3);`):

elif nargs=1 and args[1]=Conjab then
print(`Conjab(a,b,n,x): the conjectured Leading monomials`):
print(` {ekn(a,n,x),ekn(b,n,x)}`):
print(`Try: `):
print(`Conjab(2,3,5,x);`):


elif nargs=1 and args[1]=DimKernSeq then
print(`DimKernSeq(n,d,D1,S), inputs a pos. integer n, a pos. integer,d, a symbol D1, and a set S of linear differential operators with constant coefficients`):
print(`output the first d+1 terms, starting at i=0 or the vector space of polynomials in x[1], ..., x[n] annihilated by the member of S. Try:`):
print(`DimKernSeq(3,4,D1,{seq(add(D1[i]^s,i=1..3),s=1..3)});`):


elif nargs=1 and args[1]=DimKernSeqG then
print(`DimKernSeqG(n,d,D1,S), same as DimKernSeq(n,d,D1,S) (q.v.) but using Groebner bases. Try:`):
print(`DimKernSeqG(3,4,D1,{seq(add(D1[i]^s,i=1..3),s=1..3)});`):


elif nargs=1 and args[1]=ekn then
print(`ekn(x,k,n): inputs a variable x and natural numbers n and k `):
print(`Outputs the degree k elementary symmetric polynomial in n variables. Using genearating functions. Try:`):
print(`ekn(x,2,4);`):


elif nargs=1 and args[1]=eknS then
print(`eknS(x,k,n): inputs a variable x and natural numbers n and k `):
print(`Outputs the degree k elementary symmetric polynomial in n variables. Using recurrence Try:`):
print(`eknS(x,2,4);`):

elif nargs=1 and args[1]=GuessGF then

print(`GuessGF(L,q): inputs a list of numbers L guesses a rational function that fits it of the form P1(q)+P2(q)/(1-q)^d. Try:`):
print(`GuessGF([1$20],q);`):

elif nargs=1 and args[1]=GuessPol1 then
print(`GuessPol1(L,n,d): inputs a list of pairs L=[[a1,b1],[a2,b2],..., [ad,bd]] of length at least d+4, tries to`):
print(`fit it into a polynomial of degree<=d . Try:`):
print(`GuessPol1([seq([i,i^2],i=10..20)],n,2);`):


elif nargs=1 and args[1]=HilGF then
print(`HilGF(S,n,q,K): The conjetured generating function for the Hilbert series for the subset S of {1,...,n}.Try:`):
print(`HilGF({1,2,3},3,q,14);`):

elif nargs=1 and args[1]=HilSer then
print(`HilSer(S,n,K): Inputs a subset S of {1,2,...,n} , a pos. integer n, and a posivite integer K, outputs the list of length K+1`):
print(`whose (d+1)-th entry is the dimension of the space of homog. polymials of total degree d in C[x1,...,xn]/{ekn(x,k,n), k in S)}`):
print(`or equivalently, the vector space of polynomials in x1,x2,..,xn of total degree d annihilated by the differential`):
print(`operators {ekn(D_x, k,n), k in S). It is done diretly, via differential operators. Try:`):
print(`HilSer({1,2,3},3,4);`):


elif nargs=1 and args[1]=HilSerG then
print(`HilSerG(S,n,K): Inputs a subset S of {1,2,...,n} , a pos. integer n, and a posivite integer K, outputs the list of length K+1`):
print(`whose (d+1)-th entry is the dimension of the space of homog. polymials of total degree d in C[x1,...,xn]/{ekn(x,k,n), k in S)}`):
print(`or equivalently, the vector space of polynomials in x1,x2,..,xn of total degree d annihilated by the differential`):
print(`operators {ekn(D_x, k,n), k in S). It is via Groebner bases. Try:`):
print(`HilSerG({1,2,3},3,4);`):


elif nargs=1 and args[1]=hkn then
print(`hkn(x,k,n): inputs a variable x and natural numbers n and k`):
print(`Outputs the complete homogeneous symmetric polynomial of degree k in n variables x[1],...,x[n]. It uses generating functions`):
print(`Try: `):
print(`hkn(2,4,x);`):

elif nargs=1 and args[1]=hknS then
print(`hknS(x,k,n): inputs a variable x and natural numbers n and k`):
print(`Outputs the complete homogeneous symmetric polynomial of degree k in n variables x[1],...,x[n]. It uses RECURRENCE`):
print(`Try: `):
print(`hknS(2,4,x);`):

elif nargs=1 and args[1]=G13n then
print(`G13nC(n,x): The conjectured Groebner basis for {e1,e3} in x[1],...,x[n]. Should be the same as`):
print(`GSnC({1,3},n,x); for all n>=3. Try:`):
print(`G13nC(5,x);`):

elif nargs=1 and args[1]=G1kn then
print(`G1knC(k,n,x): The conjectured Groebner basis for {e1,ek} in x[1],...,x[n]. Should be the same as`):
print(`GSn({1,k},n,x); for all n>=k. Try:`):
print(`G1knC(k,n,x);`):

elif nargs=1 and args[1]=Gkn then
print(`Gkn(k,n,x): The Groebner basis for the ideal generated by Ikn(x,k,n). Done DIRECTLY`):
print(`Try: `):
print(`Gkn(2,4,x) ;`):

elif nargs=1 and args[1]=GSn then
print(`GSn(S,n,x): Inputs a natural number n and`):
print(`a subset S of {1,...,n}`):
print(`Outputs a Groebner basis of the ideal generated by e_k  k in S`):

elif nargs=1 and args[1]=Gn then
print(`Gn(n,x): The Groebner basis for the Solomon ideal in n variables x[1], ..., x[n]. Done DIRECTLY`):
print(`Try: `):
print(`Gn(3,x) ;`):


elif nargs=1 and args[1]=GnC then
print(`GnC(n,x): The Groebner basis for the Solomon ideal in n variables x[1], ..., x[n]. Done using the Bu-Zeilberger theorem`):
print(`Try: `):
print(`GnC(3,x) ;`):


elif nargs=1 and args[1]=GknC then
print(`GknC(k,n,x): The Groebner basis for the ideal in n variables x[1], ..., x[n] generated by the first .`):
print(`elementary symmetric functions. `):
print(` Done using the Bu-Zeilberger theorem`):
print(`Try: `):
print(`GknC(2,3,x) ;`):


elif nargs=1 and args[1]=Ikn then
print(`Ikn(n,x): inputs a natural number n and an integer k<=n`):
print(`Outputs a list of the elementary symmetric polynomials in n variables of degrees 1..k`):
print(`Ikn(2,3,x) ;`):

elif nargs=1 and args[1]=In then
print(`In(n,x): inputs a natural number n`):
print(`Outputs a list of the elementary symmetric polynomials in n variables of degrees k=1..n`):
print(`In(3,x) ;`):

elif nargs=1 and args[1]=ISn then
print(`ISn(S,n,x): inputs a natural number n`):
print(`Outputs a list of the elementary symmetric polynomials in n variables of degrees k=1..n`):

elif nargs=1 and args[1]=LeaSn then
print(`LeaSn(S,n,x): The sequence of leading monomials of the Groebner basis`):
print(`GSn(S,n,x). Try:`):
print(`LeaSn({1,2,3,4},4,x);`):
else
 print(`There is no such thing as`, args):

fi:


end:

###GROEBNER BASIS RESEARCH PACKAGE###

Help:=proc(): 

end:


#ekn(x,k,n): inputs a variable x and natural numbers n and k 
#Outputs the degree k elementary symmetric polynomial in n variables. Try:
#ekn(x,2,4);
ekn:=proc(x,k,n)local t,i:
option remember:
expand(coeff(mul(1+t*x[i],i=1..n),t,k)): end:

#eknS(x,k,n): inputs a variable x and natural numbers n and k 
#Outputs the degree k elementary symmetric polynomial in n variables using recursion
eknS:=proc(x,k,n) option remember:
if k<0 then RETURN(0): fi:
if k=0 then RETURN(1): fi:
if n<k then RETURN(0): fi:
if n=1 then 
  if k=0 then 1:
   else x[1]:
  fi:
else
  expand(eknS(x,k,n-1)+x[n]*eknS(x,k-1,n-1)):  fi: end:
 
#In(n,x): inputs a natural number n
#Outputs a list of the elementary symmetric polynomials in n variables of degrees k=1..n
In:=proc(n,x) local k1:
	[seq(eknS(x,k1,n),k1=1..n)]:
end:

#Gn(n,x): Inputs a natural number n
#Outputs a Groebner basis of the ideal generated by the elementary symmetric polynomials in n variables of degrees k=1..n
#w.r.t lex order with x[n]>x[n-1]>...>x[1]
Gn:=proc(n,x) local i:
	Groebner[Basis](In(n,x),plex(seq(x[n+1-i],i=1..n))):
end:


#hkn(x,k,n): inputs a variable x and natural numbers n and k
#Outputs the complete homogeneous symmetric polynomial of degree k in n variables x[1],...,x[n]
hkn:=proc(x,k,n)local i,t:
option remember:
expand(coeff(taylor(mul(1/(1-t*x[i]),i=1..n),t=0,k+1),t,k)): end:


#hknS(x,k,n): inputs a variable x and natural numbers n and k
#Outputs the complete homogeneous symmetric polynomial of degree k in n variables x[1],...,x[n]
#Using RECURSION 
hknS:=proc(x,k,n) option remember:
if k<0 then RETURN(0): fi:
if k=0 then  RETURN(1): fi:
if n<0 or (n=0 and n<k) then RETURN(0): fi:
if n=1 then  RETURN(x[1]^k): 
else
expand(hknS(x,k,n-1)+x[n]*hknS(x,k-1,n)): fi: end:


#GnC(n,x): The Groebner base of In(n,x) using the Bu-Zeilberger theorem
GnC:=proc(n,x) local k:[seq(hkn(x,n-k+1,k),k=1..n)]:end:

#CheckProp1(x,n,k): checks Proposition 1 in the paper. Try:
#CheckProp1(x,5,3);
CheckProp1:=proc(x,n,k) local i:
expand(hkn(x,k,n-k+1)-add((-1)^(i+1)*ekn(x,i,n)*hkn(x,k-i,n-k+1),i=1..k )):
end:


#CheckProp2(x,n,k): checks Proposition 1 in the paper. Try:
#CheckProp2(x,5,3);
CheckProp2:=proc(x,n,k) local i:
expand(ekn(x,k,n)-add((-1)^(i+1)*hkn(x,i,n-i+1)*ekn(x,k-i,n-i),i=1..k )):
end:


 
#Ikn(k,n,x): inputs a natural number n
#Outputs a list of the elementary symmetric polynomials in n variables of degrees k=1..n
Ikn:=proc(k,n,x) local k1:
	[seq(eknS(x,k1,n),k1=1..k)]:
end:

#Gkn(k,n,x): Inputs a natural number n
#Outputs a Groebner basis of the ideal generated by the elementary symmetric polynomials in n variables of degrees 1..k
#w.r.t lex order with x[n]>x[n-1]>...>x[1]
Gkn:=proc(k,n,x) local i:
	Groebner[Basis](Ikn(k,n,x),plex(seq(x[n+1-i],i=1..n))):
end:





#GknC(k,n,x): The Groebner base of In(n,x) using the Bu-Zeilberger theorem
GknC:=proc(k,n,x) local k1:[seq(hkn(x,k-k1+1,n-k+k1),k1=1..k)]:end:



#ISn(S,n,x): inputs a natural number n
#Outputs a list of the elementary symmetric polynomials in n variables of degrees k=1..n
ISn:=proc(S,n,x) local k1:
	[seq(eknS(x,k1,n),k1 in S)]:
end:

#GSn(S,n,x): Inputs a natural number n and
#a subset S of {1,...,n}
#Outputs a Groebner basis of the ideal generated by e_k  k in S
GSn:=proc(S,n,x) local i:
option remember:
	Groebner[Basis](ISn(S,n,x),plex(seq(x[n+1-i],i=1..n))):
end:

#G13nC(n,x): The conjectured Groebner basis for {e1,e3} in x[1],...,x[n]. Should be the same as
#GSn({1,3},n,x); for all n>=3. Try:
#G13n(5,x);
G13nC:=proc(n,x): 
[hkn(x,3,n-1)+ekn(x,3,n-1)-add(x[i]^3,i=1..n-1), hkn(x,1,n)]:
end:

#LeaSn(S,n,x): The sequence of leading monomials of the Groebner basis
#GSn(S,n,x). Try:
#LeaSn({1,2,3,4},4,x);
LeaSn:=proc(S,n,x) local i,L:
L:=GSn(S,n,x):
[seq(Groebner[LeadingTerm](L[i],plex(seq(x[n+1-i],i=1..n)))[2],i=1..nops(L))]:
end:

#G1knC(k,n,x): The conjectured Groebner basis for {e1,ek} in x[1],...,x[n]. Should be the same as
#GSn({1,k},n,x); for all n>=3. Try:
#G13n(5,x);
G1knC:=proc(k,n,x): 
[ekn(x,1,n-1)*ekn(x,k-1,n-1)-ekn(x,k,n-1), hkn(x,1,n)]:
end:




#Start Using differential operators


#Extract11(f,x): the set of coefficients of the polynomial f in the variable x. Try:
#Extract11(a+2*b*x^3,x);
Extract11:=proc(f,x) local i:
 {seq(coeff(f,x,i),i=0..degree(f,x))} minus {0}:
end:


#Extract1(f,x,n): the set of coefficients of the polynomial f in the variables x[1], ... x[n]. Try:
#Extract1(a*x[1]^2+b*x[1]*x[2]*c*x[2]^5,x,2);
Extract1:=proc(f,x,n) local gu,gu1:
if n=1 then
 RETURN(Extract11(f,x[1])):
fi:

gu:=Extract1(f,x,n-1):

{seq(op(Extract11(gu1,x[n])),gu1 in gu)}:
end:


#MyDiff(f,x,i):the i-th derivative of f w.r.t the variable x, including if i=0. Try:
#MyDiff(x^3,x,3);
MyDiff:=proc(f,x,i) :
if i=0 then
 f:
else
expand(diff(f,x$i)):
fi:
end:



#ApplyMonoDO(M,x,D1,n,P): inputs a monomial differential operator (with constant coefficients) in the form
#c*D1[1]^a1*...*D1[n]^an ,c a constant and a1, .., an, non-negative integers and applies it the polynomial P in x[1], ..., x[n]
#Try:
#ApplyMonoDO(3*D1[1]^2*D1[2]^3,x,D1,2,x[1]^3*x[2]^6);
ApplyMonoDO:=proc(M,x,D1,n,P) local c,gu,d,i:

d:=[seq(degree(M,D1[i]),i=1..n)]:
c:=normal(M/mul(D1[i]^d[i],i=1..n)):

if not type(c,numeric) then
  RETURN(FAIL):
fi:

gu:=P:

for i from 1 to n do
 gu:=MyDiff(gu,x[i],d[i]):
od:
expand(c*gu):
end:

#ApplyDO(Ope,x,D1,n,P): inputs a differential operator (with constant coefficients) in the form
#Sum(c*D1[1]^a1*...*D1[n]^an) ,c a constants and a1, .., an, non-negative integers and applies it the polynomial P in x[1], ..., x[n]
#Try:
#ApplyDO(D1[1]+D1[2],x,D1,2,x[1]^3*x[2]^6);
ApplyDO:=proc(Ope,x,D1,n,P) local i:

if not type(Ope,`+`) then
ApplyMonoDO(Ope,x,D1,n,P):
else
expand( add(ApplyMonoDO(op(i,Ope),x,D1,n,P)  , i=1..nops(Ope))):
fi:

end:



#GenPol(n,d,x,a): inputs a positive integer n, a positive integer d, a symbol x and a symbol a
#outputs a generic homog. polynomial in the n variable x[1],...,x[n] of degree d with coefficients of the form a[i]
#followed by the set of coefficients. Try:
#GenPol(4,2,x,a);
GenPol:=proc(n,d,x,a) local gu,gu1,P,mu,co,i1:
gu:=Comps(n,d):
P:=0:
mu:={}:
co:=0:
 for gu1 in gu do
 co:=co+1:
  P:=P+a[co]*mul(x[i1]^gu1[i1],i1=1..n):
  mu:=mu union {a[co]}:
 od:
P,mu:
end:

#Kern(n,d,x,D1, S): inputs pos. integers n and d, a symbol x, and a set S of differential operators with constant coefficients
#where D1[i] denotes differentiation with respect to x[i], outputs a basis for the
#set of polynomials in x[1], ..., x[n] of degree d, annihilated by the differential operators in S. Try
#Kern(3,2,x,D1,{D1[1]+D1[2]+D1[3],D1[1]^2+D1[2]^2+D1[3]^2});
Kern:=proc(n,d,x,D1,S) local gu,P,eq,var,a,P1,s,var1,var11,fr,fr1,gu1:
option remember:

gu:=GenPol(n,d,x,a) :

P:=gu[1]:
var:=gu[2]:

eq:={}:

for s in S do
P1:=ApplyDO(s,x,D1,n,P):
 eq:=eq union Extract1(P1,x,n):
od:

var1:=solve(eq,var):

	
fr:={}:

for var11 in var1 do
 if op(1,var11)=op(2,var11) then
   fr:=fr union {op(1,var11)}:
fi:
od:

P:=expand(subs(var1,P)):

gu:={seq(coeff(P,fr1,1),fr1 in fr)}:

for gu1 in gu do
 if {seq(ApplyDO(s,x,D1,n,gu1),s in S)}<>{0} then
  print(`Soemthing is wrong`):
  RETURN(FAIL):
 fi:
od:
gu:
end:



#DimKernSeq(n,d,D1,S), inputs a pos. integer n, a pos. integer,d, a symbol D1, and a set S of linear differential operators with constant coefficients
#output the first d+1 terms, starting at i=0 or the vector space of polynomials in x[1], ..., x[n] annihilated by the member of S. Try:
#DimKernSeq(3,4,D1,{seq(add(D1[i]^s,i=1..3),s=1..3)});
DimKernSeq:=proc(n,d,D1,S)  local x,d1:
[seq(nops(Kern(n,d1,x,D1,S)),d1=0..d)]:
end:

#HilSer(S,n,K): Inputs a subset S of {1,2,...,n} , a pos. integer n, and a posivite integer K, outputs the list of length K+1
#whose (d+1)-th entry is the dimension of the space of homog. polymials of total degree d in C[x1,...,xn]/{ekn(x,k,n), k in S)}
#or equivalently, the vector space of polynomials in x1,x2,..,xn of total degree d annihilated by the differential
#operators {ekn(D_x, k,n), k in S). Try:
#HilSer({1,2,3},3,4);
HilSer:=proc(S,n,K) local S1,i,D1:
S1:={seq(ekn(D1,i,n), i in S)}:
DimKernSeq(n,K,D1,S1):
end:


#HilSerG(S,n,K): Inputs a subset S of {1,2,...,n} , a pos. integer n, and a posivite integer K, outputs the list of length K+1
#whose (d+1)-th entry is the dimension of the space of homog. polymials of total degree d in C[x1,...,xn]/{ekn(x,k,n), k in S)}
#or equivalently, the vector space of polynomials in x1,x2,..,xn of total degree d annihilated by the differential
#operators {ekn(D_x, k,n), k in S). Try:
#HilSerG({1,2,3},3,4);
HilSerG:=proc(S,n,K) local S1,i,D1:
S1:={seq(ekn(D1,i,n), i in S)}:
DimKernSeqG(n,K,D1,S1):
end:


#End Using differential operators

#Start Using Groebner bases

ez:=proc(): print(`Vecs(x,n,S), Comps(n,d), IsMore1(v1,v2) , IsMore(v1,v2), Surv(x,n,S,d), DimKernSeq(n,d,D1,S)`): end:

#Vecs(x,n,S), inputs a variable name x, a positive integer n, and a set of polynomials S, in x[1], ..., x[n], outputs
#the set of exponents of the leading monomial of the Grobner basis of the ideal generated by S with pure lex order x[1], ..., x[n].
#Try:
#Vecs(x,2,{x[1]+x[2]});
Vecs:=proc(x,n,S) local gu,i,j:
option remember:
gu:=Groebner[Basis](S,plex(seq(x[i],i=1..n))):
gu:=Groebner[LeadingMonomial](gu,plex(seq(x[i],i=1..n)) ):

[seq(
[seq(degree(gu[j],x[i]),i=1..n)],
   j=1..nops(gu)
    )
]:
end:

#Comps(n,d): The set of vectors of length n with non-negative integers that add-up to d. Try:
#Comps(3,4);
Comps:=proc(n,d) local gu,d1,mu,mu1:
option remember:

if n=0 then
 if d=0 then
  RETURN({[]}):
else
 RETURN({}):
 fi:
fi:

gu:={}:

for d1 from 0 to d do
 mu:=Comps(n-1,d-d1):
 gu:=gu union {seq([op(mu1),d1], mu1 in mu)}:
od:
gu:
end:

#IsMore1(v1,v2) Is v1>=v2?
IsMore1:=proc(v1,v2) local i:
if nops(v1)<>nops(v2) then
 RETURN(FAIL):
fi:

if min(seq(v1[i]-v2[i],i=1..nops(v1)))<0 then
 RETURN(false):
fi:
true:
end:




# IsMore(v1,V): is v1 more than at least one member of V
IsMore:=proc(v1,V)  local v2:

for v2 in V do
if IsMore1(v1,v2) then
 RETURN(true):
fi:
od:
false:
end:

#Surv(x,n,S,d): all the vectors of non-neg. integers of length n, that are never >=then the the vectors in
#Vecs(x,n,S);. Try:
#Surv(x,2,{x[1]+x[2],x[1]^2+x[2]^2},1);
Surv:=proc(x,n,S,d) local lu,mu,mu1,gu:

lu:=Vecs(x,n,S):

mu:=Comps(n,d):

gu:={}:

for mu1  in mu do
 if not IsMore(mu1,lu) then
  gu:=gu union {mu1}:
 fi:
od:
gu:
end:




#DimKernSeqG(n,d,D1,S): Like  DimKernSeq(n,d,D1,S),  but using Grobner bases and survivors. Try:
#DimKernSeqG(3,4,D1,{seq(add(D1[i]^s,i=1..3),s=1..3)});
DimKernSeqG:=proc(n,d,D1,S)  local   d1:

[seq(nops(Surv(D1,n,S,d1)),d1=0..d)]:
end:

#End using Grobner bases


##start guessing

#GuessPol1(L,n,d): inputs a list of pairs L=[[a1,b1],[a2,b2],..., [ad,bd]] of length at least d+4, tries to
#fit it into a polynomial of degree<=d . Try:
#GuessPol1([seq([i,i^2],i=10..20)],n,2);

GuessPol1:=proc(L,n,d) local eq,var,i,a,P:

if nops(L)<d+4 then
 print(`the list should he at least of length`, d+4):
RETURN(FAIL):
fi:

P:=add(a[i]*n^i,i=0..d):
var:={seq(a[i],i=0..d)}:
eq:={seq(subs(n=L[i][1],P)-L[i][2],i=1..nops(L))}:
var:=solve(eq,var):

if var=NULL then
  RETURN(FAIL):
fi:

subs(var,P):

end:


#GuessGF(L,q): inputs a list of numbers L guesses a rational function that fits it of the form P1(q)+P2(q)/(1-q)^d. Try:
#GuessGF([1$20],q);

GuessGF:=proc(L,q) local L1,d1,i1,P,n,st,i,N:

if nops(L)<10 then
print(`List has to be at least of length 10`):
 RETURN(FAIL):
fi:

for d1 from 0 to nops(L)-6 do
 L1:=[seq([i1,L[i1+1]],i1=nops(L)-d1-5..nops(L)-1)]:
 P:=GuessPol1(L1,n,d1):
 if P<>FAIL then

 for i from nops(L)-1 by -1 to 1 while subs(n=i,P)-L[i+1]=0 do od:
 
st:=i:

RETURN(normal(add(L[i+1]*q^i,i=0..st)+ subs(q^(N+1)=0,sum(P*q^n,n=st+1..N)))):

fi:

od:

FAIL:

end:


##


#HilGF(S,n,q,K): The conjetured generating function for the Hilbert series for the subset S of {1,...,n}.
#Try:
#HilGF({1,2,3},3,q,14);
HilGF:=proc(S,n,q,K):GuessGF(HilSerG(S,n,K),q):end:





#Conjab(a,b,n,x): the conjectured Leading monomials {ekn(a,n,x),ekn(b,n,x)}
Conjab:=proc(a,b,n,x) local i,j,k:
[seq(mul(x[n-j],j=0..a)*mul(x[n-i],i=k..b-1)/x[n-k+1],k=1..a),
mul(x[n-i],i=0..a-1)]:
end:

MG3:=proc(n,i1,i2,x):linalg[det](
[[ekn(x,n-i1,n-i1),ekn(x,n-i2,n-i2), ekn(x,n,n)], 
[ekn(x,n-1-i1,n-i1), ekn(x,n-i2-1,n-i2), ekn(x,n-1,n)],
[ekn(x,n-2-i1,n-i1), ekn(x,n-i2-2,n-i2), ekn(x,n-2,n)]]): 
end:


#AJ3(n,x): The conjectured form for GSn({n,n-1,n-2},n,x)
AJ3:=proc(n,x) local i1,i2:
[seq( seq( -MG3(n,i1,i2,x),i2=i1+1..n),i1=1..n-1)]:
end:

#CheckAJ3(N): Checks that AJ3(n,x)= GSn({n,n-1,n-2},n,x) for n up to N
CheckAJ3:=proc(N) local n1,x:
{seq(evalb(GSn({n1,n1-1,n1-2},n1,x)=AJ3(n1,x)),n1=3..N)}:
end:



MG4:=proc(n,i1,i2,i3,x):linalg[det](
[[ekn(x,n-i1,n-i1),ekn(x,n-i2,n-i2), ekn(x,n-i3,n-i3), ekn(x,n,n)], 
[ekn(x,n-1-i1,n-i1), ekn(x,n-1-i2,n-i2), ekn(x,n-1-i3,n-i3), ekn(x,n-1,n)],
[ekn(x,n-2-i1,n-i1), ekn(x,n-i2-2,n-i2), ekn(x,n-i3-2,n-i3), ekn(x,n-2,n)],
[ekn(x,n-3-i1,n-i1), ekn(x,n-i2-3,n-i2), ekn(x,n-i3-3,n-i3), ekn(x,n-3,n)]
]): 
end:


AJ4:=proc(n,x) local i1,i2,i3:
[seq( seq( seq(-MG4(n,i1,i2,i3,x),i3=i2+1..n),i2=i1+1..n-1),i1=1..n-2)]:
end:


CheckAJ4:=proc(N) local n1,x:
{seq(evalb(GSn({n1,n1-1,n1-2,n1-3},n1,x)=AJ4(n1,x)),n1=4..N)}:
end:


MGk:=proc(n,K,x):
linalg[det]([seq( [seq(ekn(x,n-K[i]-j,n-K[i]),i=1..nops(K)) ],j=0..nops(K)-1)] ):
end:

AJk:=proc(k,n,x) local L1,L,i,j,l,K:
	L1:=[seq(K[i],i=1..k-1)]:
	L:=[seq(subs(K[1]=i, L1), i=1..n-k+2)]: 

	for j from 2 to k-1 do 
		L1:=[seq(seq(subs(K[j]=i ,l), i=l[j-1]+1..n),l in L)]:
		L:=L1: 
	od: 
	expand((-1)^floor(k/2)*[seq(MGk(n,{op(K),0},x),K in L)]):
end:

LeaAJk:=proc(k,n,x) local G:
G:=AJk(k,n,x):
[seq( Groebner[LeadingTerm](G[i],plex(seq(x[n-i],i=0..n-1)))[2],i=1..nops(G))]:
end:

CheckAJk:=proc(k,N) local n1,x:
{seq(evalb(GSn({seq(n1-i,i=0..k-1)},n1,x)=AJk(k,n1,x)),n1=k..N)}:
end:



AJab:=proc(a,b,n,x):
	[ seq(linalg[det]([[ekn(x,b-i,n-i), ekn(x,b,n)],[ekn(x,a-i,n-i),ekn(x,a,n)]]),i=1..a),linalg[det]([[ekn(x,0,n-b), ekn(x,b,n)],[ekn(x,a-b,n-b),ekn(x,a,n)]]) ]:
end:

CheckAJab:=proc(a,b,n,x):
	evalb(AJab(a,b,n,x)=GSn({a, b},n,x) ):
end:



AJ123:=proc(a,n,x):
	[seq( seq ( linalg[det]( [[ekn(x, a-i,n-i), ekn(x,a-j,n-j), ekn(x,a,n)],
		[ekn(x, a-i-1,n-i), ekn(x,a-j-1,n-j), ekn(x,a-1,n)],
		[ekn(x, a-i-2,n-i), ekn(x,a-j-2,n-j), ekn(x,a-2,n)]] ),
		j=1..i-1),i=2..a)]:
end:

CheckAJ123:=proc(a, n, x):
	evalb({op(AJ123(a,n,x))}={op(GSn({a-2,a-1,a},n,x))} ):
end: 



AJabc:=proc(a,b,c,n,x) local L:
	L:={seq(1..a),b}:
	{seq(  seq(expand(  linalg[det]([[ekn(x,c-j,n-j), ekn(x,c-i,n-i), ekn(x,c,n)] , 
				[ekn(x,b-j,n-j), ekn(x,b-i,n-i), ekn(x,b,n)],
				[ekn(x,a-j,n-j), ekn(x,a-i,n-i), ekn(x,a,n)] ]) ), j in {seq( i+1..b),c} )  ,i in L )}:
end:



CheckAJabc:=proc(a,b,c,n,x):
	evalb(AJabc(a,b,c,n,x)= convert(GSn({a,b,c},n,x),set)):
end: