Changeset 2c3a5d in git


Ignore:
Timestamp:
Apr 14, 2009, 1:52:54 PM (14 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')
Children:
3360fb21d69c352925dd6bc1692b4f0bd0c595c1
Parents:
9ea76ad6b1c6727080f37dd35068f985af1b1bd3
Message:
*hannes: code cleanup


git-svn-id: file:///usr/local/Singular/svn/trunk@11694 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular/LIB
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/dmodapp.lib

    r9ea76a r2c3a5d  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: dmodapp.lib,v 1.27 2009-04-10 08:30:16 Singular Exp $";
     2version="$Id: dmodapp.lib,v 1.28 2009-04-14 11:52:54 Singular Exp $";
    33category="Noncommutative";
    44info="
     
    77@*             Daniel Andres, daniel.andres@math.rwth-aachen.de
    88
    9 GUIDE: Let K be a field of characteristic 0, R = K[x1,..xN] and 
     9GUIDE: Let K be a field of characteristic 0, R = K[x1,..xN] and
    1010@* D be the Weyl algebra in variables x1,..xN,d1,..dN.
    1111@* In this library there are the following procedures for algebraic D-modules:
    1212@* - localization of a holonomic module D/I with respect to a mult. closed set
    13 @* of all powers of a given polynomial F from R. Our aim is to compute an 
    14 @* ideal L in D, such that D/L is a presentation of a localized module. Such L 
    15 @* always exists, since such localizations are known to be holonomic and thus 
     13@* of all powers of a given polynomial F from R. Our aim is to compute an
     14@* ideal L in D, such that D/L is a presentation of a localized module. Such L
     15@* always exists, since such localizations are known to be holonomic and thus
    1616@* cyclic modules. The procedures for the localization are DLoc,SDLoc and DLoc0.
    1717@*
    1818@* - annihilator in D of a given polynomial F from R as well as
    19 @* of a given rational function G/F from Quot(R). These can be computed via 
     19@* of a given rational function G/F from Quot(R). These can be computed via
    2020@* procedures annPoly resp. annRat.
    2121@*
    22 @* - initial form and initial ideals in Weyl algebras with respect to a given 
     22@* - initial form and initial ideals in Weyl algebras with respect to a given
    2323@* weight vector can be computed with  inForm, initialMalgrange, initialIdealW.
    2424@*
    25 @* - appelF1, appelF2 and appelF4 return ideals in parametric Weyl algebras, 
     25@* - appelF1, appelF2 and appelF4 return ideals in parametric Weyl algebras,
    2626@* which annihilate corresponding Appel hypergeometric functions.
    2727
    28 REFERENCES: 
    29 @* (SST) Saito, Sturmfels, Takayama 'Groebner Deformations of Hypergeometric 
     28REFERENCES:
     29@* (SST) Saito, Sturmfels, Takayama 'Groebner Deformations of Hypergeometric
    3030@*         Differential Equations', Springer, 2000
    3131@* (ONW) Oaku, Takayama, Walther 'A Localization Algorithm for D-modules', 2000
     
    6767LIB "nctools.lib"; // for isWeyl etc
    6868LIB "gkdim.lib";
    69 
    70 // todo: complete and include into above list
    71 // charVariety(I);       compute the characteristic variety of the ideal I
    72 // charInfo(); ???
    73 
    74 
    75 ///////////////////////////////////////////////////////////////////////////////
    76 // testing for consistency of the library:
    77 proc testdmodapp()
    78 {
    79   example initialIdealW;
    80   example initialMalgrange;
    81   example DLoc;
    82   example DLoc0;
    83   example SDLoc;
    84   example inForm;
    85   example isFsat;
    86   example annRat;
    87   example annPoly;
    88   example appelF1;
    89   example appelF2;
    90   example appelF4;
    91   example poly2list;
    92   example fl2poly;
    93   example insertGenerator;
    94   example deleteGenerator;
    95   example bFactor;
    96 }
    9769
    9870proc inForm (ideal I, intvec w)
     
    279251"USAGE:  appelF1();
    280252RETURN:  ring  (and exports an ideal into it)
    281 PURPOSE: define the ideal in a parametric Weyl algebra, 
     253PURPOSE: define the ideal in a parametric Weyl algebra,
    282254@* which annihilates Appel F1 hypergeometric function
    283255NOTE: the ideal called  IAppel1 is exported to the output ring
     
    310282"USAGE:  appelF2();
    311283RETURN:  ring (and exports an ideal into it)
    312 PURPOSE: define the ideal in a parametric Weyl algebra, 
     284PURPOSE: define the ideal in a parametric Weyl algebra,
    313285@* which annihilates Appel F2 hypergeometric function
    314286NOTE: the ideal called  IAppel2 is exported to the output ring
     
    340312"USAGE:  appelF4();
    341313RETURN:  ring  (and exports an ideal into it)
    342 PURPOSE: define the ideal in a parametric Weyl algebra, 
     314PURPOSE: define the ideal in a parametric Weyl algebra,
    343315@* which annihilates Appel F4 hypergeometric function
    344316NOTE: the ideal called  IAppel4 is exported to the output ring
     
    460432    ERROR("Basering is not a Weyl algebra");
    461433  }
    462   if (defined(LD0) || defined(BS)) 
     434  if (defined(LD0) || defined(BS))
    463435  {
    464436    ERROR("Reserved names LD0 and/or BS are used. Please rename the objects.");
     
    500472"USAGE:  DLoc0(I, F);  I an ideal, F a poly
    501473RETURN:  ring
    502 PURPOSE: compute the presentation of the localization of D/I w.r.t. f^s, 
     474PURPOSE: compute the presentation of the localization of D/I w.r.t. f^s,
    503475@*           where D is a Weyl Algebra, based on the output of procedure SDLoc
    504476ASSUME: the basering is similar to the output ring of SDLoc procedure
     
    734706  gkdim(I); // 3
    735707  def W = SDLoc(I,F);  setring W; // creates ideal LD in W = R[s]
    736   def U = DLoc0(LD, x2-y3);  setring U; // compute in R 
     708  def U = DLoc0(LD, x2-y3);  setring U; // compute in R
    737709  LD0; // Groebner basis of the presentation of localization
    738710  BS; // description of b-function for localization
     
    949921  setring R;
    950922  poly F = x2-y3;
    951   ideal I = Dx*F, Dy*F; 
     923  ideal I = Dx*F, Dy*F;
    952924  // note, that I is not holonomic, since it's dimension is not 2
    953925  gkdim(I); // 3, while dim R = 4
     
    14051377RETURN:  poly
    14061378PURPOSE: reconstruct a monic polynomial in one variable from its factorization
    1407 ASSUME:  s is a string with the name of some variable and 
     1379ASSUME:  s is a string with the name of some variable and
    14081380@*         L is supposed to consist of two entries:
    14091381@*         L[1] of the type ideal with the roots of a polynomial
     
    14671439ASSUME:  The basering is the n-th Weyl algebra in characteristic 0 and  for all
    14681440@*       1<=i<=n the identity var(i+n)*var(i)=var(i)*var(i+1)+1 holds, i.e. the
    1469 @*       sequence of variables is given by x(1),...,x(n),D(1),...,D(n), 
     1441@*       sequence of variables is given by x(1),...,x(n),D(1),...,D(n),
    14701442@*       where D(i) is the differential operator belonging to x(i).
    14711443PURPOSE: computes the initial ideal with respect to given weights.
     
    15231495    }
    15241496  }
    1525  
     1497
    15261498  // 1. create  homogenized Weyl algebra
    15271499  // 1.1 create ordering
     
    18531825  {
    18541826    dbprint(ppl,"// found no roots");
    1855   } 
     1827  }
    18561828  L = list(II,mm);
    18571829  if (ir <> 1)
     
    18621834    L = L + list(string(ir));
    18631835  }
    1864   else 
     1836  else
    18651837  {
    18661838    dbprint(ppl,"// no irreducible factors found");
    1867   } 
     1839  }
    18681840  setring save;
    18691841  L = imap(@S,L);
     
    18751847  ring r = 0,(x,y),dp;
    18761848  bFactor((x^2-1)^2);
    1877   bFactor((x^2+1)^2); 
     1849  bFactor((x^2+1)^2);
    18781850  bFactor((y^2+1/2)*(y+9)*(y-7));
    18791851}
  • Singular/LIB/sheafcoh.lib

    r9ea76a r2c3a5d  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: sheafcoh.lib,v 1.17 2009-04-10 19:28:58 motsak Exp $";
     2version="$Id: sheafcoh.lib,v 1.18 2009-04-14 11:52:54 Singular Exp $";
    33category="Commutative Algebra";
    44info="
     
    2828LIB "nctools.lib";
    2929LIB "homolog.lib";
    30 
    31 
    32 ///////////////////////////////////////////////////////////////////////////////
    33 // testing for consistency of the library:
    34 proc testSheafCohLibrary()
    35 {
    36   printlevel = printlevel + 1;
    37   example truncate;
    38   example truncateFast;
    39   example CM_regularity;
    40   example sheafCoh;
    41   example sheafCohBGG;
    42   example dimH;
    43   example dimGradedPart;
    44   example sheafCohBGG2;
    45   example getStructureSheaf;
    46   printlevel = printlevel - 1;
    47 }
    48 
    4930
    5031
     
    233214         Fast + experimental version. M shoud be a SB!
    234215DISPLAY: If @code{printlevel}>=1, step-by step timings will be printed.
    235          If @code{printlevel}>=2 we add progress debug messages 
     216         If @code{printlevel}>=2 we add progress debug messages
    236217         if @code{printlevel}>=3, even all intermediate results...
    237218EXAMPLE: example truncateFast; shows an example
     
    244225  dbprint(PL-1, "// truncateFast(M: "+ string(nrows(M)) + " x " + string(ncols(M)) +", " + string(d) + "):");
    245226  dbprint(PL-2, M);
    246  
     227
    247228  intvec save = option(get);
    248229  if( PL >= 2 )
    249230  {
    250     option(prot);   
    251     option(mem);   
     231    option(prot);
     232    option(mem);
    252233  }
    253234
     
    329310
    330311  int tTruncateEnd=timer;
    331  
     312
    332313  dbprint(PL-1, "// corrected weighting(L): ["+ string(attrib(L, "isHomog")) + "]");
    333314
     
    345326    :: After  .Time: ", tTruncateEnd - tMinBaseEnd;
    346327  }
    347  
     328
    348329  option(set, save);
    349330
     
    480461    }
    481462  }
    482  
     463
    483464  if( attrib(CM_regularity,"Algorithm") != "mres" )
    484465  {
     
    488469    def L = mres(M,0);
    489470  }
    490  
     471
    491472  intmat BeL = betti(L);
    492473  int r = nrows(module(matrix(BeL)));  // last non-zero row
     
    647628    };
    648629
    649     Betti = R; 
    650   } 
     630    Betti = R;
     631  }
    651632
    652633  int n=nvars(basering)-1;
     
    723704         refers to a not computed dimension. @*
    724705         If @code{printlevel}>=1, step-by step timings will be printed.
    725          If @code{printlevel}>=2 we add progress debug messages 
     706         If @code{printlevel}>=2 we add progress debug messages
    726707         if @code{printlevel}>=3, even all intermediate results...
    727708NOTE:    This procedure is based on the Bernstein-Gel'fand-Gel'fand
     
    744725
    745726  intvec save = option(get);
    746  
     727
    747728  if( PL >= 2 )
    748729  {
    749     option(prot);   
    750     option(mem);   
     730    option(prot);
     731    option(mem);
    751732  }
    752733
    753734  def isCoker = attrib(M, "isCoker");
    754   if( typeof(isCoker) == "int" )   
     735  if( typeof(isCoker) == "int" )
    755736  {
    756737    if( isCoker > 0 )
     
    760741  }
    761742
    762            
    763743  int i,j,k,row,col;
    764  
    765   if( typeof(attrib(M,"isHomog"))!="intvec" ) {
     744
     745  if( typeof(attrib(M,"isHomog"))!="intvec" )
     746  {
    766747     if (size(M)==0) { attrib(M,"isHomog",0); }
    767748     else { ERROR("No admissible degree vector assigned"); }
     
    769750
    770751  dbprint(PL-1, "// weighting(M): ["+ string(attrib(M, "isHomog")) + "]");
    771  
     752
    772753  option(redSB); option(redTail);
    773754
     
    777758  int ell = l + n;
    778759
    779  
     760
    780761/////////////////////////////////////////////////////////////////////////////
    781 // computations 
     762// computations
    782763
    783764  int tBegin=timer;
     
    798779  dbprint(PL-1, "// M = std(M: "+string(nrows(M)) + " x " + string(ncols(M))  + ")");
    799780  dbprint(PL-2, M);
    800   dbprint(PL-1, "// weighting(M): ["+ string(attrib(M, "isHomog")) + "]"); 
     781  dbprint(PL-1, "// weighting(M): ["+ string(attrib(M, "isHomog")) + "]");
    801782
    802783
     
    809790  dbprint(PL-1, "// MT = truncateFast(M: "+string(nrows(MT)) + " x " + string(ncols(MT)) +", " + string(bound) + ")");
    810791  dbprint(PL-2, MT);
    811   dbprint(PL-1, "// weighting(MT): ["+ string(attrib(MT, "isHomog")) + "]"); 
    812  
     792  dbprint(PL-1, "// weighting(MT): ["+ string(attrib(MT, "isHomog")) + "]");
     793
    813794  int m=nrows(MT);
    814795
     
    818799  int tTransposeJacobEnd=timer;
    819800
    820 
    821801  dbprint(PL-1, "// MT = jacob(MT: "+string(nrows(MT)) + " x " + string(ncols(MT))  + ")");
    822802  dbprint(PL-2, MT);
    823   dbprint(PL-1, "// weighting(MT): ["+ string(attrib(MT, "isHomog")) + "]"); 
    824  
     803  dbprint(PL-1, "// weighting(MT): ["+ string(attrib(MT, "isHomog")) + "]");
    825804
    826805  int tSyzBegin=timer;
    827806  MT = syz(MT);
    828   int tSyzEnd=timer;
    829 
     807  int tSyzEnd=timer;
    830808
    831809  dbprint(PL-1, "// MT = syz(MT: "+string(nrows(MT)) + " x " + string(ncols(MT))  + ")");
    832810  dbprint(PL-2, MT);
    833   dbprint(PL-1, "// weighting(MT): ["+ string(attrib(MT, "isHomog")) + "]"); 
    834 
    835  
     811  dbprint(PL-1, "// weighting(MT): ["+ string(attrib(MT, "isHomog")) + "]");
     812
    836813  int tMatrixOppBegin=timer;
    837814  module SS = TensorModuleMult(m, MT);
    838   int tMatrixOppEnd=timer; 
     815  int tMatrixOppEnd=timer;
    839816
    840817  dbprint(PL-1, "// SS = TensorModuleMult("+ string(m)+ ", MT: "+string(nrows(MT)) + " x " + string(ncols(MT))  + ")");
    841818  dbprint(PL-2, SS);
    842   dbprint(PL-1, "// weighting(SS): ["+ string(attrib(SS, "isHomog")) + "]"); 
    843  
    844  
     819  dbprint(PL-1, "// weighting(SS): ["+ string(attrib(SS, "isHomog")) + "]");
     820
    845821  //--- to the exterior algebra
    846822  def AR = Exterior(); setring AR;
     
    852828
    853829  dbprint(PL-1, "// maxbound: "+ string(maxbound));
    854  
     830
    855831  //--- here we are with our matrix
    856832  module EM=imap(R,SS);
     
    863839  attrib(EM,"isHomog",w);
    864840
    865  
    866 
    867841  ///////////////////////////////////////////////////////////////
    868842
    869843  dbprint(PL-1, "// EM: "+string(nrows(EM)) + " x " + string(ncols(EM))  + ")");
    870844  dbprint(PL-2, EM);
    871   dbprint(PL-1, "// weighting(EM): ["+ string(attrib(EM, "isHomog")) + "]"); 
    872  
     845  dbprint(PL-1, "// weighting(EM): ["+ string(attrib(EM, "isHomog")) + "]");
    873846
    874847  int tResulutionBegin=timer;
    875   resolution RE = nres(EM, maxbound); 
     848  resolution RE = nres(EM, maxbound);
    876849  int tMinResBegin=timer;
    877   RE = minres(RE);   
     850  RE = minres(RE);
    878851  int tBettiBegin=timer;
    879852  intmat Betti = betti(RE); // betti(RE, 1);?
    880853  int tResulutionEnd=timer;
    881  
     854
    882855  int tEnd = tResulutionEnd;
    883856
     
    885858  {
    886859    "
    887         ----      RESULTS  ---- 
    888         Tate Resolution (Length: ", size(RE), "): 
     860        ----      RESULTS  ----
     861        Tate Resolution (Length: ", size(RE), "):
    889862    ";
    890863    RE;
     
    893866  };
    894867
    895  
    896868  printlevel = printlevel + 1;
    897869  Betti = showResult(Betti, l, h ); // Show usual form of cohomology table
    898870  printlevel = printlevel - 1;
    899871
    900  
    901872  if(PL > 0)
    902873  {
     
    909880      Syz        Time: ", tSyzEnd - tSyzBegin, "
    910881      Mat        Time: ", tMatrixOppEnd - tMatrixOppBegin, "
    911       ------------------------------ 
     882      ------------------------------
    912883      Res        Time: ", tResulutionEnd - tResulutionBegin, "
    913884      :: NRes    Time: ", tMinResBegin - tResulutionBegin, "
     
    919890      ";
    920891  };
    921  
     892
    922893  setring R;
    923894
     
    938909   def A=sheafCohBGG(0,-9,4);
    939910   timer - t;
    940    
     911
    941912   printlevel = voice; A=sheafCohBGG2(0,-9,4); printlevel = pl;
    942    
     913
    943914   // cohomology of cotangential bundle on P^3:
    944915   //-------------------------------------------
     
    946917
    947918   module M = getCotangentialBundle();
    948    
     919
    949920   int t = timer;
    950921   def B=sheafCohBGG(M,-8,4);
    951922   timer - t;
    952    
     923
    953924   printlevel = voice; B=sheafCohBGG2(M,-8,4); printlevel = pl;
    954925}
     
    971942"
    972943{
    973   if( typeof(attrib(M,"isHomog"))=="string" ) {
    974     if (size(M)==0) {
     944  if( typeof(attrib(M,"isHomog"))=="string" )
     945  {
     946    if (size(M)==0)
     947    {
    975948      // assign weights 0 to generators of R^n (n=nrows(M))
    976949      intvec v;
     
    978951      attrib(M,"isHomog",v);
    979952    }
    980     else {
     953    else
     954    {
    981955      ERROR("No admissible degree vector assigned");
    982956    }
     
    989963    return(dimGradedPart(N,-n-1-d));
    990964  }
    991   else {
    992     if (i==0) {
     965  else
     966  {
     967    if (i==0)
     968    {
    993969      list L=Ext_R(intvec(n+1,n+2),M,1)[2];
    994970      def N0=L[2];
     
    10511027{
    10521028  int use_sres;
    1053   if( typeof(attrib(M,"isHomog"))!="intvec" ) {
     1029  if( typeof(attrib(M,"isHomog"))!="intvec" )
     1030  {
    10541031     if (size(M)==0) { attrib(M,"isHomog",0); }
    10551032     else { ERROR("No admissible degree vector assigned"); }
    10561033  }
    1057   if (size(#)>0) {
     1034  if (size(#)>0)
     1035  {
    10581036    if (#[1]=="sres") { use_sres=1; }
    10591037  }
     
    10661044  if (use_sres) { list L=Ext_R(v,M,1,"sres")[2]; }
    10671045  else          { list L=Ext_R(v,M,1)[2]; }
    1068   for (i=l; i<=h; i++) {
     1046  for (i=l; i<=h; i++)
     1047  {
    10691048    N0=L[n+2];
    10701049    N1=L[n+1];
     
    10721051                             - dimGradedPart(N0,-n-1-i);
    10731052  }
    1074   for (j=1; j<=n; j++) {
     1053  for (j=1; j<=n; j++)
     1054  {
    10751055     N=L[j];
    10761056     attrib(N,"isSB",1);
    10771057     if (dim(N)>=0) {
    1078        for (i=l; i<=h; i++) {
     1058       for (i=l; i<=h; i++)
     1059       {
    10791060         newBetti[j,i-l+1]=dimGradedPart(N,-n-1-i);
    10801061       }
     
    11321113  string s;
    11331114  maxL=4;
    1134   for (i=1;i<=nrows(data);i++) {
    1135     for (j=1;j<=ncols(data);j++) {
    1136       if (size(string(data[i,j]))>=maxL-1) {
     1115  for (i=1;i<=nrows(data);i++)
     1116  {
     1117    for (j=1;j<=ncols(data);j++)
     1118    {
     1119      if (size(string(data[i,j]))>=maxL-1)
     1120      {
    11371121        maxL=size(string(data[i,j]))+2;
    11381122      }
     
    11421126  string Row1="----";
    11431127  for (i=l; i<=h; i++) {
    1144     for (j=1; j<=maxL-size(string(i)); j++) {
     1128    for (j=1; j<=maxL-size(string(i)); j++)
     1129    {
    11451130      Row=Row+" ";
    11461131    }
     
    11501135  print(Row);
    11511136  print(Row1);
    1152   for (j=1; j<=n+1; j++) {
     1137  for (j=1; j<=n+1; j++)
     1138  {
    11531139    s = string(n+1-j);
    11541140    Row = "";
    11551141    for(k=1; k<4-size(s); k++) { Row = Row+" "; }
    11561142    Row = Row + s+":";
    1157     for (i=0; i<=h-l; i++) {
     1143    for (i=0; i<=h-l; i++)
     1144    {
    11581145      dat = data[j,i+1];
    11591146      if (dat>0) { s = string(dat); }
    1160       else {
     1147      else
     1148      {
    11611149        if (dat==0) { s="-"; }
    11621150        else        { s="*"; notSumCol[i+1]=1; }
     
    11691157  print(Row1);
    11701158  Row="chi:";
    1171   for (i=0; i<=h-l; i++) {
     1159  for (i=0; i<=h-l; i++)
     1160  {
    11721161    dat = 0;
    1173     if (notSumCol[i+1]==0) {
     1162    if (notSumCol[i+1]==0)
     1163    {
    11741164      for (j=0; j<=n; j++) { dat = dat + (-1)^j * data[n+1-j,i+1]; }
    11751165      s = string(dat);
     
    11881178  if( size(#) == 0 )
    11891179  {
    1190 
    11911180    module M = 0;
    11921181    intvec v = 0;
     
    11961185    attrib(M, "isCoker", 1);
    11971186
    1198     attrib(M);   
     1187    attrib(M);
    11991188    return(M);
    12001189  };
    12011190
    1202  
    1203 
    1204 
    1205  
    12061191  if( typeof(#[1]) == "ideal")
    12071192  {
    1208 
    1209 
    12101193    ideal I = #[1];
    12111194
     
    12191202
    12201203          module M = getStructureSheaf();
    1221          
     1204
    12221205          export M;
    12231206
     
    12321215    module M = I * gen(1);
    12331216    homog(M);
    1234    
    1235     M = modulo(gen(1), module(I * gen(1))); // basering^1 / I 
     1217
     1218    M = modulo(gen(1), module(I * gen(1))); // basering^1 / I
    12361219
    12371220    homog(M);
    1238    
     1221
    12391222    attrib(M, "isCoker", 1);
    12401223
    12411224    attrib(M);
    12421225    return(M);
    1243 */   
    1244   }   
    1245  
     1226*/
     1227  }
     1228
    12461229  ERROR("Wrong argument");
    1247  
    1248 }   
     1230
     1231}
    12491232example
    12501233{"EXAMPLE:";
     
    12601243   "Module: ", string(M), ", grading is given by weights: ", attrib(M, "isHomog");
    12611244
    1262    def A=sheafCohBGG2(M,-9,9); 
     1245   def A=sheafCohBGG2(M,-9,9);
    12631246   print(A);
    1264    
     1247
    12651248   ////////////////////////////////////////////////////////////////////////////////
    12661249   setring r;
    12671250   module M = getStructureSheaf(ideal(var(1)), 0);
    1268    
     1251
    12691252   "Basering: ";
    12701253   basering;
    12711254   "Module: ", string(M), ", grading is given by weights: ", attrib(M, "isHomog");
    12721255
    1273    def A=sheafCohBGG2(M,-9,9); 
     1256   def A=sheafCohBGG2(M,-9,9);
    12741257   print(A);
    12751258
     
    12781261   def Q = getStructureSheaf(ideal(var(1)), 1); // returns a new ring!
    12791262   setring Q; // M was exported in the new ring!
    1280    
     1263
    12811264   "Basering: ";
    12821265   basering;
    12831266   "Module: ", string(M), ", grading is given by weights: ", attrib(M, "isHomog");
    12841267
    1285    def A=sheafCohBGG2(M,-9,9); 
     1268   def A=sheafCohBGG2(M,-9,9);
    12861269   print(A);
    12871270
Note: See TracChangeset for help on using the changeset viewer.