Singular

LIB "multigrading.lib";
ring r = 0,(x,y,z,w),dp;
intmat M[2][4]=
1,1,1,1,
0,1,3,4;
setBaseMultigrading(M);
module m= ideal(  xw-yz, x2z-y3, xz2-y2w, yw2-z3);
isHomogeneous(ideal(  xw-yz, x2z-y3, xz2-y2w, yw2-z3), "checkGens");
==> 1
ideal A = xw-yz, x2z-y3, xz2-y2w, yw2-z3;
int j;
for(j=1; j<=ncols(A); j++)
{
multiDegPartition(A[j]);
}
==> _[1]=-yz+xw
==> _[1]=-y3+x2z
==> _[1]=xz2-y2w
==> _[1]=-z3+yw2
intmat v[2][1]=
1,
0;
m = setModuleGrading(m, v);
// Let's compute Syzygy!
def S = multiDegSyzygy(m); S;
==> S[1]=yw*gen(1)-x*gen(4)-z*gen(3)
==> S[2]=z2*gen(1)-y*gen(4)-w*gen(3)
==> S[3]=xz*gen(1)+y*gen(3)-w*gen(2)
==> S[4]=y2*gen(1)+x*gen(3)-z*gen(2)
"Module Units Multigrading: "; print( getModuleGrading(S) );
==> Module Units Multigrading: 
==>      3     4     4     4
==>      4     3     6     9
"Multidegrees: "; print(multiDeg(S));
==> Multidegrees: 
==>      5     5     5     5
==>      9    10     7     6
/////////////////////////////////////////////////////////////////////////////
S = multiDegGroebner(S); S;
==> S[1]=yw*gen(1)-x*gen(4)-z*gen(3)
==> S[2]=z2*gen(1)-y*gen(4)-w*gen(3)
==> S[3]=xz*gen(1)+y*gen(3)-w*gen(2)
==> S[4]=y2*gen(1)+x*gen(3)-z*gen(2)
==> S[5]=xy*gen(4)+yz*gen(3)+xw*gen(3)-zw*gen(2)
==> S[6]=xz2*gen(4)+z3*gen(3)-y2w*gen(4)-yw2*gen(3)
==> S[7]=x2z*gen(4)+xz2*gen(3)+y2w*gen(3)-yw2*gen(2)
==> S[8]=y3*gen(3)-x2z*gen(3)+xz2*gen(2)-y2w*gen(2)
==> S[9]=y3*gen(4)+xz2*gen(3)-z3*gen(2)+y2w*gen(3)
"Module Units Multigrading: "; print( getModuleGrading(S) );
==> Module Units Multigrading: 
==>      3     4     4     4
==>      4     3     6     9
"Multidegrees: "; print(multiDeg(S));
==> Multidegrees: 
==>      5     5     5     5     6     7     7     7     7
==>      9    10     7     6    10    15    12     9    12
/////////////////////////////////////////////////////////////////////////////
list L = multiDegResolution(m, 0, 1);
for( j =1; j<=size(L); j++)
{
"----------------------------------- ", j, " -----------------------------";
L[j];
"Module Multigrading: "; print( getModuleGrading(L[j]) );
"Multigrading: "; print(multiDeg(L[j]));
}
==> -----------------------------------  1  -----------------------------
==> _[1]=yz*gen(1)-xw*gen(1)
==> _[2]=z3*gen(1)-yw2*gen(1)
==> _[3]=xz2*gen(1)-y2w*gen(1)
==> _[4]=y3*gen(1)-x2z*gen(1)
==> Module Multigrading: 
==>      1
==>      0
==> Multigrading: 
==>      3     4     4     4
==>      4     9     6     3
==> -----------------------------------  2  -----------------------------
==> _[1]=yw*gen(1)-x*gen(2)+z*gen(3)
==> _[2]=z2*gen(1)-y*gen(2)+w*gen(3)
==> _[3]=xz*gen(1)-y*gen(3)-w*gen(4)
==> _[4]=y2*gen(1)-x*gen(3)-z*gen(4)
==> Module Multigrading: 
==>      3     4     4     4
==>      4     9     6     3
==> Multigrading: 
==>      5     5     5     5
==>      9    10     7     6
==> -----------------------------------  3  -----------------------------
==> _[1]=x*gen(2)-y*gen(1)-z*gen(3)+w*gen(4)
==> Module Multigrading: 
==>      5     5     5     5
==>      9    10     7     6
==> Multigrading: 
==>      6
==>     10
/////////////////////////////////////////////////////////////////////////////
L = multiDegResolution(maxideal(1), 0, 1);
for( j =1; j<=size(L); j++)
{
"----------------------------------- ", j, " -----------------------------";
L[j];
"Module Multigrading: "; print( getModuleGrading(L[j]) );
"Multigrading: "; print(multiDeg(L[j]));
}
==> -----------------------------------  1  -----------------------------
==> _[1]=w
==> _[2]=z
==> _[3]=y
==> _[4]=x
==> Module Multigrading: 
==>      0
==>      0
==> Multigrading: 
==>      1     1     1     1
==>      4     3     1     0
==> -----------------------------------  2  -----------------------------
==> _[1]=-z*gen(1)+w*gen(2)
==> _[2]=-y*gen(1)+w*gen(3)
==> _[3]=-y*gen(2)+z*gen(3)
==> _[4]=-x*gen(1)+w*gen(4)
==> _[5]=-x*gen(2)+z*gen(4)
==> _[6]=-x*gen(3)+y*gen(4)
==> Module Multigrading: 
==>      1     1     1     1
==>      4     3     1     0
==> Multigrading: 
==>      2     2     2     2     2     2
==>      7     5     4     4     3     1
==> -----------------------------------  3  -----------------------------
==> _[1]=y*gen(1)-z*gen(2)+w*gen(3)
==> _[2]=x*gen(1)-z*gen(4)+w*gen(5)
==> _[3]=x*gen(2)-y*gen(4)+w*gen(6)
==> _[4]=x*gen(3)-y*gen(5)+z*gen(6)
==> Module Multigrading: 
==>      2     2     2     2     2     2
==>      7     5     4     4     3     1
==> Multigrading: 
==>      3     3     3     3
==>      8     7     5     4
==> -----------------------------------  4  -----------------------------
==> _[1]=-x*gen(1)+y*gen(2)-z*gen(3)+w*gen(4)
==> Module Multigrading: 
==>      3     3     3     3
==>      8     7     5     4
==> Multigrading: 
==>      4
==>      8
kill v;
def h = hilbertSeries(m);
==>  ------------ 
==> This proc returns a ring with polynomials called 'numerator1/2' and 'deno\
   minator1/2'!
==> They represent the first and the second Hilbert Series.
==> The s_(i)-variables are defined to be the inverse of the t_(i)-variables.
==>  ------------ 
setring h;
numerator1;
==> -t_(1)^6*t_(2)^10+t_(1)^5*t_(2)^10+t_(1)^5*t_(2)^9-t_(1)^4*t_(2)^9+t_(1)^\
   5*t_(2)^7+t_(1)^5*t_(2)^6-t_(1)^4*t_(2)^6-t_(1)^4*t_(2)^3-t_(1)^3*t_(2)^4\
   +t_(1)
factorize(numerator1);
==> [1]:
==>    _[1]=-1
==>    _[2]=t_(1)
==>    _[3]=t_(1)^3*t_(2)^6-t_(1)^2*t_(2)^6-t_(1)^2*t_(2)^2-t_(1)*t_(2)^3-t_(\
   1)*t_(2)-1
==>    _[4]=t_(1)*t_(2)^3-1
==>    _[5]=t_(1)*t_(2)-1
==> [2]:
==>    1,1,1,1,1
denominator1;
==> t_(1)^4*t_(2)^8-t_(1)^3*t_(2)^8-t_(1)^3*t_(2)^7+t_(1)^2*t_(2)^7-t_(1)^3*t\
   _(2)^5-t_(1)^3*t_(2)^4+t_(1)^2*t_(2)^5+2*t_(1)^2*t_(2)^4+t_(1)^2*t_(2)^3-\
   t_(1)*t_(2)^4-t_(1)*t_(2)^3+t_(1)^2*t_(2)-t_(1)*t_(2)-t_(1)+1
factorize(denominator1);
==> [1]:
==>    _[1]=1
==>    _[2]=t_(1)-1
==>    _[3]=t_(1)*t_(2)-1
==>    _[4]=t_(1)*t_(2)^4-1
==>    _[5]=t_(1)*t_(2)^3-1
==> [2]:
==>    1,1,1,1,1
numerator2;
==> -t_(1)^4*t_(2)^6+t_(1)^3*t_(2)^6+t_(1)^3*t_(2)^2+t_(1)^2*t_(2)^3+t_(1)^2*\
   t_(2)+t_(1)
factorize(numerator2);
==> [1]:
==>    _[1]=-1
==>    _[2]=t_(1)
==>    _[3]=t_(1)^3*t_(2)^6-t_(1)^2*t_(2)^6-t_(1)^2*t_(2)^2-t_(1)*t_(2)^3-t_(\
   1)*t_(2)-1
==> [2]:
==>    1,1,1
denominator2;
==> t_(1)^2*t_(2)^4-t_(1)*t_(2)^4-t_(1)+1
factorize(denominator2);
==> [1]:
==>    _[1]=1
==>    _[2]=t_(1)-1
==>    _[3]=t_(1)*t_(2)^4-1
==> [2]:
==>    1,1,1