Changeset 45df9b3 in git for Singular

Timestamp:

May 13, 2015, 5:44:20 PM (9 years ago)

Author:

Oleksandr Motsak <motsak@…>

Branches:

(u'spielwiese', '2a584933abf2a2d3082034c7586d38bb6de1a30a')

Children:

f255f00715b2e38983ecf37e5ec5aaea460c09d8

Parents:

49b7480ebc6b89c61ea6555f8f339873abbac069

git-author:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2015-05-13 17:44:20+02:00

git-committer:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2015-05-27 21:55:26+02:00

Message:

Working on ZERO modules for gradedModules.lib

File:

• Singular/LIB/gradedModules.lib (modified) (45 diffs)

Singular/LIB/gradedModules.lib

@@ -23 +23 @@
     grobj(M,w[,d])  construct a graded object (map) given by matrix M
     grtest(A)       check whether A is a valid graded object
-    grisequal(A,B)  check whether A is exactly eqal to B? TODO: isomorphic!
     grdeg(M)        compute graded degrees of columns of the map M
     grview(M)       view the graded structure of map M
@@ -57 +56 @@
     matrixpres(a)      matrix presentation of direct sum of Omega^{a[i]}(i)
 ";
+    
+//    grisequal(A,B)  check whether A is exactly eqal to B? TODO: isomorphic!
 
 LIB "matrix.lib"; // ?
@@ -73 +74 @@
 "direct sum_i=1^size R(-v[i]), for source and targets of graded objects"
 {
+  int n = size(v);
+  if (n == 0) { return ("0"); }
+  ASSUME(0, n > 0 );
+
   if (R == "")
   {
@@ -80 +85 @@
   ASSUME(0, defined(R) && (R != "") );
 
-  int n = size(v);
-
-  if (n == 0) { return ("0"); }
-
-  ASSUME(0, n > 0 );
-  
   v = -v; // NOTE: due to Mathematical meanings of Singular data
   
@@ -178 +177 @@
   string R = nameof(basering);
 
-  if( typeof( N ) == "list" )
-  {
-    msg = msg + " resolution";  // TODO: what about chain maps?
+  if( typeof( N ) == "list" ) // TODO: find a better DS for graded resolutions / chain map !?
+  {
+    int n = size(N); ASSUME(0, n > 0);
+    
+    string msg1 = "";
     if( size(R) >= 2 )
     {
-      msg = msg + "(let R:="+R+")";
-      R = "R";
+      msg1 = msg1 + "(let R:="+R+")";
+      R = "R"; // !!!
+    }    
+    msg1 = msg1 + ": " ;
+
+    
+
+    list arr; arr[n] = list();
+    int exact = (1==1);
+    
+    int i = 1;
+    
+    ASSUME(1, grtest(N[i]));
+    
+    string dst = grsumstr(R, grrange(N[i]));
+    string src = grsumstr(R, grdeg(N[i]));
+    
+    arr[i] = list(dst,  src);
+
+    i = i + 1;
+    
+    while( i <= n )
+    {
+      ASSUME(1, grtest(N[i]));
+      
+      dst = grsumstr(R, grrange(N[i]));
+      
+      if( exact && (src != dst) )
+      {
+//        "src: [" + src+ "] != [" + dst + "] :(!!";
+        exact = (1==0);
+      }
+
+      src = grsumstr(R, grdeg(N[i]));
+      
+      arr[i] = list(dst,  src);
+
+      i = i + 1;
+    };
+
+    string o = "";
+
+    if( exact )
+    { // complex?
+      msg = msg + " resolution" + msg1;
+
+      o = "d";
+
+      for( i = 1; i <= n; i++ )
+      {
+        msg = msg + newline + arr[i][1] + " <-- "+o+"_" + string(i) + " --";
+      };
+      
+      msg =  msg + newline + arr[n][2];
+      msg = msg + ", given by maps: "; 
+    } else
+    {
+//      print(arr);
+
+      msg = msg + "-object collection";      
+      o = "o";
+      
+//      for( i = 1; i <= n; i++ )
+//      {
+//        msg = msg + newline + arr[i][1] + " <-- "+o+"_" + string(i) + " -- " + arr[i][2];
+//      };      
+      msg = msg + ", given by the following maps (named here as "+o+"_[1 .. "+string(n)+"]): "; 
     }
 
-
-    int i = 1;  int n = size(N);
-    string dst;
-    
-    msg = msg + ": " + newline + grsumstr(R, grrange(N[i])) + " <-- d_" + string(i) + " -- " ;
-    for( ; i < n; i++ )
-    { 
-      dst = grsumstr(R, grdeg(N[i])) +  " <-- d_" + string(i+1) + " --";
-      msg = msg + newline + dst; 
-    };
-
-    msg = msg + newline + grsumstr(R, grdeg(N[i])) + ", given by maps: "; 
 
     print(msg);
@@ -204 +258 @@
     for( i = 1; i <= size(N); i++ )
     { 
-      "d_" + string(i) + " :"; grview(N[i]); 
+      print( o+"_" + string(i) + " :" );
+      grview( N[i] ); 
     };
 
@@ -393 +448 @@
   }
 
-/*
-  if( flag ) // output details in case of non-identical permutation?
-  {
-    // grades & ordering permutation : gr[pivot] should be sorted:
-    "s: ", s;
-    "gr: ", gr;
-    "pivot: ",    pivot;
-  }
-*/
   ASSUME(1, issorted(intvec(gr[pivot]), 1));
 
@@ -407 +453 @@
 }
 
-// Q@Wolfram: what should be done with zero gens!?
 proc grdeg(M)
 "USAGE:  grdeg(M), graded object M
 RETURN:  intvec of degrees
-PURPOSE: graded degrees of columns (generators) of M
+PURPOSE: graded degrees of columns (generators) of M, describing the source of M
 ASSUME:  M must be a graded object (matrix/module/ideal/mapping)
 NOTE:    if M has zero cols it shoud have attrib(M,'degHomog') set.
@@ -423 +468 @@
     def t = attrib(M, "degHomog"); // graded degrees
 
-    if( ncols(M) == 0 )    {     return (t);    } // for now
+    if( size(t) == 0 ){ return (t); } // ZERO!
     
-    ASSUME(0, ncols(M) == size(t) );
+    ASSUME(2, ncols(M) == size(t) );
     return (t);
   }
-  
+
+  if( ncols(M) == 0 ) { return (0:0); } // FIXME: Why???
+
   ASSUME(0, ncols(M) > 0);
-
   ASSUME(0, ncols(M) == size(M) );
 
@@ -747 +793 @@
 /////////////////////////////////////////////////////////
 
-// Q@Woflram?
 proc grzero()
 "USAGE:  grzero()
@@ -755 +800 @@
 "
 {
- return ( grobj(module([0]), intvec(0), intvec(0)) );
+ return ( grobj(freemodule(0), intvec(0:0), intvec(0:0)) );
 }
 example
@@ -762 +807 @@
   ring r=32003,(x,y,z),dp;
 
-  def M = grpower( grshift( grzero(), 10), 5 );
-
-  print(M);
-
-  grview(M);
+
+  grview( grobj(freemodule(0), intvec(0:0), intvec(0:0)) );
+  grview( grobj(freemodule(0), intvec(0:0)) );
+
+  grview( grzero() );
+
+//  def M = grpower( grshift( grzero(), 3), 2 ); grview(M);
+}
+
+proc grtwists(intvec v)
+"USAGE:  grtwists(v), intvec v
+RETURN:  graded object representing S(v[1]) + ... + S(v[size(v)])
+PURPOSE: compute presentation of S(v[1]) + ... + S(v[size(v)])
+EXAMPLE: example grtwists; shows an example
+"
+{
+  matrix m[size(v)][0];
+  return( grobj(m, -v) ); // will set the rank as well
+}
+example
+{ "EXAMPLE:"; echo = 2;
+
+  ring r=32003,(x,y,z),dp;
+  
+  grview( grtwists ( intvec(-4, 1, 6 )) );
+
+  grview( grtwists ( intvec(0:0) ) );
+}
+
+proc grtwist(int a, int d)
+"USAGE:  grtwist(a,d), int a, d
+RETURN:  graded object representing S(d)^a
+PURPOSE: compute presentation of S(d)^a
+EXAMPLE: example grtwist; shows an example
+"
+{
+  ASSUME(0, a > 0);  
+  def Z = grtwists( intvec(d:a) ); // will set the rank as well
+//  ASSUME(2, grisequal(Z, grpower( grshift(grzero(), d), a ) )); // optional check
+  return(Z);
+}
+example
+{ "EXAMPLE:"; echo = 2;
+
+  ring r=32003,(x,y,z),dp;
+
+//  grview(grpower( grshift(grzero(), 10), 5 ) );
+
+  grview( grtwist (5, 10) );
 }
 
@@ -827 +916 @@
   intvec b = grrange(B);
   intvec c = a,b;
-  int r = nrows(A);
-
-  module T = align(module(B), r); //  T;  print(T);  nrows(T); // BUG!!!!
-  module S = module(A), T;
+
+  if( (ncols(B)>0) && (size(B)>0) )
+  {
+    int r = nrows(A);
+    module T = align(module(B), r); //  T;  print(T);  nrows(T); // BUG!!!!
+    module S = module(A), T;
+  }
+  else { def S = A; }
 
   intvec da = grdeg(A);
@@ -836 +929 @@
   intvec dc = da, db;
 
-  return(grobj(S, c, dc));
+
+  def SS = grobj(S, c, dc);
+  
+  ASSUME(0, size( grrange(SS) ) == (size(a) + size(b)) );
+  ASSUME(0, size( grdeg(SS) ) == (size(da) + size(db)) );
+  ASSUME(0, ncols( SS ) == size( grdeg(SS) ) );
+  ASSUME(0, nrows( SS ) == size( grrange(SS) ) );
+  
+  return(SS);
 }
 example
@@ -883 +984 @@
 {
   ASSUME(1, grtest(M) );
+           
+           
 
   intvec a = grrange(M);
+  intvec t = grdeg(M);
+
+  if( size(a) == 0 && size(t) == 0 )
+  {
+    "!! Warning: shifting '0 <- 0' leaves it as it unchanged!";
+    return (M);    
+  }
+  
   a = a - intvec(d:size(a));
-
-  intvec t = attrib(M, "degHomog");
   t = t - intvec(d:size(t));
 
@@ -904 +1013 @@
 
   grview(S);
+
+  grview( grshift( grzero(), 100 ) ); // does nothing...
 }
 
@@ -934 +1045 @@
 example
 { "EXAMPLE:"; echo = 2;
-  TODO
-}
-
-proc grtwist(int a, int d)
-"USAGE:  grtwist(a,d), int a, d
-RETURN:  graded object representing S(d)^a
-PURPOSE: compute presentation of S(d)^a
-EXAMPLE: example grtwist; shows an example
-"
-{
-  ASSUME(0, a > 0);
-
-  module Z; Z[a] = [0];
-  intvec w = -intvec(d:a);
-  Z = grobj(Z, w, w); // will set the rank as well
-  ASSUME(2, grisequal(Z, grpower( grshift(grzero(), d), a ) )); // optional check
-  return(Z);
-}
-example
-{ "EXAMPLE:"; echo = 2;
-
-  ring r=32003,(x,y,z),dp;
-
-  grview(grpower( grshift(grzero(), 10), 5 ) );
-
-  grview( grtwist (5, 10) );
+//  TODO
 }
 
@@ -969 +1055 @@
 "
 {
-  if( ncols(A) == 0 )
-  {
-    ASSUME(0, size(w) == nrows(A) );
-    attrib(A, "isHomog", w);
-    attrib(A, "degHomog", intvec(0)); // FIXME: just for now: no intvec of 0-size :(
-    ASSUME(0, grtest(A) );
-    return (A);
-  }
+  ASSUME(0, size(w) >= nrows(A) );
   
   module M = module(A);
-  ASSUME(0, size(w) >= nrows(M) );
 
   attrib( M, "rank", size(w) );
   attrib( M, "isHomog", w );
 
+  intvec @ww = 0:0;
+  
   if( size(#) > 0 )
   {
     ASSUME(0, typeof(#[1]) == "intvec" );
-    ASSUME(0, size(#[1]) == ncols(M) );
-    attrib(M, "degHomog", #[1]);
+    
+    @ww = intvec( #[1] );
+
+    if( size(@ww) != ncols(M) )
+    {
+      if( (size(M) == 0) && (ncols(M) <= 1) && (size(w) == 0) && (size(@ww) > 0) )
+      {
+        matrix m[size(w)][size(@ww)]; M = module(m); attrib( M, "isHomog", w );
+      }
+    }
+    
+    ASSUME(0, size(@ww) == ncols(M) );
   }
   else
   {
-    ASSUME(0, /* no zero cols please! */ size(M) == ncols(M) );
-    attrib(M, "degHomog", grdeg(M));
-  }
+    if( size(M) == ncols(M) ) /* no zero cols? */
+    {
+      @ww = grdeg(M); // let us compute them all :)
+    } else
+    {
+      if( (ncols(M) == 1) && (size(M) == 0) )
+      {
+        M = freemodule(0);
+      }
+      
+      attrib( M, "rank", size(w) );
+      attrib( M, "isHomog", w );
+      
+//      ASSUME(0, /* PROBLEM WITH ZERO COLUMNS / THEIR DEGREES! */ (ncols(M) == 0) );
+    }
+  }
+  
+//  type(@ww);  type(M);
+  
+  ASSUME(0, size(@ww) == ncols(M) ); // ?!
+  
+  attrib(M, "degHomog", @ww);
 
   ASSUME(0, grtest(M) );
@@ -1020 +1129 @@
 
   // Zero object:
-  matrix z[3][0];
-  def zz = grobj( z, intvec(1,2,3) ); // intvec() ??
-  grview(zz);  
+  matrix z[3][0];  grview( grobj( z, intvec(1,2,3) ) );
+  grview( grobj( freemodule(0), intvec(1,2,3) ) );
+
+  matrix z1[0][3]; grview( grobj( z1, 0:0, intvec(1,2,3) ) ); 
+  grview( grobj( freemodule(0), 0:0, intvec(1,2,3) ) );
+
+  matrix z0[0][0]; grview( grobj( z0, 0:0 ) );
+  grview( grobj( freemodule(0), 0:0 ) );
+  
+  
 
 }
@@ -1067 +1183 @@
   {
     intvec T = attrib(N, "degHomog"); // graded degrees
+
+    if( (ncols(N) == 1) && (size(T) == 0) && (size(N) == 0) )
+    {
+      //  if(b) { "Input seems to be a valid graded ZERO-arrow!"; };
+      return (1);
+    }
     
     if ( ncols(N) != size(T) )
@@ -1120 +1242 @@
   // the following calls will fail due to tests in grtest:
 
+ grobj( module([x+y, x, 0, 0], [0, x+y, y, 0]), intvec(0,0,0,0) ); // enough row weights
 // grobj( module([x+y, x, 0, 0], [0, x+y, y, 0]), intvec(0,0) ); // not enough row weights
 // grobj( module([x,0], [0,0,0], [0, y]), intvec(1,2,3) ); // zero column needs (otherwise optional) total degrees
-// grobj( module([x,0], [0,0,0], [0, y]), intvec(1,2,3), intvec(1, 1, 1) ); // incompatible total degrees (on non-zero columns)
+ grobj( module([x,0], [0,0,0], [0, y]), intvec(1,2,3), intvec(2, 10, 3) ); // compatible total degrees (on non-zero columns)
+// grobj( module([x,0], [0,0,0], [0, y]), intvec(1,2,3), intvec(2-1, 10, 3+1) ); // incompatible total degrees (on both non-zero columns)
 
 }
@@ -1143 +1267 @@
     return (B);    
   }
-
   
   module T; T[d] = 0;
@@ -1151 +1274 @@
 example
 { "EXAMPLE:"; echo = 2;
+
   ring r;
-  matrix m[1][0];
-  align(m, 3);
+  matrix m[2][0];
+  type( align(m, 3) );
+
+  matrix m[0][2];
+  type( align(m, 3) );
 }  
 
@@ -1180 +1307 @@
 }
 
-
-proc grtwists(intvec v)
-"USAGE:  grtwists(v), intvec v
-RETURN:  graded object representing S(v[1]) + ... + S(v[size(v)])
-PURPOSE: compute presentation of S(v[1]) + ... + S(v[size(v)])
-EXAMPLE: example grtwists; shows an example
-"
-{
-  int l = size(v);
-  module Z; Z[l] = [0];
-  Z = grobj(Z, -v, -v); // will set the rank as well
-  return(Z);
-}
-example
-{ "EXAMPLE:"; echo = 2;
-
-  ring r=32003,(x,y,z),dp;
-  
-  grview( grtwists ( intvec(-4, 1, 6 )) );
-}
-
-
 proc grsyz(A)
 "USAGE:  grsyz(M), graded object M
@@ -1210 +1315 @@
 {
   ASSUME(1, grtest(A));
-  intvec v = grdeg(A);
-
-//  grrange(A);
-  
-  module M = syz(A); 
-//  print(M);
-  
-  if( size(M) > 0 ) { return( grobj( M, v ) ); }
-
-  // zero syzygy?
-  return( grtwists(-v) ); // ???
+  return( grobj( syz(A), grdeg(A) ) );
+
+//   if( size(syz(A)) == 0 ) : zero syzygy? //  return( grtwists( -grdeg(A) ) );
 }
 example
@@ -1227 +1324 @@
   ring r=32003,(x,y,z),dp;
 
-  module A = grobj( module([x+y, x, 0, 3], [0, x+y, y, 2], [y, y, z, 1]), intvec(0,0,0,1) ); 
+  module A = grgroebner( grobj( module([x+y, x, 0, 3], [0, x+y, y, 2], [y, y, z, 1]), intvec(0,0,0,1) ) ); 
   grview(A);
   
-  module B = grgroebner(A);
-  grview(B);
-
-  module C = grsyz(B);  
-  grview(C);
+  grview(grsyz(A));
+  
+  module X = grgroebner( grobj( module([x]), intvec(2) ) ); 
+  grview(X);
+
+  // syzygy module should be zero!
+  grview(grsyz(X));
+  
+  
 }
 
@@ -1248 +1349 @@
   ASSUME(1, grtest(B));
 
-  // TODO: ASSUME(0, grdeg() == grrange());!!! 
+  intvec a = grdeg(A);
+  intvec b = grrange(B);
+  
+  ASSUME(0, (size(a) == size(b)) && (a == b));  // == for intvec :(
 
   return ( grobj( A*B, grrange(A), grdeg(B) ) );
@@ -1276 +1380 @@
 
 
+// TODO: think about a proper data structure for a graded resolution!?
 proc grres(def A, int l, list #)
 "USAGE:  grres(M, l[, b]), graded object M, int l, int b
@@ -1291 +1396 @@
   if(b) { list r = res(A, l, #[1]); } else { list r = res(A, l); }
 
-//  r;  v;
-
   l = size(r);
   
-  int i; module m;
+  int i;
   
   for ( i = 1; i <= l; i++ )
   {
-    if( size(r[i]) == 0 ){ r[i] = grtwists(-v); i++; break;   }
+    if( size(r[i]) == 0 )
+    {
+      r[i] = grobj(freemodule(0), v); // grtwists(-v);
+      i++;
+      break;
+    }
 
     r[i] = grobj(r[i], v); v = grdeg(r[i]);
   }
+  
   i = i-1;
 
@@ -1326 +1435 @@
 
 proc grtranspose(def M)
-"
-USAGE:   grtranspose(M), graded object M
+"USAGE:   grtranspose(M), graded object M
 RETURN:  graded object
 PURPOSE: graded transpose of M
@@ -1351 +1459 @@
   
 
-  module A = grobj( module([x+y, x, 0, 3], [0, x+y, y, 2], [y, y, z, 1]), intvec(0,0,0,1) ); A = grgroebner(A); grview(A);
-
-  "graded transpose: "; module B = grtranspose(A); grview( B ); print(B); 
-
-  "... syzygy: "; module C = grsyz(B); grview(C);
-
-  "... transposed: "; module D = grtranspose(C); grview( D ); print (D);
-
-  "... and back to presentation: "; module E = grsyz( D ); grview(E); print(E);
-
-  module F = grgens( E ); grview(F); print(F);
- 
-  module G = grpres( F ); grview(G); print(G);
+  // Corner cases: 0 <- 0!
+  module Z = grzero(); grview(Z);
+  grview( grtranspose( Z ) );
+
+  
+  // Corner cases: * <- 0
+  matrix M1[3][0];
+  
+  module Z1 = grobj( M1, intvec(-1, 0, 1) ); grview(Z1);
+  grview( grtranspose( Z1 ) );
+  
+  
+  // Corner cases: 0 <- *
+  matrix M2[0][3];
+
+  module Z2 = grobj( M2, 0:0, intvec(-1, 0, 1) ); grview(Z2);
+  grview( grtranspose( Z2 ) );
+  
 }
 
 
 proc grgens(def M)
-"
-USAGE:   grgens(M), graded object M (map)
+"USAGE:   grgens(M), graded object M (map)
 RETURN:  graded object  
 PURPOSE: try compute graded generators of coker(M) and return them as columns
@@ -1404 +1516 @@
 
   grview( B ); print(B); // Ups :( != A
+
+  grview( grgens( grzero() ) );
   
 }
@@ -1409 +1523 @@
 
 proc grpres(def M)
-"
-USAGE:   grpres(M), graded object M (submodule gens)
+"USAGE:   grpres(M), graded object M (submodule gens)
 RETURN:  graded module (via coker)
 PURPOSE: compute graded presentation matrix of submodule generated by columns of M
@@ -1418 +1531 @@
   ASSUME(1, grtest(M) );
 
-  module N = grsyz(M);
+  def N = grsyz(M);
 
 //  ASSUME(3, grisequal( M, grgens( N ) ) );
@@ -1429 +1542 @@
   ring r=32003,(x,y,z),dp;
 
-  module M = grtwists( intvec(-2, 0, 4, 4) ); grview(M);
-
-  module N = grgens(M); grview( N ); print(N);
-
-  module L = grpres( N ); grview( L ); print(L);
-
-
-  module A = grobj( module([x+y, x, 0, 3], [0, x+y, y, 2], [y, y, z, 1]), intvec(0,0,0,1) ); 
-
-  A = grgroebner(A); grview(A);
-
-  module B = grgens(A); grview( B ); print(B);
-
-  module C = grpres( B ); grview( C ); print(C);
+  def A = grgroebner( grobj( module([x+y, x, 0, 3], [0, x+y, y, 2], [y, y, z, 1]), intvec(0,0,0,1) ) );
+  grview(A);
+
+  "graded transpose: "; def B = grtranspose(A); grview( B ); print(B); 
+
+  "... syzygy: "; def C = grsyz(B); grview(C);
+
+  "... transposed: "; def D = grtranspose(C); grview( D ); print (D);
+
+  "... and back to presentation: "; def E = grsyz( D ); grview(E); print(E);
+
+  def F = grgens( E ); grview(F); print(F); 
+  def G = grpres( F ); grview(G); print(G);
+
+
+  def M = grtwists( intvec(-2, 0, 4, 4) ); grview(M);
+  
+  def N = grgens(M); grview( N ); print(N);
+  
+  def L = grpres( N ); grview( L ); print(L);  
 }
 
@@ -1504 +1623 @@
 }
 
-//
-
-
+// TODO: remove the following?
 proc KeneshlouMatrixPresentation(intvec a)
-"USAGE:  intvec a.
+"USAGE: KeneshlouMatrixPresentation(intvec a), intvec a.
 RETURN: graded object
 PURPOSE: matrix presentation for direct sum of omega^a[i](i) in form of a graded object
@@ -1675 +1792 @@
 
 proc grrange(M)
+"USAGE: grrange(M), graded object M
+RETURN: intvec
+PURPOSE: get weights of module units, thus describing the target of M
+EXAMPLE: example grrange; shows an example
+"
 {
 //  ASSUME(1, grtest(M)); // Leads to recursive call due to grtest...
   return( attrib(M, "isHomog") );
 }
+example
+{ "EXAMPLE:"; echo = 2;
+
+  ring r=32003,(x,y,z),dp;
+
+  module Z = grobj(freemodule(0),intvec(0:0),intvec(0:0));
+  
+  grrange(Z);
+  grdeg(Z);
+  
+  grview(Z);
+
+  module P=grobj(module([xy,0,xz]),intvec(0,1,0));
+
+  grrange(P);
+  grdeg(P);
+
+  grview(P);
+}
 
 proc grlift0(M, N, alpha1)
-"PURPOSE: generic random alpha0 : coker(M) -> coker(N) from random alpha1
+"USAGE: grlift0(M, N, alpha1) TODO!
+PURPOSE: generic random alpha0 : coker(M) -> coker(N) from random alpha1
 NOTE: this proc can work only if some assumptions are fulfilled (due
 to Wolfram)! e.g. at the end of a resolution for the source module...
@@ -1733 +1875 @@
 
 proc grlifting(M,N)
-"USAGE:  graded objects M and N
+"USAGE: grlifting(M,N), graded objects M and N
 RETURN: map of chain complexes (as a list)
 PURPOSE: construct a map of chain complexes between free resolutions of Img(M) and Img(N).
@@ -1823 +1965 @@
 
 proc mappingcone(M,N)
-"USAGE:M,N graded objects
+"USAGE: mappingcone(M,N), M,N graded objects
 RETURN: chain complex (as a list) 
 PURPOSE: construct a free resolution of the cokernel of a random map between Img(M), and Img(N).
@@ -1885 +2027 @@
 // correct
 proc grrndmap(def S, def D, list #) 
-"USAGE: (S,D), graded objects S and D
+"USAGE: grrndmap(S,D), graded objects S and D
 RETURN: graded object
 PURPOSE: construct a random 0-deg graded homomorphism src(S) -> src(D)
@@ -1919 +2061 @@
 
 proc grrndmap2(def D, def S, list #)
-"USAGE: (D,S), graded objects S and D
+"USAGE: grrndmap2(D,S), graded objects S and D
 RETURN: graded object
 PURPOSE: construct a random 0-deg graded homomorphism between target of D and S.
@@ -1955 +2097 @@
 // 
 proc grlifting2(A,B)
-"USAGE: (A,B), graded objects A and B (matrices defining maps)
+"USAGE: grlifting2(A,B), graded objects A and B (matrices defining maps)
 RETURN: map of chain complexes (as a list) 
 PURPOSE: construct a map of chain complexes between free resolution of
@@ -2028 +2170 @@
 // G0<-----F0+G1<------F1+G2<-------F2+G3<-----
 proc mappingcone2(A,B)
-"USAGE: (A,B), graded objects A and B (matrices defining maps)
+"USAGE: mappingcone2(A,B), graded objects A and B (matrices defining maps)
 RETURN: chain complex (as a list) 
 PURPOSE: construct the free resolution of a cokernel of a random map between M=coker(A), and N=coker(B)
@@ -2198 +2340 @@
 //G0<-----F0+G1<------F1+G2<-------F2+G3<-----
 proc mappingcone3(A,B)
-"USAGE: (A,B), graded objects A and B (matrices defining maps)
+"USAGE: mappingcone3(A,B), graded objects A and B (matrices defining maps)
 RETURN: chain complex (as a list) 
 PURPOSE: construct a free resolution of the cokernel of a random map between M=coker(A), and N=coker(B)
@@ -2290 +2432 @@
 // TODO: Please decide between KeneshlouMatrixPresentation and matrixpres, and replace one with the other!
 proc matrixpres(intvec a)
-"USAGE:  intvec a
+"USAGE:  matrixpres(a), intvec a
 RETURN:  graded object
 PURPOSE: matrix presentation for direct sum of omega^a[i](i) in form of a graded object