############################################## # Involutive Divisions # ############################################## ##############Janet Division############# Janet:=proc(u,U,Vars) local n,m,d,L,i,j,dd,V,v,Mult; #option trace; if degree(u)=0 then RETURN(Vars); fi; n:=nops(Vars); m:=ArrayNumElems(U); d:=[seq(max(seq(degree(U[j],Vars[i]),j=1..m)),i=1..n)]; Mult:=NULL; if degree(u,Vars[1])=d[1] then Mult:=Mult,Vars[1]; fi: for j from 2 to n do dd:=[seq(degree(u,Vars[l]),l=1..j-1)]; V:=NULL: for v in U do if [seq(degree(v,Vars[l]),l=1..j-1)]=dd then V:=V,v: fi: od: if degree(u,Vars[j])=max(seq(degree(v,Vars[j]), v in [V])) then Mult:=Mult,Vars[j]; fi: od: RETURN([Mult]); end: ########### Pommaret Division ############# LeftPommaret:=proc(u,U,Vars) local N,Ind,i; N:=NULL: Ind:=indets(u): for i from 1 to nops(Vars) while not (Vars[i] in Ind) do N:=N,Vars[i]: od: N:=N,Vars[i]: RETURN([N]); end: RightPommaret:=proc(u,U,Vars) local N,Ind,i; N:=NULL: Ind:=indets(u): for i from nops(Vars) by -1 to 1 while not (Vars[i] in Ind) do N:=N,Vars[i]: od: N:=N,Vars[i]: RETURN([N]); end: ################################# # Schreyer’s sort # ################################# ######################## with(Groebner): Sher1 := proc (a, b) #option trace; local i, j, f, g; i := op([op(indets(a))][-1]); j := op([op(indets(b))][-1]); if i < j then return(true); else return(false); end if; end proc: ####################### Sher2:=proc(p,q) local i,j; global Polys,tord; if p[7]<>q[7] then RETURN(TestOrder(p[7],q[7],tord)); else i := op([op(indets(p[6]))][-1]); j := op([op(indets(q[6]))][-1]); if i < j then return(true); else return(false); end if; fi; end: ############################ # Reduction # ############################ Crit:=proc(p,gg,InvDivision) global T,tord,Vars,Q,Polys,c1,c2,LL,LMF,N,g; local InvDiv,flag,t,i,NM,y,l,lmp; #option trace; if InvDivision=J then InvDiv:=Janet: elif InvDivision=RP then InvDiv:=RightPommaret: elif InvDivision=LP then InvDiv:=LeftPommaret: elif InvDivision=L then InvDiv:=LID: elif InvDivision=T then InvDiv:=Thomas: fi: N:=NULL; l:=LM(Polys[p[2]]); g:=LM(Polys[gg[2]]);lmp:=LM(Polys[p[5]]); if l*g=p[4]*lmp then c1:=c1+1; RETURN(true); elif divide(LM(p[4]*Polys[p[5]]),lcm(l,g)) and p[4]*lmp<>lcm(l,g) then c2:=c2+1; RETURN(true); fi; RETURN(false); end: ################ Normal Form Algorithm ################# with(Groebner): Normalform:=proc(pp,TermOrder,InvDivision) #option trace; local LMF,Vars,p,r,flag,g,u,Mult,InvDiv,FF,j,i,qq,c1,LO,Ma,b,cd,QQQ,m,A,B,M; global tord,T,Polys,ISR2; if InvDivision=J then InvDiv:=Janet: elif InvDivision=RP then InvDiv:=RightPommaret: elif InvDivision=LP then InvDiv:=LeftPommaret: elif InvDivision=L then InvDiv:=LID: elif InvDivision=T then InvDiv:=Thomas: fi:LO:=[9]; LMF:=copy(Array([seq(v[7], v in T)])); Vars:=[op(TermOrder)]; p:=pp[4]*Polys[pp[5]]: r:=0; FF:=copy(Array([seq(Polys[v[1]], v in T)])); j:=0:m:=ArrayNumElems(FF); qq:=NULL; QQQ:=NULL; A,B:=LeadingTerm(p,TermOrder); while p<>0 do j:=j+1: flag:=false: i:=1; while not flag and i<=m do g:=FF[i]: if divide(B,LMF[i],'u') then Mult:=InvDiv(LMF[i],LMF,Vars); if indets(u) subset {op(Mult)} then if j=1 and pp[6]=u*T[i][6] then ISR2:=ISR2+1; RETURN([0,[0,qq]]); fi; if j=1 then cd:=[pp[6],u*T[i][6]]; M := sort(cd, proc (a, b) options operator, arrow; Sher1(a, b) end proc); if M[-1]=pp[6] then qq:=pp[6]; fi; fi; flag:=true: if j=1 then if Crit(pp,T[i],InvDivision) then RETURN([0,[0,qq]]); fi: fi: p:=simplify(p-(A/LeadingCoefficient(g,TermOrder))*u*g); A,B:=LeadingTerm(p,TermOrder); else i:=i+1; fi: else i:=i+1; fi: od: if not flag then j:=j+1; r:=simplify(r+A*B); p:=simplify(p-A*B); A,B:=LeadingTerm(p,TermOrder); fi: od: RETURN([r,[LM(r),qq]]); end: ################ AutoReduce ################# AutoReduction:=proc(f,F,TermOrder,InvDivision) #option trace; local LMF,Vars,p,r,flag,g,u,Mult,InvDiv,i,rr,LMFF,A,B; global tord; if InvDivision=J then InvDiv:=Janet: elif InvDivision=RP then InvDiv:=RightPommaret: elif InvDivision=LP then InvDiv:=LeftPommaret: elif InvDivision=L then InvDiv:=LID: elif InvDivision=T then InvDiv:=Thomas: fi: LMF:=copy(Array([seq(LeadingMonomial(v,tord), v in F)])); Vars:=[op(TermOrder)]; p:=f: r:=0; rr:=ArrayNumElems(F); LMFF:=copy(Array([seq(v, v in LMF),LM(f)])); A,B:=LeadingTerm(p,TermOrder); while p<>0 do flag:=false:i:=1; while not flag and i<=rr do g:=F[i]: if divide(B,LMF[i],'u') then Mult:=InvDiv(LMF[i],LMFF,Vars); if indets(u) subset {op(Mult)} then flag:=true: p:=simplify(p-(A/LeadingCoefficient(g,TermOrder))*u*g); A,B:=LeadingTerm(p,TermOrder); else i:=i+1; fi: else i:=i+1; fi: od: if not flag then r:=simplify(r+A*B); p:=simplify(p-A*B); A,B:=LeadingTerm(p,TermOrder); fi: od: RETURN(r); end: ############################### AutoReduce:=proc(F,TermOrder,InvDivision) local InvDiv,H,i; #option trace; description "AutoReduce procedure Involutive-Reduces the list F of polynomials. For using Janet, LeftPommaret, RightPommaret, Lexicographic induced and Thomas divisions, write J, LP, RP, L and T, respectively for InvDivision."; if InvDivision=J then InvDiv:=Janet: elif InvDivision=RP then InvDiv:=RightPommaret: elif InvDivision=LP then InvDiv:=LeftPommaret: elif InvDivision=L then InvDiv:=LID: elif InvDivision=T then InvDiv:=Thomas: fi: H:=copy(F); for i from 1 to ArrayNumElems(F) do H(i):=AutoReduction(H[i],Array([op({seq(h , h in H)} minus {H[i],0})]),TermOrder,InvDivision); od: RETURN(Array([op({seq(h, h in H)} minus {0})])); end: ######################### with(PolynomialIdeals): ################# LM:=proc(f) global tord; if f<>0 then RETURN(LeadingMonomial(f,tord)); fi: RETURN(0); end: LT := proc (f) global tord; if f=0 then return(0); fi; LeadingMonomial(f, tord)*LeadingCoefficient(f, tord); end proc: ################# LC:=proc(f) global tord; RETURN(LeadingCoefficient(f,tord)); end: ############################# # Hilbert function # ############################# binom:=proc(n,r) if n>=r and r>=0 then return(binomial(n,r)); else return(0); fi; end: ################################# HFI:=proc(F,s,T,V,invdiv) local n,G,K,H; #option trace; n:=nops(V); G:=copy(Array([seq(g[-2],g in F)])); K:= [seq(nops({op(invdiv(g,G,V))}),g in G)]; H:=add(i , i in [seq(binom(s-degree(G[i])+K[i]-1,s-degree(G[i])),i=1..ArrayNumElems(G))]); return(H); end: ##################################################### InvBasis:=proc(Ideal,Tord,InvDivision) #option trace; global tord,T,Q,Polys,Vars,c1,c2,rdz,LMF,critelim, reduct,mmtelim,isr,deg; local InvDiv,F,p,TT,q,h,NM,np,j,n, H, S, P, QQ, i, SS,A,NN,NMM, a, firsttime, firstbytes, syz, FLAGE, k,hh,aa,syyzz,syyz,kk,l,d,Q1,flg,w,s,y,NN1,NMM1,TH,THH,THT; if InvDivision=J then InvDiv:=Janet: elif InvDivision=RP then InvDiv:=RightPommaret: elif InvDivision=LP then InvDiv:=LeftPommaret: elif InvDivision=L then InvDiv:=LID: elif InvDivision=T then InvDiv:=Thomas: fi: tord:=Tord; Vars:=[op(Tord)]; F:=copy(AutoReduce(Array(Ideal),tord,InvDivision)); F:=copy(sort(F,(a,b)->TestOrder(a,b,tord))); n:=ArrayNumElems(F): syz:=NULL; Polys := copy(Array(1 .. n, proc (i) options operator, arrow; F[i] end proc)); T:=copy(Array(1..1,[[1,1,{},1,1,e[1],LM(Polys[1]),LT(Polys[1])]])); Q:=copy(Array(1..ArrayNumElems(F)-1,[seq([i,i,{},1,i,e[i],LM(Polys[i]),LT(Polys[i])],i=2..n)])); Q := sort(Q, proc (a, b) options operator, arrow; Sher2(a, b) end proc); while ArrayNumElems(Q) <> 0 do p := Q[1]; deg := max(deg, degree(Polys[p[1]])); Q := copy(Array(1 .. ArrayNumElems(Q)-1, proc (t) options operator, arrow; Q[t+1] end proc)); FLAGE := false; j:=1; if nops([syz]) <> 0 then for j to nops([syz]) while FLAGE = false do if divide(p[6],[syz][j],'b') = true then if b<>1 then FLAGE := true; mmtelim := mmtelim+1; fi; fi; end do; end if; if FLAGE = false then hh:=Normalform(p,tord,InvDivision); h:=hh[1]: if nops(hh[2])>1 then if nops([op(hh[2][2])])<>1 then syz:=syz,hh[2][2]; fi; fi; if h=0 then rdz:=rdz+1: fi: if h=0 and p[1]=p[2] then SS:=Array([]); S:=copy(Q): for s in S do if s[2]<>p[1] then SS(ArrayNumElems(SS)+1):=s; else isr:=isr+1: fi; od: Q:=copy(SS); elif h<>0 and hh[2][1]<>p[7] then k := ArrayNumElems(T)+1; Polys[p[1]]:=h; T(k):=[p[1],p[1],{},1,p[1],e[p[1]],hh[2][1],LT(Polys[p[1]])]; TT:=Array([]); for q in T do if divide(q[7], hh[2][1]) and hh[2][1] <> q[7] then Q(ArrayNumElems(Q)+1):=q; else TT(ArrayNumElems(TT)+1):=q; fi: od: T:=copy(TT); for i from 1 to ArrayNumElems(T) do q:=T[i]; NM:={op(Vars)} minus {op(InvDiv(q[7],Array([seq(w[7], w in T)]),Vars))}; for y in NM minus q[3] do n:=n+1: Polys(n):=expand(y*Polys[q[1]]); Q(ArrayNumElems(Q)+1):=[n,q[2],{},y,q[1],expand(y*q[6]),LM(Polys(n)),LT(Polys(n))]; od: T[i][3]:=q[3] union NM; od: elif h<>0 and hh[2][1]=p[7] then Polys[p[1]]:=h; T(ArrayNumElems(T)+1):=p; for i from 1 to ArrayNumElems(T) do q:=T[i]; NM:={op(Vars)} minus {op(InvDiv(q[7],Array([seq(w[7], w in T)]),Vars))}; for y in NM minus q[3] do n:=n+1: Polys(n):=expand(y*Polys[q[1]]); Q(ArrayNumElems(Q)+1):=[n,q[2],{},y,q[1],expand(y*q[6]),LM(Polys(n)),LT(Polys(n))]; od: T[i][3]:=q[3] union NM; od; fi; Q:=convert(Q,list); Q := sort(Q, proc (a, b) options operator, arrow; Sher2(a, b) end proc); Q:=copy(Array(1..nops(Q),Q)); fi; od: TH:=Array(1..ArrayNumElems(T),[seq([Polys[tt[1]],tt[7],tt[8]], tt in T)]): THH:=Array(1..ArrayNumElems(T),[seq(tt[7], tt in T)]): THT:=Array(1..ArrayNumElems(T),[seq(tt[8], tt in T)]): T:=Array([seq(Polys[tt[1]], tt in T)]); RETURN([T,TH,THH,THT]); end: ################################# InvBasis2:=proc(Ideal,Tord,InvDivision) #option trace; global tord,T,Q,Polys,Vars,c1,c2,rdz,LMF,critelim, reduct,mmtelim,isr,deg,HE; local InvDiv,F,p,TT,q,h,NM,np,j,n, H, S, P, QQ, i, SS,A,NN,NMM, a, firsttime, firstbytes, syz, FLAGE, k,hh,aa,syyzz,syyz,kk,l,d,Q1,flg,w,s,y,NN1,NMM1,flag1,i0,THH; if InvDivision=J then InvDiv:=Janet: elif InvDivision=RP then InvDiv:=RightPommaret: elif InvDivision=LP then InvDiv:=LeftPommaret: elif InvDivision=L then InvDiv:=LID: elif InvDivision=T then InvDiv:=Thomas: fi: tord:=Tord; Vars:=[op(Tord)]; F:=copy(AutoReduce(Array(Ideal),tord,InvDivision)); F:=copy(sort(F,(a,b)->TestOrder(a,b,tord))); n:=ArrayNumElems(F): syz:=NULL; Polys := copy(Array(1 .. n, proc (i) options operator, arrow; F[i] end proc)); T:=copy(Array(1..1,[[1,1,{},1,1,e[1],LM(Polys[1]),LT(Polys[1])]])); Q:=copy(Array(1..ArrayNumElems(F)-1,[seq([i,i,{},1,i,e[i],LM(Polys[i]),LT(Polys[i])],i=2..n)])); Q := sort(Q, proc (a, b) options operator, arrow; Sher2(a, b) end proc); while ArrayNumElems(Q) <> 0 do d:=degree(Polys[Q[1][1]]); deg := max(deg,degree(Polys[Q[1][1]])); if HFI(T,d,Tord,Vars,Janet)=MMM(d) then Q1:=Array([]): flag1:=false; i0:=0: for q in Q while flag1=false do if degree(Polys[q[1]])=d then HE:=HE+1; i0:=i0+1: else flag1:=true: fi: od: Q:=copy(Array(1..ArrayNumElems(Q)-i0, proc (t) options operator, arrow; Q[t+i0] end proc)): fi; if ArrayNumElems(Q) <> 0 then p := Q[1]; Q := copy(Array(1 .. ArrayNumElems(Q)-1, proc (t) options operator, arrow; Q[t+1] end proc)); FLAGE := false; j:=1; if nops([syz]) <> 0 then for j to nops([syz]) while FLAGE = false do if divide(p[6],[syz][j],'b') = true then if b<>1 then FLAGE := true; mmtelim := mmtelim+1; fi; fi; end do; end if; if FLAGE = false then hh:=Normalform(p,tord,InvDivision); h:=hh[1]: if nops(hh[2])>1 then if nops([op(hh[2][2])])<>1 then syz:=syz,hh[2][2]; fi; fi; if h=0 then rdz:=rdz+1: fi: if h=0 and p[1]=p[2] then SS:=Array([]); S:=copy(Q): for s in S do if s[2]<>p[1] then SS(ArrayNumElems(SS)+1):=s; else isr:=isr+1: fi; od: Q:=copy(SS); elif h<>0 and hh[2][1]<>p[7] then k := ArrayNumElems(T)+1; Polys[p[1]]:=h; T(k):=[p[1],p[1],{},1,p[1],e[p[1]],hh[2][1],LT(Polys[p[1]])]; TT:=Array([]); for q in T do if divide(q[7], hh[2][1]) and hh[2][1] <> q[7] then Q(ArrayNumElems(Q)+1):=q; else TT(ArrayNumElems(TT)+1):=q; fi: od: T:=copy(TT); for i from 1 to ArrayNumElems(T) do q:=T[i]; NM:={op(Vars)} minus {op(InvDiv(q[7],Array([seq(w[7], w in T)]),Vars))}; for y in NM minus q[3] do n:=n+1: Polys(n):=expand(y*Polys[q[1]]); Q(ArrayNumElems(Q)+1):=[n,q[2],{},y,q[1],expand(y*q[6]),LM(Polys(n)),LT(Polys(n))]; od: T[i][3]:=q[3] union NM; od: elif h<>0 and hh[2][1]=p[7] then Polys[p[1]]:=h; T(ArrayNumElems(T)+1):=p; for i from 1 to ArrayNumElems(T) do q:=T[i]; NM:={op(Vars)} minus {op(InvDiv(q[7],Array([seq(w[7], w in T)]),Vars))}; for y in NM minus q[3] do n:=n+1: Polys(n):=expand(y*Polys[q[1]]); Q(ArrayNumElems(Q)+1):=[n,q[2],{},y,q[1],expand(y*q[6]),LM(Polys(n)),LT(Polys(n))]; od: T[i][3]:=q[3] union NM; od; fi; Q:=convert(Q,list); Q := sort(Q, proc (a, b) options operator, arrow; Sher2(a, b) end proc); Q:=copy(Array(1..nops(Q),Q)); fi; fi; od: THH:=Array([seq(tt[7], tt in T)]): T:=Array([seq(Polys[tt[1]], tt in T)]): RETURN([T,THH]); end: ################################################################ TEST := proc (u, F, V,Tord) local M,VV, k,i,Ind,L,lu; #option trace; L:=F; lu:=LM(u); M[1] := {op(Janet(lu, L,V))}; M[2] := {op(RightPommaret(lu, L, V))}; if nops(M[1]) = nops(M[2]) then return (true); else VV:= sort([op(`minus`(M[1], M[2]))], proc (a, b) options operator, arrow; TestOrder(b, a, Tord) end proc); Ind:=indets(u): for i from nops(V) to 1 by -1 while not (V[i] in Ind) do od: return (false, VV[1],V[i]); end if; end proc: ################################################################ GTEST := proc (F, V,Tord) local u, A; for u in F do A := TEST(u, F,V, Tord); if nops([A]) <> 1 then RETURN(A); end if; end do; RETURN(true); end proc: ######################## Pommaert Basis ######################### POM := proc (F, Tord,InDiv) local G, L, chen, A, u, LL, LLL,i, B, K,V,uu,m,secondtime,firsttime,secondbytes,firstbytes,sj,LR,ltsj,sjj,KK,LH,LS,LLH; global tord,T,Q,Polys,Vars,c1,c2,c3,deg,rdz, reduct,ltshh, syzelim, mmtelim,MMM,HE,isr,ISR2; #option trace; firsttime, firstbytes := kernelopts(cputime, bytesused); HE:=0; deg:=0: ISR2:=0; reduct := 0; c1:=0:c2:=0:rdz:=0; mmtelim := 0; syzelim := 0; isr:=0: V:=[seq([op(Tord)][i], i = 1 .. nops([op(Tord)]))]; LH:=copy(InvBasis(F, Tord,J)); L :=copy(LH[1]); LLL:=copy(LH[2]); MMM:=(d->HFI(LLL,d,Tord,V,Janet)); chen := NULL; LR:=copy(LH[3]); A := GTEST(LR,V,Tord); while A <> true do uu := rand(-5 .. 5)(); while uu = 0 do uu := rand(-5 .. 5)(); end do; m := A[3] = uu*A[2]+A[3]; LS:=expand(subs(m, L)); LLH :=copy(InvBasis2(LS,Tord,J)); LL:=copy(LLH[1]); LR:=copy(LLH[2]): B := GTEST(LR, V,Tord); if B <> A then L:=LL; A := B; chen := chen, m; end if; end do; secondtime, secondbytes := kernelopts(cputime, bytesused); printf("%-1s %1s %1s %1s: %3a %3a\n", The, cpu, time, is, secondtime-firsttime, sec); printf("%-1s %1s %1s: %3a %3a\n", The, used, memory, secondbytes-firstbytes, bytes); printf("%-1s %1s %1s : %3g\n",Num,of,Rds,rdz): printf("%-1s %1s %1s : %3a\n",Num,of,criteria,[c1,c2]): printf("%-1s %1s %1s : %3a\n",Max,of,degree,deg): printf("%-1s %1s %1s : %3a\n",Num,of,linearchange , nops([chen])): printf("%-1s %1s %1s %1s %1s %1s: %3a\n", The, number, of, MMT, elimination, is, mmtelim); printf("%-1s %1s %1s %1s %1s %1s: %3a\n", The, number, of, HilbertDriven, elimination, is, HE); return (L,chen); end: ################################# # Examples # ################################# print("####################HAAS 3"); F := [a*h^2*y^3-h^5*y+x^6, bb*h^2*x^3-h^5*x+y^6, -9*a*bb*h^4*x^2*y^2+3*a*h^7*y^2+3*bb*h^7*x^2-h^10+36*x^5*y^5]: POM(F,tdeg(x,y,a,bb,h),J): print("####################Liu"); F:=[y*z-y*t0-x*ee+a*ee, z*t0-z*x-y*ee+a*ee, t0*x-y*t0-z*ee+a*ee, x*y-z*x-t0*ee+a*ee]: POM(F,tdeg(z, y, x, t0, a, ee),J): print("####################Cyclic 5"); F:=[a*bb*c*d*e-x^5, a*bb*c*d + a*bb*c*e + a*bb*d*e + a*c*d*e + bb*c*d*e, a*bb*c + a*bb*e + a*d*e + bb*c*d + c*d*e, a*bb*x + a*e*x + bb*c*x + c*d*x + d*e*x, a + bb + c + d + e]: POM(F,tdeg(a,bb,c,d,e,x),J): print("####################Noon"); F := [10*x1^2*x4+10*x2^2*x4+10*x3^2*x4-11*x4*z^2+10*z^3, 10*x1^2*x3+10*x2^2*x3+10*x3*x4^2-11*x3*z^2+10*z^3, 10*x1*x2^2+10*x1*x3^2+10*x1*x4^2-11*x1*z^2+10*z^3, 10*x1^2*x2+10*x2*x3^2+10*x2*x4^2-11*x2*z^2+10*z^3]: POM(F, tdeg(x1, x2, x3, x4, z), J); print("####################Weispfenning94"); F := [y^4+x*y^2*zz+x^2*hh^2-2*x*y*hh^2+y^2*hh^2+zz^2*hh^2, x*y^4+y*zz^4-2*x^2*y*hh^2-3*hh^5, -y^2*x^3+x*y*zz^3+y^4*hh+x*y^2*zz*hh-2*x*y*hh^3]: POM(F, tdeg(x,y,zz,hh), J): print("####################Katsura5"); F := [2*at^2+2*au^2+av^2-av*x+2*ax^2+2*ay^2+2*az^2, 2*at*au+2*at*az+2*au*av-au*x+ax*ay+ay*az, 2*a*at*y+2*a*au*z+2*at*av*x-at*x^2+au^2*x+2*ax*az*x, 2*at*au+2*at*ax+2*au*ay+2*av*az-az*x, at^2+2*av*ax+2*av*ay+2*av*az-ay*x, 2*at+2*au+av+2*ax+2*ay+2*az-x]: POM(F, tdeg(ax, ay, az, at, au, av,x), J): print("####################Eco7"); F := [-x^3+x*x1*x7+x1*x2*x7+x2*x3*x7+x3*x4*x7+x4*x5*x7+x5*x6*x7, -2*x^3+x*x2*x7+x1*x3*x7+x2*x4*x7+x3*x5*x7+x4*x6*x7, -3*x^3+x*x3*x7+x1*x4*x7+x2*x5*x7+x3*x6*x7, -4*x^3+x*x4*x7+x1*x5*x7+x2*x6*x7, -5*x^3+x*x5*x7+x1*x6*x7, -6*x^2+x6*x7, x1+x2+x3+x4+x5+x6+x]: POM(F, tdeg(x1, x2, x3, x4,x5,x6,x7,x), J): print("####################Lichtblau"); F := [x*z^10-110*t^2*z^9+495*t^3*z^8-1320*t^4*z^7+2772*t^5*z^6-5082*t^6*z^5+7590*t^7*z^4-8085*t^8*z^3+5555*t^9*z^2-2189*t^10*z+374*t^11, y*z^10-22*t*z^10+110*t^2*z^9-330*t^3*z^8+1848*t^5*z^6-3696*t^6*z^5+3300*t^7*z^4-1650*t^8*z^3+550*t^9*z^2-88*t^10*z-22*t^11]: POM(F, tdeg(x,y,t,z), J): print("####################Cyclic6"); F:=[a*b*c*d*e*f -x^6, a*bb*c*d*e + a*bb*c*d*f + a*bb*c*e*f + a*bb*d*e*f + a*c*d*e*f + bb*c*d*e*f, a*bb*c*d + a*bb*c*f + a*bb*e*f + a*d*e*f + bb*c*d*e + c*d*e*f, a*bb*c + a*bb*f + a*e*f + bb*c*d + c*d*e + d*e*f, a*bb + a*f + bb*c + c*d + d*e + e*f, a + bb + c + d + e + f]: POM(F,tdeg(a,bb,c,d,e,f,x),J): print("####################Katsura6"); F:=[ x1+2*x2+2*x3+2*x4+2*x5+2*x6+2*x7-x, 2*x4*x3+2*x5*x2+2*x6*x1+2*x7*x2-x6*x, x3^2+2*x4*x2+2*x5*x1+2*x6*x2+2*x7*x3-x5*x, 2*x3*x2+2*x4*x1+2*x5*x2+2*x6*x3+2*x7*x4-x*x4, x2^2+2*x3*x1+2*x4*x2+2*x5*x3+2*x6*x4+2*x7*x5-x3*x, 2*x2*x1+2*x3*x2+2*x4*x3+2*x5*x4+2*x6*x5+2*x7*x6-x2*x, x1^2+2*x2^2+2*x3^2+2*x4^2+2*x5^2+2*x6^2+2*x7^2-x1*x ]: POM(F, tdeg(x1, x2, x3, x4,x5,x6,x7,x), J): print("####################Sturmfels and Eisenbud"); F :=[bb*vv+ss*uu, bb*ww+tt*uu, ss*ww+tt*vv, bb*yy+ss*xx, bb*zz+tt*xx, ss*zz+tt*yy, uu*yy+vv*xx, uu*zz+ww*xx, vv*zz+ww*yy]: POM(F, tdeg(bb, xx, yy, zz, ss, tt, uu, vv, ww), J);