Back to Forum | View unanswered posts | View active topics



Post new topic Reply to topic  Page 1 of 1
  [ 8 posts ] 
  Print view | E-mail friend Previous topic | Next topic 
Author Message
E. Javier Elizondo
 Post subject: Hilbert Series with multi weights in each variable
PostPosted: Tue May 29, 2007 2:45 am 
Hi, I am trying to compute the hilbert series for each module in a minimal free resolution of an ideal with each variable having 5 weights (it is graded under Z^5).

I looked at the manual but I do not see how to put the multiweights in each variable, I can only see how to put one weight to each variable.

I hope someone can help to compute this.

Thanks in adavance, Javier.


Report this post
Top
  
Reply with quote  
Noppadol Mekareeya
 Post subject: Re: Hilbert Series with multi weights in each variable
PostPosted: Wed Jul 07, 2010 5:28 pm 
Hi! I am interested in a similar problem on multigraded Hilbert series. I know that Macaulay2 can compute this, but I was wondering how to do so using Singular. It would be great if someone could give me an example. Thank you very much.


Report this post
Top
  
Reply with quote  
Wolfram Decker
 Post subject: Re: Hilbert Series with multi weights in each variable
PostPosted: Fri Aug 13, 2010 1:32 pm 

Joined: Thu Apr 02, 2009 5:04 pm
Posts: 11
Multigradings are currently under development in SINGULAR.
We will keep you updated on this. If you have further wishes
in this direction, please let us know. You may also follow our
discussion via the Events link on the SINGULAR webpage:
see the wiki under
Software Workshop Geometry and Combinatorics 2010 - Part 2


Report this post
Top
 Profile  
Reply with quote  
lk
 Post subject: Re: Hilbert Series with multi weights in each variable
PostPosted: Thu Aug 26, 2010 4:33 pm 
There is a library called "mgrad.lib" which can be downloaded from
code.google.com/p/convex-singular/source/browse/#svn/trunk/srcs/Singular/samples
. A description of the contained methods is provided on
code.google.com/p/convex-singular/wiki/Multigrading
. This is still work in progress. You can take a Singular intmat g with as many columns as your ring has variables and assign this to your ring with setBaseMultigrading(g). Then you can use most of the methods provided in the library.
There is also a method hilbertSeries(module/ideal) which will provide the multigraded Hilbert series as described in [Miller/Sturmfels]. I am working on it, but so far it does not work for ideals and I haven't checked correctness for modules yet.

lk


Report this post
Top
  
Reply with quote  
vinay
 Post subject: Re: Hilbert Series with multi weights in each variable
PostPosted: Fri Aug 27, 2010 3:30 pm 

Joined: Sat Oct 01, 2005 11:40 am
Posts: 40
Location: IIT Guwahati, Guwahati, Assam, INDIA
I downloaded OO.lib, mgrad.lib & test.sing from th ethe link you gave.
After executing test.sing, I an getting fatal error:
Code:
A:
Singular : signal 11 (v: 3042/2010010208):
Segment fault/Bus error occurred at 80f13ca because of 12 (r:1282917352)
please inform the authors
trying to restart...
   ? error occurred in OO.lib::CallMethod line 60: `    return (M(P)); // P? O?`
   ? last reserved name was `return`
   ? leaving OO.lib::CallMethod
   skipping text from `;` error at token `)`
   ? leaving OO.lib::CallMethod
Auf Wiedersehen.

option(prot) and TRACE doesnt give much information, just that there is some problem with CallMethod().

Singular --version gives:
Code:
Singular for ix86-Linux version 3-0-4 (3042-2010010208)  Jan  2 2010 08:45:44



-- VInay


Report this post
Top
 Profile  
Reply with quote  
gorzel
 Post subject: Re: Hilbert Series with multi weights in each variable
PostPosted: Fri Aug 27, 2010 5:55 pm 

Joined: Wed Mar 03, 2010 5:08 pm
Posts: 108
Location: Germany, Münster
Your Singular version 3-0-4 is too old -- you need Singular 3-1-1.

(the file test.sing does not show the functionality)

Put the libraries in the directory Singular/3-1-1/LIB.
Then you may run:

Code:
> system("version");
3115
> LIB "mgrad.lib";
// ** loaded /data/tmp/sing311/Singular/3-1-1/LIB/mgrad.lib (0.1,2010-02-13)
> example mDegResolution;
// proc mDegResolution from lib mgrad.lib
EXAMPLE:
 
  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);
  isHomogenous(ideal(  xw-yz, x2z-y3, xz2-y2w, yw2-z3), "checkGens");
1
  ideal A = xw-yz, x2z-y3, xz2-y2w, yw2-z3;
  for( int i=1; i<=ncols(A); i++)
    {
      mDegPartition(A[i]);
_[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 = mDegSyzygy(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(mDeg(S));
Multidegrees:
     5     5     5     5
     9    10     7     6

  S = mDegGroebner(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(mDeg(S));
Multidegrees:
     5     5     5     5     6     7     7     7     7
     9    10     7     6    10    15    12     9    12


  def L = mDegResolution(m, 0, 1);

  for( int j =1; j<=size(L); j++)
    {
      "----------------------------------- ", 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
-----------------------------------  4  -----------------------------
_[1]=0
Module Multigrading:
     6
    10
Multigrading:
0,
0

  def h = hilbertSeries(m);
This proc returns a ring with polynomials called 'numerator' and 'denominator!
  setring h;

  numerator;
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
  denominator;
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
  poly d = gcd(numerator, denominator);
  numerator/d;
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
  denominator/d;
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


> example hilbertSeries;
// proc hilbertSeries from lib mgrad.lib
EXAMPLE:
 
  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);
This proc returns a ring with polynomials called 'numerator' and 'denominator!
  setring h;
 
  numerator;
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
  denominator;
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
 
  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;

  def L = mDegResolution(I, 0, 1);

  for( int j = 1; j<=size(L); j++)
  {
    "----------------------------------- ", 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
-----------------------------------  4  -----------------------------
_[1]=0
Module Multigrading:
    13
    15
Multigrading:
0,
0

 
  def hh = hilbertSeries(I); setring hh;
This proc returns a ring with polynomials called 'numerator' and 'denominator!
 
  numerator;
t_(1)^13*t_(2)^15-2*t_(1)^11*t_(2)^15+t_(1)^9*t_(2)^15-t_(1)^4+2*t_(1)^2
  denominator;
t_(1)^10*t_(2)^13-t_(1)^9*t_(2)^13-t_(1)^8*t_(2)^13+t_(1)^7*t_(2)^13-t_(1)^7*t_(2)^8+t_(1)^6*t_(2)^8+t_(1)^5*t_(2)^8-t_(1)^4*t_(2)^8-t_(1)^6*t_(2)^5+t_(1)^5*t_(2)^5+t_(1)^4*t_(2)^5-t_(1)^3*t_(2)^5+t_(1)^3-t_(1)^2-t_(1)+1

  poly d = gcd(numerator, denominator);
 
  numerator/d;
t_(1)^13*t_(2)^15-2*t_(1)^11*t_(2)^15+t_(1)^9*t_(2)^15-t_(1)^4+2*t_(1)^2
  denominator/d;
t_(1)^10*t_(2)^13-t_(1)^9*t_(2)^13-t_(1)^8*t_(2)^13+t_(1)^7*t_(2)^13-t_(1)^7*t_(2)^8+t_(1)^6*t_(2)^8+t_(1)^5*t_(2)^8-t_(1)^4*t_(2)^8-t_(1)^6*t_(2)^5+t_(1)^5*t_(2)^5+t_(1)^4*t_(2)^5-t_(1)^3*t_(2)^5+t_(1)^3-t_(1)^2-t_(1)+1




Report this post
Top
 Profile  
Reply with quote  
vinay
 Post subject: Re: Hilbert Series with multi weights in each variable
PostPosted: Sun Aug 29, 2010 6:16 am 

Joined: Sat Oct 01, 2005 11:40 am
Posts: 40
Location: IIT Guwahati, Guwahati, Assam, INDIA
Thanks! It worked...
I was being lazy for the upgrade to 3-1-1. But I did it now :-)

-- VInay


Report this post
Top
 Profile  
Reply with quote  
lkastner
 Post subject: Re: Hilbert Series with multi weights in each variable
PostPosted: Wed Sep 01, 2010 1:53 pm 

Joined: Thu Aug 26, 2010 4:32 pm
Posts: 4
hilbertSeries() might work now. You need to get the latest verseion of mgrad.lib, then you can test it in the following way:

ring R = 0,(x,y,z,w),dp;
intmat W[1][4] =
1,1, 1,1;
setBaseMultigrading(W);
ideal I = z3,y3zw2,x2y4w2xyz2;

def h = hilbertSeries(I); setring h;

numerator1;
denumerator1;

numerator2;
denumerator2;

The fraction numerator1/denumerator1 represents the Hilbert series of the ideal I. numerator2/denumerator2 is the same with the gcd divided out.
We do not check whether the multigrading is positive, i.e. if the degree zero part of the ring is finite dimensional.
Please tell us about any bug or wrong result you might encounter.

lk


Report this post
Top
 Profile  
Reply with quote  
Display posts from previous:  Sort by  
Post new topic Reply to topic  Page 1 of 1
  [ 8 posts ] 

You can post new topics in this forum
You can reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot post attachments in this forum

It is currently Fri May 13, 2022 11:06 am
Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group