Changeset e0883c in git


Ignore:
Timestamp:
Mar 2, 2021, 2:14:39 PM (3 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'd25190065115c859833252500a64cfb7b11e3a50')
Children:
ca899b79b2b68c594ba1ee0e0933ff3665264f5a
Parents:
10c141e8168f988737b6f5c59ccfacdb691d0eea
Message:
format
File:
1 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/sheafcoh.lib

    r10c141 re0883c  
    127127"
    128128{
    129   if ( typeof(attrib(phi,"isHomog"))=="string" ) {
    130     if (size(phi)==0) {
     129  if ( typeof(attrib(phi,"isHomog"))=="string" )
     130  {
     131    if (size(phi)==0)
     132    {
    131133      // assign weights 0 to generators of R^n (n=nrows(phi))
    132134      intvec v;
     
    134136      attrib(phi,"isHomog",v);
    135137    }
    136     else {
     138    else
     139    {
    137140      ERROR("No admissible degree vector assigned");
    138141    }
    139142  }
    140   else {
     143  else
     144  {
    141145   intvec v=attrib(phi,"isHomog");
    142146  }
     
    144148  int s = nrows(phi);
    145149  module L; // TOO BIG!!!
    146   for (i=1; i<=s; i++) {
    147     if (d>v[i]) {
     150  for (i=1; i<=s; i++)
     151  {
     152    if (d>v[i])
     153    {
    148154      L = L+maxideal(d-v[i])*gen(i);
    149155    }
    150     else {
     156    else
     157    {
    151158      L = L+gen(i);
    152159    }
     
    227234  dbprint(PL-1, "// M is a SB! ");
    228235
    229   if ( typeof(attrib(M,"isHomog"))=="string" ) {
    230     if (size(M)==0) {
     236  if ( typeof(attrib(M,"isHomog"))=="string" )
     237  {
     238    if (size(M)==0)
     239    {
    231240      // assign weights 0 to generators of R^n (n=nrows(M))
    232241      intvec v;
     
    234243      attrib(M,"isHomog",v);
    235244    }
    236     else {
     245    else
     246    {
    237247      ERROR("No admissible degree vector assigned");
    238248    }
    239249  }
    240   else {
     250  else
     251  {
    241252   intvec v=attrib(M,"isHomog");
    242253  }
     
    247258  int s = nrows(M);
    248259
    249    int tKBaseBegin = timer;
    250     module L = kbase(M, d); // TODO: check whether this is always correct!?!
    251 
    252 
    253     dbprint(PL-1, "// L = kbase(M,d): "+string(nrows(L)) + " x " + string(ncols(L)) +"");
    254     dbprint(PL-2, L);
    255     dbprint(PL-1, "// weighting(L): ["+ string(attrib(L, "isHomog")) + "]");
    256 
    257    int tModuloBegin = timer;
    258     L = modulo(L,M);
    259 
    260     dbprint(PL-1, "// L = modulo(L,M): "+string(nrows(L)) + " x " + string(ncols(L)) +"");
    261     dbprint(PL-2, L);
    262     dbprint(PL-1, "// weighting(L): ["+ string(attrib(L, "isHomog")) + "]");
    263 
    264    int tPruneBegin = timer;
    265     L = prune(L);
    266 
    267     dbprint(PL-1, "// L = prune(L): "+string(nrows(L)) + " x " + string(ncols(L)) +"");
    268     dbprint(PL-2, L);
    269     dbprint(PL-1, "// weighting(L): ["+ string(attrib(L, "isHomog")) + "]");
    270 
    271    int tPruneEnd = timer;
    272     L = minbase(L);
    273    int tMinBaseEnd = timer;
    274 
    275     dbprint(PL-1, "// L = minbase(L): "+string(nrows(L)) + " x " + string(ncols(L)) +"");
    276     dbprint(PL-2, L);
    277     dbprint(PL-1, "// weighting(L): ["+ string(attrib(L, "isHomog")) + "]");
    278 
    279 
    280 
     260  int tKBaseBegin = timer;
     261  module L = kbase(M, d); // TODO: check whether this is always correct!?!
     262
     263  dbprint(PL-1, "// L = kbase(M,d): "+string(nrows(L)) + " x " + string(ncols(L)) +"");
     264  dbprint(PL-2, L);
     265  dbprint(PL-1, "// weighting(L): ["+ string(attrib(L, "isHomog")) + "]");
     266
     267  int tModuloBegin = timer;
     268  L = modulo(L,M);
     269
     270  dbprint(PL-1, "// L = modulo(L,M): "+string(nrows(L)) + " x " + string(ncols(L)) +"");
     271  dbprint(PL-2, L);
     272  dbprint(PL-1, "// weighting(L): ["+ string(attrib(L, "isHomog")) + "]");
     273
     274  int tPruneBegin = timer;
     275  L = prune(L);
     276
     277  dbprint(PL-1, "// L = prune(L): "+string(nrows(L)) + " x " + string(ncols(L)) +"");
     278  dbprint(PL-2, L);
     279  dbprint(PL-1, "// weighting(L): ["+ string(attrib(L, "isHomog")) + "]");
     280
     281  int tPruneEnd = timer;
     282  L = minbase(L);
     283  int tMinBaseEnd = timer;
     284
     285  dbprint(PL-1, "// L = minbase(L): "+string(nrows(L)) + " x " + string(ncols(L)) +"");
     286  dbprint(PL-2, L);
     287  dbprint(PL-1, "// weighting(L): ["+ string(attrib(L, "isHomog")) + "]");
    281288
    282289  if (size(L)!=0)
    283290  {
    284 
    285291    // it only remains to set the degrees for L:
    286292    // ------------------------------------------
     
    298304  dbprint(PL-1, "// corrected weighting(L): ["+ string(attrib(L, "isHomog")) + "]");
    299305
    300 
    301306  if(PL > 0)
    302307  {
     
    313318
    314319  option(set, save);
    315 
    316320  return(L);
    317321}
    318322example
    319323{"EXAMPLE:";
    320    echo = 2;
    321    ring R=0,(x,y,z,u,v),dp;
    322    module M=maxideal(3);
    323    homog(M);
    324    // compute presentation matrix for truncated module (R/<x,y,z,u>^3)_(>=2)
    325    int t=timer;
    326    module M2t=truncate(M,2);
    327    t = timer - t;
    328    "// Simple truncate: ", t;
    329    t=timer;
    330    module M2=truncateFast(std(M),2);
    331    t = timer - t;
    332    "// Fast truncate: ", t;
    333    print(M2);
    334    "// Check: M2t == M2?: ", size(NF(M2, std(M2t))) + size(NF(M2t, std(M2)));
    335 
    336    dimGradedPart(M2,1);
    337    dimGradedPart(M2,2);
    338    // this should coincide with:
    339    dimGradedPart(M,2);
    340    // shift grading by 1:
    341    intvec v=1;
    342    attrib(M,"isHomog",v);
    343    t=timer;
    344    M2t=truncate(M,2);
    345    t = timer - t;
    346    "// Simple truncate: ", t;
    347    t=timer;
    348    M2=truncateFast(std(M),2);
    349    t = timer - t;
    350    "// Fast truncate: ", t;
    351    print(M2);
    352    "// Check: M2t == M2?: ", size(NF(M2, std(M2t))) + size(NF(M2t, std(M2))); //?
    353    dimGradedPart(M2,3);
     324  echo = 2;
     325  ring R=0,(x,y,z,u,v),dp;
     326  module M=maxideal(3);
     327  homog(M);
     328  // compute presentation matrix for truncated module (R/<x,y,z,u>^3)_(>=2)
     329  int t=timer;
     330  module M2t=truncate(M,2);
     331  t = timer - t;
     332  "// Simple truncate: ", t;
     333  t=timer;
     334  module M2=truncateFast(std(M),2);
     335  t = timer - t;
     336  "// Fast truncate: ", t;
     337  print(M2);
     338  "// Check: M2t == M2?: ", size(NF(M2, std(M2t))) + size(NF(M2t, std(M2)));
     339
     340  dimGradedPart(M2,1);
     341  dimGradedPart(M2,2);
     342  // this should coincide with:
     343  dimGradedPart(M,2);
     344  // shift grading by 1:
     345  intvec v=1;
     346  attrib(M,"isHomog",v);
     347  t=timer;
     348  M2t=truncate(M,2);
     349  t = timer - t;
     350  "// Simple truncate: ", t;
     351  t=timer;
     352  M2=truncateFast(std(M),2);
     353  t = timer - t;
     354  "// Fast truncate: ", t;
     355  print(M2);
     356  "// Check: M2t == M2?: ", size(NF(M2, std(M2t))) + size(NF(M2t, std(M2))); //?
     357  dimGradedPart(M2,3);
    354358}
    355359
    356360///////////////////////////////////////////////////////////////////////////////
    357 
    358 
    359 
    360 
    361361
    362362proc dimGradedPart(module phi, int d)
     
    371371"
    372372{
    373   if ( typeof(attrib(phi,"isHomog"))=="string" ) {
    374     if (size(phi)==0) {
     373  if ( typeof(attrib(phi,"isHomog"))=="string" )
     374  {
     375    if (size(phi)==0)
     376    {
    375377      // assign weights 0 to generators of R^n (n=nrows(phi))
    376378      intvec v;
     
    379381    else { ERROR("No admissible degree vector assigned"); }
    380382  }
    381   else {
     383  else
     384  {
    382385    intvec v=attrib(phi,"isHomog");
    383386  }
     
    385388  int i,m,dummy;
    386389  module L,LL;
    387   for (i=1; i<=s; i++) {
    388     if (d>v[i]) {
     390  for (i=1; i<=s; i++)
     391  {
     392    if (d>v[i])
     393    {
    389394      L = L+maxideal(d-v[i])*gen(i);
    390395      LL = LL+maxideal(d+1-v[i])*gen(i);
    391396    }
    392     else {
     397    else
     398    {
    393399      L = L+gen(i);
    394       if (d==v[i]) {
     400      if (d==v[i])
     401      {
    395402        LL = LL+maxideal(1)*gen(i);
    396403      }
    397       else {
     404      else
     405      {
    398406        LL = LL+gen(i);
    399407      }
     
    435443"
    436444{
    437   if ( typeof(attrib(M,"isHomog"))=="string" ) {
    438     if (size(M)==0) {
     445  if ( typeof(attrib(M,"isHomog"))=="string" )
     446  {
     447    if (size(M)==0)
     448    {
    439449      // assign weights 0 to generators of R^n (n=nrows(M))
    440450      intvec v;
     
    442452      attrib(M,"isHomog",v);
    443453    }
    444     else {
     454    else
     455    {
    445456      ERROR("No admissible degree vector assigned");
    446457    }
     
    450461  {
    451462    def L = minres( res(M,0) ); // let's try it out!
    452   } else
     463  }
     464  else
    453465  {
    454466    def L = mres(M,0);
     
    457469  intmat BeL = betti(L);
    458470  int r = nrows(module(matrix(BeL)));  // last non-zero row
    459   if (typeof(attrib(BeL,"rowShift"))!="string") {
     471  if (typeof(attrib(BeL,"rowShift"))!="string")
     472  {
    460473    int shift = attrib(BeL,"rowShift");
    461474  }
     
    464477example
    465478{"EXAMPLE:";
    466    echo = 2;
    467    ring R=0,(x,y,z,u),dp;
    468    resolution T1=mres(maxideal(1),0);
    469    module M=T1[3];
    470    intvec v=2,2,2,2,2,2;
    471    attrib(M,"isHomog",v);
    472    CM_regularity(M);
     479  echo = 2;
     480  ring R=0,(x,y,z,u),dp;
     481  resolution T1=mres(maxideal(1),0);
     482  module M=T1[3];
     483  intvec v=2,2,2,2,2,2;
     484  attrib(M,"isHomog",v);
     485  CM_regularity(M);
    473486}
    474487
     
    579592example
    580593{"EXAMPLE:";
    581    echo = 2;
    582    // cohomology of structure sheaf on P^4:
    583    //-------------------------------------------
    584    ring r=0,x(1..5),dp;
    585    module M=0;
    586    def A=sheafCohBGG(M,-9,4);
    587    // cohomology of cotangential bundle on P^3:
    588    //-------------------------------------------
    589    ring R=0,(x,y,z,u),dp;
    590    resolution T1=mres(maxideal(1),0);
    591    module M=T1[3];
    592    intvec v=2,2,2,2,2,2;
    593    attrib(M,"isHomog",v);
    594    def B=sheafCohBGG(M,-8,4);
     594  echo = 2;
     595  // cohomology of structure sheaf on P^4:
     596  //-------------------------------------------
     597  ring r=0,x(1..5),dp;
     598  module M=0;
     599  def A=sheafCohBGG(M,-9,4);
     600  // cohomology of cotangential bundle on P^3:
     601  //-------------------------------------------
     602  ring R=0,(x,y,z,u),dp;
     603  resolution T1=mres(maxideal(1),0);
     604  module M=T1[3];
     605  intvec v=2,2,2,2,2,2;
     606  attrib(M,"isHomog",v);
     607  def B=sheafCohBGG(M,-8,4);
    595608}
    596609
     
    606619  {
    607620    Betti = betti(R);
    608   } else
     621  }
     622  else
    609623  {
    610624    if(typeof(R)!="intmat")
     
    643657  int i, j;
    644658
    645   for (j=1; j<=row; j++) {
    646     for (i=l; i<=h; i++) {
    647       if( (n+2-shift-j)>0 ) {
    648 
    649         if (  (k+1-j-i+ell-shift>0) and (j+i-ell+shift>=1)) {
     659  for (j=1; j<=row; j++)
     660  {
     661    for (i=l; i<=h; i++)
     662    {
     663      if( (n+2-shift-j)>0 )
     664      {
     665        if (  (k+1-j-i+ell-shift>0) and (j+i-ell+shift>=1))
     666        {
    650667          newBetti[n+2-shift-j,i-l+1]=Betti[j,k+1-j-i+ell-shift];
    651668        }
    652669        else { newBetti[n+2-shift-j,i-l+1]=-1; }
    653 
    654670      }
    655671    }
    656672  }
    657673
    658   for (j=2; j<=n+1; j++) {
    659     for (i=1; i<min(j, iWTH); i++) {
     674  for (j=2; j<=n+1; j++)
     675  {
     676    for (i=1; i<min(j, iWTH); i++)
     677    {
    660678      newBetti[j,i]= -1;
    661679    }
    662680  }
    663681
    664   for (j=1; j<=n; j++) {
    665     for (i=iWTH; i>=k+j; i--) {
     682  for (j=1; j<=n; j++)
     683  {
     684    for (i=iWTH; i>=k+j; i--)
     685    {
    666686      newBetti[j,i]=0; // -1;
    667687    }
     
    673693    displayCohom(newBetti, l, h, n);
    674694  }
    675 
    676695  return(newBetti);
    677696}
     
    900919example
    901920{"EXAMPLE:";
    902    echo = 2;
    903    int pl = printlevel;
    904    int l,h, t;
    905 
    906    //-------------------------------------------
    907    // cohomology of structure sheaf on P^4:
    908    //-------------------------------------------
    909    ring r=32001,x(1..5),dp;
    910 
    911    module M= getStructureSheaf(); // OO_P^4
    912 
    913    l = -12; h = 12; // range of twists: l..h
    914 
    915    printlevel = 0;
    916    //////////////////////////////////////////////
    917    t = timer;
    918 
    919    def A = sheafCoh(M, l, h); // global Ext method:
    920 
    921    "Time: ", timer - t;
    922    //////////////////////////////////////////////
    923    t = timer;
    924 
    925    A = sheafCohBGG(M, l, h);  // BGG method (without optimization):
    926 
    927    "Time: ", timer - t;
    928    //////////////////////////////////////////////
    929    t = timer;
    930 
    931    A = sheafCohBGG2(M, l, h); // BGG method (with optimization)
    932 
    933    "Time: ", timer - t;
    934    //////////////////////////////////////////////
    935    printlevel = pl;
    936 
    937    kill A, r;
    938 
    939    //-------------------------------------------
    940    // cohomology of cotangential bundle on P^3:
    941    //-------------------------------------------
    942    ring R=32001,(x,y,z,u),dp;
    943 
    944    module M = getCotangentialBundle();
    945 
    946    l = -12; h = 11; // range of twists: l..h
    947 
    948 
    949    //////////////////////////////////////////////
    950    printlevel = 0;
    951    t = timer;
    952 
    953    def B = sheafCoh(M, l, h); // global Ext method:
    954 
    955    "Time: ", timer - t;
    956    //////////////////////////////////////////////
    957    t = timer;
    958 
    959    B = sheafCohBGG(M, l, h);  // BGG method (without optimization):
    960 
    961    "Time: ", timer - t;
    962    //////////////////////////////////////////////
    963    t = timer;
    964 
    965    B = sheafCohBGG2(M, l, h); // BGG method (with optimization)
    966 
    967    "Time: ", timer - t;
    968    //////////////////////////////////////////////
    969    printlevel = pl;
     921  echo = 2;
     922  int pl = printlevel;
     923  int l,h, t;
     924
     925  //-------------------------------------------
     926  // cohomology of structure sheaf on P^4:
     927  //-------------------------------------------
     928  ring r=32001,x(1..5),dp;
     929
     930  module M= getStructureSheaf(); // OO_P^4
     931
     932  l = -12; h = 12; // range of twists: l..h
     933
     934  printlevel = 0;
     935  //////////////////////////////////////////////
     936  t = timer;
     937
     938  def A = sheafCoh(M, l, h); // global Ext method:
     939
     940  "Time: ", timer - t;
     941  //////////////////////////////////////////////
     942  t = timer;
     943
     944  A = sheafCohBGG(M, l, h);  // BGG method (without optimization):
     945
     946  "Time: ", timer - t;
     947  //////////////////////////////////////////////
     948  t = timer;
     949
     950  A = sheafCohBGG2(M, l, h); // BGG method (with optimization)
     951
     952  "Time: ", timer - t;
     953  //////////////////////////////////////////////
     954  printlevel = pl;
     955
     956  kill A, r;
     957
     958  //-------------------------------------------
     959  // cohomology of cotangential bundle on P^3:
     960  //-------------------------------------------
     961  ring R=32001,(x,y,z,u),dp;
     962
     963  module M = getCotangentialBundle();
     964
     965  l = -12; h = 11; // range of twists: l..h
     966
     967  //////////////////////////////////////////////
     968  printlevel = 0;
     969  t = timer;
     970
     971  def B = sheafCoh(M, l, h); // global Ext method:
     972
     973  "Time: ", timer - t;
     974  //////////////////////////////////////////////
     975  t = timer;
     976
     977  B = sheafCohBGG(M, l, h);  // BGG method (without optimization):
     978
     979  "Time: ", timer - t;
     980  //////////////////////////////////////////////
     981  t = timer;
     982
     983  B = sheafCohBGG2(M, l, h); // BGG method (with optimization)
     984
     985  "Time: ", timer - t;
     986  //////////////////////////////////////////////
     987  printlevel = pl;
    970988}
    971989
     
    10031021  int Result;
    10041022  int n=nvars(basering)-1;
    1005   if ((i>0) and (i<=n)) {
     1023  if ((i>0) and (i<=n))
     1024  {
    10061025    list L=Ext_R(n-i,M,1)[2];
    10071026    def N=L[1];
     
    10191038      return(Result);
    10201039    }
    1021     else {
     1040    else
     1041    {
    10221042      return(0);
    10231043    }
     
    10261046example
    10271047{"EXAMPLE:";
    1028    echo = 2;
    1029    ring R=0,(x,y,z,u),dp;
    1030    resolution T1=mres(maxideal(1),0);
    1031    module M=T1[3];
    1032    intvec v=2,2,2,2,2,2;
    1033    attrib(M,"isHomog",v);
    1034    dimH(0,M,2);
    1035    dimH(1,M,0);
    1036    dimH(2,M,1);
    1037    dimH(3,M,-5);
     1048  echo = 2;
     1049  ring R=0,(x,y,z,u),dp;
     1050  resolution T1=mres(maxideal(1),0);
     1051  module M=T1[3];
     1052  intvec v=2,2,2,2,2,2;
     1053  attrib(M,"isHomog",v);
     1054  dimH(0,M,2);
     1055  dimH(1,M,0);
     1056  dimH(2,M,1);
     1057  dimH(3,M,-5);
    10381058}
    10391059
     
    11001120     N=L[j];
    11011121     attrib(N,"isSB",1);
    1102      if (dim(N)>=0) {
     1122     if (dim(N)>=0)
     1123     {
    11031124       for (i=l; i<=h; i++)
    11041125       {
     
    11121133example
    11131134{"EXAMPLE:";
    1114    echo = 2;
    1115    //
    1116    // cohomology of structure sheaf on P^4:
    1117    //-------------------------------------------
    1118    ring r=0,x(1..5),dp;
    1119    module M=0;
    1120    def A=sheafCoh(0,-7,2);
    1121    //
    1122    // cohomology of cotangential bundle on P^3:
    1123    //-------------------------------------------
    1124    ring R=0,(x,y,z,u),dp;
    1125    resolution T1=mres(maxideal(1),0);
    1126    module M=T1[3];
    1127    intvec v=2,2,2,2,2,2;
    1128    attrib(M,"isHomog",v);
    1129    def B=sheafCoh(M,-6,2);
     1135  echo = 2;
     1136  //
     1137  // cohomology of structure sheaf on P^4:
     1138  //-------------------------------------------
     1139  ring r=0,x(1..5),dp;
     1140  module M=0;
     1141  def A=sheafCoh(0,-7,2);
     1142  //
     1143  // cohomology of cotangential bundle on P^3:
     1144  //-------------------------------------------
     1145  ring R=0,(x,y,z,u),dp;
     1146  resolution T1=mres(maxideal(1),0);
     1147  module M=T1[3];
     1148  intvec v=2,2,2,2,2,2;
     1149  attrib(M,"isHomog",v);
     1150  def B=sheafCoh(M,-6,2);
    11301151}
    11311152
     
    11701191  string Row="    ";
    11711192  string Row1="----";
    1172   for (i=l; i<=h; i++) {
     1193  for (i=l; i<=h; i++)
     1194  {
    11731195    for (j=1; j<=maxL-size(string(i)); j++)
    11741196    {
     
    12771299example
    12781300{"EXAMPLE:";
    1279    echo = 2; int pl = printlevel;
    1280    printlevel = voice;
    1281 
    1282 
    1283    ////////////////////////////////////////////////////////////////////////////////
    1284    ring r;
    1285    module M = getStructureSheaf();
    1286    "Basering: ";
    1287    basering;
    1288    "Module: ", string(M), ", grading is given by weights: ", attrib(M, "isHomog");
    1289 
    1290    def A=sheafCohBGG2(M,-9,9);
    1291    print(A);
    1292 
    1293    ////////////////////////////////////////////////////////////////////////////////
    1294    setring r;
    1295    module M = getStructureSheaf(ideal(var(1)), 0);
    1296 
    1297    "Basering: ";
    1298    basering;
    1299    "Module: ", string(M), ", grading is given by weights: ", attrib(M, "isHomog");
    1300 
    1301    def A=sheafCohBGG2(M,-9,9);
    1302    print(A);
    1303 
    1304    ////////////////////////////////////////////////////////////////////////////////
    1305    setring r;
    1306    def Q = getStructureSheaf(ideal(var(1)), 1); // returns a new ring!
    1307    setring Q; // M was exported in the new ring!
    1308 
    1309    "Basering: ";
    1310    basering;
    1311    "Module: ", string(M), ", grading is given by weights: ", attrib(M, "isHomog");
    1312 
    1313    def A=sheafCohBGG2(M,-9,9);
    1314    print(A);
    1315 
    1316    printlevel = pl;
     1301  echo = 2; int pl = printlevel;
     1302  printlevel = voice;
     1303
     1304
     1305  //////////////////////////////////////////////////////////////////////////////
     1306  ring r;
     1307  module M = getStructureSheaf();
     1308  "Basering: ";
     1309  basering;
     1310  "Module: ", string(M), ", grading is given by weights: ", attrib(M, "isHomog");
     1311
     1312  def A=sheafCohBGG2(M,-9,9);
     1313  print(A);
     1314
     1315  //////////////////////////////////////////////////////////////////////////////
     1316  setring r;
     1317  module M = getStructureSheaf(ideal(var(1)), 0);
     1318
     1319  "Basering: ";
     1320  basering;
     1321  "Module: ", string(M), ", grading is given by weights: ", attrib(M, "isHomog");
     1322
     1323  def A=sheafCohBGG2(M,-9,9);
     1324  print(A);
     1325
     1326  //////////////////////////////////////////////////////////////////////////////
     1327  setring r;
     1328  def Q = getStructureSheaf(ideal(var(1)), 1); // returns a new ring!
     1329  setring Q; // M was exported in the new ring!
     1330
     1331  "Basering: ";
     1332  basering;
     1333  "Module: ", string(M), ", grading is given by weights: ", attrib(M, "isHomog");
     1334
     1335  def A=sheafCohBGG2(M,-9,9);
     1336  print(A);
     1337
     1338  printlevel = pl;
    13171339}
    13181340
     
    13481370  return(M);
    13491371}
    1350 
    1351 
    1352 
    13531372
    13541373
Note: See TracChangeset for help on using the changeset viewer.