Changeset edf8b1a in git


Ignore:
Timestamp:
Jan 4, 2021, 5:55:43 PM (3 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
a7e3f7590f057fa806e1c687326dd5faea7c529d
Parents:
b2f037ce9ae0395fef8be8ef08c3eb73d09dc8c9
Message:
typos
File:
1 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/tateProdCplxNegGrad.lib

    rb2f037 redf8b1a  
    1 /////////////////////////////////////////////////////////////////////////////
    2 version ="version tateProdCplxNegGrad.lib 4.2.0.1 Dec_2020 "; // $Id$
     1///////////////////////////////////////////////////////////////////////////////
     2// version ="version tateProdCplxNegGrad.lib 4.2.0.1 Dec_2020 "; //$id$
    33info = "
    44LIBRARY:   tateProdCplxNegGrad.lib for computing sheaf cohomology on product of projective spaces
    … …  
    1313      [2] Eisenbud, Erman, Schreyer: Tate Resolutions on Products of Projective Spaces: Cohomology and Direct Image Complexes (2019)
    1414PROCEDURES:
    15       productOfProjectiveSpaces(intvec c)                   creates rings S,E corresponding to the product
     15      productOfProjectiveSpaces(intvec c)                        creates rings S,E corresponding to the product
    1616      truncate(module M, intvec c)                          truncates module M at c
    17       truncateCoker(module M, intvec c)                     truncates the cokernel at c
    18       symExt(matrix m)                                      computes first differential of R(M)
    19       sufficientlyPositiveMultidegree(module M)             computes a sufficiently positive multidegree for M
    20       tateResolution(module M, intvec low, intvec high)     computes subquotient complex of Tate resolution T(F)
    21       cohomologyMatrix(module M, intvec low, intvec high)   computes cohomologymatrix of corresponding sheaf
     17      truncateCoker(module M, intvec c)                        truncates the cokernel at c
     18      symExt(matrix m)                                computes first differential of R(M)
     19      sufficientlyPositiveMultidegree(module M)                    computes a sufficiently positive multidegree for M
     20      tateResolution(module M, intvec low, intvec high)            computes subquotient complex of Tate resolution T(F)
     21      cohomologyMatrix(module M, intvec low, intvec high)            computes cohomologymatrix of corresponding sheaf
    2222      cohomologyMatrixFromResolution(multigradedcomplex T, intvec low, intvec high)  computes dimensions of sheaf cohomology groups contained in T
    23       eulerPolynomialTable(module M, intvec low, intvec high) computes table of Euler polynomials
    24       cohomologyHashTable(module M, intvec low, intvec high)  computes cohomology hash table
     23      eulerPolynomialTable(module M, intvec low, intvec high)          computes table of Euler polynomials
     24      cohomologyHashTable(module M, intvec low, intvec high)          computes cohomology hash table
    2525      twist(module M,intvec c)                            twists module M by c
    26       beilinsonWindow(multigradedcomplex T)                  computes Beilinson window of T
     26      beilinsonWindow(multigradedcomplex T)                      computes Beilinson window of T
    2727      regionComplex(multigradedcomplex T, intvec d, intvec I, intvec J, intvec K)    computes region complex
    28       strand(multigradedcomplex T, intvec c, intvec J)       computes strand
    29       firstQuadrantComplex(multigradedcomplex T, intvec c)   computes first quadrant complex
    30       lastQuadrantComplex(multigradedcomplex T, intvec c)    computes last quadrant complex
    31       shift(multigradedcomplex A, int i)                     shifts the multigraded complex by i
     28      strand(multigradedcomplex T, intvec c, intvec J)                computes strand
     29      firstQuadrantComplex(multigradedcomplex T, intvec c)              computes first quadrant complex
     30      lastQuadrantComplex(multigradedcomplex T, intvec c)                computes last quadrant complex
     31      proc shift(multigradedcomplex A, int i)                      shifts the multigraded complex by i
    3232";
    3333
    3434
    35 /////////////////////////////////////////////////////////////////////////////
    36 include necessary libraries
     35///////////////////////////////////////////////////////////////////////////////
     36//include necessary libraries
    3737LIB "multigrading.lib";
    3838LIB "matrix.lib";
    … …  
    4040LIB "methods.lib";
    4141
    42  Idee: in multigradedcomplex noch zusaetzlich ring E speichern
     42// Idee: in multigradedcomplex noch zusaetzlich ring E speichern
    4343static proc mod_init()
    4444{
    … …  
    4949}
    5050
    51 /////////////////////////////////////////////////////////////////////////////
     51///////////////////////////////////////////////////////////////////////////////
    5252proc printMultigradedComplex(multigradedcomplex C)
    5353"USAGE:  printMultigradedComplex(C); C multigradedcomplex
    … …  
    159159
    160160
    161 /////////////////////////////////////////////////////////////////////////////
     161///////////////////////////////////////////////////////////////////////////////
    162162proc createMultigradedComplex(list reso)
    163163"USAGE:    createMultigradeComplex(reso); reso list
    … …  
    171171  Reso.differentials = delete(reso,1);
    172172
    173   create the free modules corresponding to the differentials
     173  // create the free modules corresponding to the differentials
    174174  list mods;
    175175  module M;
    … …  
    181181  }
    182182
    183   last special case
     183  // last special case
    184184  M = freemodule(ncols(Reso.differentials[size(Reso.differentials)]));
    185185  M = setModuleGrading(M,multiDeg(Reso.differentials[size(Reso.differentials)]));
    … …  
    190190
    191191
    192 /////////////////////////////////////////////////////////////////////////////
     192///////////////////////////////////////////////////////////////////////////////
    193193proc productOfProjectiveSpaces(intvec c)
    194194"USAGE:  productOfProjectiveSpaces(c); c intvec
    … …  
    228228  ring E = Exterior();
    229229
    230   set multigrading
     230  // set multigrading
    231231  intmat grading[size(c)][sum(c)+ size(c)];
    232232  k = 1;
    … …  
    262262
    263263
    264 /////////////////////////////////////////////////////////////////////////////
     264///////////////////////////////////////////////////////////////////////////////
    265265proc truncate(module M, intvec c)
    266266"USAGE:   truncate(M,c); M module, c intvec
    … …  
    278278
    279279  intmat MGrading = getModuleGrading(M);
    280   determine the free module in which M lives
     280  // determine the free module in which M lives
    281281  int n = nrows(M);
    282282
    283   compute the module with which we have to intersect the module M in order to obtain generators of the truncation
     283  // compute the module with which we have to intersect the module M in order to obtain generators of the truncation
    284284  ideal F;
    285285  int i,j;
    … …  
    299299  }
    300300
    301   now compute the intersection of M and T
     301  // now compute the intersection of M and T
    302302  module intersection = intersect(M,T);
    303303  intersection = setModuleGrading(intersection,MGrading);
    … …  
    321321
    322322
    323 /////////////////////////////////////////////////////////////////////////////
     323///////////////////////////////////////////////////////////////////////////////
    324324proc truncateCoker(module M, intvec c)
    325325"USAGE:   truncateCoker(M,c);  M module, c intvec
    … …  
    342342{"EXAMPLE:";
    343343  echo = 2;
    344   example 1
     344  // example 1
    345345  intvec c1 = 1,1,1;
    346346  def(S1,E1) = productOfProjectiveSpaces(c1);
    … …  
    351351  truncateCoker(M1,c1);
    352352
    353   example 2
     353  // example 2
    354354  intvec c2 = 1,1;
    355355  def (S2,E2) = productOfProjectiveSpaces(c2);
    … …  
    362362
    363363
    364 /////////////////////////////////////////////////////////////////////////////
     364///////////////////////////////////////////////////////////////////////////////
    365365proc symExt(matrix m)
    366366"USAGE:  symExt(m); m matrix
    … …  
    394394
    395395
    396 /////////////////////////////////////////////////////////////////////////////
     396///////////////////////////////////////////////////////////////////////////////
    397397proc sufficientlyPositiveMultidegree(module M)
    398398"USAGE:  sufficientlyPositiveMultidegree(M); M module
    … …  
    433433{"EXAMPLE:";
    434434  echo = 2;
    435   example 1
     435  // example 1
    436436  intvec c1 = 1,2;
    437437  def (S1,E1) = productOfProjectiveSpaces(c1);
    … …  
    442442  sufficientlyPositiveMultidegree(M1);
    443443
    444   example 2
     444  // example 2
    445445  intvec c2 = 1,1;
    446446  def (S2,E2) = productOfProjectiveSpaces(c2);
    … …  
    451451  sufficientlyPositiveMultidegree(M2);
    452452
    453   example 3
     453  // example 3
    454454  intvec c3 = 1,1,1;
    455455  def (S3,E3) = productOfProjectiveSpaces(c3);
    … …  
    462462
    463463
    464 /////////////////////////////////////////////////////////////////////////////
     464///////////////////////////////////////////////////////////////////////////////
    465465proc tateResolution(module M, intvec low, intvec high)
    466466"USAGE:  tateResolution(M,low,high); M module, L list, low intvec, high intvec
    … …  
    492492  }
    493493
    494   now truncate M at hi
     494  // now truncate M at hi
    495495  module N = truncateCoker(M,hi);
    496496
    … …  
    509509  multigradedcomplex tate = createMultigradedComplex(reso);
    510510
    511   for output as in M2, comment the delete commands out and shift by sum(hi)- size(regs) + 2 instead
     511  // for output as in M2, comment the delete commands out and shift by sum(hi)- size(regs) + 2 instead
    512512  tate = deleteFirstEntry(tate);
    513513  tate = deleteFirstEntry(tate);
    … …  
    520520{"EXAMPLE:";
    521521  echo = 2;
    522   example 1
     522  // example 1
    523523  intvec c1 = 1,1,1;
    524524  intvec low1 = 0,0,0;
    … …  
    535535  tate1.differentials;
    536536
    537   example 2
     537  // example 2
    538538  intvec c2 = 1,2;
    539539  def (S2,E2) = productOfProjectiveSpaces(c2);
    … …  
    549549  tate2;
    550550
    551   example 3
     551  // example 3
    552552  intvec c3 = 1,1;
    553553  def (S3,E3) = productOfProjectiveSpaces(c3);
    … …  
    565565
    566566
    567 /////////////////////////////////////////////////////////////////////////////
     567///////////////////////////////////////////////////////////////////////////////
    568568proc cohomologyMatrix(module M, intvec low, intvec high)
    569569"USAGE:  cohomologyMatrix(M,L,low,high); M module, L list, low intvec, high intvec
    … …  
    592592  setring(E);
    593593  list reso = tate.differentials;
    594   int n = nvars(E)-2; i.e. if P = P^{n_1} x P^{n_2}, then n = n_1+n_2
     594  int n = nvars(E)-2; // i.e. if P = P^{n_1} x P^{n_2}, then n = n_1+n_2
    595595
    596596  int i,j,k,d,numhk;
    597   ring Z = 0,h,dp; in this ring we compute the cohomologymatrix
     597  ring Z = 0,h,dp; // in this ring we compute the cohomologymatrix
    598598  setring(Z);
    599599  matrix cohomologymat[high[2]-low[2]+1][high[1]-low[1]+1];
    600600
    601   for (i = low[1]; i <= high[1]; i++)  iterate over rows
     601  for (i = low[1]; i <= high[1]; i++)  //iterate over rows
    602602  {
    603603    for (j = low[2]; j <= high[2]; j++)
    … …  
    623623{"EXAMPLE:";
    624624  echo = 2;
    625   example 1
     625  // example 1
    626626  intvec c1 = 1,1;
    627627  def (S1,E1) = productOfProjectiveSpaces(c1);
    … …  
    636636  print(cohomologymat);
    637637
    638   example 2
     638  // example 2
    639639  intvec c2 = 1,2;
    640640  def (S2,E2) = productOfProjectiveSpaces(c2);
    … …  
    649649  print(cohomologymat);
    650650
    651   example 3
     651  // example 3
    652652  setring(S2);
    653653  module M3 = x(0)(0),x(1)(0)^3 + x(1)(1)^3 +x(1)(2)^3;
    … …  
    660660
    661661
    662 /////////////////////////////////////////////////////////////////////////////
     662///////////////////////////////////////////////////////////////////////////////
    663663proc cohomologyMatrixFromResolution(multigradedcomplex T, intvec low, intvec high)
    664664"USAGE:  cohomologyMatrixFromResolution(T,low,high); T multigradedcomplex, low intvec, high intvec
    … …  
    694694
    695695  ring E = basering;
    696   int n = nvars(E)-2; i.e. if P = P^{n_1} x P^{n_2}, then n = n_1+n_2
    697   now compute the cohomology table from the tate resolution
     696  int n = nvars(E)-2; // i.e. if P = P^{n_1} x P^{n_2}, then n = n_1+n_2
     697  // now compute the cohomology table from the tate resolution
    698698  int i,j,k,d,numhk;
    699   ring Z = 0,h,dp; in this ring we compute the cohomologymatrix
     699  ring Z = 0,h,dp; // in this ring we compute the cohomologymatrix
    700700  setring(Z);
    701701  matrix cohomologymat[high[2]-low[2]+1][high[1]-low[1]+1];
    702702
    703   for (i = low[1]; i <= high[1]; i++)  iterate over rows
     703  for (i = low[1]; i <= high[1]; i++)  //iterate over rows
    704704  {
    705705    for (j = low[2]; j <= high[2]; j++)
    706706    {
    707       compute the entry (i,j) of the cohomologymatrix
     707      // compute the entry (i,j) of the cohomologymatrix
    708708      for (k=0; k<= n; k++)
    709709      {
    710         compute coefficient of h^k in entry (i,j)
    711         find these information in the term d = -i-j-k
     710        // compute coefficient of h^k in entry (i,j)
     711        // find these information in the term d = -i-j-k
    712712        d = -i-j-k;
    713         as we don't shift the resolution by some homological degree, the dth term corresponds
    714         to the (d+1+T.shift)th entry in T
     713        // as we don't shift the resolution by some homological degree, the dth term corresponds
     714        // to the (d+1+T.shift)th entry in T
    715715        setring(E);
    716716        numhk = 0;
    … …  
    754754
    755755
    756 ////////////////////////////////////////////////////////////////////////
     756//////////////////////////////////////////////////////////////////////////
    757757proc eulerPolynomialTable(module M, intvec low, intvec high)
    758758"USAGE:  eulerPolynomialTable(M,low,high); M module, L list, low intvec, high intvec
    … …  
    779779
    780780  int i,j,k,d,numhk;
    781   ring Z = 0,h,dp; in this ring we compute the eulerpolynomialtable
     781  ring Z = 0,h,dp; // in this ring we compute the eulerpolynomialtable
    782782  setring(Z);
    783783  HashTable eulerpolynomialtable;
    … …  
    795795    }
    796796    entry = entry +low;
    797     now compute euler polynomial
     797    // now compute euler polynomial
    798798    setring(Z);
    799799    eulerpoly = 0;
    … …  
    818818{"EXAMPLE:";
    819819  echo = 2;
    820   example 1
     820  // example 1
    821821  intvec c1 = 1,1;
    822822  def (S1,E1) = productOfProjectiveSpaces(c1);
    … …  
    837837  print(cohomologymat);
    838838
    839   example 2
     839  // example 2
    840840  intvec c2 =  1,1,1;
    841841  def (S2,E2) = productOfProjectiveSpaces(c2);
    … …  
    852852
    853853
    854 ////////////////////////////////////////////////////////////////////////
     854//////////////////////////////////////////////////////////////////////////
    855855proc cohomologyHashTable(module M, intvec low, intvec high)
    856856"USAGE:  cohomologyHashTable(M,L,low,high); M module, low intvec, high intvec
    … …  
    873873  }
    874874
    875   int n = nvars(basering)-size(low); ie if P = P^{n_1} x \cdtos x P^{n_t}, then n = n_1 + \cdots + n_t
     875  int n = nvars(basering)-size(low); // ie if P = P^{n_1} x \cdtos x P^{n_t}, then n = n_1 + \cdots + n_t
    876876  def (E,tate) = tateResolution(M,low, high);
    877877  setring(E);
    … …  
    893893    for (k=0; k<= n; k++)
    894894    {
    895       compute vorfaktor of h^k in entry (i,j)
    896       find these information in the term d = -i-j-k
     895      // compute vorfaktor of h^k in entry (i,j)
     896      // find these information in the term d = -i-j-k
    897897      d = -sum(entry)-k;
    898       as we don't shift the resolution by some homological degree, the dth term corresponds
    899       to the (d+tate.shift)th entry in reso
     898      // as we don't shift the resolution by some homological degree, the dth term corresponds
     899      // to the (d+tate.shift)th entry in reso
    900900      setring(E);
    901901      numhk = 0;
    … …  
    932932
    933933
    934 ////////////////////////////////////////////////////////////////////////
     934//////////////////////////////////////////////////////////////////////////
    935935proc twist(module M,intvec c)
    936936"USAGE:  twist(M,c); M module, c intvec
    … …  
    966966
    967967
    968 /////////////////////////////////////////////////////////////////////////////
     968///////////////////////////////////////////////////////////////////////////////
    969969proc beilinsonWindow(multigradedcomplex T)
    970970"USAGE:  beilinsonWindow(T); T multigradedcomplex
    … …  
    983983  intvec n = getDimensionVector(getVariableWeights(basering));
    984984
    985   go through all modules in the complex
     985  // go through all modules in the complex
    986986  for (i = size(T.modules); i >= 1; i--)
    987987  {
    … …  
    989989    if (size(c)>1)
    990990    {
    991       need to determine the module grading
     991      // need to determine the module grading
    992992      T.modules[i] = setModuleGrading(freemodule(size(c)-1),deleteColumnsIntmat(getModuleGrading(T.modules[i]),c));
    993993
    994994      if(i > 2 && i <= size(T.differentials))
    995995      {
    996         delete rows and columns in the corresponding maps
    997         delete rows in T.differentials[i] and adjust the module grading
     996        //delete rows and columns in the corresponding maps
     997        // delete rows in T.differentials[i] and adjust the module grading
    998998        A = matrix(T.differentials[i]);
    999999        A = deleteRows(A,c);
    10001000        T.differentials[i] = setModuleGrading(module(A),deleteColumnsIntmat(getModuleGrading(T.differentials[i]),c));
    1001         delete columns in T.differentials[i-1] if i > 2
    1002         delete columns in T.differentials[i-1]
     1001        //delete columns in T.differentials[i-1] if i > 2
     1002        //delete columns in T.differentials[i-1]
    10031003        A = matrix(T.differentials[i-1]);
    10041004        A = deleteColumns(A,c);
    … …  
    10091009        if(i == 1)
    10101010        {
    1011           only have to delete rows
     1011          //only have to delete rows
    10121012          A = matrix(T.differentials[i]);
    10131013          A = deleteRows(A,c);
    … …  
    10161016        else
    10171017        {
    1018           only have to delete columns
     1018          // only have to delete columns
    10191019          A = matrix(T.differentials[i-1]);
    10201020          A = deleteColumns(A,c);
    … …  
    10671067
    10681068
    1069 /////////////////////////////////////////////////////////////////////////////
     1069///////////////////////////////////////////////////////////////////////////////
    10701070proc regionComplex(multigradedcomplex T, intvec d, intvec I, intvec J, intvec K)
    10711071"USAGE:  regionComplex(T,d,I,J,K); T multigradedcomplex, d intvec, I intvec, J intvec, K intvec
    … …  
    10861086  intmat grad;
    10871087
    1088   go through all modules in the complex T
     1088  // go through all modules in the complex T
    10891089  for (i = size(T.modules); i>= 1; i--)
    10901090  {
    10911091    c = goodColumns(getModuleGrading(T.modules[i]),d,I,J,K);
    1092     analogous procedure to beilinsonWindow
     1092    // analogous procedure to beilinsonWindow
    10931093    if (size(c)>1)
    10941094    {
    1095       need to determine the module grading
     1095      // need to determine the module grading
    10961096      T.modules[i] = setModuleGrading(freemodule(size(c)-1),deleteColumnsIntmat(getModuleGrading(T.modules[i]),c));
    10971097
    10981098      if(i > 2 && i <= size(T.differentials))
    10991099      {
    1100         delete rows and columns in the corresponding maps
    1101         delete rows in T.differentials[i] and adjust the module grading
     1100        //delete rows and columns in the corresponding maps
     1101        // delete rows in T.differentials[i] and adjust the module grading
    11021102        A = matrix(T.differentials[i]);
    11031103        A = deleteRows(A,c);
    11041104        T.differentials[i] = setModuleGrading(module(A),deleteColumnsIntmat(getModuleGrading(T.differentials[i]),c));
    1105         delete columns in T.differentials[i-1] if i > 2
    1106         delete columns in T.differentials[i-1]
     1105        //delete columns in T.differentials[i-1] if i > 2
     1106        //delete columns in T.differentials[i-1]
    11071107        A = matrix(T.differentials[i-1]);
    11081108        A = deleteColumns(A,c);
    … …  
    11131113        if(i == 1)
    11141114        {
    1115           only have to delete rows
     1115          //only have to delete rows
    11161116          A = matrix(T.differentials[i]);
    11171117          A = deleteRows(A,c);
    … …  
    11201120        else
    11211121        {
    1122           only have to delete columns
     1122          // only have to delete columns
    11231123          A = matrix(T.differentials[i-1]);
    11241124          A = deleteColumns(A,c);
    … …  
    11321132    }
    11331133  }
    1134   delete not necessary zeros in T
     1134  // delete not necessary zeros in T
    11351135  T = deleteZerosMultigradedComplex(T);
    11361136  return(T);
    … …  
    11731173
    11741174
    1175 /////////////////////////////////////////////////////////////////////////////
     1175///////////////////////////////////////////////////////////////////////////////
    11761176proc strand(multigradedcomplex T, intvec c, intvec J)
    11771177"USAGE:  strand(T,c,J)
    … …  
    11811181"
    11821182{
    1183   if first entry of I is not 0, then add 0 for better compatibility
     1183  // if first entry of I is not 0, then add 0 for better compatibility
    11841184  if (J[1] != 0)
    11851185  {
    … …  
    12211221
    12221222
    1223 //////////////////////////////////////////////////////////////////////////
     1223////////////////////////////////////////////////////////////////////////////
    12241224proc firstQuadrantComplex(multigradedcomplex T, intvec c)
    12251225"USAGE:  firstQuadrantComplex(T,c); T multigradedcomplex, c intvec
    … …  
    12341234
    12351235
    1236 /////////////////////////////////////////////////////////////////////////////
     1236///////////////////////////////////////////////////////////////////////////////
    12371237proc lastQuadrantComplex(multigradedcomplex T, intvec c)
    12381238"USAGE:  lastQuadrantComplex(T,c); T multigradedcomplex, c intvec
    … …  
    12471247
    12481248
    1249 /////////////////////////////////////////////////////////////////////////////
     1249///////////////////////////////////////////////////////////////////////////////
    12501250proc sortedBases(int i)
    12511251"USAGE:  computes a list sortedB where in each entry k we have sortedB[k] = all monomials of degree k*e_i
    … …  
    12791279
    12801280
    1281 /////////////////////////////////////////////////////////////////////////////
     1281///////////////////////////////////////////////////////////////////////////////
    12821282proc diffAntiCommutative(ideal I, ideal J)
    12831283"USAGE:  differentiate the second input by the first
    … …  
    12881288{
    12891289  matrix D = diff(I,J);
    1290   now have to correct the signs since Singular does not do it right...?
     1290  //now have to correct the signs since Singular does not do it right...?
    12911291  int i,j;
    12921292  for (i = 1; i<= nrows(D); i++)
    … …  
    13181318
    13191319
    1320 /////////////////////////////////////////////////////////////////////////////
     1320///////////////////////////////////////////////////////////////////////////////
    13211321proc koszulmap(int i, list sortedB)
    13221322"USAGE:  computes the ith koszul map
    … …  
    13571357
    13581358
    1359 /////////////////////////////////////////////////////////////////////////////
     1359///////////////////////////////////////////////////////////////////////////////
    13601360proc simpleBeilinsonBundle(int a, int w, list L)
    13611361"USAGE:  computes a basic beilinson bundle (i.e. the pullback of a single projective space factor),
    … …  
    13771377  if ( w<1 || w>t)
    13781378  {
    1379     return(B); return the zero module
    1380   }
    1381 
    1382   initialize unit vector with one in position w
     1379    return(B); // return the zero module
     1380  }
     1381
     1382  // initialize unit vector with one in position w
    13831383  intvec d = (1..t) - (1..t);
    13841384  d[w] = 1;
    … …  
    13881388  if ( a < 0 || a > nw )
    13891389  {
    1390     return(B); return the zero bundle
     1390    return(B); // return the zero bundle
    13911391  }
    13921392
    … …  
    14171417      setring(S);
    14181418      matrix K = fetch(E,K);
    1419       have to add multigrading
     1419      // have to add multigrading
    14201420      B.iscoker = 1;
    14211421      M = module(K);
    14221422      intmat gradeM[t][nrows(M)];
    14231423      M = setModuleGrading(M,gradeM);
    1424       B.m = twist(M,-d);   STIMMT DAS SO WIRKLICH?
     1424      B.m = twist(M,-d);   //STIMMT DAS SO WIRKLICH?
    14251425      }
    14261426  }
    … …  
    14411441
    14421442
    1443 /////////////////////////////////////////////////////////////////////////////
     1443///////////////////////////////////////////////////////////////////////////////
    14441444proc beilinsonBundle(intvec a, list L)
    14451445"USAGE:  computes a beilinson bundle (i.e. the pullback of a single projective space factor),
    … …  
    14851485
    14861486
    1487 /////////////////////////////////////////////////////////////////////////////
     1487///////////////////////////////////////////////////////////////////////////////
    14881488proc printBundle(bundle B)
    14891489"USAGE:  prints a bundle
    … …  
    15041504
    15051505
    1506 /////////////////////////////////////////////////////////////////////////////
     1506///////////////////////////////////////////////////////////////////////////////
    15071507proc tensorBundle(bundle B1, bundle B2)
    15081508"USAGE:  computes the tensor product of the bundles
    … …  
    15131513  bundle B;
    15141514
    1515   first have to consider the two special cases
     1515  // first have to consider the two special cases
    15161516  if (B1.iscoker == 0 || B2.iscoker == 0)
    15171517  {
    … …  
    15201520      if (B1.m == 0)
    15211521      {
    1522         return 0
     1522        // return 0
    15231523        B = B1;
    15241524      }
    15251525      else
    15261526      {
    1527         then B1.m is just the free module of rank 1
     1527        // then B1.m is just the free module of rank 1
    15281528        B = B2;
    15291529      }
    … …  
    15331533      if (B2.m == 0)
    15341534      {
    1535         return 0
     1535        // return 0
    15361536        B = B2;
    15371537      }
    15381538      else
    15391539      {
    1540         then B2.m is just the free module of rank 1
     1540        // then B2.m is just the free module of rank 1
    15411541        B = B1;
    15421542      }
    … …  
    15591559  bundle B2 = simpleBeilinsonBundle(1,2,E);
    15601560
    1561   bundle B3 = simpleBeilinsonBundle(1,0,E); zero bundle
     1561  bundle B3 = simpleBeilinsonBundle(1,0,E); // zero bundle
    15621562  bundle B4 = simpleBeilinsonBundle(0,1,E);
    15631563
    … …  
    15731573
    15741574
    1575 /////////////////////////////////////////////////////////////////////////////
     1575///////////////////////////////////////////////////////////////////////////////
    15761576proc directSumBundle(bundle B1, bundle B2)
    15771577"USAGE:  computes the direct sum of the bundles B1 and B2
    … …  
    15821582  bundle B;
    15831583  module M;
    1584   first have to consider the special cases
     1584  // first have to consider the special cases
    15851585  if (B1.iscoker == 0 || B2.iscoker == 0)
    15861586  {
    … …  
    15891589      if(B1.m == 0 || B2.m == 0)
    15901590      {
    1591         return B2
     1591        // return B2
    15921592        B = B2;
    15931593      }
    15941594      else
    15951595      {
    1596         then B1.m is just the free module of rank 1
     1596        // then B1.m is just the free module of rank 1
    15971597        if(B2.iscoker == 0)
    15981598        {
    1599           both bundles are the bundles corresponding to S^1
     1599          // both bundles are the bundles corresponding to S^1
    16001600          M = freemodule(2);
    16011601          intmat grading[2][2];
    … …  
    16051605        else
    16061606        {
    1607           have to add zero row to B2.m
     1607          // have to add zero row to B2.m
    16081608          matrix z[ncols(B2.m)][1];
    16091609          M = module(transpose(concat(z,transpose(B2.m))));
    … …  
    16191619      if (B2.m == 0)
    16201620      {
    1621         return B1
     1621        // return B1
    16221622        B = B1;
    16231623      }
    16241624      else
    16251625      {
    1626         then B2.m is just the free module of rank 1
    1627         have to add zero row to B1.m
     1626        // then B2.m is just the free module of rank 1
     1627        // have to add zero row to B1.m
    16281628        matrix z[ncols(B1.m)][1];
    16291629        M = module(transpose(concat(transpose(B1.m),z)));
    … …  
    16381638  {
    16391639    intmat grading = concatIntmat(getModuleGrading(B1.m), getModuleGrading(B2.m));
    1640     need to construct the new matrix
     1640    // need to construct the new matrix
    16411641    matrix M1[nrows(B1.m)][ncols(B2.m)];
    16421642    matrix M2[nrows(B2.m)][ncols(B1.m)];
    … …  
    16601660  bundle B1 = simpleBeilinsonBundle(1,1,E);
    16611661  bundle B2 = simpleBeilinsonBundle(1,2,E);
    1662   bundle B3 = simpleBeilinsonBundle(1,0,E); zero bundle
     1662  bundle B3 = simpleBeilinsonBundle(1,0,E); // zero bundle
    16631663  bundle B4 = simpleBeilinsonBundle(0,1,E);
    16641664
    … …  
    16741674
    16751675
    1676 /////////////////////////////////////////////////////////////////////////////
     1676///////////////////////////////////////////////////////////////////////////////
    16771677proc concatIntmat(intmat A, intmat B)
    16781678{
    … …  
    16831683    ERROR("A and B do not have the same number of rows");
    16841684  }
    1685   return the concatenated matrix [A; B]
     1685  // return the concatenated matrix [A; B]
    16861686  int i,j;
    16871687  intmat AB[nrows(A)][ncols(A)+ncols(B)];
    … …  
    17051705
    17061706
    1707 /////////////////////////////////////////////////////////////////////////////
     1707///////////////////////////////////////////////////////////////////////////////
    17081708proc shift(multigradedcomplex A, int i)
    17091709"USAGE:  computes A[i], the shifted multigraded complex
    … …  
    17271727
    17281728
    1729 /////////////////////////////////////////////////////////////////////////////
    1730 
    1731  static procedures
    1732 
    1733 /////////////////////////////////////////////////////////////////////////////
    1734 
    1735 
    1736 /////////////////////////////////////////////////////////////////////////////
    1737 static proc jacobM(matrix M) kopiert aus sheafcoh.lib
    1738 {
    1739   computes the jacobian matrix of the input matrix
     1729///////////////////////////////////////////////////////////////////////////////
     1730//
     1731// static procedures
     1732//
     1733///////////////////////////////////////////////////////////////////////////////
     1734
     1735
     1736///////////////////////////////////////////////////////////////////////////////
     1737static proc jacobM(matrix M) //kopiert aus sheafcoh.lib
     1738{
     1739  // computes the jacobian matrix of the input matrix
    17401740   int n=nvars(basering);
    17411741   matrix B=transpose(diff(M,var(1)));
    … …  
    17491749
    17501750
    1751 ////////////////////////////////////////////////////////////////////////
     1751//////////////////////////////////////////////////////////////////////////
    17521752static proc countMultiDegree(intvec c, intmat multiDegrees)
    17531753"USAGE:  counts how often a multidegree occurs in the matrix multiDegrees
    … …  
    17561756"
    17571757{
    1758   iterate through the columns of matrix multiDegrees and count how often c arises as a colum
     1758  // iterate through the columns of matrix multiDegrees and count how often c arises as a colum
    17591759  int numc;
    17601760  int i;
    … …  
    17701770
    17711771
    1772 /////////////////////////////////////////////////////////////////////////////
     1772///////////////////////////////////////////////////////////////////////////////
    17731773static proc subtractIntMat(intmat A, int d)
    17741774{
    1775   uses subtract to subtract d from all the columns
     1775  //uses subtract to subtract d from all the columns
    17761776  matrix result;
    17771777  intvec c;
    … …  
    17891789
    17901790
    1791 /////////////////////////////////////////////////////////////////////////////
     1791///////////////////////////////////////////////////////////////////////////////
    17921792static proc subtract(intvec c, int d)
    17931793{
    1794   if size(c) != 2 then error
    1795   assume d >0
    1796   subtract in total d from the intvec c (go through all possibilities)
    1797   there are in total d+1 possibilities
     1794  //if size(c) != 2 then error
     1795  // assume d >0
     1796  //subtract in total d from the intvec c (go through all possibilities)
     1797  // there are in total d+1 possibilities
    17981798  intmat result[2][d+1];
    17991799  int i = d;
    … …  
    18101810
    18111811
    1812 /////////////////////////////////////////////////////////////////////////////
     1812///////////////////////////////////////////////////////////////////////////////
    18131813static proc matrixWithSpecificEntries(int a, int b, intvec c)
    18141814{
    1815   ith row has entries c[i]
     1815  // ith row has entries c[i]
    18161816  int i,j;
    18171817  intmat A[a][b];
    … …  
    18271827
    18281828
    1829 /////////////////////////////////////////////////////////////////////////////
     1829///////////////////////////////////////////////////////////////////////////////
    18301830static proc deleteZerosReso(list L)
    18311831"USAGE:  deletes all the zero entries in the list which represents a complex
    … …  
    18411841    if (size(L) <= 1)
    18421842    {
    1843       nothing more to do, list is just zero and ist just an empty complex
     1843      // nothing more to do, list is just zero and ist just an empty complex
    18441844      flag = 0;
    18451845    }
    … …  
    18471847    else
    18481848    {
    1849       check whether entry is the zero module (size(L[i]) == 0)
    1850       or if the entry is the zero matrix (L[i] == 0)
     1849      // check whether entry is the zero module (size(L[i]) == 0)
     1850      // or if the entry is the zero matrix (L[i] == 0)
    18511851      if (L[i] == 0 || size(L[i]) == 0)
    18521852      {
    1853         delete list entry
     1853        // delete list entry
    18541854        L = delete(L,2);
    18551855        L[1] = L[1]-1;
    … …  
    18741874
    18751875
    1876 /////////////////////////////////////////////////////////////////////////////
     1876///////////////////////////////////////////////////////////////////////////////
    18771877static proc deleteColumnsIntmat(intmat A, intvec c)
    18781878"USAGE:  delete the columns of A not corresponding to the indices in c[2],..., c[size(c)]
    … …  
    18921892
    18931893
    1894 /////////////////////////////////////////////////////////////////////////////
     1894///////////////////////////////////////////////////////////////////////////////
    18951895static proc deleteRows(matrix A, intvec c)
    18961896"USAGE:  delete the rows of A not corresponding to the indices in c[2],..., c[size(c)]
    … …  
    19071907
    19081908
    1909 /////////////////////////////////////////////////////////////////////////////
     1909///////////////////////////////////////////////////////////////////////////////
    19101910static proc deleteColumns(matrix A, intvec c)
    19111911"USAGE:  delete the columns of A not in c[2],..., c[size(c)]
    … …  
    19281928
    19291929
    1930 /////////////////////////////////////////////////////////////////////////////
     1930///////////////////////////////////////////////////////////////////////////////
    19311931static proc goodColumns(intmat A, intvec c, intvec I, intvec J, intvec K)
    19321932"USAGE:  compute columns of A which have entries in the desired range
    … …  
    19391939"
    19401940{
    1941   need to filter which columns satisfy a_i < c_i for i in I
    1942   a_i = c_i for i in J, a_i >= c_i for i in K
     1941  // need to filter which columns satisfy a_i < c_i for i in I
     1942  // a_i = c_i for i in J, a_i >= c_i for i in K
    19431943  intvec d;
    19441944  for (int i = 1; i <= ncols(A); i++)
    … …  
    19531953
    19541954
    1955 /////////////////////////////////////////////////////////////////////////////
     1955///////////////////////////////////////////////////////////////////////////////
    19561956static proc isGood(intvec a, intvec c, intvec I, intvec J, intvec K)
    19571957{
    1958   return 1 if the vector a satisfies a_i < c_i for i in I
    1959   a_i = c_i for i in J, a_i >= c_i for i in K
     1958  // return 1 if the vector a satisfies a_i < c_i for i in I
     1959  // a_i = c_i for i in J, a_i >= c_i for i in K
    19601960  int i;
    19611961
    … …  
    19871987
    19881988
    1989 /////////////////////////////////////////////////////////////////////////////
     1989///////////////////////////////////////////////////////////////////////////////
    19901990static proc isDisjoint(intvec I, intvec J, intvec K)
    19911991"USAGE:  test whether the entries of I,J,K are disjoint (not consider 0)
    … …  
    20172017
    20182018
    2019 /////////////////////////////////////////////////////////////////////////////
     2019///////////////////////////////////////////////////////////////////////////////
    20202020static proc getColumnIntmat(intmat A, int i)
    20212021"USAGE:   returns intvec corresponding to ith column if the matrix
    … …  
    20332033
    20342034
    2035 /////////////////////////////////////////////////////////////////////////////
     2035///////////////////////////////////////////////////////////////////////////////
    20362036static proc getTargetGrading(matrix A, intmat sourceGrading)
    20372037"USAGE:  computes the shifts in the target of A when we regard A as a homogeneous map
    … …  
    20442044"
    20452045{
    2046   consider the map F1 = \oplus S(-d_j) \to F0 = \oplus S(-c_i)
     2046  // consider the map F1 = \oplus S(-d_j) \to F0 = \oplus S(-c_i)
    20472047  int cols = ncols(A);
    20482048  int rows = nrows(A);
    20492049  intmat targetGrading[nrows(sourceGrading)][rows];
    20502050
    2051   TODO : Check if sourceGrading has the right size
     2051  // TODO : Check if sourceGrading has the right size
    20522052
    20532053  int i,j;
    … …  
    20612061      if (A[i,nonzeroentry]!= 0)
    20622062        {
    2063         apply formula and compute c_i
     2063        // apply formula and compute c_i
    20642064
    20652065        for (j = 1; j<= nrows(sourceGrading); j++)
    … …  
    20682068        }
    20692069
    2070         do the following to stop the while loop
     2070        // do the following to stop the while loop
    20712071        break;
    20722072        }
    … …  
    20942094
    20952095
    2096 /////////////////////////////////////////////////////////////////////////////
     2096///////////////////////////////////////////////////////////////////////////////
    20972097static proc getSourceGrading(matrix A, intmat targetGrading)
    20982098"USAGE:  computes the shifts in the target of A when we regard A as a homogeneous map
    … …  
    21032103"
    21042104{
    2105   TODO: Eine der beiden Funktionen ist eigentlich unnoetig, kann man auch auf die andere zurueckfuehren
    2106 
    2107   consider the map F1 = \oplus S(-d_j) \to F0 = \oplus S(-c_i)
     2105  // TODO: Eine der beiden Funktionen ist eigentlich unnoetig, kann man auch auf die andere zurueckfuehren
     2106
     2107  // consider the map F1 = \oplus S(-d_j) \to F0 = \oplus S(-c_i)
    21082108  int cols = ncols(A);
    21092109  int rows = nrows(A);
    21102110  intmat sourceGrading[2][cols];
    21112111
    2112   TODO : Check if targetGrading has the right size
     2112  // TODO : Check if targetGrading has the right size
    21132113
    21142114  int i;
    … …  
    21222122      if (A[nonzeroentry,i]!= 0)
    21232123        {
    2124           apply formula and compute c_i
     2124          // apply formula and compute c_i
    21252125          sourceGrading[1,i] = targetGrading[1,nonzeroentry] + multiDeg(poly(A[nonzeroentry,i]))[1];
    21262126          sourceGrading[2,i] = targetGrading[2,nonzeroentry] + multiDeg(poly(A[nonzeroentry,i]))[2];
    21272127
    2128           in this case stop the while loop
     2128          // in this case stop the while loop
    21292129          break;
    21302130        }
    … …  
    21512151
    21522152
    2153 /////////////////////////////////////////////////////////////////////////////
     2153///////////////////////////////////////////////////////////////////////////////
    21542154static proc isLEQ(intvec c, intvec d)
    21552155"USAGE:  checks whether the intvec c is lower or equal to the intvec d (componentwise)
    … …  
    21862186
    21872187
    2188 /////////////////////////////////////////////////////////////////////////////
     2188///////////////////////////////////////////////////////////////////////////////
    21892189static proc isSmaller(intvec c, intvec d)
    21902190"USAGE:  isSmaller(c,d); c intvec, d intvec
    … …  
    22222222
    22232223
    2224 /////////////////////////////////////////////////////////////////////////////
     2224///////////////////////////////////////////////////////////////////////////////
    22252225static proc vectorsLEQ(intvec c)
    22262226"USAGE:  compute all vectors >= 0 and <= c
    … …  
    22482248
    22492249  return(A);
    2250   lowerbounds = concat(lowerbounds, matrix(getModuleGrading(T[i])));
     2250  //lowerbounds = concat(lowerbounds, matrix(getModuleGrading(T[i])));
    22512251}
    22522252example
    … …  
    22602260
    22612261
    2262 /////////////////////////////////////////////////////////////////////////////
     2262///////////////////////////////////////////////////////////////////////////////
    22632263static proc inBeilinsonWindow(intmat D, intvec n)
    22642264"USAGE:  compute the indices of all multidegrees in D in the range 0 \leq a \leq n
    … …  
    23032303
    23042304
    2305 /////////////////////////////////////////////////////////////////////////////
     2305///////////////////////////////////////////////////////////////////////////////
    23062306static proc deleteZerosMultigradedComplex(multigradedcomplex T)
    23072307"USAGE:  delete superflous zeros in a multigraded complex
    … …  
    23682368
    23692369
    2370 /////////////////////////////////////////////////////////////////////////////
     2370///////////////////////////////////////////////////////////////////////////////
    23712371static proc getDimensionVector(intmat variableWeights)
    23722372"USAGE:  compute the indices of all multidegrees in D in the range 0 \leq a \leq n
    … …  
    23892389
    23902390
    2391 /////////////////////////////////////////////////////////////////////////////
     2391///////////////////////////////////////////////////////////////////////////////
    23922392static proc gradingAndVectorCompatible(module M, intvec c)
    23932393{
    … …  
    24032403
    24042404
    2405 /////////////////////////////////////////////////////////////////////////////
     2405///////////////////////////////////////////////////////////////////////////////
    24062406static proc deleteFirstEntry(multigradedcomplex tate)
    24072407{
Note: See TracChangeset for help on using the changeset viewer.