Changeset 94cd93 in git

Timestamp:

Jan 19, 2015, 2:40:39 PM (9 years ago)

Author:

Oleksandr Motsak <motsak@…>

Branches:

(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')

Children:

a7c8b1fd065150adf6d6165eac463687c886eaae

Parents:

777f8bb0bd3e850c5c7084702f167df3c1b53113

git-author:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2015-01-19 14:40:39+01:00

git-committer:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2015-01-19 15:05:24+01:00

Message:

Added basic operations with graded objects

fix: some minors

File:

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

Singular/LIB/gradedModules.lib

@@ -5 +5 @@
 LIBRARY: gradedModules.lib     Operations with graded modules/matrices/resolutions
 AUTHOR:  Oleksandr Motsak <U@D>, where U={motsak}, D={mathematik.uni-kl.de}
+         Hanieh Keneshlou <hkeneshlou@yahoo.com>
 KEYWORDS: graded modules, graded homomorphisms, syzygies
 OVERVIEW:
     @* The library contains several procedures for operations with graded modules/matrices/resolutions
-
+    @* TODO!
 NOTE:        
-    @* try @code{example TestGRRes;} from examples
+    @* try @code{example TestGRRes; example grsum; } from examples
 PROCEDURES:
-        
+
+    grzero()        presentation of basering(0)^1
+    grshift(M,d)    shift graded module M by d
+    grtwist(r,d)    presentation of basering(d)^r
+    grsum(M,N)      direct sum of two graded modules M \oplus N
+    grpower(M,p)    direct p-th power of graded module M
     grview(M)       view the graded structure of M
     grdeg(M)        compute graded degrees of M    
@@ -22 +28 @@
 @*
 [MO]   Motsak, O.: Non-commutative Computer Algebra with applications: Graded commutative algebra and related
-       structures in Singular with applications, Ph.D. thesis, TU Kaiserslautern, 2010?
+       structures in Singular with applications, Ph.D. thesis, TU Kaiserslautern, 2010 TODO!?
 ";
-
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -77 +82 @@
 "
 {
-  if( size(N) == 0 ) { return (); }
+//  if( size(N) == 0 ) { return (); }
   
   if( typeof( N ) == "list" )
@@ -107 +112 @@
     D[1, c+d] = c; // top row indeces
     v = L[c];
-    D[nr+2*d, c+d] = deg(v) + gr[ leadexp(v)[m] ]; // bottom row with computed column induced degrees
+    if( v != 0 )
+    {
+      D[nr+2*d, c+d] = deg(v) + gr[ leadexp(v)[m] ]; // bottom row with computed column induced degrees
+    } else
+    {
+      D[nr+2*d, c+d] = 0; // TODO: 0/-1 is valid :(
+    }
   }
   
@@ -115 +126 @@
     for( c = nc; c > 0; c-- )
     {
-      D[r+d, c+d] = deg(M[r, c]); // central block with degrees
-//      if( D[r+d, c+d] < 0 ) { D[r+d, c+d] = 0; }
+      D[r+d, c+d] = deg(M[r, c]); // central block with degrees (-1 means zero entry)
     }
     D[r+d, nc+2*d] = r; // right-most block with indeces
@@ -217 +227 @@
   def w = attrib(M, "isHomog"); // grading weights?
   ASSUME(0, /* input must be correctly graded! */ nrows(M) == size(w) );   
-  
+
+  if( size(M) == 0 )  {    return (w);  } // TODO???
+
   int m = ncols(M); // m > 0 in Singular!
-  int n = nvars(basering) + 1; // index of mod. column in the leadexp 
+  int n = nvars(basering) + 1; // index of mod. column in the leadexp
 
   module L = lead(M[1..m]); // leading module-terms for input column vectors
@@ -584 +596 @@
 }
 
+/////////////////////////////////////////////////////////
+
+// ????
+proc grzero()
+"presentation of S(0)^1
+TODO: can we return this as an undefined value?????
+"
+{
+ module Z = 0;
+ attrib(Z,"isHomog",intvec(0));
+ return (Z);
+}
+
+proc grpower(def A, int p)
+"
+compute A \oplus ... \opuls A (p-times)
+"
+{
+  if(p==0){ return ( grzero() ); } // just ERROR ???
+
+  ASSUME(0, p > 0);
+
+  if(p==1){ return(A); }
+
+  def N = grsum(A,A);
+
+  if(p==2){ return(N); }
+
+  // TODO: replace recursion with a loop!
+  // see http://en.wikipedia.org/wiki/Exponentiation_by_squaring
+  if((p%2)==0)
+    { return ( grpower(N, p div 2) ); }
+  else
+    { return ( grsum( A, grpower(N, (p-1) div 2) )); }
+}  
+  
+
+proc grsum(def A,def B)
+"
+direct sum of graded modules
+"
+{
+  intvec a = attrib(A, "isHomog");
+  intvec b = attrib(B, "isHomog");
+  intvec c = a,b;                       
+  int r = nrows(A);
+  
+  ASSUME( 0, r == size(a) );
+
+  module T; T[r] = 0; T = T, module(transpose(B));
+  module AB = module(A), transpose(T);
+
+  attrib(AB, "isHomog", c);
+  return(AB);
+}
+example
+{ "EXAMPLE:"; echo = 2; int assumeLevel = 5;
+   
+  ring r=32003,(x,y,z),dp;
+
+  grview(grpower( grshift(grzero(), 10), 5 ) );
+  
+  module A = [x+y, x, 0 ], [0, x+y, y];
+  attrib(A,"isHomog", intvec(1,1,1));
+  grview(A);
+  
+  matrix B[2][2] = z,0, 0,z;
+  attrib(B,"isHomog", intvec(-2,-3));
+  grview(B);
+
+  def C = grsum(A,B);
+
+  print(C);
+  homog(C);
+  grview(C);
+
+  def D = grsum(grpower(A, 2), grpower(B, 2));
+
+  print(D);
+  homog(D);
+  grview(D);  
+
+  def D10 = grshift(D, 10);
+
+  print(D10);
+  homog(D10);
+  grview(D10);
+
+  "";  def T = grtwist(5, 10);
+  
+  print(T);
+  homog(T);
+  grview(T);
+  
+  "";  def TT = grsum(grtwist(3, 0), grtwist(5,-1));
+  
+  print(TT);
+  homog(TT);
+  grview(TT);
+}
+
+proc grshift( def M, int d)
+"
+shift graded module M by delta so that 1 is in M_d
+"
+{
+  intvec a = attrib(M, "isHomog");
+  attrib(M, "isHomog", intvec( a + intvec(d:size(a))) );
+  return (M);
+}
+
+proc grisequal (def A, def B)
+"TODO"
+{
+  return (1==1); // TODO!
+}
+
+proc grtwist(int a, int d)
+"
+matrix presentation for twisted polynomial ring S(d)^a
+"
+{
+  matrix zero[a][a]; // TODO ???
+  module Z = zero;
+  attrib(Z, "isHomog", intvec(d:a));
+
+  ASSUME(2, grisequal(Z, grpower( grshift(grzero(), d), a ) )); // optional check
+  return(Z); 
+}