#### D.15.13.50 hilbertSeries

Procedure from library `multigrading.lib` (see multigrading_lib).

Usage:
  hilbertSeries(I); I is poly/vector/ideal/module

Purpose:
  computes the multigraded Hilbert Series of I

Note:
  input must have multigraded-homogeneous generators.
  Multigrading should be positive.

Returns:
  a ring in variables t_(i), s_(i), with polynomials
  numerator1 and denominator1 and mutually prime numerator2 and denominator2, quotients of which give the series.

Example:

    LIB "multigrading.lib";
    ring r = 0,(x,y,z,w),dp;
    intmat g[2][4]=
    1,1,1,1,
    0,1,3,4;
    setBaseMultigrading(g);
    module M = ideal(xw-yz, x2z-y3, xz2-y2w, yw2-z3);
    intmat V[2][1]=
    1,
    0;
    M = setModuleGrading(M, V);
    def h = hilbertSeries(M); setring h;
    ==>  ------------
    ==> 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.
    ==>  ------------
    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
    factorize(denominator2);
    ==> [1]:
    ==>    _[1]=1
    ==>    _[2]=t_(1)-1
    ==>    _[3]=t_(1)*t_(2)^4-1
    ==> [2]:
    ==>    1,1,1
    kill g, h; setring r;
    intmat g[2][4]=
    1,2,3,4,
    0,0,5,8;
    setBaseMultigrading(g);
    ideal I = x^2, y, z^3;
    I = std(I);
    list L = multiDegResolution(I, 0, 1);
    for( int j = 1; j<=size(L); j++)
    {
    "----------------------------------- ", j, " -----------------------------";
    L[j];
    "Module Multigrading: "; print( getModuleGrading(L[j]) );
    "Multigrading: "; print(multiDeg(L[j]));
    }
    ==> -----------------------------------  1  -----------------------------
    ==> _[1]=y
    ==> _[2]=x2
    ==> _[3]=z3
    ==> Module Multigrading:
    ==>      0
    ==>      0
    ==> Multigrading:
    ==>      2     2     9
    ==>      0     0    15
    ==> -----------------------------------  2  -----------------------------
    ==> _[1]=-x2*gen(1)+y*gen(2)
    ==> _[2]=-z3*gen(1)+y*gen(3)
    ==> _[3]=-z3*gen(2)+x2*gen(3)
    ==> Module Multigrading:
    ==>      2     2     9
    ==>      0     0    15
    ==> Multigrading:
    ==>      4    11    11
    ==>      0    15    15
    ==> -----------------------------------  3  -----------------------------
    ==> _[1]=z3*gen(1)-x2*gen(2)+y*gen(3)
    ==> Module Multigrading:
    ==>      4    11    11
    ==>      0    15    15
    ==> Multigrading:
    ==>     13
    ==>     15
    multiDeg(I);
    ==> 2,2,9,
    ==> 0,0,15
    def h = hilbertSeries(I); setring h;
    ==>  ------------
    ==> 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.
    ==>  ------------
    factorize(numerator2);
    ==> [1]:
    ==>    _[1]=-1
    ==>    _[2]=t_(1)+1
    ==>    _[3]=t_(1)^6*t_(2)^10+t_(1)^3*t_(2)^5+1
    ==> [2]:
    ==>    1,1,1
    factorize(denominator2);
    ==> [1]:
    ==>    _[1]=1
    ==>    _[2]=t_(1)*t_(2)^2-1
    ==>    _[3]=t_(1)*t_(2)^2+1
    ==>    _[4]=t_(1)^2*t_(2)^4+1
    ==> [2]:
    ==>    1,1,1,1
    kill r, h, g, V;
    ////////////////////////////////////////////////
    ring R = 0,(x,y,z),dp;
    intmat W[2][3] =
    1,1, 1,
    0,0,-1;
    setBaseMultigrading(W);
    ideal I = x3y,yz2,y2z,z4;
    def h = hilbertSeries(I); setring h;
    ==>  ------------
    ==> 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.
    ==>  ------------
    factorize(numerator2);
    ==> [1]:
    ==>    _[1]=1
    ==>    _[2]=-t_(1)^5*s_(2)+t_(1)^3*s_(2)^3+t_(1)^2*s_(2)^2+t_(1)^3+t_(1)^2*s_\
       (2)+t_(1)^2+t_(1)*s_(2)+t_(1)+1
    ==> [2]:
    ==>    1,1
    factorize(denominator2);
    ==> [1]:
    ==>    _[1]=-1
    ==>    _[2]=t_(1)-1
    ==> [2]:
    ==>    1,1
    kill R, W, h;
    ////////////////////////////////////////////////
    ring R = 0,(x,y,z,a,b,c),dp;
    intmat W[2][6] =
    1,1, 1,1,1,1,
    0,0,-1,0,0,0;
    setBaseMultigrading(W);
    ideal I = x3y,yz2,y2z,z4;
    def h = hilbertSeries(I); setring h;
    ==>  ------------
    ==> 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.
    ==>  ------------
    factorize(numerator2);
    ==> [1]:
    ==>    _[1]=1
    ==>    _[2]=-t_(1)^5*s_(2)+t_(1)^3*s_(2)^3+t_(1)^2*s_(2)^2+t_(1)^3+t_(1)^2*s_\
       (2)+t_(1)^2+t_(1)*s_(2)+t_(1)+1
    ==> [2]:
    ==>    1,1
    factorize(denominator2);
    ==> [1]:
    ==>    _[1]=1
    ==>    _[2]=t_(1)-1
    ==> [2]:
    ==>    1,4
    kill R, W, h;
    ////////////////////////////////////////////////
    // This is example 5.3.9. from Robbianos book.
    ring R = 0,(x,y,z,w),dp;
    intmat W[1][4] =
    1,1, 1,1;
    setBaseMultigrading(W);
    ideal I = z3,y3zw2,x2y4w2xyz2;
    hilb(std(I));
    ==> //         1 t^0
    ==> //        -1 t^3
    ==> //        -1 t^6
    ==> //         1 t^8
    ==>
    ==> //         1 t^0
    ==> //         1 t^1
    ==> //         1 t^2
    ==> //        -1 t^6
    ==> //        -1 t^7
    ==> // dimension (proj.)  = 2
    ==> // degree (proj.)   = 1
    def h = hilbertSeries(I); setring h;
    ==>  ------------
    ==> 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.
    ==>  ------------
    numerator1;
    ==> t_(1)^8-t_(1)^6-t_(1)^3+1
    denominator1;
    ==> t_(1)^4-4*t_(1)^3+6*t_(1)^2-4*t_(1)+1
    factorize(numerator2);
    ==> [1]:
    ==>    _[1]=1
    ==>    _[2]=t_(1)^7+t_(1)^6-t_(1)^2-t_(1)-1
    ==> [2]:
    ==>    1,1
    factorize(denominator2);
    ==> [1]:
    ==>    _[1]=1
    ==>    _[2]=t_(1)-1
    ==> [2]:
    ==>    1,3
    kill h;
    ////////////////////////////////////////////////
    setring R;
    ideal I2 = x2,y2,z2; I2;
    ==> I2[1]=x2
    ==> I2[2]=y2
    ==> I2[3]=z2
    hilb(std(I2));
    ==> //         1 t^0
    ==> //        -3 t^2
    ==> //         3 t^4
    ==> //        -1 t^6
    ==>
    ==> //         1 t^0
    ==> //         3 t^1
    ==> //         3 t^2
    ==> //         1 t^3
    ==> // dimension (proj.)  = 0
    ==> // degree (proj.)   = 8
    def h = hilbertSeries(I2); setring h;
    ==>  ------------
    ==> 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.
    ==>  ------------
    numerator1;
    ==> -t_(1)^6+3*t_(1)^4-3*t_(1)^2+1
    denominator1;
    ==> t_(1)^4-4*t_(1)^3+6*t_(1)^2-4*t_(1)+1
    kill h;
    ////////////////////////////////////////////////
    setring R;
    W = 2,2,2,2;
    setBaseMultigrading(W);
    getVariableWeights();
    ==> 2,2,2,2
    intvec w = 2,2,2,2;
    hilb(std(I2), 1, w);
    ==> 1,0,0,0,-3,0,0,0,3,0,0,0,-1,0
    kill w;
    def h = hilbertSeries(I2); setring h;
    ==>  ------------
    ==> 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.
    ==>  ------------
    numerator1; denominator1;
    ==> -t_(1)^12+3*t_(1)^8-3*t_(1)^4+1
    ==> t_(1)^8-4*t_(1)^6+6*t_(1)^4-4*t_(1)^2+1
    kill h;
    kill R, W;
    ////////////////////////////////////////////////
    ring R = 0,(x),dp;
    intmat W[1][1] =
    1;
    setBaseMultigrading(W);
    ideal I;
    I = 1; I;
    ==> I[1]=1
    hilb(std(I));
    ==>
    ==> // dimension (affine) = 0
    ==> // degree (affine)  = 0
    def h = hilbertSeries(I); setring h;
    ==>  ------------
    ==> 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.
    ==>  ------------
    numerator1; denominator1;
    ==> 0
    ==> -t_(1)+1
    kill h;
    ////////////////////////////////////////////////
    setring R;
    I = x; I;
    ==> I[1]=x
    hilb(std(I));
    ==> //         1 t^0
    ==> //        -1 t^1
    ==>
    ==> //         1 t^0
    ==> // dimension (affine) = 0
    ==> // degree (affine)  = 1
    def h = hilbertSeries(I); setring h;
    ==>  ------------
    ==> 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.
    ==>  ------------
    numerator1; denominator1;
    ==> -t_(1)+1
    ==> -t_(1)+1
    kill h;
    ////////////////////////////////////////////////
    setring R;
    I = x^5; I;
    ==> I[1]=x5
    hilb(std(I));
    ==> //         1 t^0
    ==> //        -1 t^5
    ==>
    ==> //         1 t^0
    ==> //         1 t^1
    ==> //         1 t^2
    ==> //         1 t^3
    ==> //         1 t^4
    ==> // dimension (affine) = 0
    ==> // degree (affine)  = 5
    hilb(std(I), 1);
    ==> 1,0,0,0,0,-1,0
    def h = hilbertSeries(I); setring h;
    ==>  ------------
    ==> 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.
    ==>  ------------
    numerator1; denominator1;
    ==> -t_(1)^5+1
    ==> -t_(1)+1
    kill h;
    ////////////////////////////////////////////////
    setring R;
    I = x^10; I;
    ==> I[1]=x10
    hilb(std(I));
    ==> //         1 t^0
    ==> //        -1 t^10
    ==>
    ==> //         1 t^0
    ==> //         1 t^1
    ==> //         1 t^2
    ==> //         1 t^3
    ==> //         1 t^4
    ==> //         1 t^5
    ==> //         1 t^6
    ==> //         1 t^7
    ==> //         1 t^8
    ==> //         1 t^9
    ==> // dimension (affine) = 0
    ==> // degree (affine)  = 10
    def h = hilbertSeries(I); setring h;
    ==>  ------------
    ==> 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.
    ==>  ------------
    numerator1; denominator1;
    ==> -t_(1)^10+1
    ==> -t_(1)+1
    kill h;
    ////////////////////////////////////////////////
    setring R;
    module M = 1;
    M = setModuleGrading(M, W);
    hilb(std(M));
    ==>
    ==> // dimension (affine) = 0
    ==> // degree (affine)  = 0
    def h = hilbertSeries(M); setring h;
    ==>  ------------
    ==> 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.
    ==>  ------------
    numerator1; denominator1;
    ==> 0
    ==> -t_(1)+1
    kill h;
    ////////////////////////////////////////////////
    setring R;
    kill M; module M = x^5*gen(1);
    //  intmat V[1][3] = 0; // TODO: this would lead to a wrong result!!!?
    intmat V[1][1] = 0; // all gen(i) of degree 0!
    M = setModuleGrading(M, V);
    hilb(std(M));
    ==> //         1 t^0
    ==> //        -1 t^5
    ==>
    ==> //         1 t^0
    ==> //         1 t^1
    ==> //         1 t^2
    ==> //         1 t^3
    ==> //         1 t^4
    ==> // dimension (affine) = 0
    ==> // degree (affine)  = 5
    def h = hilbertSeries(M); setring h;
    ==>  ------------
    ==> 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.
    ==>  ------------
    numerator1; denominator1;
    ==> -t_(1)^5+1
    ==> -t_(1)+1
    kill h;
    ////////////////////////////////////////////////
    setring R;
    module N = x^5*gen(3);
    kill V;
    intmat V[1][3] = 0; // all gen(i) of degree 0!
    N = setModuleGrading(N, V);
    hilb(std(N));
    ==> //         3 t^0
    ==> //        -1 t^5
    ==>
    ==> //         3 t^0
    ==> //        -1 t^5
    ==> // dimension (proj.)  = 0
    ==> // degree (proj.)   = 2
    def h = hilbertSeries(N); setring h;
    ==>  ------------
    ==> 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.
    ==>  ------------
    numerator1; denominator1;
    ==> -t_(1)^5+3
    ==> -t_(1)+1
    kill h;
    ////////////////////////////////////////////////
    setring R;
    module S = M + N;
    S = setModuleGrading(S, V);
    hilb(std(S));
    ==> //         3 t^0
    ==> //        -2 t^5
    ==>
    ==> //         3 t^0
    ==> //        -2 t^5
    ==> // dimension (proj.)  = 0
    ==> // degree (proj.)   = 1
    def h = hilbertSeries(S); setring h;
    ==>  ------------
    ==> 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.
    ==>  ------------
    numerator1; denominator1;
    ==> -2*t_(1)^5+3
    ==> -t_(1)+1
    kill h;
    kill V;
    kill R, W;

User manual for Singular version 4-0-3, 2016, generated by texi2html.